@sigil-sifter/magic 1.0.1 → 1.1.0

package/src/data/gameFormats.js

@@ -1,25 +1,25 @@
-const format = (name) => ({ name });
-
-export default [
-    format('standard'),
-    format('future'),
-    format('historic'),
-    format('timeless'),
-    format('gladiator'),
-    format('pioneer'),
-    format('modern'),
-    format('legacy'),
-    format('pauper'),
-    format('vintage'),
-    format('penny'),
-    format('commander'),
-    format('oathbreaker'),
-    format('standardbrawl'),
-    format('brawl'),
-    format('alchemy'),
-    format('paupercommander'),
-    format('duel'),
-    format('oldschool'),
-    format('premodern'),
-    format('predh'),
-];
+const format = (name) => ({ name });
+
+export default [
+    format('standard'),
+    format('future'),
+    format('historic'),
+    format('timeless'),
+    format('gladiator'),
+    format('pioneer'),
+    format('modern'),
+    format('legacy'),
+    format('pauper'),
+    format('vintage'),
+    format('penny'),
+    format('commander'),
+    format('oathbreaker'),
+    format('standardbrawl'),
+    format('brawl'),
+    format('alchemy'),
+    format('paupercommander'),
+    format('duel'),
+    format('oldschool'),
+    format('premodern'),
+    format('predh'),
+];

package/src/data/games.js

@@ -1,5 +1,5 @@
-export default [
-    { name: 'Paper' },
-    { name: 'MTGO' },
-    { name: 'Arena' },
-];
+export default [
+    { name: 'Paper' },
+    { name: 'MTGO' },
+    { name: 'Arena' },
+];

package/src/data/guilds.js

@@ -1,33 +1,33 @@
-const colorCombo = (name, colors) => ({
-    name,
-    expr: new RegExp('^' + name + '$', 'i'),
-    colorChars: colors.split('')
-});
-
-export default [
-    colorCombo('Azorius', 'WU'),
-    colorCombo('Dimir', 'UB'),
-    colorCombo('Rakdos', 'BR'),
-    colorCombo('Gruul', 'RG'),
-    colorCombo('Selesnya', 'WG'),
-    colorCombo('Orzhov', 'WB'),
-    colorCombo('Izzet', 'UR'),
-    colorCombo('Golgari', 'BG'),
-    colorCombo('Boros', 'WR'),
-    colorCombo('Simic', 'UG'),
-    colorCombo('Bant', 'WUG'),
-    colorCombo('Esper', 'WUB'),
-    colorCombo('Grixis', 'UBR'),
-    colorCombo('Jund', 'BRG'),
-    colorCombo('Naya', 'WRG'),
-    colorCombo('Abzan', 'WBG'),
-    colorCombo('Jeskai', 'WUR'),
-    colorCombo('Sultai', 'UBG'),
-    colorCombo('Mardu', 'WBR'),
-    colorCombo('Temur', 'URG'),
-    colorCombo('Chaos', 'UBRG'),
-    colorCombo('Aggression', 'WBRG'),
-    colorCombo('Altruism', 'WURG'),
-    colorCombo('Growth', 'WUBG'),
-    colorCombo('Artifice', 'WUBR'),
-];
+const colorCombo = (name, colors) => ({
+    name,
+    expr: new RegExp('^' + name + '$', 'i'),
+    colorChars: colors.split('')
+});
+
+export default [
+    colorCombo('Azorius', 'WU'),
+    colorCombo('Dimir', 'UB'),
+    colorCombo('Rakdos', 'BR'),
+    colorCombo('Gruul', 'RG'),
+    colorCombo('Selesnya', 'WG'),
+    colorCombo('Orzhov', 'WB'),
+    colorCombo('Izzet', 'UR'),
+    colorCombo('Golgari', 'BG'),
+    colorCombo('Boros', 'WR'),
+    colorCombo('Simic', 'UG'),
+    colorCombo('Bant', 'WUG'),
+    colorCombo('Esper', 'WUB'),
+    colorCombo('Grixis', 'UBR'),
+    colorCombo('Jund', 'BRG'),
+    colorCombo('Naya', 'WRG'),
+    colorCombo('Abzan', 'WBG'),
+    colorCombo('Jeskai', 'WUR'),
+    colorCombo('Sultai', 'UBG'),
+    colorCombo('Mardu', 'WBR'),
+    colorCombo('Temur', 'URG'),
+    colorCombo('Chaos', 'UBRG'),
+    colorCombo('Aggression', 'WBRG'),
+    colorCombo('Altruism', 'WURG'),
+    colorCombo('Growth', 'WUBG'),
+    colorCombo('Artifice', 'WUBR'),
+];

package/src/data/languages.js

@@ -1,30 +1,30 @@
-const language = (acronym, name, expr) => ({
-    acronyms: Array.isArray(acronym) ? acronym : [acronym],
-    name,
-    expr: expr || new RegExp('^' + name + '$', 'i')
-});
-
-// https://cran.r-project.org/web/packages/scryr/vignettes/languages.html
-export default [
-    language('en', 'English'),
-    language('es', 'Spanish'),
-    language('fr', 'French'),
-    language('de', 'German'),
-    language('it', 'Italian'),
-    language('pt', 'Portuguese'),
-    language(['ja', 'jp'], 'Japanese'),
-    language(['ko', 'kr'], 'Korean'),
-    language('ru', 'Russian'),
-    language(['zhs', 'cs'], 'Chinese (Simplified)',
-        /^(Chinese \(Simplified\)|Simplified Chinese)$/i
-    ),
-    language(['zht', 'ct'], 'Chinese (Traditional)',
-        /^(Chinese \(Traditional\)|Traditional Chinese)$/i
-    ),
-    language('he', 'Hebrew'),
-    language('la', 'Latin'),
-    language('grc', 'Ancient Greek'),
-    language('ar', 'Arabic'),
-    language('sa', 'Sanskrit'),
-    language('ph', 'Phyrexian')
-];
+const language = (acronym, name, expr) => ({
+    acronyms: Array.isArray(acronym) ? acronym : [acronym],
+    name,
+    expr: expr || new RegExp('^' + name + '$', 'i')
+});
+
+// https://cran.r-project.org/web/packages/scryr/vignettes/languages.html
+export default [
+    language('en', 'English'),
+    language('es', 'Spanish'),
+    language('fr', 'French'),
+    language('de', 'German'),
+    language('it', 'Italian'),
+    language('pt', 'Portuguese'),
+    language(['ja', 'jp'], 'Japanese'),
+    language(['ko', 'kr'], 'Korean'),
+    language('ru', 'Russian'),
+    language(['zhs', 'cs'], 'Chinese (Simplified)',
+        /^(Chinese \(Simplified\)|Simplified Chinese)$/i
+    ),
+    language(['zht', 'ct'], 'Chinese (Traditional)',
+        /^(Chinese \(Traditional\)|Traditional Chinese)$/i
+    ),
+    language('he', 'Hebrew'),
+    language('la', 'Latin'),
+    language('grc', 'Ancient Greek'),
+    language('ar', 'Arabic'),
+    language('sa', 'Sanskrit'),
+    language('ph', 'Phyrexian')
+];

package/src/data/rarities.js

@@ -1,25 +1,25 @@
-export default [{
-    index: 0,
-    char: 'C',
-    name: 'Common',
-}, {
-    index: 1,
-    char: 'U',
-    name: 'Uncommon',
-}, {
-    index: 2,
-    char: 'R',
-    name: 'Rare'
-}, {
-    index: 3,
-    char: 'M',
-    name: 'Mythic'
-}, {
-    index: 3,
-    char: 'S',
-    name: 'Special'
-}, {
-    index: 4,
-    char: 'B',
-    name: 'Bonus'
-}];
+export default [{
+    index: 0,
+    char: 'C',
+    name: 'Common',
+}, {
+    index: 1,
+    char: 'U',
+    name: 'Uncommon',
+}, {
+    index: 2,
+    char: 'R',
+    name: 'Rare'
+}, {
+    index: 3,
+    char: 'M',
+    name: 'Mythic'
+}, {
+    index: 3,
+    char: 'S',
+    name: 'Special'
+}, {
+    index: 4,
+    char: 'B',
+    name: 'Bonus'
+}];

package/src/expressions/ArrayLengthExpression.js

@@ -1,15 +1,15 @@
-import { NumericExpression } from 'sigil-sifter/expressions';
-
-export default class ArrayLengthExpression extends NumericExpression {
-    equals(val) {
-        return val.length === this.value;
-    }
-
-    greaterThan(val) {
-        return val.length > this.value;
-    }
-
-    lessThan(val) {
-        return val.length < this.value;
-    }
-}
+import { NumericExpression } from 'sigil-sifter/expressions';
+
+export default class ArrayLengthExpression extends NumericExpression {
+    equals(val) {
+        return val.length === this.value;
+    }
+
+    greaterThan(val) {
+        return val.length > this.value;
+    }
+
+    lessThan(val) {
+        return val.length < this.value;
+    }
+}

package/src/expressions/ColorExpression.js

@@ -1,40 +1,40 @@
-import { Expression } from 'sigil-sifter/expressions';
-
-export default class ColorExpression extends Expression {
-    static match(sifter, str) {
-        return str.match(sifter.ColorExtension.colorNamesExpr)
-            || str.match(/^([wubrgc]+)/i);
-    }
-
-    constructor(sifter, match, str) {
-        super(sifter, match, str);
-        this.value = match[0];
-        this.colors = sifter.ColorExtension.resolveColors(this.value);
-        this.colorless = this.colors.includes('C');
-        if (this.colorless && this.colors.length > 1)
-            throw new Error('A card cannot be both colorless and colored.');
-    }
-
-    includes(val) {
-        if (this.colorless) return val.length === 0;
-        return this.colors.every(c => val.includes(c));
-    }
-
-    equals(val) {
-        if (this.colorless) return val.length === 0;
-        return val.length === this.colors.length
-            && val.every(c => this.colors.includes(c));
-    }
-
-    greaterThan(val) {
-        if (this.colorless) return val.length > 0;
-        return val.length > this.colors.length
-            && this.colors.every(c => val.includes(c));
-    }
-
-    lessThan(val) {
-        if (this.colorless) return false;
-        return val.length < this.colors.length
-            && val.every(c => this.colors.includes(c));
-    }
-}
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class ColorExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(sifter.ColorExtension.colorNamesExpr)
+            || str.match(/^([wubrgc]+)/i);
+    }
+
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.value = match[0];
+        this.colors = sifter.ColorExtension.resolveColors(this.value);
+        this.colorless = this.colors.includes('C');
+        if (this.colorless && this.colors.length > 1)
+            throw new Error('A card cannot be both colorless and colored.');
+    }
+
+    includes(val) {
+        if (this.colorless) return val.length === 0;
+        return this.colors.every(c => val.includes(c));
+    }
+
+    equals(val) {
+        if (this.colorless) return val.length === 0;
+        return val.length === this.colors.length
+            && val.every(c => this.colors.includes(c));
+    }
+
+    greaterThan(val) {
+        if (this.colorless) return val.length > 0;
+        return val.length > this.colors.length
+            && this.colors.every(c => val.includes(c));
+    }
+
+    lessThan(val) {
+        if (this.colorless) return false;
+        return val.length < this.colors.length
+            && val.every(c => this.colors.includes(c));
+    }
+}

package/src/expressions/DevotionExpression.js

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

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

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

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

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