@bablr/language-en-regex-vm-pattern 0.7.1 → 0.9.0

package/lib/grammar.macro.js

@@ -1,14 +1,25 @@
-import { i, re } from '@bablr/boot/shorthand.macro';
+import { re, spam as m } from '@bablr/boot';
 import {
   Node,
   CoveredBy,
   InjectFrom,
-  UnboundAttributes,
+  UndefinedAttributes,
   AllowEmpty,
+  Literal,
 } from '@bablr/helpers/decorators';
 import objectEntries from 'iter-tools-es/methods/object-entries';
 import * as Shared from '@bablr/helpers/productions';
-import { buildString, buildBoolean, buildNumber, buildNullTag } from '@bablr/helpers/builders';
+import {
+  eat,
+  eatMatch,
+  match,
+  holdForMatch,
+  guard,
+  defineAttribute,
+  fail,
+  o,
+} from '@bablr/helpers/grammar';
+import { buildString, buildBoolean } from '@bablr/helpers/builders';
 
 export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-regex-pattern';
 
@@ -66,17 +77,17 @@ const getSpecialPattern = (span) => {
 export const grammar = class RegexGrammar {
   @Node
   *Pattern() {
-    yield i`eat(<*Punctuator '/' balanced='/' balancedSpan='Pattern' /> 'openToken')`;
-    yield i`eat(<Alternatives />)`;
-    yield i`eat(<*Punctuator '/' balancer /> 'closeToken')`;
-    yield i`eat(<Flags /> 'flags$')`;
+    yield eat(m`openToken: <*Punctuator '/' { balanced: '/', balancedSpan: 'Pattern' } />`);
+    yield eat(m`<_Alternatives />`);
+    yield eat(m`closeToken: <*Punctuator '/' { balancer: true } />`);
+    yield eat(m`flags$: <Flags />`);
   }
 
-  @UnboundAttributes(Object.keys(flagCharacters))
+  @UndefinedAttributes(Object.keys(flagCharacters))
   @AllowEmpty
   @Node
   *Flags({ ctx }) {
-    const flags = yield i`match(/[gimsuy]+/)`;
+    const flags = yield match(re`/[gimsuy]+/`);
 
     const flagsStr = ctx.sourceTextFor(flags) || '';
 
@@ -84,212 +95,216 @@ export const grammar = class RegexGrammar {
 
     for (const { 0: name, 1: chr } of Object.entries(flagCharacters)) {
       if (flagsStr.includes(chr)) {
-        yield i`bindAttribute(${buildString(name)} true)`;
+        yield defineAttribute(name, true);
       } else {
-        yield i`bindAttribute(${buildString(name)} false)`;
+        yield defineAttribute(name, false);
       }
     }
 
     for (const flagChr of flagsStr) {
-      yield i`eat(<*Keyword ${buildString(flagChr)} /> 'tokens[]')`;
+      yield eat(m`tokens[]: <*Keyword ${buildString(flagChr)} />`);
     }
   }
 
   @AllowEmpty
   *Alternatives() {
     do {
-      yield i`eat(<Alternative /> 'alternatives[]$')`;
-    } while (yield i`eatMatch(<*Punctuator '|' /> 'separators[]')`);
+      yield eat(m`alternatives[]$: <Alternative />`);
+    } while (yield eatMatch(m`separatorTokens[]: <*Punctuator '|' />`));
   }
 
   @AllowEmpty
   @Node
   *Alternative() {
-    yield i`eat(<Elements /> 'elements[]$')`;
+    yield eat(m`elements[]+$: <_Elements />`);
   }
 
   @AllowEmpty
   *Elements() {
-    yield i`eat([])`;
-    while (yield i`match(/[^|]/)`) {
-      yield i`eat(<+Element />)`;
+    yield eat(m`.[]: []`);
+    while (yield match(re`/[^|]/`)) {
+      yield eat(m`.[]+: <__Element />`);
     }
   }
 
   *Element() {
-    yield i`guard(<*Keyword /[*+?]/ />)`;
-
-    yield i`eat(<Any /> null [
-        <+CharacterClass '[' />
-        <+Group '(?:' />
-        <+Assertion /[$^]|\\b/i />
-        <+Gap '\\g' />
-        <+CharacterSet /\.|\\[dswp]/i />
-        <*+Character />
-      ])`;
-
-    if (yield i`match(/[*+?{]/)`) {
-      return i`holdForMatch(<Quantifier />)`;
+    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 holdForMatch(m`<Quantifier />`);
     }
   }
 
   @CoveredBy('Element')
   @Node
   *Group() {
-    yield i`eat(<*Punctuator '(?:' balanced=')' /> 'openToken')`;
-    yield i`eat(<Alternatives />)`;
-    yield i`eat(<*Punctuator ')' balancer /> 'closeToken')`;
+    yield eat(m`openToken: <*Punctuator '(?:' { balanced: ')' } />`);
+    yield eat(m`<_Alternatives />`);
+    yield eat(m`closeToken: <*Punctuator ')' { balancer: true } />`);
   }
 
   @Node
   *CapturingGroup() {
-    yield i`eat(<*Punctuator '(' balanced=')' /> 'openToken')`;
-    yield i`eat(<Alternatives />)`;
-    yield i`eat(<*Punctuator ')' balancer /> 'closeToken')`;
+    yield eat(m`openToken: <*Punctuator '(' { balanced: ')' } />`);
+    yield eat(m`<_Alternatives />`);
+    yield eat(m`closeToken: <*Punctuator ')' { balancer: true } />`);
   }
 
   @CoveredBy('Element')
   *Assertion() {
-    yield i`eat(<Any /> null [
-      <*StartOfInputAssertion '^' />
-      <*EndOfInputAssertion '$' />
-      <*@WordBoundaryAssertion /\\b/i />
-    ])`;
+    yield eat(m`<_Any />`, [
+      m`<*StartOfInputAssertion '^' />`,
+      m`<*EndOfInputAssertion '$' />`,
+      m`<*WordBoundaryAssertion /\\b/i />`,
+    ]);
   }
 
   @CoveredBy('Assertion')
   @Node
   *StartOfInputAssertion() {
-    yield i`eat(<*Keyword '^' /> 'sigilToken')`;
+    yield eat(m`sigilToken: <*Keyword '^' />`);
   }
 
   @CoveredBy('Assertion')
   @Node
   *EndOfInputAssertion() {
-    yield i`eatMatch(<*Keyword '$' /> 'sigilToken')`;
+    yield eatMatch(m`sigilToken: <*Keyword '$' />`);
   }
 
-  @UnboundAttributes(['negate'])
+  @UndefinedAttributes(['negate'])
   @CoveredBy('Assertion')
   @Node
   *WordBoundaryAssertion({ ctx }) {
-    yield i`eatMatch(<*Punctuator '\\' /> 'escapeToken')`;
-    const m = yield i`eat(<*Keyword /b/i /> 'value')`;
-    yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(m) === 'B')})`;
+    yield eatMatch(m`escapeToken: <*Punctuator '\\' />`);
+    const m_ = yield eat(m`value: <*Keyword /b/i />`);
+    yield defineAttribute('negate', buildBoolean(ctx.sourceTextFor(m_) === 'B'));
   }
 
   @CoveredBy('Assertion')
   @Node
   *Gap() {
-    yield i`eatMatch(<*Punctuator '\\' /> 'escapeToken')`;
-    yield i`eat(<*Keyword 'g' /> 'value')`;
+    yield eatMatch(m`escapeToken: <*Punctuator '\\' />`);
+    yield eat(m`value: <*Keyword 'g' />`);
   }
 
   @CoveredBy('Element')
   @CoveredBy('CharacterClassElement')
   @Node
   *Character() {
-    if (yield i`match('\\')`) {
-      yield i`eat(<@EscapeSequence /> null)`;
+    if (yield match('\\')) {
+      yield eat(m`@: <EscapeSequence />`);
     } else {
-      yield i`eat(/[^\r\n\t]/)`;
+      yield eat(re`/[^\r\n\t]/`);
     }
   }
 
-  @UnboundAttributes(['negate'])
+  @UndefinedAttributes(['negate'])
   @CoveredBy('Element')
   @Node
   *CharacterClass() {
-    yield i`eat(<*Punctuator '[' balancedSpan='CharacterClass' balanced=']' /> 'openToken')`;
+    yield eat(m`openToken: <*Punctuator '[' { balancedSpan: 'CharacterClass', balanced: ']' } />`);
 
-    let neg = yield i`eatMatch(<*Keyword '^' /> 'negateToken')`;
+    let negate = yield eatMatch(m`negateToken: <*Keyword '^' />`, null, o({ bind: true }));
 
-    yield i`bindAttribute('negate' ${buildBoolean(neg)})`;
+    yield defineAttribute('negate', !!negate);
 
-    while (yield i`match(/./s)`) {
-      yield i`eat(<+CharacterClassElement /> 'elements[]$')`;
+    while (yield match(re`/./s`)) {
+      yield eat(m`elements[]+$: <__CharacterClassElement />`);
     }
 
-    yield i`eat(<*Punctuator ']' balancer /> 'closeToken')`;
+    yield eat(m`closeToken: <*Punctuator ']' { balancer: true } />`);
   }
 
   *CharacterClassElement() {
-    yield i`eat(<Any /> null [
-        <CharacterSet /\\[dswp]/i />
-        <Gap '\\g' />
-        <*+Character />
-      ])`;
-
-    if (yield i`match('-')`) {
-      return i`holdForMatch(<+CharacterClassRange />)`;
+    yield eat(m`<_Any />`, [
+      m`<__CharacterSet /\\[dswp]/i />`,
+      m`<Gap '\\g' />`,
+      m`<*Character />`,
+    ]);
+
+    if (yield match('-')) {
+      return holdForMatch(m`<CharacterClassRange />`);
     }
   }
 
   @CoveredBy('CharacterClassElement')
   @Node
   *CharacterClassRange() {
-    yield i`eat(<*+Character /> 'min$')`;
-    yield i`eat(<*Punctuator '-' /> 'sigilToken')`;
-    yield i`eat(<*+Character /> 'max$')`;
+    yield eat(m`min+$: <*Character />`);
+    yield eat(m`sigilToken: <*Punctuator '-' />`);
+    yield eat(m`max+$: <*Character />`);
   }
 
   @CoveredBy('Element')
   *CharacterSet() {
-    yield i`eat(<Any /> null [
-      <+AnyCharacterSet '.' />
-      <+DigitCharacterSet /\\[dD]/  />
-      <+SpaceCharacterSet /\\[sS]/  />
-      <+WordCharacterSet /\\[wW]/  />
-    ])`;
+    yield eat(m`<_Any />`, [
+      m`<AnyCharacterSet '.' />`,
+      m`<DigitCharacterSet /\\[dD]/  />`,
+      m`<SpaceCharacterSet /\\[sS]/  />`,
+      m`<WordCharacterSet /\\[wW]/  />`,
+    ]);
   }
 
+  @CoveredBy('Element')
   @CoveredBy('CharacterSet')
   @Node
   *AnyCharacterSet() {
-    yield i`eat(<*Keyword '.' /> 'sigilToken')`;
+    yield eat(m`sigilToken: <*Keyword '.' />`);
   }
 
-  @UnboundAttributes(['negate'])
+  @UndefinedAttributes(['negate'])
+  @CoveredBy('Element')
   @CoveredBy('CharacterSet')
   @Node
   *DigitCharacterSet({ ctx }) {
-    yield i`eat(<*Punctuator '\\' /> 'escapeToken')`;
+    yield eat(m`escapeToken: <*Punctuator '\\' />`);
 
-    let code = yield i`eat(<*Keyword /[dD]/ /> 'value')`;
+    let code = yield eat(m`value: <*Keyword /[dD]/ />`);
 
-    yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(code) === 'D')})`;
+    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'D');
   }
 
-  @UnboundAttributes(['negate'])
+  @UndefinedAttributes(['negate'])
+  @CoveredBy('Element')
   @CoveredBy('CharacterSet')
   @Node
   *SpaceCharacterSet({ ctx }) {
-    yield i`eat(<*Punctuator '\\' /> 'escapeToken')`;
+    yield eat(m`escapeToken: <*Punctuator '\\' />`);
 
-    let code = yield i`eat(<*Keyword /[sS]/ /> 'value')`;
+    let code = yield eat(m`value: <*Keyword /[sS]/ />`);
 
-    yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(code) === 'S')})`;
+    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'S');
   }
 
-  @UnboundAttributes(['negate'])
+  @UndefinedAttributes(['negate'])
+  @CoveredBy('Element')
   @CoveredBy('CharacterSet')
   @Node
   *WordCharacterSet({ ctx }) {
-    yield i`eat(<*Punctuator '\\' /> 'escapeToken')`;
+    yield eat(m`escapeToken: <*Punctuator '\\' />`);
 
-    let code = yield i`eat(<*Keyword /[wW]/ /> 'value')`;
+    let code = yield eat(m`value: <*Keyword /[wW]/ />`);
 
-    yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(code) === 'W')})`;
+    yield defineAttribute('negate', ctx.sourceTextFor(code) === 'W');
   }
 
-  @UnboundAttributes(['min', 'max'])
+  @UndefinedAttributes(['min', 'max'])
   @Node
   *Quantifier({ ctx }) {
-    yield i`eat(<+Element /> 'element$')`;
+    yield eat(m`element+$: <__Element />`);
 
     let attrs, sigil;
 
-    if ((sigil = yield i`eatMatch(<*Keyword /[*+?]/ /> 'sigilToken')`)) {
+    if ((sigil = yield eatMatch(m`sigilToken: <*Keyword /[*+?]/ />`))) {
       switch (ctx.sourceTextFor(sigil)) {
         case '*':
           attrs = { min: 0, max: Infinity };
@@ -301,12 +316,12 @@ export const grammar = class RegexGrammar {
           attrs = { min: 0, max: 1 };
           break;
       }
-    } else if (yield i`eat(<*Punctuator '{' balanced='}' /> 'openToken')`) {
+    } else if (yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`)) {
       let max;
-      let min = yield i`eat(<*UnsignedInteger /> 'min$')`;
+      let min = yield eat(m`min$: <*UnsignedInteger />`);
 
-      if (yield i`eatMatch(<*Punctuator ',' /> 'separator')`) {
-        max = yield i`eatMatch(<*UnsignedInteger /> 'max$')`;
+      if (yield eatMatch(m`separator: <*Punctuator ',' />`)) {
+        max = yield eatMatch(m`max$: <*UnsignedInteger />`);
       }
 
       min = min && ctx.sourceTextFor(min);
@@ -317,74 +332,79 @@ export const grammar = class RegexGrammar {
 
       attrs = { min, max };
 
-      yield i`eat(<*Punctuator '}' balancer /> 'closeToken')`;
+      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
     }
 
-    yield i`bindAttribute('min' ${attrs.min ? buildNumber(attrs.min) : buildNullTag()})`;
-    yield i`bindAttribute('max' ${attrs.max ? buildNumber(attrs.max) : buildNullTag()})`;
+    yield defineAttribute('min', attrs.min);
+    yield defineAttribute('max', attrs.max);
   }
 
   @Node
   *UnsignedInteger() {
-    yield i`eat(/\d+/)`;
+    yield eat(re`/\d+/`);
+  }
+
+  @Node
+  *UnsignedHexInteger() {
+    yield eat(re`/[\da-fA-F]+/`);
   }
 
   @Node
-  *EscapeSequence({ state, ctx, value: props }) {
+  *EscapeSequence({ state, ctx }) {
     const parentSpan = state.span;
 
-    yield i`eat(<*Punctuator '\\' openSpan='Escape' /> 'escape')`;
+    yield eat(m`escape: <*Punctuator '\\' { openSpan: 'Escape' } />`);
 
-    let match;
+    let m_;
 
-    if ((match = yield i`match(/[\\/nrt0]/)`)) {
-      const match_ = ctx.sourceTextFor(match);
-      yield i`eat(<*Keyword ${buildString(match_)} closeSpan='Escape' /> 'code')`;
-    } else if (
-      (match = yield i`match(${getSpecialPattern(parentSpan, ctx.reifyExpression(props))})`)
-    ) {
-      const match_ = ctx.sourceTextFor(match);
-      yield i`eat(<*Keyword ${buildString(match_)} closeSpan='Escape' /> 'code')`;
-    } else if (yield i`match(/[ux]/)`) {
-      yield i`eat(<EscapeCode closeSpan='Escape' /> 'code')`;
+    if ((m_ = yield match(re`/[\\/nrt0]/`))) {
+      const match_ = ctx.sourceTextFor(m_);
+      yield eat(m`code: <*Keyword ${buildString(match_)} { closeSpan: 'Escape' } />`);
+    } else if ((m_ = yield match(getSpecialPattern(parentSpan)))) {
+      const match_ = ctx.sourceTextFor(m_);
+      yield eat(m`code: <*Keyword ${buildString(match_)} { closeSpan: 'Escape' } />`);
+    } else if (yield match(re`/[ux]/`)) {
+      yield eat(m`code: <EscapeCode { closeSpan: 'Escape' } />`);
     } else {
-      yield i`fail()`;
+      yield fail();
     }
   }
 
   @Node
   *EscapeCode() {
-    if (yield i`eatMatch(<*Keyword 'u' /> 'type')`) {
-      if (yield i`eatMatch(<*Punctuator '{' /> 'openToken')`) {
-        yield i`eatMatch(<*UnsignedInteger /> 'value$')`;
-        yield i`eat(<*Punctuator '}' /> 'closeToken')`;
+    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 i`eat(<*UnsignedInteger /\d{4}/ /> 'value$')`;
-        yield i`eat(null 'closeToken')`;
+        yield eat(m`value$: <*UnsignedHexInteger /[\da-fA-F]{4}/ />`);
+        yield eat(m`closeToken: null`);
       }
-    } else if (yield i`eatMatch(<*Keyword 'x' /> 'type')`) {
-      yield i`eat(null 'openToken')`;
-      yield i`eat(<*UnsignedInteger /\d{2}/ /> 'value$')`;
-      yield i`eat(null 'closeToken')`;
+    } 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 i`eatMatch(<*Digit />)`);
+    while (yield eatMatch(m`<*Digit />`));
   }
 
   @Node
   *Digit() {
-    yield i`eat(/\d/)`;
+    yield eat(re`/\d/`);
   }
 
   @InjectFrom(Shared)
   *Any() {}
 
+  @Literal
   @Node
   @InjectFrom(Shared)
   *Keyword() {}
 
+  @Literal
   @Node
   @InjectFrom(Shared)
   *Punctuator() {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/language-en-regex-vm-pattern",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "A BABLR language for nonbacktracking JS-style regexes",
   "engines": {
     "node": ">=12.0.0"
@@ -10,7 +10,9 @@
     ".": "./lib/grammar.js",
     "./package.json": "./package.json"
   },
-  "files": ["lib/**/*.js"],
+  "files": [
+    "lib/**/*.js"
+  ],
   "sideEffects": false,
   "scripts": {
     "build": "macrome build",
@@ -20,18 +22,18 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.23.2",
-    "@bablr/helpers": "^0.20.0",
-    "@bablr/agast-helpers": "^0.5.0",
-    "@bablr/agast-vm-helpers": "^0.5.0",
-    "iter-tools-es": "^7.5.3"
+    "@bablr/boot": "0.8.1",
+    "@bablr/helpers": "0.22.1",
+    "@bablr/agast-helpers": "0.7.1",
+    "@bablr/agast-vm-helpers": "0.7.1",
+    "iter-tools-es": "7.5.3"
   },
   "devDependencies": {
-    "@bablr/boot": "^0.6.0",
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
     "@bablr/macrome": "^0.1.3",
     "@bablr/macrome-generator-bablr": "^0.3.2",
     "@qnighy/dedent": "0.1.1",
-    "bablr": "^0.6.0",
+    "bablr": "^0.7.0",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.47.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
@@ -40,7 +42,12 @@
     "mocha": "^10.4.0",
     "prettier": "^2.0.5"
   },
-  "keywords": ["bablr-language", "grammar", "english", "regex"],
+  "keywords": [
+    "bablr-language",
+    "grammar",
+    "english",
+    "regex"
+  ],
   "repository": "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>",