@bablr/language-en-regex-vm-pattern 0.11.0 → 0.12.0

package/lib/grammar.js

@@ -1,36 +1,49 @@
-/* @macrome
- * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./grammar.macro.js#c3c390f3e54607dfde1d07c0e099e54294ab7f32
- * This file is autogenerated. Please do not edit it directly.
- * When editing run `npx macrome watch` then change the file this is generated from.
- */
-import _applyDecs from "@babel/runtime/helpers/applyDecs2305";
-let _initProto, _FlagsDecs, _GroupDecs, _AssertionDecs, _StartOfInputAssertionDecs, _EndOfInputAssertionDecs, _WordBoundaryAssertionDecs, _GapDecs, _CharacterDecs, _CharacterClassDecs, _CharacterClassRangeDecs, _CharacterSetDecs, _AnyCharacterSetDecs, _DigitCharacterSetDecs, _SpaceCharacterSetDecs, _WordCharacterSetDecs, _QuantifierDecs, _AnyDecs, _KeywordDecs, _PunctuatorDecs;
 import { re, spam as m } from '@bablr/boot';
-import { Node, CoveredBy, InjectFrom, UndefinedAttributes, AllowEmpty, Literal } from '@bablr/helpers/decorators';
 import objectEntries from 'iter-tools-es/methods/object-entries';
-import * as Shared from '@bablr/helpers/productions';
-import { eat, eatMatch, match, shiftMatch, guard, defineAttribute, fail, o } from '@bablr/helpers/grammar';
+import {
+  eat,
+  eatMatch,
+  match,
+  shiftMatch,
+  guard,
+  defineAttribute,
+  fail,
+  r,
+  startSpan,
+  endSpan,
+  eatHeld,
+} from '@bablr/helpers/grammar';
 import { buildString } from '@bablr/helpers/builders';
+import { get } from '@bablr/agast-helpers/path';
+import { printSource } from '@bablr/agast-helpers/tree';
+
 export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-regex-pattern';
+
 export const dependencies = {};
+
 export const defaultMatcher = m`<Pattern />`;
-const escapables = new Map(objectEntries({
-  n: '\n',
-  r: '\r',
-  t: '\t',
-  0: '\0'
-}));
+
+const escapables = new Map(
+  objectEntries({
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    0: '\0',
+  }),
+);
+
 const flagCharacters = {
   global: 'g',
   ignoreCase: 'i',
   multiline: 'm',
   dotAll: 's',
   unicode: 'u',
-  sticky: 'y'
+  sticky: 'y',
 };
-const unique = flags => flags.length === new Set(flags).size;
-const getSpecialPattern = span => {
+
+const unique = (flags) => flags.length === new Set(flags).size;
+
+const getSpecialPattern = (span) => {
   if (span === 'Pattern') {
     return re`/[*+?{}[\]().^$|\n\\<>]/`;
   } else if (span === 'CharacterClass') {
@@ -39,90 +52,123 @@ const getSpecialPattern = span => {
     throw new Error('unknown span type for special pattern');
   }
 };
+
 export const grammar = class RegexGrammar {
-  static {
-    [_initProto] = _applyDecs(this, [[Node, 2, "Pattern"], [_FlagsDecs, 2, "Flags"], [AllowEmpty, 2, "Alternatives"], [[AllowEmpty, Node], 2, "Alternative"], [AllowEmpty, 2, "Elements"], [_GroupDecs, 2, "Group"], [Node, 2, "CapturingGroup"], [_AssertionDecs, 2, "Assertion"], [_StartOfInputAssertionDecs, 2, "StartOfInputAssertion"], [_EndOfInputAssertionDecs, 2, "EndOfInputAssertion"], [_WordBoundaryAssertionDecs, 2, "WordBoundaryAssertion"], [_GapDecs, 2, "Gap"], [_CharacterDecs, 2, "Character"], [_CharacterClassDecs, 2, "CharacterClass"], [_CharacterClassRangeDecs, 2, "CharacterClassRange"], [_CharacterSetDecs, 2, "CharacterSet"], [_AnyCharacterSetDecs, 2, "AnyCharacterSet"], [_DigitCharacterSetDecs, 2, "DigitCharacterSet"], [_SpaceCharacterSetDecs, 2, "SpaceCharacterSet"], [_WordCharacterSetDecs, 2, "WordCharacterSet"], [_QuantifierDecs, 2, "Quantifier"], [Node, 2, "UnsignedInteger"], [Node, 2, "UnsignedHexInteger"], [Node, 2, "EscapeSequence"], [Node, 2, "EscapeCode"], [Node, 2, "Digit"], [_AnyDecs, 2, "Any"], [_KeywordDecs, 2, "Keyword"], [_PunctuatorDecs, 2, "Punctuator"]], []).e;
-  }
   constructor() {
-    _initProto(this);
-  }
-  *[(_FlagsDecs = [UndefinedAttributes(Object.keys(flagCharacters)), AllowEmpty, Node], _GroupDecs = [CoveredBy('Element'), Node], _AssertionDecs = CoveredBy('Element'), _StartOfInputAssertionDecs = [CoveredBy('Assertion'), Node], _EndOfInputAssertionDecs = [CoveredBy('Assertion'), Node], _WordBoundaryAssertionDecs = [UndefinedAttributes(['negate']), CoveredBy('Assertion'), Node], _GapDecs = [CoveredBy('Assertion'), Node], _CharacterDecs = [CoveredBy('Element'), CoveredBy('CharacterClassElement'), Node], _CharacterClassDecs = [UndefinedAttributes(['negate']), CoveredBy('Element'), Node], _CharacterClassRangeDecs = [CoveredBy('CharacterClassElement'), Node], _CharacterSetDecs = CoveredBy('Element'), _AnyCharacterSetDecs = [CoveredBy('Element'), CoveredBy('CharacterSet'), Node], _DigitCharacterSetDecs = [UndefinedAttributes(['negate']), CoveredBy('Element'), CoveredBy('CharacterSet'), Node], _SpaceCharacterSetDecs = [UndefinedAttributes(['negate']), CoveredBy('Element'), CoveredBy('CharacterSet'), Node], _WordCharacterSetDecs = [UndefinedAttributes(['negate']), CoveredBy('Element'), CoveredBy('CharacterSet'), Node], _QuantifierDecs = [UndefinedAttributes(['min', 'max']), Node], _AnyDecs = InjectFrom(Shared), _KeywordDecs = [Literal, Node, InjectFrom(Shared)], _PunctuatorDecs = [Literal, Node, InjectFrom(Shared)], "Pattern")]() {
-    yield eat(m`openToken: <*Punctuator '/' { balanced: '/', balancedSpan: 'Pattern' } />`);
+    this.literals = new Set(['Keyword']);
+    this.emptyables = new Set(['Alternatives', 'Alternative', 'Elements', 'Flags']);
+    this.attributes = new Map(
+      Object.entries({
+        Flags: Object.fromEntries(Object.keys(flagCharacters).map((key) => [key, undefined])),
+        WordBoundaryAssertion: { negate: undefined },
+        CharacterClass: { negate: undefined },
+        DigitCharacterSet: { negate: undefined },
+        SpaceCharacterSet: { negate: undefined },
+        WordCharacterSet: { negate: undefined },
+        Quantifier: { min: undefined, max: undefined },
+      }),
+    );
+  }
+
+  *Pattern() {
+    yield eat(m`openToken*: <* '/' />`);
+    yield startSpan('Pattern', '/');
     yield eat(m`<__Alternatives />`);
-    yield eat(m`closeToken: <*Punctuator '/' { balancer: true } />`);
-    yield eat(m`flags$: <Flags />`);
+    yield endSpan();
+    yield eat(m`closeToken*: <* '/' />`);
+    yield eat(m`flags: <Flags />`);
   }
-  *Flags({
-    ctx
-  }) {
+
+  *Flags() {
     const flags = yield match(re`/[gimsuy]+/`);
-    const flagsStr = ctx.sourceTextFor(flags) || '';
+
+    const flagsStr = printSource(flags) || '';
+
     if (flagsStr && !unique(flagsStr)) throw new Error('flags must be unique');
-    for (const {
-      0: name,
-      1: chr
-    } of Object.entries(flagCharacters)) {
+
+    for (const { 0: name, 1: chr } of Object.entries(flagCharacters)) {
       if (flagsStr.includes(chr)) {
         yield defineAttribute(name, true);
       } else {
         yield defineAttribute(name, false);
       }
     }
+
     for (const flagChr of flagsStr) {
-      yield eat(m`tokens[]: <*Keyword ${buildString(flagChr)} />`);
+      yield eat(m`tokens[]*: <*Keyword ${buildString(flagChr)} />`);
     }
   }
+
   *Alternatives() {
     do {
       yield eat(m`alternatives[]$: <Alternative />`);
-    } while (yield eatMatch(m`#separatorTokens[]: <*Punctuator '|' />`));
+    } while (yield eatMatch(m`#separatorTokens: <* '|' />`));
   }
+
   *Alternative() {
     yield eat(m`elements[]+$: <__Elements />`);
   }
-  *Elements() {
-    yield eat(m`.[]: []`);
+
+  *Elements({ matcher }) {
     while (yield match(re`/[^|]/`)) {
-      yield eat(m`.[]+: <_Element />`);
+      yield eat(m`${get('refMatcher', matcher)} <_Element />`);
     }
   }
+
   *Element() {
     yield guard(m`<*Keyword /[*+?]/ />`);
-    yield eat(m`<__Any />`, [m`<CharacterClass '[' />`, m`<Group '(?:' />`, m`<__Assertion /[$^]|\\b/i />`, m`<Gap '\\g' />`, m`<__CharacterSet /\.|\\[dswp]/i />`, m`<*Character />`]);
-    if (yield match(re`/[*+?{]/`)) {
-      return shiftMatch(m`<Quantifier />`);
+
+    if (yield eatMatch(m`<CharacterClass '[' />`)) {
+    } else if (yield eatMatch(m`<Group '(?:' />`)) {
+    } else if (yield eatMatch(m`<_Assertion /[$^]|\\b/i />`)) {
+    } else if (yield eatMatch(m`<Gap '\\g' />`)) {
+    } else if (yield eatMatch(m`<_CharacterSet /\.|\\[dswp]/i />`)) {
+    } else {
+      yield eat(m`<*Character />`);
     }
+
+    return r(shiftMatch(m`<Quantifier /[*+?{]/ />`));
   }
+
   *Group() {
-    yield eat(m`openToken: <*Punctuator '(?:' { balanced: ')' } />`);
+    yield eat(m`openToken*: <* '(?:' />`);
     yield eat(m`<__Alternatives />`);
-    yield eat(m`closeToken: <*Punctuator ')' { balancer: true } />`);
+    yield eat(m`closeToken*: <* ')' />`);
   }
+
   *CapturingGroup() {
-    yield eat(m`openToken: <*Punctuator '(' { balanced: ')' } />`);
+    yield eat(m`openToken*: <* '(' />`);
     yield eat(m`<__Alternatives />`);
-    yield eat(m`closeToken: <*Punctuator ')' { balancer: true } />`);
+    yield eat(m`closeToken*: <* ')' />`);
   }
+
   *Assertion() {
-    yield eat(m`<__Any />`, [m`<StartOfInputAssertion '^' />`, m`<EndOfInputAssertion '$' />`, m`<WordBoundaryAssertion /\\b/i />`]);
+    if (yield eatMatch(m`<StartOfInputAssertion '^' />`)) {
+    } else if (yield eatMatch(m`<EndOfInputAssertion '$' />`)) {
+    } else {
+      yield eat(m`<WordBoundaryAssertion /\\b/i />`);
+    }
   }
+
   *StartOfInputAssertion() {
-    yield eat(m`sigilToken: <*Keyword '^' />`);
+    yield eat(m`sigilToken*: <*Keyword '^' />`);
   }
+
   *EndOfInputAssertion() {
-    yield eatMatch(m`sigilToken: <*Keyword '$' />`);
+    yield eatMatch(m`sigilToken*: <*Keyword '$' />`);
   }
-  *WordBoundaryAssertion({
-    ctx
-  }) {
-    yield eatMatch(m`escapeToken: <*Punctuator '\\' />`);
-    const m_ = yield eat(m`value: <*Keyword /b/i />`);
-    yield defineAttribute('negate', ctx.sourceTextFor(m_) === 'B');
+
+  *WordBoundaryAssertion() {
+    yield eatMatch(m`escapeToken*: <* '\\' />`);
+    const m_ = yield eat(m`value*: <*Keyword /b/i />`);
+    yield defineAttribute('negate', printSource(m_.node) === 'B');
   }
+
   *Gap() {
-    yield eatMatch(m`escapeToken: <*Punctuator '\\' />`);
-    yield eat(m`value: <*Keyword 'g' />`);
+    yield eatMatch(m`escapeToken*: <* '\\' />`);
+    yield eat(m`value*: <*Keyword 'g' />`);
   }
+
   *Character() {
     if (yield match('\\')) {
       yield eat(m`@: <EscapeSequence />`);
@@ -130,154 +176,181 @@ export const grammar = class RegexGrammar {
       yield eat(re`/[^\r\n\t]/`);
     }
   }
+
   *CharacterClass() {
-    yield eat(m`openToken: <*Punctuator '[' { balancedSpan: 'CharacterClass', balanced: ']' } />`);
-    let negate = yield eatMatch(m`negateToken: <*Keyword '^' />`, null, o({
-      bind: true
-    }));
+    yield eat(m`openToken*: <* '[' />`);
+    yield startSpan('CharacterClass', ']');
+
+    let negate = yield eatMatch(m`negateToken*: <*Keyword '^' />`);
+
     yield defineAttribute('negate', !!negate);
-    while (yield match(re`/./s`)) {
+
+    while (yield match(re`/[^\]]/s`)) {
       yield eat(m`elements[]+$: <_CharacterClassElement />`);
     }
-    yield eat(m`closeToken: <*Punctuator ']' { balancer: true } />`);
+
+    yield endSpan();
+    yield eat(m`closeToken*: <* ']' />`);
   }
+
   *CharacterClassElement() {
-    yield eat(m`<__Any />`, [m`<__CharacterSet /\\[dswp]/i />`, m`<Gap '\\g' />`, m`<*Character />`]);
+    if (yield eatMatch(m`<_CharacterSet /\\[dswp]/i />`)) {
+    } else if (yield eatMatch(m`<Gap '\\g' />`)) {
+    } else {
+      yield eat(m`<*Character />`);
+    }
+
     if (yield match('-')) {
-      return shiftMatch(m`<CharacterClassRange />`);
+      return r(shiftMatch(m`<CharacterClassRange />`));
     }
   }
+
   *CharacterClassRange() {
-    yield eat(m`min+$: <*Character />`);
-    yield eat(m`sigilToken: <*Punctuator '-' />`);
+    yield eatHeld(m`min+$: <*Character />`);
+    yield eat(m`sigilToken*: <* '-' />`);
     yield eat(m`max+$: <*Character />`);
   }
+
   *CharacterSet() {
-    yield eat(m`<__Any />`, [m`<AnyCharacterSet '.' />`, m`<DigitCharacterSet /\\[dD]/  />`, m`<SpaceCharacterSet /\\[sS]/  />`, m`<WordCharacterSet /\\[wW]/  />`]);
+    if (yield eatMatch(m`<AnyCharacterSet '.' />`)) {
+    } else if (yield eatMatch(m`<DigitCharacterSet /\\[dD]/  />`)) {
+    } else if (yield eatMatch(m`<SpaceCharacterSet /\\[sS]/  />`)) {
+    } else {
+      yield eat(m`<WordCharacterSet /\\[wW]/ />`);
+    }
   }
+
   *AnyCharacterSet() {
-    yield eat(m`sigilToken: <*Keyword '.' />`);
-  }
-  *DigitCharacterSet({
-    ctx
-  }) {
-    yield eat(m`escapeToken: <*Punctuator '\\' />`);
-    let code = yield eat(m`value: <*Keyword /[dD]/ />`);
-    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'D');
-  }
-  *SpaceCharacterSet({
-    ctx
-  }) {
-    yield eat(m`escapeToken: <*Punctuator '\\' />`);
-    let code = yield eat(m`value: <*Keyword /[sS]/ />`);
-    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'S');
-  }
-  *WordCharacterSet({
-    ctx
-  }) {
-    yield eat(m`escapeToken: <*Punctuator '\\' />`);
-    let code = yield eat(m`value: <*Keyword /[wW]/ />`);
-    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'W');
-  }
-  *Quantifier({
-    ctx
-  }) {
-    yield eat(m`element+$: <_Element />`);
+    yield eat(m`sigilToken*: <*Keyword '.' />`);
+  }
+
+  *DigitCharacterSet() {
+    yield eat(m`escapeToken*: <* '\\' />`);
+
+    let code = yield eat(m`value*: <*Keyword /[dD]/ />`);
+
+    yield defineAttribute('negate', printSource(code.node) === 'D');
+  }
+
+  *SpaceCharacterSet() {
+    yield eat(m`escapeToken*: <* '\\' />`);
+
+    let code = yield eat(m`value*: <*Keyword /[sS]/ />`);
+
+    yield defineAttribute('negate', printSource(code.node) === 'S');
+  }
+
+  *WordCharacterSet() {
+    yield eat(m`escapeToken*: <* '\\' />`);
+
+    let code = yield eat(m`value*: <*Keyword /[wW]/ />`);
+
+    yield defineAttribute('negate', printSource(code.node) === 'W');
+  }
+
+  *Quantifier() {
+    yield eatHeld(m`element+$: <_Element />`);
+
     let attrs, sigil;
-    if (sigil = yield eatMatch(m`sigilToken: <*Keyword /[*+?]/ />`)) {
-      switch (ctx.sourceTextFor(sigil)) {
+
+    if ((sigil = yield eatMatch(m`sigilToken*: <*Keyword /[*+?]/ />`))) {
+      switch (printSource(sigil.node)) {
         case '*':
-          attrs = {
-            min: 0,
-            max: Infinity
-          };
+          attrs = { min: 0, max: Infinity };
           break;
         case '+':
-          attrs = {
-            min: 1,
-            max: Infinity
-          };
+          attrs = { min: 1, max: Infinity };
           break;
         case '?':
-          attrs = {
-            min: 0,
-            max: 1
-          };
+          attrs = { min: 0, max: 1 };
           break;
         default:
           yield fail();
       }
-    } else if (yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`)) {
+    } else if (yield eat(m`openToken*: <* '{' />`)) {
       let max;
       let min = yield eat(m`min$: <*UnsignedInteger />`);
-      if (yield eatMatch(m`separator: <*Punctuator ',' />`)) {
+
+      if (yield eatMatch(m`separator$: <* ',' />`)) {
         max = yield eatMatch(m`max$: <*UnsignedInteger />`);
       }
-      min = min && ctx.sourceTextFor(min);
-      max = max && ctx.sourceTextFor(max);
+
+      min = min && printSource(min.node);
+      max = max && printSource(max.node);
+
       min = min && parseInt(min, 10);
       max = max && parseInt(max, 10);
-      attrs = {
-        min,
-        max
-      };
-      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
+
+      attrs = { min, max };
+
+      yield eat(m`closeToken*: <* '}' />`);
     }
+
     yield defineAttribute('min', attrs.min);
     yield defineAttribute('max', attrs.max);
   }
+
   *UnsignedInteger() {
     yield eat(re`/\d+/`);
   }
+
   *UnsignedHexInteger() {
     yield eat(re`/[\da-fA-F]+/`);
   }
-  *EscapeSequence({
-    state,
-    ctx
-  }) {
-    const parentSpan = state.span;
-    yield eat(m`escape: <*Punctuator '\\' { openSpan: 'Escape' } />`);
+
+  *EscapeSequence({ s }) {
+    const parentSpan = s().span;
+
+    yield startSpan('Escape');
+
+    yield eat(m`escape*: <* '\\' />`);
+
     let m_;
     let cooked;
-    if (m_ = yield match(re`/[\\/nrt0]/`)) {
-      const match_ = ctx.sourceTextFor(m_);
-      yield eat(m`code: <*Keyword ${buildString(match_)} { closeSpan: 'Escape' } />`);
+
+    if ((m_ = yield match(re`/[\\/nrt0]/`))) {
+      const match_ = printSource(m_);
+      yield eat(m`code*: <*Keyword ${buildString(match_)} />`);
+
       cooked = escapables.get(match_) || match_;
-    } else if (m_ = yield match(getSpecialPattern(parentSpan))) {
-      cooked = ctx.sourceTextFor(m_);
-      yield eat(m`code: <*Keyword ${buildString(cooked)} { closeSpan: 'Escape' } />`);
+    } else if ((m_ = yield match(getSpecialPattern(parentSpan)))) {
+      cooked = printSource(m_);
+      yield eat(m`code*: <*Keyword ${buildString(cooked)} />`);
     } else if (yield match(re`/[ux]/`)) {
-      let code = yield eat(m`code: <EscapeCode { closeSpan: 'Escape' } />`);
-      let value = code.get('value');
-      cooked = String.fromCodePoint(parseInt(ctx.sourceTextFor(value), 16));
+      let code = yield eat(m`code*: <EscapeCode />`);
+
+      let value = get('value', code.node);
+
+      cooked = String.fromCodePoint(parseInt(printSource(value), 16));
     } else {
       yield fail();
     }
+
+    yield endSpan();
+
     yield defineAttribute('cooked', cooked);
   }
+
   *EscapeCode() {
-    if (yield eatMatch(m`type: <*Keyword 'u' />`)) {
-      if (yield eatMatch(m`openToken: <*Punctuator '{' />`)) {
-        yield eatMatch(m`value$: <*UnsignedHexInteger />`);
-        yield eat(m`closeToken: <*Punctuator '}' />`);
+    if (yield eatMatch(m`type*: <*Keyword 'u' />`)) {
+      if (yield eatMatch(m`openToken*: <* '{' />`)) {
+        yield eatMatch(m`value: <*UnsignedHexInteger />`);
+        yield eat(m`closeToken*: <* '}' />`);
       } else {
-        yield eat(m`value$: <*UnsignedHexInteger /[\da-fA-F]{4}/ />`);
-        yield eat(m`closeToken: null`);
+        yield eat(m`value: <*UnsignedHexInteger /[\da-fA-F]{4}/ />`);
       }
-    } else if (yield eatMatch(m`type: <*Keyword 'x' />`)) {
-      yield eat(m`openToken: null`);
-      yield eat(m`value$: <*UnsignedHexInteger /[\da-fA-F]{2}/ />`);
-      yield eat(m`closeToken: null`);
+    } else if (yield eatMatch(m`type*: <*Keyword 'x' />`)) {
+      yield eat(m`value: <*UnsignedHexInteger /[\da-fA-F]{2}/ />`);
     }
   }
+
   *Digits() {
     while (yield eatMatch(m`<*Digit />`));
   }
+
   *Digit() {
     yield eat(re`/\d/`);
   }
-  *Any() {}
-  *Keyword() {}
-  *Punctuator() {}
-};
+};
+
+export default { canonicalURL, dependencies, grammar, defaultMatcher };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/language-en-regex-vm-pattern",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "A BABLR language for nonbacktracking JS-style regexes",
   "engines": {
     "node": ">=12.0.0"
@@ -15,25 +15,19 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build": "macrome build",
-    "watch": "macrome watch",
-    "clean": "macrome clean",
     "test": "mocha"
   },
   "dependencies": {
-    "@babel/runtime": "7.28.2",
-    "@bablr/boot": "0.10.0",
-    "@bablr/helpers": "0.24.0",
-    "@bablr/agast-helpers": "0.9.0",
-    "@bablr/agast-vm-helpers": "0.9.0",
+    "@bablr/boot": "0.11.0",
+    "@bablr/helpers": "0.25.0",
+    "@bablr/agast-helpers": "0.10.0",
+    "@bablr/agast-vm-helpers": "0.10.0",
     "iter-tools-es": "7.5.3"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#c97bfa4b3663f8378e9b3e42bb5a41e685406cf9",
-    "@bablr/macrome": "^0.1.3",
-    "@bablr/macrome-generator-bablr": "^0.3.2",
     "@qnighy/dedent": "0.1.1",
-    "bablr": "^0.10.0",
+    "bablr": "^0.11.0",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.47.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
@@ -48,7 +42,10 @@
     "english",
     "regex"
   ],
-  "repository": "git@github.com:bablr-lang/language-en-regex-vm-pattern.git",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/bablr-lang/language-en-regex-vm-pattern.git"
+  },
   "homepage": "https://github.com/bablr-lang/language-en-regex-vm-pattern",
   "author": "Conrad Buck <conartist6@gmail.com>",
   "license": "MIT"

package/lib/grammar.macro.js

@@ -1,405 +0,0 @@
-import { re, spam as m } from '@bablr/boot';
-import {
-  Node,
-  CoveredBy,
-  InjectFrom,
-  UndefinedAttributes,
-  AllowEmpty,
-  Literal,
-} from '@bablr/helpers/decorators';
-import objectEntries from 'iter-tools-es/methods/object-entries';
-import * as Shared from '@bablr/helpers/productions';
-import {
-  eat,
-  eatMatch,
-  match,
-  shiftMatch,
-  guard,
-  defineAttribute,
-  fail,
-  o,
-} from '@bablr/helpers/grammar';
-import { buildString } from '@bablr/helpers/builders';
-
-export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-regex-pattern';
-
-export const dependencies = {};
-
-export const defaultMatcher = m`<Pattern />`;
-
-const escapables = new Map(
-  objectEntries({
-    n: '\n',
-    r: '\r',
-    t: '\t',
-    0: '\0',
-  }),
-);
-
-const flagCharacters = {
-  global: 'g',
-  ignoreCase: 'i',
-  multiline: 'm',
-  dotAll: 's',
-  unicode: 'u',
-  sticky: 'y',
-};
-
-const unique = (flags) => flags.length === new Set(flags).size;
-
-const getSpecialPattern = (span) => {
-  if (span === 'Pattern') {
-    return re`/[*+?{}[\]().^$|\n\\<>]/`;
-  } else if (span === 'CharacterClass') {
-    return re`/[\]\\]/`;
-  } else {
-    throw new Error('unknown span type for special pattern');
-  }
-};
-
-export const grammar = class RegexGrammar {
-  @Node
-  *Pattern() {
-    yield eat(m`openToken: <*Punctuator '/' { balanced: '/', balancedSpan: 'Pattern' } />`);
-    yield eat(m`<__Alternatives />`);
-    yield eat(m`closeToken: <*Punctuator '/' { balancer: true } />`);
-    yield eat(m`flags$: <Flags />`);
-  }
-
-  @UndefinedAttributes(Object.keys(flagCharacters))
-  @AllowEmpty
-  @Node
-  *Flags({ ctx }) {
-    const flags = yield match(re`/[gimsuy]+/`);
-
-    const flagsStr = ctx.sourceTextFor(flags) || '';
-
-    if (flagsStr && !unique(flagsStr)) throw new Error('flags must be unique');
-
-    for (const { 0: name, 1: chr } of Object.entries(flagCharacters)) {
-      if (flagsStr.includes(chr)) {
-        yield defineAttribute(name, true);
-      } else {
-        yield defineAttribute(name, false);
-      }
-    }
-
-    for (const flagChr of flagsStr) {
-      yield eat(m`tokens[]: <*Keyword ${buildString(flagChr)} />`);
-    }
-  }
-
-  @AllowEmpty
-  *Alternatives() {
-    do {
-      yield eat(m`alternatives[]$: <Alternative />`);
-    } while (yield eatMatch(m`#separatorTokens[]: <*Punctuator '|' />`));
-  }
-
-  @AllowEmpty
-  @Node
-  *Alternative() {
-    yield eat(m`elements[]+$: <__Elements />`);
-  }
-
-  @AllowEmpty
-  *Elements() {
-    yield eat(m`.[]: []`);
-    while (yield match(re`/[^|]/`)) {
-      yield eat(m`.[]+: <_Element />`);
-    }
-  }
-
-  *Element() {
-    yield guard(m`<*Keyword /[*+?]/ />`);
-
-    yield eat(m`<__Any />`, [
-      m`<CharacterClass '[' />`,
-      m`<Group '(?:' />`,
-      m`<__Assertion /[$^]|\\b/i />`,
-      m`<Gap '\\g' />`,
-      m`<__CharacterSet /\.|\\[dswp]/i />`,
-      m`<*Character />`,
-    ]);
-
-    if (yield match(re`/[*+?{]/`)) {
-      return shiftMatch(m`<Quantifier />`);
-    }
-  }
-
-  @CoveredBy('Element')
-  @Node
-  *Group() {
-    yield eat(m`openToken: <*Punctuator '(?:' { balanced: ')' } />`);
-    yield eat(m`<__Alternatives />`);
-    yield eat(m`closeToken: <*Punctuator ')' { balancer: true } />`);
-  }
-
-  @Node
-  *CapturingGroup() {
-    yield eat(m`openToken: <*Punctuator '(' { balanced: ')' } />`);
-    yield eat(m`<__Alternatives />`);
-    yield eat(m`closeToken: <*Punctuator ')' { balancer: true } />`);
-  }
-
-  @CoveredBy('Element')
-  *Assertion() {
-    yield eat(m`<__Any />`, [
-      m`<StartOfInputAssertion '^' />`,
-      m`<EndOfInputAssertion '$' />`,
-      m`<WordBoundaryAssertion /\\b/i />`,
-    ]);
-  }
-
-  @CoveredBy('Assertion')
-  @Node
-  *StartOfInputAssertion() {
-    yield eat(m`sigilToken: <*Keyword '^' />`);
-  }
-
-  @CoveredBy('Assertion')
-  @Node
-  *EndOfInputAssertion() {
-    yield eatMatch(m`sigilToken: <*Keyword '$' />`);
-  }
-
-  @UndefinedAttributes(['negate'])
-  @CoveredBy('Assertion')
-  @Node
-  *WordBoundaryAssertion({ ctx }) {
-    yield eatMatch(m`escapeToken: <*Punctuator '\\' />`);
-    const m_ = yield eat(m`value: <*Keyword /b/i />`);
-    yield defineAttribute('negate', ctx.sourceTextFor(m_) === 'B');
-  }
-
-  @CoveredBy('Assertion')
-  @Node
-  *Gap() {
-    yield eatMatch(m`escapeToken: <*Punctuator '\\' />`);
-    yield eat(m`value: <*Keyword 'g' />`);
-  }
-
-  @CoveredBy('Element')
-  @CoveredBy('CharacterClassElement')
-  @Node
-  *Character() {
-    if (yield match('\\')) {
-      yield eat(m`@: <EscapeSequence />`);
-    } else {
-      yield eat(re`/[^\r\n\t]/`);
-    }
-  }
-
-  @UndefinedAttributes(['negate'])
-  @CoveredBy('Element')
-  @Node
-  *CharacterClass() {
-    yield eat(m`openToken: <*Punctuator '[' { balancedSpan: 'CharacterClass', balanced: ']' } />`);
-
-    let negate = yield eatMatch(m`negateToken: <*Keyword '^' />`, null, o({ bind: true }));
-
-    yield defineAttribute('negate', !!negate);
-
-    while (yield match(re`/./s`)) {
-      yield eat(m`elements[]+$: <_CharacterClassElement />`);
-    }
-
-    yield eat(m`closeToken: <*Punctuator ']' { balancer: true } />`);
-  }
-
-  *CharacterClassElement() {
-    yield eat(m`<__Any />`, [
-      m`<__CharacterSet /\\[dswp]/i />`,
-      m`<Gap '\\g' />`,
-      m`<*Character />`,
-    ]);
-
-    if (yield match('-')) {
-      return shiftMatch(m`<CharacterClassRange />`);
-    }
-  }
-
-  @CoveredBy('CharacterClassElement')
-  @Node
-  *CharacterClassRange() {
-    yield eat(m`min+$: <*Character />`);
-    yield eat(m`sigilToken: <*Punctuator '-' />`);
-    yield eat(m`max+$: <*Character />`);
-  }
-
-  @CoveredBy('Element')
-  *CharacterSet() {
-    yield eat(m`<__Any />`, [
-      m`<AnyCharacterSet '.' />`,
-      m`<DigitCharacterSet /\\[dD]/  />`,
-      m`<SpaceCharacterSet /\\[sS]/  />`,
-      m`<WordCharacterSet /\\[wW]/  />`,
-    ]);
-  }
-
-  @CoveredBy('Element')
-  @CoveredBy('CharacterSet')
-  @Node
-  *AnyCharacterSet() {
-    yield eat(m`sigilToken: <*Keyword '.' />`);
-  }
-
-  @UndefinedAttributes(['negate'])
-  @CoveredBy('Element')
-  @CoveredBy('CharacterSet')
-  @Node
-  *DigitCharacterSet({ ctx }) {
-    yield eat(m`escapeToken: <*Punctuator '\\' />`);
-
-    let code = yield eat(m`value: <*Keyword /[dD]/ />`);
-
-    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'D');
-  }
-
-  @UndefinedAttributes(['negate'])
-  @CoveredBy('Element')
-  @CoveredBy('CharacterSet')
-  @Node
-  *SpaceCharacterSet({ ctx }) {
-    yield eat(m`escapeToken: <*Punctuator '\\' />`);
-
-    let code = yield eat(m`value: <*Keyword /[sS]/ />`);
-
-    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'S');
-  }
-
-  @UndefinedAttributes(['negate'])
-  @CoveredBy('Element')
-  @CoveredBy('CharacterSet')
-  @Node
-  *WordCharacterSet({ ctx }) {
-    yield eat(m`escapeToken: <*Punctuator '\\' />`);
-
-    let code = yield eat(m`value: <*Keyword /[wW]/ />`);
-
-    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'W');
-  }
-
-  @UndefinedAttributes(['min', 'max'])
-  @Node
-  *Quantifier({ ctx }) {
-    yield eat(m`element+$: <_Element />`);
-
-    let attrs, sigil;
-
-    if ((sigil = yield eatMatch(m`sigilToken: <*Keyword /[*+?]/ />`))) {
-      switch (ctx.sourceTextFor(sigil)) {
-        case '*':
-          attrs = { min: 0, max: Infinity };
-          break;
-        case '+':
-          attrs = { min: 1, max: Infinity };
-          break;
-        case '?':
-          attrs = { min: 0, max: 1 };
-          break;
-        default:
-          yield fail();
-      }
-    } else if (yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`)) {
-      let max;
-      let min = yield eat(m`min$: <*UnsignedInteger />`);
-
-      if (yield eatMatch(m`separator: <*Punctuator ',' />`)) {
-        max = yield eatMatch(m`max$: <*UnsignedInteger />`);
-      }
-
-      min = min && ctx.sourceTextFor(min);
-      max = max && ctx.sourceTextFor(max);
-
-      min = min && parseInt(min, 10);
-      max = max && parseInt(max, 10);
-
-      attrs = { min, max };
-
-      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
-    }
-
-    yield defineAttribute('min', attrs.min);
-    yield defineAttribute('max', attrs.max);
-  }
-
-  @Node
-  *UnsignedInteger() {
-    yield eat(re`/\d+/`);
-  }
-
-  @Node
-  *UnsignedHexInteger() {
-    yield eat(re`/[\da-fA-F]+/`);
-  }
-
-  @Node
-  *EscapeSequence({ state, ctx }) {
-    const parentSpan = state.span;
-
-    yield eat(m`escape: <*Punctuator '\\' { openSpan: 'Escape' } />`);
-
-    let m_;
-    let cooked;
-
-    if ((m_ = yield match(re`/[\\/nrt0]/`))) {
-      const match_ = ctx.sourceTextFor(m_);
-      yield eat(m`code: <*Keyword ${buildString(match_)} { closeSpan: 'Escape' } />`);
-
-      cooked = escapables.get(match_) || match_;
-    } else if ((m_ = yield match(getSpecialPattern(parentSpan)))) {
-      cooked = ctx.sourceTextFor(m_);
-      yield eat(m`code: <*Keyword ${buildString(cooked)} { closeSpan: 'Escape' } />`);
-    } else if (yield match(re`/[ux]/`)) {
-      let code = yield eat(m`code: <EscapeCode { closeSpan: 'Escape' } />`);
-
-      let value = code.get('value');
-
-      cooked = String.fromCodePoint(parseInt(ctx.sourceTextFor(value), 16));
-    } else {
-      yield fail();
-    }
-
-    yield defineAttribute('cooked', cooked);
-  }
-
-  @Node
-  *EscapeCode() {
-    if (yield eatMatch(m`type: <*Keyword 'u' />`)) {
-      if (yield eatMatch(m`openToken: <*Punctuator '{' />`)) {
-        yield eatMatch(m`value$: <*UnsignedHexInteger />`);
-        yield eat(m`closeToken: <*Punctuator '}' />`);
-      } else {
-        yield eat(m`value$: <*UnsignedHexInteger /[\da-fA-F]{4}/ />`);
-        yield eat(m`closeToken: null`);
-      }
-    } else if (yield eatMatch(m`type: <*Keyword 'x' />`)) {
-      yield eat(m`openToken: null`);
-      yield eat(m`value$: <*UnsignedHexInteger /[\da-fA-F]{2}/ />`);
-      yield eat(m`closeToken: null`);
-    }
-  }
-
-  *Digits() {
-    while (yield eatMatch(m`<*Digit />`));
-  }
-
-  @Node
-  *Digit() {
-    yield eat(re`/\d/`);
-  }
-
-  @InjectFrom(Shared)
-  *Any() {}
-
-  @Literal
-  @Node
-  @InjectFrom(Shared)
-  *Keyword() {}
-
-  @Literal
-  @Node
-  @InjectFrom(Shared)
-  *Punctuator() {}
-};