@bablr/language-en-regex-vm-pattern 0.5.1 → 0.7.0

package/lib/grammar.macro.js

@@ -1,8 +1,14 @@
 import { i, re } from '@bablr/boot/shorthand.macro';
-import { Node, CoveredBy, InjectFrom, Attributes, AllowEmpty } from '@bablr/helpers/decorators';
+import {
+  Node,
+  CoveredBy,
+  InjectFrom,
+  UnboundAttributes,
+  AllowEmpty,
+} from '@bablr/helpers/decorators';
 import objectEntries from 'iter-tools-es/methods/object-entries';
 import * as Shared from '@bablr/helpers/productions';
-import { buildString, buildBoolean, buildNumber, buildNull } from '@bablr/agast-vm-helpers';
+import { buildString, buildBoolean, buildNumber, buildNullTag } from '@bablr/agast-vm-helpers';
 
 export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-regex-pattern';
 
@@ -17,6 +23,25 @@ const escapables = new Map(
   }),
 );
 
+export const getCooked = (escapeNode, span, ctx) => {
+  let cooked;
+  const codeNode = escapeNode.get('code');
+  const type = ctx.sourceTextFor(codeNode.get('typeToken'));
+  const value = ctx.sourceTextFor(codeNode.get('value'));
+
+  if (!type) {
+    const match_ = ctx.sourceTextFor(codeNode);
+
+    cooked = escapables.get(match_) || match_;
+  } else if (type === 'u' || type === 'x') {
+    cooked = parseInt(value, 16);
+  } else {
+    throw new Error();
+  }
+
+  return cooked.toString(10);
+};
+
 const flagCharacters = {
   global: 'g',
   ignoreCase: 'i',
@@ -30,7 +55,7 @@ const unique = (flags) => flags.length === new Set(flags).size;
 
 const getSpecialPattern = (span) => {
   if (span === 'Pattern') {
-    return re`/[*+{}[\]().^$|\n\\]/`;
+    return re`/[*+{}[\]().^$|\n\\<>]/`;
   } else if (span === 'CharacterClass') {
     return re`/[\]\\]/`;
   } else {
@@ -41,13 +66,13 @@ 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 i`eat(<*Punctuator '/' balanced='/' balancedSpan='Pattern' /> 'openToken')`;
+    yield i`eat(<Alternatives />)`;
+    yield i`eat(<*Punctuator '/' balancer /> 'closeToken')`;
+    yield i`eat(<Flags /> 'flags$')`;
   }
 
-  @Attributes(Object.keys(flagCharacters))
+  @UnboundAttributes(Object.keys(flagCharacters))
   @AllowEmpty
   @Node
   *Flags({ ctx }) {
@@ -66,100 +91,98 @@ export const grammar = class RegexGrammar {
     }
 
     for (const flagChr of flagsStr) {
-      yield i`eat(<*Keyword ${buildString(flagChr)}> 'tokens[]')`;
+      yield i`eat(<*Keyword ${buildString(flagChr)} /> 'tokens[]')`;
     }
   }
 
   @AllowEmpty
   *Alternatives() {
     do {
-      yield i`eat(<Alternative> 'alternatives[]')`;
-    } while (yield i`eatMatch(<~*Punctuator '|'> 'separators[]')`);
+      yield i`eat(<Alternative /> 'alternatives[]$')`;
+    } while (yield i`eatMatch(<*Punctuator '|' /> 'separators[]')`);
   }
 
   @AllowEmpty
   @Node
   *Alternative() {
-    yield i`eat(<Elements>)`;
+    yield i`eat(<Elements /> 'elements[]$')`;
   }
 
   @AllowEmpty
   *Elements() {
-    let matched = false;
+    yield i`eat([])`;
     while (yield i`match(/[^|]/)`) {
-      matched = true;
-      yield i`eat(<+Element> 'elements[]')`;
+      yield i`eat(<+Element />)`;
     }
-    if (!matched) yield i`eat(null 'elements[]')`;
   }
 
   *Element() {
-    yield i`guard(<~*Keyword /[*+?]/>)`;
-
-    yield i`eat(<Any> null [
-        <+CharacterClass '['>
-        <+Group '(?:'>
-        <+Assertion /[$^]|\\b/i>
-        <+Gap '\\g'>
-        <+CharacterSet /\.|\\[dswp]/i>
-        <*+Character>
+    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>)`;
+      return i`holdForMatch(<Quantifier />)`;
     }
   }
 
   @CoveredBy('Element')
   @Node
   *Group() {
-    yield i`eat(<~*Punctuator '(?:' balanced=')'> 'openToken')`;
-    yield i`eat(<Alternatives>)`;
-    yield i`eat(<~*Punctuator ')' balancer> 'closeToken')`;
+    yield i`eat(<*Punctuator '(?:' balanced=')' /> 'openToken')`;
+    yield i`eat(<Alternatives />)`;
+    yield i`eat(<*Punctuator ')' balancer /> 'closeToken')`;
   }
 
   @Node
   *CapturingGroup() {
-    yield i`eat(<~*Punctuator '(' balanced=')'> 'openToken')`;
-    yield i`eat(<Alternatives>)`;
-    yield i`eat(<~*Punctuator ')' balancer> 'closeToken')`;
+    yield i`eat(<*Punctuator '(' balanced=')' /> 'openToken')`;
+    yield i`eat(<Alternatives />)`;
+    yield i`eat(<*Punctuator ')' balancer /> 'closeToken')`;
   }
 
   @CoveredBy('Element')
   *Assertion() {
-    yield i`eat(<Any> null [
-      <*StartOfInputAssertion '^'>
-      <*EndOfInputAssertion '$'>
-      <*@WordBoundaryAssertion /\\b/i>
+    yield i`eat(<Any /> null [
+      <*StartOfInputAssertion '^' />
+      <*EndOfInputAssertion '$' />
+      <*@WordBoundaryAssertion /\\b/i />
     ])`;
   }
 
   @CoveredBy('Assertion')
   @Node
   *StartOfInputAssertion() {
-    yield i`eat(<~*Keyword '^'> 'sigilToken')`;
+    yield i`eat(<*Keyword '^' /> 'sigilToken')`;
   }
 
   @CoveredBy('Assertion')
   @Node
   *EndOfInputAssertion() {
-    yield i`eatMatch(<~*Keyword '$'> 'sigilToken')`;
+    yield i`eatMatch(<*Keyword '$' /> 'sigilToken')`;
   }
 
-  @Attributes(['negate'])
+  @UnboundAttributes(['negate'])
   @CoveredBy('Assertion')
   @Node
   *WordBoundaryAssertion({ ctx }) {
-    yield i`eatMatch(<~*Punctuator '\\'> 'escapeToken')`;
-    const m = yield i`eat(<~*Keyword /b/i> 'value')`;
+    yield i`eatMatch(<*Punctuator '\\' /> 'escapeToken')`;
+    const m = yield i`eat(<*Keyword /b/i /> 'value')`;
     yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(m) === 'B')})`;
   }
 
   @CoveredBy('Assertion')
   @Node
   *Gap() {
-    yield i`eatMatch(<~*Punctuator '\\'> 'escapeToken')`;
-    yield i`eat(<~*Keyword 'g'> 'value')`;
+    yield i`eatMatch(<*Punctuator '\\' /> 'escapeToken')`;
+    yield i`eat(<*Keyword 'g' /> 'value')`;
   }
 
   @CoveredBy('Element')
@@ -167,106 +190,106 @@ export const grammar = class RegexGrammar {
   @Node
   *Character() {
     if (yield i`match('\\')`) {
-      yield i`eat(<@EscapeSequence> null)`;
+      yield i`eat(<@EscapeSequence /> null)`;
     } else {
       yield i`eat(/[^\r\n\t]/)`;
     }
   }
 
-  @Attributes(['negate'])
+  @UnboundAttributes(['negate'])
   @CoveredBy('Element')
   @Node
   *CharacterClass() {
-    yield i`eat(<~*Punctuator '[' balancedSpan='CharacterClass' balanced=']'> 'openToken')`;
+    yield i`eat(<*Punctuator '[' balancedSpan='CharacterClass' balanced=']' /> 'openToken')`;
 
-    let neg = yield i`eatMatch(<~*Keyword '^'> 'negateToken')`;
+    let neg = yield i`eatMatch(<*Keyword '^' /> 'negateToken')`;
 
     yield i`bindAttribute('negate' ${buildBoolean(neg)})`;
 
     while (yield i`match(/./s)`) {
-      yield i`eat(<+CharacterClassElement> 'elements[]')`;
+      yield i`eat(<+CharacterClassElement /> 'elements[]$')`;
     }
 
-    yield i`eat(<~*Punctuator ']' balancer> 'closeToken')`;
+    yield i`eat(<*Punctuator ']' balancer /> 'closeToken')`;
   }
 
   *CharacterClassElement() {
-    yield i`eat(<Any> null [
-        <CharacterSet /\\[dswp]/i>
-        <Gap '\\g'>
-        <*+Character>
+    yield i`eat(<Any /> null [
+        <CharacterSet /\\[dswp]/i />
+        <Gap '\\g' />
+        <*+Character />
       ])`;
 
     if (yield i`match('-')`) {
-      return i`holdForMatch(<+CharacterClassRange>)`;
+      return i`holdForMatch(<+CharacterClassRange />)`;
     }
   }
 
   @CoveredBy('CharacterClassElement')
   @Node
   *CharacterClassRange() {
-    yield i`eat(<*+Character> 'min')`;
-    yield i`eat(<~*Punctuator '-'> 'sigilToken')`;
-    yield i`eat(<*+Character> 'max')`;
+    yield i`eat(<*+Character /> 'min$')`;
+    yield i`eat(<*Punctuator '-' /> 'sigilToken')`;
+    yield i`eat(<*+Character /> 'max$')`;
   }
 
   @CoveredBy('Element')
   *CharacterSet() {
-    yield i`eat(<Any> null [
-      <+AnyCharacterSet '.'>
-      <+DigitCharacterSet /\\[dD]/>
-      <+SpaceCharacterSet /\\[sS]/>
-      <+WordCharacterSet /\\[wW]/>
+    yield i`eat(<Any /> null [
+      <+AnyCharacterSet '.' />
+      <+DigitCharacterSet /\\[dD]/  />
+      <+SpaceCharacterSet /\\[sS]/  />
+      <+WordCharacterSet /\\[wW]/  />
     ])`;
   }
 
   @CoveredBy('CharacterSet')
   @Node
   *AnyCharacterSet() {
-    yield i`eat(<~*Keyword '.'> 'sigilToken')`;
+    yield i`eat(<*Keyword '.' /> 'sigilToken')`;
   }
 
-  @Attributes(['negate'])
+  @UnboundAttributes(['negate'])
   @CoveredBy('CharacterSet')
   @Node
   *DigitCharacterSet({ ctx }) {
-    yield i`eat(<~*Punctuator '\\'> 'escapeToken')`;
+    yield i`eat(<*Punctuator '\\' /> 'escapeToken')`;
 
-    let code = yield i`eat(<~*Keyword /[dD]/> 'value')`;
+    let code = yield i`eat(<*Keyword /[dD]/ /> 'value')`;
 
     yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(code) === 'D')})`;
   }
 
-  @Attributes(['negate'])
+  @UnboundAttributes(['negate'])
   @CoveredBy('CharacterSet')
   @Node
   *SpaceCharacterSet({ ctx }) {
-    yield i`eat(<~*Punctuator '\\'> 'escapeToken')`;
+    yield i`eat(<*Punctuator '\\' /> 'escapeToken')`;
 
-    let code = yield i`eat(<~*Keyword /[sS]/> 'value')`;
+    let code = yield i`eat(<*Keyword /[sS]/ /> 'value')`;
 
     yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(code) === 'S')})`;
   }
 
-  @Attributes(['negate'])
+  @UnboundAttributes(['negate'])
   @CoveredBy('CharacterSet')
   @Node
   *WordCharacterSet({ ctx }) {
-    yield i`eat(<~*Punctuator '\\'> 'escapeToken')`;
+    yield i`eat(<*Punctuator '\\' /> 'escapeToken')`;
 
-    let code = yield i`eat(<~*Keyword /[wW]/> 'value')`;
+    let code = yield i`eat(<*Keyword /[wW]/ /> 'value')`;
 
     yield i`bindAttribute('negate' ${buildBoolean(ctx.sourceTextFor(code) === 'W')})`;
   }
 
-  @Attributes(['min', 'max'])
+  @UnboundAttributes(['min', 'max'])
   @Node
   *Quantifier({ ctx }) {
-    yield i`eat(<+Element> 'element')`;
+    yield i`eat(<+Element /> 'element$')`;
 
     let attrs, sigil;
 
-    if ((sigil = yield i`eatMatch(<~*Keyword /[*+?]/> 'sigilToken')`)) {
+    if ((sigil = yield i`eatMatch(<*Keyword /[*+?]/ /> 'sigilToken')`)) {
       switch (ctx.sourceTextFor(sigil)) {
         case '*':
           attrs = { min: 0, max: Infinity };
@@ -278,12 +301,12 @@ export const grammar = class RegexGrammar {
           attrs = { min: 0, max: 1 };
           break;
       }
-    } else if (yield i`eat(<~*Punctuator '{' balanced='}'> 'openToken')`) {
+    } else if (yield i`eat(<*Punctuator '{' balanced='}' /> 'openToken')`) {
       let max;
-      let min = yield i`eat(<*UnsignedInteger> 'min')`;
+      let min = yield i`eat(<*UnsignedInteger /> 'min$')`;
 
-      if (yield i`eatMatch(<~*Punctuator ','> 'separator')`) {
-        max = yield i`eatMatch(<*UnsignedInteger> 'max')`;
+      if (yield i`eatMatch(<*Punctuator ',' /> 'separator')`) {
+        max = yield i`eatMatch(<*UnsignedInteger /> 'max$')`;
       }
 
       min = min && ctx.sourceTextFor(min);
@@ -294,11 +317,11 @@ export const grammar = class RegexGrammar {
 
       attrs = { min, max };
 
-      yield i`eat(<~*Punctuator '}' balancer> 'closeToken')`;
+      yield i`eat(<*Punctuator '}' balancer /> 'closeToken')`;
     }
 
-    yield i`bindAttribute('min' ${attrs.min ? buildNumber(attrs.min) : buildNull()})`;
-    yield i`bindAttribute('max' ${attrs.max ? buildNumber(attrs.max) : buildNull()})`;
+    yield i`bindAttribute('min' ${attrs.min ? buildNumber(attrs.min) : buildNullTag()})`;
+    yield i`bindAttribute('max' ${attrs.max ? buildNumber(attrs.max) : buildNullTag()})`;
   }
 
   @Node
@@ -306,57 +329,48 @@ export const grammar = class RegexGrammar {
     yield i`eat(/\d+/)`;
   }
 
-  @Attributes(['cooked'])
   @Node
   *EscapeSequence({ state, ctx, value: props }) {
     const parentSpan = state.span;
 
-    yield i`eat(<~*Punctuator '\\' openSpan='Escape'> 'escape')`;
+    yield i`eat(<*Punctuator '\\' openSpan='Escape' /> 'escape')`;
 
-    let match, cooked;
+    let match;
 
     if ((match = yield i`match(/[\\/nrt0]/)`)) {
       const match_ = ctx.sourceTextFor(match);
-      yield i`eat(<~*Keyword ${buildString(match_)} closeSpan='Escape'> 'value')`;
-      cooked = escapables.get(match_) || 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'> 'value')`;
-      cooked = ctx.sourceTextFor(match);
+      yield i`eat(<*Keyword ${buildString(match_)} closeSpan='Escape' /> 'code')`;
     } else if (yield i`match(/[ux]/)`) {
-      const codeNode = yield i`eat(<EscapeCode closeSpan='Escape'> 'value')`;
-      cooked = parseInt(
-        codeNode.properties.digits.map((digit) => ctx.sourceTextFor(digit)).join(''),
-        16,
-      );
+      yield i`eat(<EscapeCode closeSpan='Escape' /> 'code')`;
     } else {
       yield i`fail()`;
     }
-
-    yield i`bindAttribute(cooked ${buildString(cooked)})`;
   }
 
   @Node
   *EscapeCode() {
-    if (yield i`eatMatch(<~*Keyword 'u'> 'type')`) {
-      if (yield i`eatMatch(<~*Punctuator '{'> 'openToken')`) {
-        yield i`eatMatch(<Digits> 'value')`;
-        yield i`eat(<~*Punctuator '}'> 'closeToken')`;
+    if (yield i`eatMatch(<*Keyword 'u' /> 'type')`) {
+      if (yield i`eatMatch(<*Punctuator '{' /> 'openToken')`) {
+        yield i`eatMatch(<*UnsignedInteger /> 'value$')`;
+        yield i`eat(<*Punctuator '}' /> 'closeToken')`;
       } else {
-        yield i`eat(<Digits /\d{4}/> 'value')`;
+        yield i`eat(<*UnsignedInteger /\d{4}/ /> 'value$')`;
         yield i`eat(null 'closeToken')`;
       }
-    } else if (yield i`eatMatch(<~*Keyword 'x'> 'type')`) {
+    } else if (yield i`eatMatch(<*Keyword 'x' /> 'type')`) {
       yield i`eat(null 'openToken')`;
-      yield i`eat(<Digits /\d{2}/> 'value')`;
+      yield i`eat(<*UnsignedInteger /\d{2}/ /> 'value$')`;
       yield i`eat(null 'closeToken')`;
     }
   }
 
   *Digits() {
-    while (yield i`eatMatch(<*Digit>)`);
+    while (yield i`eatMatch(<*Digit />)`);
   }
 
   @Node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/language-en-regex-vm-pattern",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "A BABLR language for nonbacktracking JS-style regexes",
   "engines": {
     "node": ">=12.0.0"
@@ -22,24 +22,24 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.23.2",
-    "@bablr/helpers": "0.18.1",
-    "@bablr/agast-helpers": "0.3.2",
-    "@bablr/agast-vm-helpers": "0.3.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"
   },
   "devDependencies": {
-    "@bablr/boot": "0.4.0",
+    "@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.1",
+    "@bablr/macrome": "^0.1.3",
+    "@bablr/macrome-generator-bablr": "^0.3.2",
     "@qnighy/dedent": "0.1.1",
-    "bablr": "0.4.1",
+    "bablr": "^0.6.0",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.47.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
     "eslint-plugin-import": "^2.27.5",
     "expect": "^29.6.2",
-    "mocha": "10.4.0",
+    "mocha": "^10.4.0",
     "prettier": "^2.0.5"
   },
   "keywords": [