@bablr/boot 0.2.2 → 0.2.3

package/lib/languages/cstml.js

@@ -78,14 +78,15 @@ const covers = buildCovers({
     'String',
     'Content',
     'UnsignedInteger',
+    'Flags',
   ],
   [sym.fragment]: ['Attributes', 'Fragment'],
   Attribute: ['MappingAttribute', 'BooleanAttribute'],
   AttributeValue: ['String', 'Number'],
   TagType: ['Identifier', 'GlobalIdentifier'],
-  Terminal: ['Literal', 'Trivia', 'Escape'],
+  Terminal: ['Literal', 'Trivia'],
   PropertyValue: ['Gap', 'Node', 'Null'],
-  EmbeddedTerminal: ['Literal', 'Escape'],
+  EmbeddedTerminal: ['Literal'],
   Number: ['Integer', 'Infinity'],
 });
 
@@ -110,10 +111,10 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   DoctypeTag(p) {
-    p.eat('<!', PN, { path: 'open' });
+    p.eat('<!', PN, { path: 'openToken' });
     p.eatProduction('UnsignedInteger', { path: 'version' });
-    p.eat(':', PN, { path: 'versionSeparator' });
-    p.eat('cstml', KW, { path: 'doctype' });
+    p.eat(':', PN, { path: 'versionSeparatorToken' });
+    p.eat('cstml', KW, { path: 'doctypeToken' });
 
     let sp = p.eatMatchTrivia(_);
 
@@ -122,17 +123,17 @@ const grammar = class CSTMLMiniparserGrammar {
       sp = p.eatMatchTrivia(_);
     }
 
-    p.eat('>', PN, { path: 'close' });
+    p.eat('>', PN, { path: 'closeToken' });
   }
 
   // @Node
   Null(p) {
-    p.eat('null', KW, { path: 'value' });
+    p.eat('null', KW, { path: 'sigilToken' });
   }
 
   // @Node
   Gap(p) {
-    p.eat('<//>', PN, { path: 'value' });
+    p.eat('<//>', PN, { path: 'sigilToken' });
   }
 
   // @Node
@@ -160,7 +161,11 @@ const grammar = class CSTMLMiniparserGrammar {
     const { token } = props || {};
 
     if (token) {
-      p.eatProduction('Literal');
+      if (p.match(/<\*?@/y)) {
+        p.eatProduction('Node');
+      } else {
+        p.eatProduction('Literal');
+      }
     } else {
       if (p.match(/<\*?#/y)) {
         p.eatProduction('Node');
@@ -176,7 +181,7 @@ const grammar = class CSTMLMiniparserGrammar {
   Property(p) {
     p.eatProduction('Reference', { path: 'reference' });
     p.eatMatchTrivia(_);
-    p.eat(':', PN, { path: 'mapOperator' });
+    p.eat(':', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
     p.eatProduction('PropertyValue', { path: 'value' });
   }
@@ -193,27 +198,36 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   OpenFragmentTag(p) {
-    p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+    p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
+    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
   // @Node
-  OpenNodeTag(p) {
-    p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-
-    let tr = p.eatMatch('#', PN, { path: 'triviaFlag' });
-    let tok = p.eatMatch('*', PN, { path: 'tokenFlag' });
-    let esc = p.eatMatch('@', PN, { path: 'escapeFlag' });
-    let exp = p.eatMatch('+', PN, { path: 'expressionFlag' });
+  Flags(p) {
+    let tr = p.eatMatch('#', PN, { path: 'triviaToken' });
+    p.eatMatch('~', PN, { path: 'intrinsicToken' });
+    p.eatMatch('*', PN, { path: 'tokenToken' });
+    let esc = p.eatMatch('@', PN, { path: 'escapeToken' });
+    let exp = p.eatMatch('+', PN, { path: 'expressionToken' });
 
     if ((tr && esc) || (exp && (tr || esc))) throw new Error();
+  }
+
+  // @Node
+  OpenNodeTag(p) {
+    p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
+
+    let flags = null;
+    if (!p.atExpression) {
+      flags = p.eatProduction('Flags', { path: 'flags' });
+    }
 
     p.eatProduction('TagType', { path: 'type' });
 
     let sp = p.eatMatchTrivia(_);
 
     let iv;
-    if (tok && sp && (p.match(/['"/]/y) || p.atExpression)) {
+    if (flags.properties.intrinsic && sp && (p.match(/['"/]/y) || p.atExpression)) {
       iv = p.eatProduction('String', { path: 'intrinsicValue' });
 
       sp = p.eatMatchTrivia(_);
@@ -226,21 +240,21 @@ const grammar = class CSTMLMiniparserGrammar {
 
     p.eatMatchTrivia(_);
     if (iv) {
-      p.eat('/', PN, { path: 'selfClosingToken' });
+      p.eat('/', PN, { path: 'selfClosingTagToken' });
     }
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
   // @Node
   CloseNodeTag(p) {
-    p.eat('</', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+    p.eat('</', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
+    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
   // @Node
   CloseFragmentTag(p) {
-    p.eat('</', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+    p.eat('</', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
+    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
   // @Fragment
@@ -271,7 +285,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   BooleanAttribute(p) {
-    p.eat('!', KW, { path: 'negated' });
+    p.eat('!', KW, { path: 'negateToken' });
     p.eat(/\w+/y, ID, { path: 'key' });
   }
 
@@ -279,7 +293,7 @@ const grammar = class CSTMLMiniparserGrammar {
   MappingAttribute(p) {
     p.eat(/\w+/y, LIT, { path: 'key' });
     p.eatMatchTrivia(_);
-    p.eat('=', PN, { path: 'mapOperator' });
+    p.eat('=', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
     p.eatProduction('AttributeValue', { path: 'value' });
   }
@@ -296,7 +310,7 @@ const grammar = class CSTMLMiniparserGrammar {
   TagType(p) {
     if (p.match(/[\w.]+:/y)) {
       p.eatProduction('LanguageReference', { path: 'language' });
-      p.eat(':', PN, { path: 'namespaceOperator' });
+      p.eat(':', PN, { path: 'namespaceSeparatorToken' });
       p.eatProduction('Identifier', { path: 'type' });
     } else {
       p.eatProduction('Identifier', { path: 'type' });
@@ -326,11 +340,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Cover
   Terminal(p) {
-    if (p.match(/!['"]/y)) {
-      p.eatProduction('Escape');
-    } else if (p.match(/#['"]/y)) {
-      p.eatProduction('Trivia');
-    } else if (p.match(/['"]/y)) {
+    if (p.match(/['"]/y)) {
       p.eatProduction('Literal');
     } else {
       throw new Error();
@@ -341,7 +351,7 @@ const grammar = class CSTMLMiniparserGrammar {
   Reference(p) {
     p.eatProduction('Identifier', { path: 'name' });
     p.eatMatchTrivia(_);
-    p.eatMatch('[]', PN, { path: 'arrayOperator' });
+    p.eatMatch('[]', PN, { path: 'arrayToken' });
   }
 
   // @Cover
@@ -355,21 +365,6 @@ const grammar = class CSTMLMiniparserGrammar {
     }
   }
 
-  // @Node
-  Escape(p) {
-    p.eat('!', PN, { path: 'escapeOperator' });
-    p.eatProduction('String', { path: 'rawValue' });
-    p.eatMatchTrivia(_);
-    p.eat(':', PN, { path: 'rawOperator' });
-    p.eatProduction('String', { path: 'value' });
-  }
-
-  // @Node
-  Trivia(p) {
-    p.eat('#', PN, { path: 'trivializeOperator' });
-    p.eatProduction('String', { path: 'value' });
-  }
-
   // @Node
   Literal(p) {
     p.eatProduction('String', { path: 'value' });
@@ -417,11 +412,11 @@ const grammar = class CSTMLMiniparserGrammar {
 
     const span = q === '"' ? 'Double' : 'Single';
 
-    p.eat(q, PN, { path: 'open', startSpan: span, balanced: q });
+    p.eat(q, PN, { path: 'openToken', startSpan: span, balanced: q });
     while (p.match(/./sy) || p.atExpression) {
       p.eatProduction('Content', { path: 'content' });
     }
-    p.eat(q, PN, { path: 'close', endSpan: span, balancer: true });
+    p.eat(q, PN, { path: 'closeToken', endSpan: span, balancer: true });
   }
 
   // @Node

package/lib/languages/instruction.js

@@ -37,7 +37,6 @@ const grammar = class InstructionMiniparserGrammar {
   Call(p) {
     p.eat(/\w+/y, ID, { path: 'verb' });
     p.eatMatchTrivia(_);
-    p.eatMatch(/[!#]/y, PN, { path: 'verbSuffix' });
     p.eatProduction('Tuple', { path: 'arguments' });
   }
 
@@ -68,7 +67,7 @@ const grammar = class InstructionMiniparserGrammar {
 
   // @Node
   Object(p) {
-    p.eat('{', PN, { path: 'open', balanced: '}' });
+    p.eat('{', PN, { path: 'openToken', balanced: '}' });
 
     p.eatMatchTrivia(_);
 
@@ -82,21 +81,21 @@ const grammar = class InstructionMiniparserGrammar {
 
     p.eatMatchTrivia(_);
 
-    p.eat('}', PN, { path: 'close', balancer: true });
+    p.eat('}', PN, { path: 'closeToken', balancer: true });
   }
 
   // @Node
   Property(p) {
     p.eat(/\w+/y, LIT, { path: 'key' });
     p.eatMatchTrivia(_);
-    p.eat(':', PN, { path: 'mapOperator' });
+    p.eat(':', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
     p.eatProduction('Expression', { path: 'value' });
   }
 
   // @Node
   Array(p) {
-    p.eat('[', PN, { path: 'open', balanced: ']' });
+    p.eat('[', PN, { path: 'openToken', balanced: ']' });
 
     p.eatMatchTrivia(_);
 
@@ -108,12 +107,12 @@ const grammar = class InstructionMiniparserGrammar {
       first = false;
     }
 
-    p.eat(']', PN, { path: 'close', balancer: true });
+    p.eat(']', PN, { path: 'closeToken', balancer: true });
   }
 
   // @Node
   Tuple(p) {
-    p.eat('(', PN, { path: 'open', balanced: ')' });
+    p.eat('(', PN, { path: 'openToken', balanced: ')' });
 
     let sep = p.eatMatchTrivia(_);
 
@@ -124,17 +123,17 @@ const grammar = class InstructionMiniparserGrammar {
       i++;
     }
 
-    p.eat(')', PN, { path: 'close', balancer: true });
+    p.eat(')', PN, { path: 'closeToken', balancer: true });
   }
 
   // @Node
   Boolean(p) {
-    p.eat(/true|false/y, KW, { path: 'value' });
+    p.eat(/true|false/y, KW, { path: 'sigilToken' });
   }
 
   // @Node
   Null(p) {
-    p.eat('null', KW, { path: 'value' });
+    p.eat('null', KW, { path: 'sigilToken' });
   }
 };
 

package/lib/languages/regex.js

@@ -12,7 +12,7 @@ const dependencies = {};
 const covers = buildCovers({
   [node]: [
     'RegExpLiteral',
-    'Flag',
+    'Flags',
     'Pattern',
     'Alternative',
     'Group',
@@ -55,7 +55,6 @@ const flags = {
   unicode: 'u',
   sticky: 'y',
 };
-const flagsReverse = Object.fromEntries(Object.entries(flags).map(([key, value]) => [value, key]));
 
 const PN = 'Punctuator';
 const KW = 'Keyword';
@@ -115,26 +114,32 @@ const cookEscape = (escape, span) => {
 const grammar = class RegexMiniparserGrammar {
   // @Node
   Pattern(p) {
-    p.eat('/', PN, { path: 'open', balanced: '/' });
+    p.eat('/', PN, { path: 'openToken', balanced: '/' });
     p.eatProduction('Alternatives', { path: 'alternatives[]' });
-    p.eat('/', PN, { path: 'close', balancer: true });
-    p.eatProduction('Flags', { path: 'flags[]' });
+    p.eat('/', PN, { path: 'closeToken', balancer: true });
+
+    if (p.match(/[gimsuy]/y || p.atExpression)) {
+      p.eatProduction('Flags', { path: 'flags' });
+    }
   }
 
+  // @Node
   Flags(p) {
-    const flags = p.match(/[gimsuy]+/y) || '';
+    const flagsStr = p.match(/[gimsuy]+/y) || '';
 
-    if (!unique(flags)) throw new Error('flags must be unique');
+    if (flagsStr && !unique(flagsStr)) throw new Error('flags must be unique');
 
-    for (const _ of flags) {
-      p.eatProduction('Flag');
+    const attrs = {};
+
+    for (const { 0: name, 1: chr } of Object.entries(flags)) {
+      attrs[name] = flagsStr.includes(chr);
     }
-  }
 
-  // @Node
-  Flag(p) {
-    const flag = p.eatMatch(/[gimsuy]/y, KW, { path: 'value' });
-    return { attrs: { kind: flagsReverse[flag] } };
+    for (const flag of flagsStr) {
+      p.eat(flag, KW, { path: 'tokens[]' });
+    }
+
+    return { attrs };
   }
 
   Alternatives(p) {
@@ -181,16 +186,16 @@ const grammar = class RegexMiniparserGrammar {
 
   // @Node
   Group(p) {
-    p.eat('(?:', PN, { path: 'open', balanced: ')' });
+    p.eat('(?:', PN, { path: 'openToken', balanced: ')' });
     p.eatProduction('Alternatives', { path: 'alternatives[]' });
-    p.eat(')', PN, { path: 'close', balancer: true });
+    p.eat(')', PN, { path: 'closeToken', balancer: true });
   }
 
   // @Node
   CapturingGroup(p) {
-    p.eat('(', PN, { path: 'open', balanced: ')' });
+    p.eat('(', PN, { path: 'openToken', balanced: ')' });
     p.eatProduction('Alternatives', { path: 'alternatives[]' });
-    p.eat(')', PN, { path: 'close', balancer: true });
+    p.eat(')', PN, { path: 'closeToken', balancer: true });
   }
 
   Assertion(p) {
@@ -206,20 +211,20 @@ const grammar = class RegexMiniparserGrammar {
   // @CoveredBy('Assertion')
   // @Node
   StartOfInputAssertion(p) {
-    p.eat('^', KW, { path: 'value' });
+    p.eat('^', KW, { path: 'sigilToken' });
   }
 
   // @CoveredBy('Assertion')
   // @Node
   EndOfInputAssertion(p) {
-    p.eat('$', KW, { path: 'value' });
+    p.eat('$', KW, { path: 'sigilToken' });
   }
 
   // @CoveredBy('Assertion')
   // @Node
   WordBoundaryAssertion(p) {
     let attrs;
-    if (p.eatMatch('\\', ESC, { path: 'escape' })) {
+    if (p.eatMatch('\\', ESC, { path: 'escapeToken' })) {
       const m = p.eat(/b/iy, KW, { path: 'value' });
       attrs = { negate: m === 'B' };
     } else {
@@ -256,9 +261,9 @@ const grammar = class RegexMiniparserGrammar {
 
   // @Node
   CharacterClass(p) {
-    p.eat('[', PN, { path: 'open', balanced: ']', startSpan: 'CharacterClass' });
+    p.eat('[', PN, { path: 'openToken', balanced: ']', startSpan: 'CharacterClass' });
 
-    const negate = !!p.eatMatch('^', KW, { path: 'negate', boolean: true });
+    const negate = !!p.eatMatch('^', KW, { path: 'negateToken', boolean: true });
 
     let first = !negate;
     while (p.match(/./sy)) {
@@ -266,7 +271,9 @@ const grammar = class RegexMiniparserGrammar {
       first = false;
     }
 
-    p.eat(']', PN, { path: 'close', balancer: true, endSpan: 'CharacterClass' });
+    p.eat(']', PN, { path: 'closeToken', balancer: true, endSpan: 'CharacterClass' });
+
+    return { attrs: { negate } };
   }
 
   // @Cover
@@ -284,7 +291,7 @@ const grammar = class RegexMiniparserGrammar {
 
   // @Node
   Gap(p) {
-    p.eat('\\', PN, { path: 'escape' });
+    p.eat('\\', PN, { path: 'escapeToken' });
     p.eat('g', KW, { path: 'value' });
   }
 
@@ -294,7 +301,7 @@ const grammar = class RegexMiniparserGrammar {
       path: 'min',
       ...when(first, { span: 'CharacterClass:First' }),
     });
-    p.eat('-', PN, { path: 'rangeOperator' });
+    p.eat('-', PN, { path: 'rangeToken' });
     p.eatProduction('Character', { path: 'max' });
   }
 
@@ -321,13 +328,13 @@ const grammar = class RegexMiniparserGrammar {
   // @CoveredBy('CharacterSet')
   // @Node
   AnyCharacterSet(p) {
-    p.eat('.', KW, { path: 'value' });
+    p.eat('.', KW, { path: 'sigilToken' });
   }
 
   // @CoveredBy('CharacterSet')
   // @Node
   WordCharacterSet(p) {
-    p.eat('\\', PN, { path: 'escape' });
+    p.eat('\\', PN, { path: 'escapeToken' });
 
     let attrs;
 
@@ -343,7 +350,7 @@ const grammar = class RegexMiniparserGrammar {
   // @CoveredBy('CharacterSet')
   // @Node
   SpaceCharacterSet(p) {
-    p.eat('\\', PN, { path: 'escape' });
+    p.eat('\\', PN, { path: 'escapeToken' });
 
     let attrs;
 
@@ -359,7 +366,7 @@ const grammar = class RegexMiniparserGrammar {
   // @CoveredBy('CharacterSet')
   // @Node
   DigitCharacterSet(p) {
-    p.eat('\\', PN, { path: 'escape' });
+    p.eat('\\', PN, { path: 'escapeToken' });
 
     let attrs;
 
@@ -379,15 +386,15 @@ const grammar = class RegexMiniparserGrammar {
     let attrs;
 
     if (p.eatMatch('*', KW, { path: 'value' })) {
-      const greedy = !p.eatMatch('?', KW, { path: 'greedyOperator' });
+      const greedy = !p.eatMatch('?', KW, { path: 'greedyToken' });
       attrs = { min: 0, max: Infinity, greedy };
     } else if (p.eatMatch('+', KW, { path: 'value' })) {
-      const greedy = !p.eatMatch('?', KW, { path: 'greedyOperator' });
+      const greedy = !p.eatMatch('?', KW, { path: 'greedyToken' });
       attrs = { min: 1, max: Infinity, greedy };
     } else if (p.eatMatch('?', KW, { path: 'value' })) {
       attrs = { min: 0, max: 1, greedy: true };
     } else if (p.match('{')) {
-      p.eat('{', PN, { path: 'open', balanced: '}' });
+      p.eat('{', PN, { path: 'openToken', balanced: '}' });
 
       let max;
       let min = p.eat(/\d+/y, 'Number', { path: 'min' });
@@ -396,9 +403,9 @@ const grammar = class RegexMiniparserGrammar {
         max = p.eatMatch(/\d+/y, 'Number', { path: 'max' });
       }
 
-      p.eat('}', PN, { path: 'close', balancer: true });
+      p.eat('}', PN, { path: 'closeToken', balancer: true });
 
-      const greedy = !p.eatMatch('?', KW, { path: 'greedyOperator' });
+      const greedy = !p.eatMatch('?', KW, { path: 'greedyToken' });
 
       attrs = { min: min && parseInt(min, 10), max: max && parseInt(max, 10), greedy };
     }

package/lib/languages/spamex.js

@@ -25,7 +25,7 @@ const covers = buildCovers({
 const grammar = class SpamexMiniparserGrammar {
   // @Cover
   Matcher(p) {
-    if (p.match(/<(?:[*#@+]*[ \t]*)?(?:\w|$)/y)) {
+    if (p.match(/<(?:[*#@+~]*)?(?:\w|$)/y)) {
       p.eatProduction('NodeMatcher');
     } else if (p.match(/['"]/y)) {
       p.eatProduction('CSTML:String');
@@ -38,18 +38,13 @@ const grammar = class SpamexMiniparserGrammar {
 
   // @Node
   NodeMatcher(p) {
-    p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
+    p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
 
-    let tr = p.eatMatch('#', PN, { path: 'triviaFlag' });
-    p.eatMatch('*', PN, { path: 'tokenFlag' });
-    let esc = p.eatMatch('@', PN, { path: 'escapeFlag' });
-    let exp = p.eatMatch('+', PN, { path: 'expressionFlag' });
-
-    if ((tr && esc) || (exp && (tr || esc))) throw new Error();
+    p.eatProduction('CSTML:Flags', { path: 'flags' });
 
     if (p.match(/\w+:/y)) {
       p.eat(/\w+/y, ID, { path: 'language' });
-      p.eat(':', PN, { path: 'namespaceOperator' });
+      p.eat(':', PN, { path: 'namespaceSeparatorToken' });
       p.eat(/\w+/y, ID, { path: 'type' });
     } else {
       p.eat(/\w+/y, ID, { path: 'type' });
@@ -69,7 +64,7 @@ const grammar = class SpamexMiniparserGrammar {
     }
 
     p.eatMatchTrivia(_);
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
   Attributes(p) {
@@ -100,7 +95,7 @@ const grammar = class SpamexMiniparserGrammar {
   MappingAttribute(p) {
     p.eat(/\w+/y, LIT, { path: 'key' });
     p.eatMatchTrivia(_);
-    p.eat('=', PN, { path: 'mapOperator' });
+    p.eat('=', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
     p.eatProduction('AttributeValue', { path: 'value' });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"