// Safe JavaScript card source. A card implementation is a module-shaped // expression that calls the builder API below: // // export default [ // triggered(when.enters(permanents.withType('creature')), () => { // gainLife(you, 1) // }), // ] // // The source is tokenized, parsed and evaluated against that API only. It is // never passed to eval or new Function, so a saved override cannot run code. import type { Ability, Condition, Cost, Duration, Effect, KeywordAbility, ManaSpec, ObjectSelector, PlayerRef, SearchDestination, StaticEffect, Target, TokenSpec, TriggerEvent, Value, Zone, } from './types.js' import { SIMPLE_KEYWORDS } from './compile.js' import { singularize } from './parse.js' import { Selector, PLAYER_REFS, DURATIONS, ZONES, SEARCH_DESTINATIONS, COLOR_CODES, CHOICES, RESTRICTION_RULES, REPLACEMENT_WHATS, REPLACEMENT_RESULTS, TRIGGER_PLAYERS, VALUE_KINDS, EFFECT_OPS, STATIC_OPS, COST_KINDS, CONDITION_KINDS, TRIGGER_KINDS, ABILITY_KINDS, expectKind, isRecord, asRecord, asString, asNumber, asBoolean, optionalString, stringArray, asPlayer, asTriggerPlayer, asDuration, asZone, asSearchDestination, asValue, asSelector, isTarget, asTarget, asEffects, asEffect, asStaticEffects, asStaticEffect, asCosts, asCost, asCondition, asTrigger, asAbility, asAbilityArray, asOptions } from './source-validation.js' import { self, triggerSubject, previousTarget, anyTarget, targetPlayerOrPlaneswalker, targetOptions, target, each, pick, divided, targetSpell, targetAbility, X, itsPower, itsToughness, count, cardsInHand, maxCardsInHand, maxOpponentCount, totalManaValue, totalPower, anyNumber, eventAmount, mana, anyColor, asToken, CopyOf, copyOf, manaCost, tapCost, untapCost, tapOther, energyCost, loyalty, payLife, discardCost, sacrificeCost, sacrificeSelf, exileSelf, exileFromGraveyard, reveal, choice, returnToHandCost, behold, waterbend, blight, chooseCost, putCounterCost, removeCountersCost, forage, collectEvidence, millCost } from './source-values.js' export function staticPump(targetValue: unknown, power: unknown, toughness: unknown): StaticEffect { return { op: 'pump', target: asTarget(targetValue), power: asValue(power), toughness: asValue(toughness) } } export function staticGrant(targetValue: unknown, keyword: unknown, options?: unknown): StaticEffect { const data = asOptions(options) return { op: 'grant', target: asTarget(targetValue), keyword: asString(keyword, 'keyword'), ...(data.value !== undefined ? { value: asString(data.value, 'keyword value') } : {}), } } export function staticRestrict(targetValue: unknown, rule: unknown, options?: unknown): StaticEffect { const data = asOptions(options) const text = asString(rule, 'restriction rule') return { op: 'restriction', target: asTarget(targetValue), rule: text, ...(data.value !== undefined ? { value: asValue(data.value) } : {}), ...(data.comparison === 'or_greater' || data.comparison === 'or_less' ? { comparison: data.comparison } : {}), ...(data.detail !== undefined ? { detail: asString(data.detail, 'detail') } : {}), ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), } } export function staticSetPt(targetValue: unknown, power: unknown, toughness: unknown, options?: unknown): StaticEffect { const data = asOptions(options) return { op: 'set_pt', target: asTarget(targetValue), ...(power !== null && power !== undefined ? { power: asValue(power) } : {}), ...(toughness !== null && toughness !== undefined ? { toughness: asValue(toughness) } : {}), ...(data.base === true ? { base: true } : {}), } } export function grantAbility(targetValue: unknown, ability: unknown): StaticEffect { return { op: 'grant_ability', target: asTarget(targetValue), ability: asAbility(ability) } } export function entersTapped(targetValue: unknown, options?: unknown): StaticEffect { const data = asOptions(options) return { op: 'enters_tapped', target: asTarget(targetValue), ...(data.unless !== undefined ? { unless: asCondition(data.unless) } : {}), ...(data.unlessCost !== undefined ? { unlessCost: asCost(data.unlessCost) } : {}), } } export function entersWithCounters(targetValue: unknown, counter: unknown, amount: unknown): StaticEffect { return { op: 'enters_with_counters', target: asTarget(targetValue), counter: asString(counter, 'counter'), amount: asValue(amount), } } export function control(targetValue: unknown): StaticEffect { return { op: 'control', target: asTarget(targetValue) } } export function choose(what: unknown): StaticEffect { const text = asString(what, 'choice') if (!CHOICES.has(text)) throw new Error(`unknown choice "${text}"`) return { op: 'choose', what: text as 'creature_type' | 'color' | 'card_name' | 'player' | 'opponent' | 'number' } } export function replace(what: unknown, options?: unknown): StaticEffect { const text = asString(what, 'replacement') if (!REPLACEMENT_WHATS.has(text)) throw new Error(`unknown replacement "${text}"`) const data = asOptions(options) const instead = asString(data.instead, 'replacement result') if (!REPLACEMENT_RESULTS.has(instead)) throw new Error(`unknown replacement result "${instead}"`) return { op: 'replacement', what: text as 'dies' | 'leaves_battlefield' | 'discard' | 'draw', instead: instead as 'exile' | 'return_to_hand' | 'return_to_library' | 'prevent', ...(data.target !== undefined ? { target: asTarget(data.target) } : {}), } } export function replacementAmount(what: unknown, multiplier: unknown, options?: unknown): StaticEffect { const text = asString(what, 'replacement amount') if (text !== 'life_gain' && text !== 'damage' && text !== 'draw' && text !== 'energy') { throw new Error(`unknown replacement amount "${text}"`) } const data = asOptions(options) return { op: 'replacement_amount', what: text, multiplier: asNumber(multiplier, 'replacement multiplier'), ...(data.add !== undefined ? { add: asNumber(data.add, 'replacement add') } : {}), ...(data.combatOnly === true ? { combatOnly: true } : {}), ...(data.noncombatOnly === true ? { noncombatOnly: true } : {}), ...(data.sourceColor !== undefined ? { sourceColor: asString(data.sourceColor, 'source color') } : {}), ...(data.controller === 'you' ? { controller: 'you' as const } : {}), } } export function tokenReplacement(from: unknown, tokens: unknown, options?: unknown): StaticEffect { const data = asOptions(options) const names = Array.isArray(from) ? from.map(entry => asString(entry, 'token name')) : [] const specs = Array.isArray(tokens) ? tokens.map(asToken) : [] return { op: 'token_replacement', from: names, tokens: specs, ...(data.who === 'each_player' ? { who: 'each_player' as const } : {}), } } export function counterMultiplier(targetValue: unknown, multiplier: unknown, options?: unknown): StaticEffect { const data = asOptions(options) return { op: 'counter_multiplier', target: asTarget(targetValue), multiplier: asNumber(multiplier, 'counter multiplier'), ...(data.counter !== undefined ? { counter: asString(data.counter, 'counter') } : {}), ...(data.add !== undefined ? { add: asNumber(data.add, 'counter add') } : {}), } } export function tokenMultiplier(multiplier: unknown, options?: unknown): StaticEffect { const data = asOptions(options) if (data.who !== undefined && data.who !== 'you' && data.who !== 'each_player') { throw new Error("tokenMultiplier() who must be 'you' or 'each_player'") } return { op: 'token_multiplier', multiplier: asNumber(multiplier, 'token multiplier'), who: data.who === 'each_player' ? 'each_player' : 'you', ...(data.creatureOnly === true ? { creatureOnly: true } : {}), } } export function costReduction(targetValue: unknown, amount: unknown, options?: unknown): StaticEffect { const data = asOptions(options) return { op: 'cost_reduction', target: asTarget(targetValue), ...(typeof amount === 'string' && /^(?:\{[^}]+\})+$/.test(amount) ? { symbols: amount } : { amount: asValue(amount) }), ...(data.condition !== undefined ? { condition: asCondition(data.condition) } : {}), } } export function costIncrease(amount: unknown, options?: unknown): StaticEffect { const data = asOptions(options) const spellType = data.spellType if (spellType !== undefined && spellType !== 'noncreature' && spellType !== 'creature') { throw new Error('spellType must be noncreature or creature') } return { op: 'cost_increase', amount: asValue(amount), ...(spellType ? { spellType } : {}), } } export function searchRestriction(who: unknown, amount: unknown): StaticEffect { if (who !== 'opponent' && who !== 'you') throw new Error('searchRestriction() expects you or opponent') return { op: 'search_restriction', who, amount: asValue(amount) } } export function exileInsteadOfGraveyard(owner?: unknown): StaticEffect { if (owner !== undefined && owner !== 'opponent' && owner !== 'you') { throw new Error('exileInsteadOfGraveyard() expects you or opponent') } return { op: 'exile_instead_of_graveyard', ...(owner ? { owner } : {}) } } // --------------------------------------------------------------------------- // Triggers // ---------------------------------------------------------------------------