mana-scribe 1.0.2 → 2.0.0

package/README.md

@@ -1,20 +1,21 @@
 # mana-scribe
 [![Tests](https://github.com/matortheeternal/mana-scribe/actions/workflows/tests.yml/badge.svg)](https://github.com/matortheeternal/mana-scribe/actions/workflows/tests.yml) [![codecov](https://codecov.io/github/matortheeternal/mana-scribe/graph/badge.svg?token=Z81O4KMEOH)](https://codecov.io/github/matortheeternal/mana-scribe)
 
- Mana Scribe is a utility for working with Magic: The Gathering mana costs and activation costs.
+Mana Scribe is a utility for working with Magic: The Gathering mana costs and activation costs.
 
 Supports both brace `{3}{R/U}` and shortform `3R/U` notation.
 
 ## Features
 
 - Parse MTG mana costs into structured objects
-- Supports all major symbols: generic, colored, hybrid, phyrexian, snow, energy, tap/untap, variable
+- Supports all major symbols: generic, colored, 2-5 color hybrid, phyrexian, generic hybrid, phyrexian hybrid, snow, energy, tap/untap, variable
 - Works with both Scryfall braces and shortform notation
 - Compute:
   - Converted mana cost
   - Color identity
   - Devotion
-- Extensible design — add new symbol types by subclassing
+- Compare mana costs (equality, greater than, less than)
+- Easily add custom colors, types of mana, or other extra symbols
 
 Note: When the parser encounters an unrecognized symbol it stops parsing and returns the symbols it parsed so far.  You can access the unparsed string component through the property `remainingStr`.
 
@@ -44,35 +45,76 @@ console.log(cost.cmc);     // 3
 console.log(cost.colors);  // ['W','U','B']
 ```
 
-## Activation costs
-`ActivationCost` offers the same functionality as the `ManaCost` class, but supports additional symbols such as Tap, Untap, and Energy.
+### Comparison example
+The `ManaCost` class supports equality and comparison operators under superset semantics:
+
+- `equals(other)` → true if the costs are exactly the same
+- `greaterThan(other)` → true if this cost includes all symbols of other plus additional ones, or generic mana cost is higher.
+- `lessThan(other)` → true if this cost is a strict subset of other, or generic mana cost is lower.
+
+```js
+const a = ManaCost.parse('{3}{B}{B}{B}');
+const b = ManaCost.parse('{1}{B}{B}{B}');
+
+console.log(a.equals(b));       // false
+console.log(a.greaterThan(b));  // true
+console.log(b.lessThan(a));     // true
+```
+
+
+### Activation costs
+`ActivationCost` offers the same functionality as the `ManaCost` class, but supports additional symbols such as Tap, Untap, and Energy.  It does not have comparison functions.
 
 ```js
 import { ActivationCost } from 'mana-scribe';
 
 const cost = ActivationCost.parse('{1}{G}{T}');
-console.log(cost.symbols.map(s => s.type)); // ["generic", "colored", "tap"]
+console.log(cost.symbols.map(s => s.type)); // ["genericMana", "coloredMana", "tap"]
 console.log(cost.toString(true));           // "{1}{G}{T}"
 ```
 
 ## Extending
 
-The library is class-based. Each symbol type is a subclass of a base Symbol class and implements:
+### Custom colors
+
+You can add custom colors of mana with `symbolRegistry.addColor`.
+
+```js
+import { symbolRegistry, ManaCost } from 'mana-scribe';
+
+symbolRegistry.addColor({ id: 'P', name: 'Purple' });
+const cost = ManaCost.parse('{3}{R/P}{P}');
+console.log(cost.symbols.map(s => s.type)); // ["genericMana", "twoColorHybridMana", "coloredMana"]
+console.log(cost.cmc); // 5
+console.log(cost.colors);  // ['R','P']
+console.log(cost.getDevotionTo('P')); // 2
+```
 
-- `static match(str)` → returns a regex match object if it applies
-- `get colors()` → returns an array of the colors associated with the symbol
-- `cmcValue()` → returns an integer corresponding to how much this symbol contributes to a card's overall converted mana cost.
+### Custom mana types
 
-This makes it easy to add custom symbols or patch existing ones in your own project.
+You can add custom types of mana with `symbolRegistry.addManaType`. This is for mana produced by specific sources, like snow mana.
 
-## Project Status
+```js
+import { symbolRegistry, ActivationCost } from 'mana-scribe';
+
+symbolRegistry.addManaType({ id: 'A', name: 'Artificial' }); // mana produced by an artifact
+const cost = ActivationCost.parse('{A}{A}{T}');
+console.log(cost.symbols.map(s => s.type)); // ["typedMana", "typedMana", "tap"]
+console.log(cost.colors);  // []
+```
 
-This is an early but complete implementation.
+### Extra symbols
 
-Current priorities:
-- [x] Support core MTG symbols
-- [x] Add test coverage
-- [ ] Other improvements? TBD
+You can add additional symbols for use in activation costs with `symbolRegistry.addExtraSym`. This is used for things like the energy symbol.
+
+```js
+import { symbolRegistry, ActivationCost } from 'mana-scribe';
+
+symbolRegistry.addManaType({ id: '\\@', name: 'Chaos' });
+const cost = ActivationCost.parse('{@}');
+console.log(cost.symbols.map(s => s.type)); // ["extra"]
+console.log(cost.colors);  // []
+```
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mana-scribe",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Library for parsing and querying Magic: The Gathering mana costs — with support for CMC, devotion, and color identity.",
   "keywords": [
     "mtg",
@@ -29,6 +29,7 @@
   },
   "scripts": {
     "test": "jasmine --config=jasmine.json",
+    "debug:test": "node --inspect-brk node_modules/jasmine/bin/jasmine.js --config=jasmine.json",
     "coverage": "c8 npm test"
   },
   "files": [

package/src/arrayComparison.js

@@ -0,0 +1,50 @@
+function toFrequencyMap(arr) {
+    const map = new Map();
+    for (const el of arr) {
+        if (el.type === 'genericMana' || el.type === 'infiniteMana') {
+            map.set('generic', (map.get('generic') || 0) + el.cmcValue());
+        } else {
+            const key = el.toString();
+            map.set(key, (map.get(key) || 0) + 1);
+        }
+    }
+    return map;
+}
+
+export function arrayEquals(arr1, arr2) {
+    const m1 = toFrequencyMap(arr1);
+    const m2 = toFrequencyMap(arr2);
+
+    if (m1.size !== m2.size) return false;
+    for (const [key, count] of m1.entries()) {
+        if ((m2.get(key) || 0) !== count) return false;
+    }
+    return true;
+}
+
+export function arrayGreaterThan(arr1, arr2) {
+    const m1 = toFrequencyMap(arr1);
+    const m2 = toFrequencyMap(arr2);
+
+    let larger = false;
+    for (const [key, count] of m2.entries()) {
+        if ((m1.get(key) || 0) < count) return false;
+        larger = larger || m1.get(key) > count;
+    }
+
+    return larger || m1.size > m2.size;
+}
+
+export function arrayLessThan(arr1, arr2) {
+    const m1 = toFrequencyMap(arr1);
+    const m2 = toFrequencyMap(arr2);
+
+    let smaller = false;
+    for (const [key, count] of m1.entries()) {
+        if ((m2.get(key) || 0) < count) return false;
+        smaller = smaller || (count < (m2.get(key) || 0));
+    }
+
+    return smaller || m1.size < m2.size;
+}
+

package/src/costs/ActivationCost.js

@@ -3,14 +3,15 @@ import ColoredManaSymbol from '../symbols/ColoredManaSymbol.js';
 import ColoredPhyrexianManaSymbol from '../symbols/ColoredPhyrexianManaSymbol.js';
 import ColorlessManaSymbol from '../symbols/ColorlessManaSymbol.js';
 import ColorlessPhyrexianManaSymbol from '../symbols/ColorlessPhyrexianManaSymbol.js';
-import EnergySymbol from '../symbols/EnergySymbol.js';
+import ExtraSymbol from '../symbols/ExtraSymbol.js';
 import FiveColorHybridManaSymbol from '../symbols/FiveColorHybridManaSymbol.js';
 import FourColorHybridManaSymbol from '../symbols/FourColorHybridManaSymbol.js';
 import GenericHybridManaSymbol from '../symbols/GenericHybridManaSymbol.js';
 import GenericManaSymbol from '../symbols/GenericManaSymbol.js';
-import HalfColoredManaSymbol from '../symbols/HalfColoredManaSymbol.js';
+import HalfManaSymbol from '../symbols/HalfManaSymbol.js';
+import HybridPhyrexianManaSymbol from '../symbols/HybridPhyrexianManaSymbol.js';
 import InfiniteManaSymbol from '../symbols/InfiniteManaSymbol.js';
-import SnowManaSymbol from '../symbols/SnowManaSymbol.js';
+import TypedManaSymbol from '../symbols/TypedManaSymbol.js';
 import TapSymbol from '../symbols/TapSymbol.js';
 import ThreeColorHybridManaSymbol from '../symbols/ThreeColorHybridManaSymbol.js';
 import TwoColorHybridManaSymbol from '../symbols/TwoColorHybridManaSymbol.js';
@@ -20,13 +21,13 @@ import VariableManaSymbol from '../symbols/VariableManaSymbol.js';
 export default class ActivationCost extends Cost {
     static get allowedSymbols() {
         return [
-            ColoredPhyrexianManaSymbol, GenericHybridManaSymbol, FiveColorHybridManaSymbol,
-            FourColorHybridManaSymbol, ThreeColorHybridManaSymbol, TwoColorHybridManaSymbol,
-            ColorlessPhyrexianManaSymbol, HalfColoredManaSymbol,
-            GenericManaSymbol, VariableManaSymbol,
-            InfiniteManaSymbol, SnowManaSymbol,
-            ColoredManaSymbol, ColorlessManaSymbol,
-            EnergySymbol, TapSymbol, UntapSymbol,
+            HybridPhyrexianManaSymbol, ColoredPhyrexianManaSymbol,
+            GenericHybridManaSymbol, FiveColorHybridManaSymbol,
+            FourColorHybridManaSymbol, ThreeColorHybridManaSymbol,
+            TwoColorHybridManaSymbol, HalfManaSymbol, ColorlessPhyrexianManaSymbol,
+            GenericManaSymbol, VariableManaSymbol, InfiniteManaSymbol,
+            TypedManaSymbol, ColoredManaSymbol, ColorlessManaSymbol,
+            ExtraSymbol, TapSymbol, UntapSymbol,
         ];
     }
 }

package/src/costs/ManaCost.js

@@ -7,22 +7,25 @@ import FiveColorHybridManaSymbol from '../symbols/FiveColorHybridManaSymbol.js';
 import FourColorHybridManaSymbol from '../symbols/FourColorHybridManaSymbol.js';
 import GenericHybridManaSymbol from '../symbols/GenericHybridManaSymbol.js';
 import GenericManaSymbol from '../symbols/GenericManaSymbol.js';
-import HalfColoredManaSymbol from '../symbols/HalfColoredManaSymbol.js';
+import HalfManaSymbol from '../symbols/HalfManaSymbol.js';
 import InfiniteManaSymbol from '../symbols/InfiniteManaSymbol.js';
-import SnowManaSymbol from '../symbols/SnowManaSymbol.js';
+import TypedManaSymbol from '../symbols/TypedManaSymbol.js';
 import ThreeColorHybridManaSymbol from '../symbols/ThreeColorHybridManaSymbol.js';
 import TwoColorHybridManaSymbol from '../symbols/TwoColorHybridManaSymbol.js';
+import HybridPhyrexianManaSymbol from '../symbols/HybridPhyrexianManaSymbol.js';
 import VariableManaSymbol from '../symbols/VariableManaSymbol.js';
+import { arrayEquals, arrayGreaterThan, arrayLessThan } from '../arrayComparison.js';
 
 export default class ManaCost extends Cost {
     static get allowedSymbols() {
         return [
-            ColoredPhyrexianManaSymbol, GenericHybridManaSymbol, FiveColorHybridManaSymbol,
-            FourColorHybridManaSymbol, ThreeColorHybridManaSymbol, TwoColorHybridManaSymbol,
-            ColorlessPhyrexianManaSymbol, HalfColoredManaSymbol,
-            GenericManaSymbol, VariableManaSymbol,
-            InfiniteManaSymbol, SnowManaSymbol,
-            ColoredManaSymbol, ColorlessManaSymbol
+            HybridPhyrexianManaSymbol, ColoredPhyrexianManaSymbol,
+            GenericHybridManaSymbol, FiveColorHybridManaSymbol,
+            FourColorHybridManaSymbol, ThreeColorHybridManaSymbol,
+            TwoColorHybridManaSymbol, HalfManaSymbol,
+            ColorlessPhyrexianManaSymbol,
+            GenericManaSymbol, VariableManaSymbol, InfiniteManaSymbol,
+            TypedManaSymbol, ColoredManaSymbol, ColorlessManaSymbol
         ];
     }
 
@@ -35,4 +38,16 @@ export default class ManaCost extends Cost {
             return devotion + (sym.colors.includes(color) ? 1 : 0);
         }, 0);
     }
+
+    equals(other) {
+        return arrayEquals(this.symbols, other.symbols);
+    }
+
+    greaterThan(other) {
+        return arrayGreaterThan(this.symbols, other.symbols);
+    }
+
+    lessThan(other) {
+        return arrayLessThan(this.symbols, other.symbols);
+    }
 }

package/src/customErrors.js

@@ -4,3 +4,17 @@ export class NotImplementedError extends Error {
         this.name = 'NotImplementedError';
     }
 }
+
+export class SchemaError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SchemaError';
+    }
+}
+
+export class AlreadyRegisteredError extends Error {
+    constructor(label, id) {
+        super(`${label} with id "${id}" already registered`);
+        this.name = 'AlreadyRegisteredError';
+    }
+}

package/src/index.js

@@ -1,4 +1,26 @@
 import ActivationCost from './costs/ActivationCost.js';
 import ManaCost from './costs/ManaCost.js';
+import symbolRegistry from './services/SymbolRegistry.js';
 
-export { ActivationCost, ManaCost };
+const baseColors = [
+    { id: 'W', name: 'White' },
+    { id: 'U', name: 'Blue'  },
+    { id: 'B', name: 'Black' },
+    { id: 'R', name: 'Red'   },
+    { id: 'G', name: 'Green' },
+];
+
+const baseTypes = [
+    { id: 'S', name: 'Snow',     },
+    { id: 'L', name: 'Legendary' },
+];
+
+const extraSymbols = [
+    { id: 'E', name: 'Energy' }
+];
+
+baseColors.forEach(color => symbolRegistry.addColor(color));
+baseTypes.forEach(type => symbolRegistry.addManaType(type));
+extraSymbols.forEach(type => symbolRegistry.addExtraSym(type));
+
+export { ActivationCost, ManaCost, symbolRegistry };

package/src/services/SymbolRegistry.js

@@ -0,0 +1,80 @@
+import { AlreadyRegisteredError, SchemaError } from '../customErrors.js';
+
+const ReservedIds = {
+    H: 'Phyrexian',
+    I: 'Infinite Mana',
+    Q: 'Untap',
+    T: 'Tap',
+    X: 'Variable Mana',
+    Y: 'Variable Mana',
+    Z: 'Variable Mana',
+};
+
+function isEscapedChar(str) {
+    return str.length === 2 && str[0] === '\\';
+}
+
+function validateSchema(item, label) {
+    if (!item.id || item.id.constructor !== String)
+        throw new SchemaError(`${label} must have a string property "id"`);
+    if (item.id.length !== 1 && !isEscapedChar(item.id))
+        throw new SchemaError(`${label} property "id" length must be 1`);
+    if (ReservedIds.hasOwnProperty(item.id))
+        throw new SchemaError(
+            `${label} id "${item.id}" is not allowed (used for ${ReservedIds[item.id]})`
+        );
+    if (!item.name || item.name.constructor !== String)
+        throw new SchemaError(`${label} must have a string property "name"`);
+}
+
+class SymbolRegistry {
+    constructor() {
+        this.colors = new Map();
+        this.manaTypes = new Map();
+        this.extraSymbols = new Map();
+    }
+
+    checkIfRegistered(key) {
+        if (this.colors.has(key))
+            throw new AlreadyRegisteredError('Color', key);
+        if (this.manaTypes.has(key))
+            throw new AlreadyRegisteredError('ManaType', key);
+        if (this.extraSymbols.has(key))
+            throw new AlreadyRegisteredError('ExtraSym', key);
+    }
+
+    addColor(item) {
+        validateSchema(item, 'Color');
+        const key = item.id;
+        this.checkIfRegistered(key);
+        this.colors.set(key, item);
+    }
+
+    addManaType(item) {
+        validateSchema(item, 'ManaType');
+        const key = item.id;
+        this.checkIfRegistered(key);
+        this.manaTypes.set(key, item);
+    }
+
+    addExtraSym(item) {
+        validateSchema(item, 'ExtraSym');
+        const key = item.id;
+        this.checkIfRegistered(key);
+        this.extraSymbols.set(key, item);
+    }
+
+    get colorKeys() {
+        return [...this.colors.keys()];
+    }
+
+    get manaTypeKeys() {
+        return [...this.manaTypes.keys()];
+    }
+
+    get extraSymKeys() {
+        return [...this.extraSymbols.keys()];
+    }
+}
+
+export default new SymbolRegistry();

package/src/services/regExpService.js

@@ -0,0 +1,12 @@
+import symbolRegistry from './SymbolRegistry.js';
+
+export function msr(str) {
+    const colorKeys = symbolRegistry.colorKeys.join('');
+    const mTypeKeys = symbolRegistry.manaTypeKeys.join('');
+    const extraKeys = symbolRegistry.extraSymKeys.join('');
+    const pstr = str.raw[0]
+        .replaceAll('\\c', '[' + colorKeys + ']')
+        .replaceAll('\\T', '[' + mTypeKeys + ']')
+        .replaceAll('\\#', '[' + extraKeys + ']');
+    return new RegExp(`^({${pstr}}|${pstr})`, 'i');
+}

package/src/symbols/ColoredManaSymbol.js

@@ -1,9 +1,9 @@
 import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class ColoredManaSymbol extends Symbol {
     static match(str) {
-        return str.match(/^{[WUBRG]}/i)
-            || str.match(/^[WUBRG]/i);
+        return str.match(msr`\c`)
     }
 
     get colors() {

package/src/symbols/ColoredPhyrexianManaSymbol.js

@@ -1,9 +1,9 @@
 import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class ColoredPhyrexianManaSymbol extends Symbol {
     static match(str) {
-        return str.match(/^{(h\/[wubrg]|[wubrg]\/h)}/i)
-            || str.match(/^(h\/[wubrg]|[wubrg]\/h)/i);
+        return str.match(msr`(H\/\c|\c\/H)`);
     }
 
     get colors() {

package/src/symbols/ColorlessManaSymbol.js

@@ -1,9 +1,9 @@
 import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class ColorlessManaSymbol extends Symbol {
     static match(str) {
-        return str.match(/^{C}/i)
-            || str.match(/^C/i);
+        return str.match(msr`C`);
     }
 
     get colors() {

package/src/symbols/ColorlessPhyrexianManaSymbol.js

@@ -1,9 +1,9 @@
 import ColorlessManaSymbol from './ColorlessManaSymbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class ColorlessPhyrexianManaSymbol extends ColorlessManaSymbol {
     static match(str) {
-        return str.match(/^{(h\/c|c\/h|h)}/i)
-            || str.match(/^(h\/c|c\/h|h)/i);
+        return str.match(msr`(H\/c|c\/H|H)`);
     }
 
     get type() {

package/src/symbols/ExtraSymbol.js

@@ -0,0 +1,12 @@
+import NonManaSymbol from './NonManaSymbol.js';
+import { msr } from '../services/regExpService.js';
+
+export default class ExtraSymbol extends NonManaSymbol {
+    static match(str) {
+        return str.match(msr`\#`);
+    }
+
+    get type() {
+        return 'extra';
+    }
+}

package/src/symbols/FiveColorHybridManaSymbol.js

@@ -1,9 +1,9 @@
 import HybridManaSymbol from './HybridManaSymbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class FiveColorHybridManaSymbol extends HybridManaSymbol {
     static match(str) {
-        return super.match(str, 5, /^{[WUBRG](\/[WUBRG]){4}}/i)
-            || super.match(str, 5, /^[WUBRG](\/[WUBRG]){4}/i);
+        return super.match(str, 5, msr`\c(\/\c){4}`);
     }
 
     get type() {

package/src/symbols/FourColorHybridManaSymbol.js

@@ -1,9 +1,9 @@
 import HybridManaSymbol from './HybridManaSymbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class FourColorHybridManaSymbol extends HybridManaSymbol {
     static match(str) {
-        return super.match(str, 4, /^{[WUBRG](\/[WUBRG]){3}}/i)
-            || super.match(str, 4, /^[WUBRG](\/[WUBRG]){3}/i);
+        return super.match(str, 4, msr`\c(\/\c){3}`);
     }
 
     get type() {

package/src/symbols/GenericHybridManaSymbol.js

@@ -1,9 +1,9 @@
 import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class GenericHybridManaSymbol extends Symbol {
     static match(str) {
-        return str.match(/^{\d\/([WUBRGC])}/i)
-            || str.match(/^\d\/([WUBRGC])/i)
+        return str.match(msr`\d\/(\c|c)`);
     }
 
     get colors() {

package/src/symbols/GenericManaSymbol.js

@@ -1,9 +1,9 @@
 import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class GenericManaSymbol extends Symbol {
     static match(str) {
-        return str.match(/^{[0-9][0-9]?}/)
-            || str.match(/^[0-9][0-9]?/);
+        return str.match(msr`[0-9][0-9]?`);
     }
 
     get type() {

package/src/symbols/HalfManaSymbol.js

@@ -0,0 +1,23 @@
+import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
+import { symbolRegistry } from '../index.js';
+
+export default class HalfManaSymbol extends Symbol {
+    static match(str) {
+        return str.match(msr`\|(\c|\T)`);
+    }
+
+    get colors() {
+        const c = this.raw[1];
+        const colorIds = symbolRegistry.colorKeys;
+        return colorIds.includes(c) ? [c] : [];
+    }
+
+    get type() {
+        return 'halfMana';
+    }
+
+    cmcValue() {
+        return 0.5;
+    }
+}

package/src/symbols/HybridPhyrexianManaSymbol.js

@@ -0,0 +1,16 @@
+import HybridManaSymbol from './HybridManaSymbol.js';
+import { msr } from '../services/regExpService.js';
+
+export default class HybridPhyrexianManaSymbol extends HybridManaSymbol {
+    static match(str) {
+        return super.match(str, 3, msr`(H\/\c\/\c|\c\/H\/\c|\c\/\c\/H)`);
+    }
+
+    get colors() {
+        return this.raw.split('/').filter(c => c !== 'H');
+    }
+
+    get type() {
+        return 'hybridPhyrexianMana';
+    }
+}

package/src/symbols/InfiniteManaSymbol.js

@@ -1,9 +1,9 @@
 import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class InfiniteManaSymbol extends Symbol {
     static match(str) {
-        return str.match(/^{I}/i)
-            || str.match(/^I/i)
+        return str.match(msr`I`);
     }
 
     get type() {

package/src/symbols/TapSymbol.js

@@ -1,9 +1,9 @@
 import NonManaSymbol from './NonManaSymbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class TapSymbol extends NonManaSymbol {
     static match(str) {
-        return str.match(/^{T}/i)
-            || str.match(/^T/i);
+        return str.match(msr`T`);
     }
 
     get type() {

package/src/symbols/ThreeColorHybridManaSymbol.js

@@ -1,9 +1,9 @@
 import HybridManaSymbol from './HybridManaSymbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class ThreeColorHybridManaSymbol extends HybridManaSymbol {
     static match(str) {
-        return super.match(str, 3, /^{[WUBRG](\/[WUBRG]){2}}/i)
-            || super.match(str, 3, /^[WUBRG](\/[WUBRG]){2}/i);
+        return super.match(str, 3, msr`\c(\/\c){2}`);
     }
 
     get type() {

package/src/symbols/TwoColorHybridManaSymbol.js

@@ -1,9 +1,9 @@
 import HybridManaSymbol from './HybridManaSymbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class TwoColorHybridManaSymbol extends HybridManaSymbol {
     static match(str) {
-        return super.match(str, 2, /^{[WUBRG]\/[WUBRG]}/i)
-            || super.match(str, 2, /^[WUBRG]\/[WUBRG]/i);
+        return super.match(str, 2, msr`\c\/\c`);
     }
 
     get type() {

package/src/symbols/TypedManaSymbol.js

@@ -0,0 +1,21 @@
+import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
+
+// used for typed mana, like snow or legendary
+export default class TypedManaSymbol extends Symbol {
+    static match(str) {
+        return str.match(msr`\T`);
+    }
+
+    get colors() {
+        return [];
+    }
+
+    get type() {
+        return 'typedMana';
+    }
+
+    cmcValue() {
+        return 1;
+    }
+}

package/src/symbols/UntapSymbol.js

@@ -1,9 +1,9 @@
 import NonManaSymbol from './NonManaSymbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class UntapSymbol extends NonManaSymbol {
     static match(str) {
-        return str.match(/^{Q}/i)
-            || str.match(/^Q/i);
+        return str.match(msr`Q`);
     }
 
     get type() {

package/src/symbols/VariableManaSymbol.js

@@ -1,9 +1,9 @@
 import Symbol from './Symbol.js';
+import { msr } from '../services/regExpService.js';
 
 export default class VariableManaSymbol extends Symbol {
     static match(str) {
-        return str.match(/^{[XYZ]}/i)
-            || str.match(/^[XYZ]/i);
+        return str.match(msr`[XYZ]`);
     }
 
     get type() {

package/src/symbols/EnergySymbol.js

@@ -1,12 +0,0 @@
-import NonManaSymbol from './NonManaSymbol.js';
-
-export default class EnergySymbol extends NonManaSymbol {
-    static match(str) {
-        return str.match(/^{E}/i)
-            || str.match(/^E/i);
-    }
-
-    get type() {
-        return 'energy';
-    }
-}

package/src/symbols/HalfColoredManaSymbol.js

@@ -1,21 +0,0 @@
-import Symbol from './Symbol.js';
-
-export default class HalfColoredManaSymbol extends Symbol {
-    static match(str) {
-        return str.match(/^{\|[WUBRGS]}/i)
-            || str.match(/^\|[WUBRGS]/i);
-    }
-
-    get colors() {
-        const c = this.raw[1];
-        return c === 'S' ? [] : [c];
-    }
-
-    get type() {
-        return 'halfColoredMana';
-    }
-
-    cmcValue() {
-        return 0.5;
-    }
-}

package/src/symbols/SnowManaSymbol.js

@@ -1,20 +0,0 @@
-import Symbol from './Symbol.js';
-
-export default class SnowManaSymbol extends Symbol {
-    static match(str) {
-        return str.match(/^{S}/i)
-            || str.match(/^S/i);
-    }
-
-    get colors() {
-        return [];
-    }
-
-    get type() {
-        return 'snowMana';
-    }
-
-    cmcValue() {
-        return 1;
-    }
-}