@sigil-sifter/magic 1.0.1 → 1.1.0

package/src/expressions/KeywordAbilityExpression.js

@@ -1,33 +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
-        );
-    }
-}
+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

@@ -1,34 +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.'
-        );
-    }
-}
+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

@@ -1,36 +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);
-    }
-}
+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

@@ -1,41 +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;
-    }
-}
+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

@@ -1,35 +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));
-    }
-}
+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

@@ -1,30 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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

@@ -1,11 +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;
-    }
-}
+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;
+    }
+}