@sigil-sifter/magic 1.0.0

package/src/expressions/DevotionExpression.js

@@ -0,0 +1,56 @@
+import {SearchSyntaxError} from 'sigil-sifter/core';
+import ManaExpression from './ManaExpression.js';
+
+const allowedSymbolTypes = [
+    'coloredMana',
+    'twoColorHybridMana',
+    'threeColorHybridMana',
+    'fourColorHybridMana',
+    'fiveColorHybridMana'
+];
+
+function isAllowedColor(prevSymbol, sym) {
+    const inputValue = sym.colors.sort().join('/');
+    if (prevSymbol.length)
+        return prevSymbol[0] === inputValue;
+    prevSymbol.push(inputValue);
+    return true;
+}
+
+export default class DevotionExpression extends ManaExpression {
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        let prevSymbol = [];
+        const invalidInput = this.searchManaCost.symbols.some(sym => {
+            return !allowedSymbolTypes.includes(sym.type)
+                || !isAllowedColor(prevSymbol, sym);
+        });
+        if (invalidInput)
+            throw new SearchSyntaxError(
+                'Devotion can only match single color and hybrid mana',
+                match[0]
+            );
+    }
+
+    includes(val) {
+        return this.greaterThan(val) || this.equals(val);
+    }
+
+    equals(val) {
+        return this.searchManaCost.colors.some(c => {
+            return val.getDevotionTo(c) === this.searchManaCost.getDevotionTo(c);
+        });
+    }
+
+    greaterThan(val) {
+        return this.searchManaCost.colors.some(c => {
+            return val.getDevotionTo(c) > this.searchManaCost.getDevotionTo(c);
+        });
+    }
+
+    lessThan(val) {
+        return this.searchManaCost.colors.every(c => {
+            return val.getDevotionTo(c) < this.searchManaCost.getDevotionTo(c);
+        });
+    }
+}

package/src/expressions/EvenOddExpression.js

@@ -0,0 +1,43 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class EvenOddExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^(even|odd)/i);
+    }
+
+    static parse(sifter, match, str) {
+        return new EvenOddExpression(sifter, match, str);
+    }
+
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        const isOdd = match[1].toLowerCase() === 'odd';
+        this.expectedRemainder = isOdd ? 1 : 0;
+    }
+
+    includes(val) {
+        return (val % 2) === this.expectedRemainder;
+    }
+
+    equals(val) {
+        throw new SearchSyntaxError(
+            'Equality operators are not supported for even/odd ' +
+            'expressions, use the includes operator (\':\') instead.'
+        );
+    }
+
+    greaterThan(val) {
+        throw new SearchSyntaxError(
+            'Comparison operators are not supported for even/odd ' +
+            'expressions, use the includes operator (\':\') instead.'
+        );
+    }
+
+    lessThan(val) {
+        throw new SearchSyntaxError(
+            'Comparison operators are not supported for even/odd ' +
+            'expressions, use the includes operator (\':\') instead.'
+        );
+    }
+}

package/src/expressions/ExactStringExpression.js

@@ -0,0 +1,11 @@
+import { StringExpression } from 'sigil-sifter/expressions';
+
+export default class ExactStringExpression extends StringExpression {
+    includes(value) {
+        return this.equals(value);
+    }
+
+    equals(value) {
+        return value.toLowerCase() === this.value;
+    }
+}

package/src/expressions/FormatExpression.js

@@ -0,0 +1,19 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { StringExpression } from 'sigil-sifter/expressions';
+
+export default class FormatExpression extends StringExpression {
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.format = sifter.FormatExtension.resolveFormat(this.value);
+        if (!this.format)
+            throw new SearchSyntaxError('Unknown game format', match[0]);
+    }
+
+    includes(val) {
+        return this.equals(val);
+    }
+
+    equals(val) {
+        return this.format.expr.test(val);
+    }
+}

package/src/expressions/GameExpression.js

@@ -0,0 +1,19 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { StringExpression } from 'sigil-sifter/expressions';
+
+export default class GameExpression extends StringExpression {
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.game = sifter.GameExtension.resolveGame(this.value);
+        if (!this.game)
+            throw new SearchSyntaxError('Unknown game', match[0]);
+    }
+
+    includes(val) {
+        return val.some(g => this.game.expr.test(g));
+    }
+
+    equals(val) {
+        return this.includes(val);
+    }
+}

package/src/expressions/KeywordAbilityExpression.js

@@ -0,0 +1,33 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { StringExpression } from 'sigil-sifter/expressions';
+
+export default class KeywordAbilityExpression extends StringExpression {
+    static parse(sifter, match, str) {
+        return new KeywordAbilityExpression(sifter, match, str);
+    }
+
+    includes(val) {
+        return val.includes(this.value);
+    }
+
+    equals(val) {
+        throw new SearchSyntaxError(
+            'Keyword expressions do not support the equals operator',
+            this.remainingStr
+        );
+    }
+
+    greaterThan(val) {
+        throw new SearchSyntaxError(
+            'Keyword expressions do not support the greater than operator',
+            this.remainingStr
+        );
+    }
+
+    lessThan(val) {
+        throw new SearchSyntaxError(
+            'Keyword expressions do not support the less than operator',
+            this.remainingStr
+        );
+    }
+}

package/src/expressions/LanguageExpression.js

@@ -0,0 +1,34 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { StringExpression } from 'sigil-sifter/expressions';
+
+export default class LanguageExpression extends StringExpression {
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.value = match[1];
+        this.language = sifter.LanguageExtension.resolveLanguage(this.value);
+        if (!this.language)
+            throw new SearchSyntaxError('Unknown language', this.value);
+    }
+
+    includes(val) {
+        return this.equals(val);
+    }
+
+    equals(val) {
+        return val === this.language.acronyms[0];
+    }
+
+    greaterThan(val) {
+        throw new SearchSyntaxError(
+            'Comparison operators are not supported for language ' +
+            'expressions, use the includes operator (\':\') instead.'
+        );
+    }
+
+    lessThan(val) {
+        throw new SearchSyntaxError(
+            'Comparison operators are not supported for language ' +
+            'expressions, use the includes operator (\':\') instead.'
+        );
+    }
+}

package/src/expressions/ManaExpression.js

@@ -0,0 +1,36 @@
+import { StringExpression } from 'sigil-sifter/expressions';
+import {SearchSyntaxError} from 'sigil-sifter/core';
+import { ManaCost } from 'mana-scribe';
+
+export default class ManaExpression extends StringExpression {
+    static parse(sifter, match, str) {
+        return new this(sifter, match, str);
+    }
+
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.searchManaCost = ManaCost.parse(this.value);
+        const unparsedManaCost = this.searchManaCost.remainingStr;
+        if (unparsedManaCost.length > 0)
+            throw new SearchSyntaxError(
+                'Failed to parse mana cost',
+                unparsedManaCost
+            );
+    }
+
+    includes(val) {
+        return this.greaterThan(val) || this.equals(val);
+    }
+
+    equals(val) {
+        return val.equals(this.searchManaCost);
+    }
+
+    greaterThan(val) {
+        return val.greaterThan(this.searchManaCost);
+    }
+
+    lessThan(val) {
+        return val.lessThan(this.searchManaCost);
+    }
+}

package/src/expressions/PowTouExpression.js

@@ -0,0 +1,41 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class PowTouExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^(pow(er)?|tou(ghness)?)/i);
+    }
+
+    static parse(sifter, match, str) {
+        return new PowTouExpression(sifter, match, str);
+    }
+
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        const key = match[1].toLowerCase();
+        this.powerMode = key === 'pow' || key === 'power';
+    }
+
+    includes() {
+        throw new SearchSyntaxError(
+            'Includes operator is not supported for pow/tou expressions, ' +
+            'use a comparison or equality operator instead.'
+        );
+    }
+
+    equals({ power, toughness }) {
+        return power === toughness;
+    }
+
+    greaterThan({ power, toughness }) {
+        return this.powerMode
+            ? power < toughness
+            : toughness < power;
+    }
+
+    lessThan({ power, toughness }) {
+        return this.powerMode
+            ? power > toughness
+            : toughness > power;
+    }
+}

package/src/expressions/ProducesExpression.js

@@ -0,0 +1,35 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class ProducesExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(sifter.ColorExtension.colorNamesExpr)
+            || str.match(/^([wubrgc]+)/i);
+    }
+
+    static parse(sifter, match, str) {
+        return new this(sifter, match, str);
+    }
+
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.value = match[0];
+        this.colors = sifter.ColorExtension.resolveColors(this.value);
+    }
+
+    includes(val) {
+        return this.colors.every(c => val.includes(c));
+    }
+
+    equals(val) {
+        return val.length === this.colors.length && this.includes(val);
+    }
+
+    greaterThan(val) {
+        return val.length > this.colors.length && this.includes(val);
+    }
+
+    lessThan(val) {
+        return val.length < this.colors.length
+            && val.every(c => this.colors.includes(c));
+    }
+}

package/src/expressions/RarityExpression.js

@@ -0,0 +1,30 @@
+import { StringExpression } from 'sigil-sifter/expressions';
+
+export default class RarityExpression extends StringExpression {
+    static match(sifter, str) {
+        return str.match(sifter.RarityExtension.rarityExpr);
+    }
+
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.rarity = sifter.RarityExtension.resolveRarity(this.value);
+    }
+
+    includes(val) {
+        return this.equals(val);
+    }
+
+    equals(val) {
+        return this.rarity.name.toLowerCase() === val;
+    }
+
+    greaterThan(val) {
+        const valGroup = this.sifter.RarityExtension.resolveRarity(val);
+        return this.rarity.index < valGroup.index;
+    }
+
+    lessThan(val) {
+        const valGroup = this.sifter.RarityExtension.resolveRarity(val);
+        return this.rarity.index > valGroup.index;
+    }
+}

package/src/expressions/has/IndicatorExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class IndicatorExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^indicator/i);
+    }
+
+    includes(card) {
+        return card.hasIndicator;
+    }
+}

package/src/expressions/has/WatermarkExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class WatermarkExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^watermark/i);
+    }
+
+    includes(card) {
+        return card.hasWatermark;
+    }
+}

package/src/expressions/is/BoosterExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class BoosterExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^booster/i);
+    }
+
+    includes(card) {
+        return card.isBooster;
+    }
+}

package/src/expressions/is/DFCExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class DFCExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^dfc/i);
+    }
+
+    includes(card) {
+        return card.isDFC;
+    }
+}

package/src/expressions/is/EtchedExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class EtchedExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^etched/i);
+    }
+
+    includes(card) {
+        return card.isEtched;
+    }
+}

package/src/expressions/is/FlipExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class FlipExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^flip/i);
+    }
+
+    includes(card) {
+        return card.isFlip;
+    }
+}

package/src/expressions/is/FoilExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class FoilExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^foil/i);
+    }
+
+    includes(card) {
+        return card.isFoil;
+    }
+}

package/src/expressions/is/FrenchVanillaExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class FrenchVanillaExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^frenchvanilla/i);
+    }
+
+    includes(card) {
+        return card.isFrenchVanilla;
+    }
+}

package/src/expressions/is/FullArtExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class FullArtExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^full(art)?/i);
+    }
+
+    includes(card) {
+        return card.isFullArt;
+    }
+}

package/src/expressions/is/GlossyExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class GlossyExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^glossy/i);
+    }
+
+    includes(card) {
+        return card.isGlossy;
+    }
+}

package/src/expressions/is/HistoricExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class HistoricExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^historic/i);
+    }
+
+    includes(card) {
+        return card.isHistoric;
+    }
+}

package/src/expressions/is/HybridExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class HybridExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^hybrid/i);
+    }
+
+    includes(card) {
+        return card.isHybrid;
+    }
+}

package/src/expressions/is/LevelerExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class LevelerExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^leveler/i);
+    }
+
+    includes(card) {
+        return card.isLeveler;
+    }
+}

package/src/expressions/is/MDFCExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class MDFCExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^mdfc/i);
+    }
+
+    includes(card) {
+        return card.isMDFC;
+    }
+}

package/src/expressions/is/MeldExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class MeldExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^meld/i);
+    }
+
+    includes(card) {
+        return card.isMeld;
+    }
+}

package/src/expressions/is/ModalExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class ModalExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^modal/i);
+    }
+
+    includes(card) {
+        return card.isModal;
+    }
+}

package/src/expressions/is/NonFoilExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class NonFoilExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^nonfoil/i);
+    }
+
+    includes(card) {
+        return card.isNonFoil;
+    }
+}

package/src/expressions/is/PartyExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class PartyExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^party/i);
+    }
+
+    includes(card) {
+        return card.isParty;
+    }
+}

package/src/expressions/is/PermanentExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class PermanentExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^permanent/i);
+    }
+
+    includes(card) {
+        return card.isPermanent;
+    }
+}

package/src/expressions/is/PhyrexianExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class PhyrexianExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^phyrexian/i);
+    }
+
+    includes(card) {
+        return card.isPhyrexian;
+    }
+}

package/src/expressions/is/PromoExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class PromoExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^promo/i);
+    }
+
+    includes(card) {
+        return card.isPromo;
+    }
+}

package/src/expressions/is/ReprintExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class ReprintExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^reprint/i);
+    }
+
+    includes(card) {
+        return card.isReprint;
+    }
+}

package/src/expressions/is/ReservedExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class ReservedExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^reserved/i);
+    }
+
+    includes(card) {
+        return card.isReserved;
+    }
+}

package/src/expressions/is/SpellExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class SpellExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^spell/i);
+    }
+
+    includes(card) {
+        return card.isSpell;
+    }
+}