@bablr/boot 0.2.2 → 0.2.4

package/lib/builders.js

@@ -70,18 +70,10 @@ const buildNodeOpenTag = (flags, type, attributes = {}) => {
   return freeze({ type: 'OpenNodeTag', value: freeze({ flags, type, attributes }) });
 };
 
-const buildFragmentOpenTag = (flags = {}, language) => {
-  return freeze({ type: 'OpenFragmentTag', value: freeze({ flags: freeze(flags), language }) });
-};
-
 const buildNodeCloseTag = (type) => {
   return freeze({ type: 'CloseNodeTag', value: freeze({ type }) });
 };
 
-const buildFragmentCloseTag = () => {
-  return freeze({ type: 'CloseFragmentTag', value: freeze({}) });
-};
-
 const buildLiteral = (value) => {
   return freeze({ type: 'Literal', value });
 };
@@ -374,9 +366,7 @@ const lit = (str) => buildLiteral(stripArray(str));
 
 const gap = buildGap;
 const nodeOpen = buildNodeOpenTag;
-const fragOpen = buildFragmentOpenTag;
 const nodeClose = buildNodeCloseTag;
-const fragClose = buildFragmentCloseTag;
 const node = buildNode;
 const s_node = buildSyntacticNode;
 const e_node = buildEscapeNode;
@@ -398,9 +388,7 @@ module.exports = {
   buildReference,
   buildGap,
   buildNodeOpenTag,
-  buildFragmentOpenTag,
   buildNodeCloseTag,
-  buildFragmentCloseTag,
   buildLiteral,
   buildNode,
   buildSyntacticNode,
@@ -411,9 +399,7 @@ module.exports = {
   lit,
   gap,
   nodeOpen,
-  fragOpen,
   nodeClose,
-  fragClose,
   node,
   s_node,
   e_node,

package/lib/index.js

@@ -66,6 +66,10 @@ const parse = (language, type, sourceText) => {
 const getAgASTValue = (language, miniNode) => {
   if (!miniNode) return miniNode;
 
+  if (isArray(miniNode)) {
+    return miniNode.map(node => getAgASTValue(node));
+  }
+
   const { language: languageName, type, attributes } = miniNode;
   const flags = { escape: false, trivia: false, token: false, intrinsic: false };
   const properties = {};
@@ -138,7 +142,7 @@ const getAgASTValue = (language, miniNode) => {
 
 const str = buildTag(cstml, 'String');
 const num = buildTag(cstml, 'Integer');
-const cst = buildTag(cstml, 'Fragment');
+const cst = buildTag(cstml, 'Node');
 const re = buildTag(regex, 'Pattern');
 const i = buildTag(instruction, 'Call');
 

package/lib/languages/cstml.js

@@ -68,77 +68,62 @@ const covers = buildCovers({
     'Gap',
     'Node',
     'IdentifierPath',
-    'OpenFragmentTag',
     'OpenNodeTag',
     'CloseNodeTag',
-    'CloseFragmentTag',
     'Terminal',
     'Number',
     'Digit',
     'String',
     'Content',
     'UnsignedInteger',
+    'Flags',
   ],
-  [sym.fragment]: ['Attributes', 'Fragment'],
+  [sym.fragment]: ['Attributes'],
   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'],
 });
 
 const grammar = class CSTMLMiniparserGrammar {
-  Fragment(p) {
-    p.eatMatchTrivia(_);
-    p.eatProduction('OpenFragmentTag', { path: 'open' });
-    p.eatMatchTrivia(_);
-    while (p.match(/<[^/]/y) || p.atExpression) {
-      p.eatProduction('Node', { path: 'root' });
-      p.eatMatchTrivia(_);
-    }
-    p.eatProduction('CloseFragmentTag', { path: 'close' });
-    p.eatMatchTrivia(_);
-  }
-
   // @Node
   Document(p) {
     p.eatProduction('DoctypeTag', { path: 'doctype' });
-    p.eatProduction('Fragment', { path: 'tree' });
+    p.eatProduction('Node', { path: 'tree' });
   }
 
   // @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(_);
 
-    if ((sp && p.match(/\w+/y)) || p.atExpression) {
+    if ((sp && p.match(/[a-zA-Z]+/y)) || p.atExpression) {
       p.eatProduction('Attributes');
       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
   Node(p) {
-    if (p.match('<>')) throw new Error('Fragment is not a node');
-
     let open = p.eatProduction('OpenNodeTag', { path: 'open' });
 
     p.eatMatchTrivia(_);
@@ -160,11 +145,15 @@ 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');
-      } else if (p.match(/\w/y)) {
+      } else if (p.match(/[a-zA-Z]/y)) {
         p.eatProduction('Property');
       } else if (p.match(/['"]/y)) {
         p.eatProduction('Literal');
@@ -176,8 +165,6 @@ const grammar = class CSTMLMiniparserGrammar {
   Property(p) {
     p.eatProduction('Reference', { path: 'reference' });
     p.eatMatchTrivia(_);
-    p.eat(':', PN, { path: 'mapOperator' });
-    p.eatMatchTrivia(_);
     p.eatProduction('PropertyValue', { path: 'value' });
   }
 
@@ -192,67 +179,64 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   // @Node
-  OpenFragmentTag(p) {
-    p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+  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: 'open', startSpan: 'Tag', balanced: '>' });
+    p.eat('<', PN, { path: 'openToken', 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' });
-
-    if ((tr && esc) || (exp && (tr || esc))) throw new Error();
+    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(_);
     }
 
-    if ((sp && p.match(/\w+/y)) || p.atExpression) {
+    if ((sp && p.match(/[a-zA-Z]+/y)) || p.atExpression) {
       p.eatProduction('Attributes');
       sp = p.eatMatchTrivia(_);
     }
 
     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 });
-  }
-
-  // @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
   Attributes(p) {
     let sp = true;
-    while (sp && (p.match(/\w+/y) || p.atExpression)) {
+    while (sp && (p.match(/[a-zA-Z]+/y) || p.atExpression)) {
       if (p.atExpression) {
         p.eatProduction('Attributes'); // ??
       } else {
         p.eatProduction('Attribute', { path: 'attributes[]' });
       }
-      if (p.match(/\s+\w/y) || (p.match(/\s+$/y) && !p.quasisDone)) {
+      if (p.match(/\s+[a-zA-Z]/y) || (p.match(/\s+$/y) && !p.quasisDone)) {
         sp = p.eatMatchTrivia(_);
       } else {
         sp = false;
@@ -262,7 +246,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Cover
   Attribute(p) {
-    if (p.match(/\w[\w-_]*\s*=/y)) {
+    if (p.match(/[a-zA-Z][[a-zA-Z]-_]*\s*=/y)) {
       p.eatProduction('MappingAttribute');
     } else {
       p.eatProduction('BooleanAttribute');
@@ -271,15 +255,15 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   BooleanAttribute(p) {
-    p.eat('!', KW, { path: 'negated' });
-    p.eat(/\w+/y, ID, { path: 'key' });
+    p.eat('!', KW, { path: 'negateToken' });
+    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
   }
 
   // @Node
   MappingAttribute(p) {
-    p.eat(/\w+/y, LIT, { path: 'key' });
+    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
     p.eatMatchTrivia(_);
-    p.eat('=', PN, { path: 'mapOperator' });
+    p.eat('=', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
     p.eatProduction('AttributeValue', { path: 'value' });
   }
@@ -294,9 +278,9 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   TagType(p) {
-    if (p.match(/[\w.]+:/y)) {
+    if (p.match(/[[a-zA-Z].]+:/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' });
@@ -321,16 +305,12 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   Identifier(p) {
-    p.eatLiteral(/\w[\w-_]*/y);
+    p.eatLiteral(/[a-zA-Z][[a-zA-Z]-_]*/y);
   }
 
   // @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 +321,9 @@ const grammar = class CSTMLMiniparserGrammar {
   Reference(p) {
     p.eatProduction('Identifier', { path: 'name' });
     p.eatMatchTrivia(_);
-    p.eatMatch('[]', PN, { path: 'arrayOperator' });
+    p.eatMatch('[]', PN, { path: 'arrayToken' });
+    p.eatMatchTrivia(_);
+    p.eat(':', PN, { path: 'mapToken' });
   }
 
   // @Cover
@@ -355,21 +337,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 +384,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

@@ -35,9 +35,8 @@ const covers = buildCovers({
 const grammar = class InstructionMiniparserGrammar {
   // @Node
   Call(p) {
-    p.eat(/\w+/y, ID, { path: 'verb' });
+    p.eat(/[a-zA-Z]+/y, ID, { path: 'verb' });
     p.eatMatchTrivia(_);
-    p.eatMatch(/[!#]/y, PN, { path: 'verbSuffix' });
     p.eatProduction('Tuple', { path: 'arguments' });
   }
 
@@ -59,8 +58,8 @@ const grammar = class InstructionMiniparserGrammar {
       p.eatProduction('Boolean');
     } else if (p.match('null')) {
       p.eatProduction('Null');
-    } else if (p.match(/\w/y)) {
-      p.eat(/\w+/y, ID, p.m.attributes);
+    } else if (p.match(/[a-zA-Z]/y)) {
+      p.eat(/[a-zA-Z]+/y, ID, p.m.attributes);
     } else if (p.match('<')) {
       p.eatProduction('Spamex:Matcher');
     }
@@ -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.eat(/[a-zA-Z]+/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';
@@ -97,10 +96,10 @@ const cookEscape = (escape, span) => {
     return String.fromCodePoint(parseInt(hexMatch[1], 16));
   }
 
-  let litMatch = /\\([nrt0])/y.exec(escape);
+  let litMatch = /\\([\\nrt0])/y.exec(escape);
 
   if (litMatch) {
-    return escapables.get(litMatch[1]);
+    return escapables.get(litMatch[1]) || litMatch[1];
   }
 
   let specialMatch = getSpecialPattern(span).exec(escape.slice(1));
@@ -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) {
@@ -149,7 +154,7 @@ const grammar = class RegexMiniparserGrammar {
   }
 
   Elements(p) {
-    while (p.match(/[^|]/y)) {
+    while (p.match(/[^|]/y || p.atExpression)) {
       p.eatProduction('Element');
     }
   }
@@ -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 {
@@ -242,6 +247,8 @@ const grammar = class RegexMiniparserGrammar {
         )
       ) {
         // done
+      } else if (p.eatMatchEscape(new RegExp(String.raw`\\${specialPattern.source}`, 'y'))) {
+        // done
       } else {
         throw new Error('escape required');
       }
@@ -256,9 +263,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 +273,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 +293,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 +303,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 +330,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 +352,7 @@ const grammar = class RegexMiniparserGrammar {
   // @CoveredBy('CharacterSet')
   // @Node
   SpaceCharacterSet(p) {
-    p.eat('\\', PN, { path: 'escape' });
+    p.eat('\\', PN, { path: 'escapeToken' });
 
     let attrs;
 
@@ -359,7 +368,7 @@ const grammar = class RegexMiniparserGrammar {
   // @CoveredBy('CharacterSet')
   // @Node
   DigitCharacterSet(p) {
-    p.eat('\\', PN, { path: 'escape' });
+    p.eat('\\', PN, { path: 'escapeToken' });
 
     let attrs;
 
@@ -379,15 +388,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 +405,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(/<[^!/]/y)) {
       p.eatProduction('NodeMatcher');
     } else if (p.match(/['"]/y)) {
       p.eatProduction('CSTML:String');
@@ -38,21 +38,22 @@ 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();
+    if (!p.atExpression) {
+      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(/\w+/y, ID, { path: 'type' });
+    if (p.match(/[a-zA-Z]+:/y)) {
+      p.eat(/[a-zA-Z]+/y, ID, { path: 'language' });
+      p.eat(':', PN, { path: 'namespaceSeparatorToken' });
+      p.eat(/[a-zA-Z]+/y, ID, { path: 'type' });
     } else {
-      p.eat(/\w+/y, ID, { path: 'type' });
+      if (p.atExpression) {
+        p.eatProduction('Identifier', { path: 'type' });
+      } else {
+        p.eatMatch(/[a-zA-Z]+/y, ID, { path: 'type' });
+      }
     }
 
     let sp = p.eatMatchTrivia(_);
@@ -63,20 +64,20 @@ const grammar = class SpamexMiniparserGrammar {
       sp = p.eatMatchTrivia(_);
     }
 
-    if ((sp && p.match(/\w+/y)) || p.atExpression) {
+    if ((sp && p.match(/[a-zA-Z]+/y)) || p.atExpression) {
       p.eatProduction('Attributes', { path: 'attributes[]' });
       sp = p.eatMatchTrivia(_);
     }
 
     p.eatMatchTrivia(_);
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
   Attributes(p) {
     let sp = true;
-    while (sp && (p.match(/\w+/y) || p.atExpression)) {
+    while (sp && (p.match(/[a-zA-Z]+/y) || p.atExpression)) {
       p.eatProduction('Attribute');
-      if (p.match(/\s+\w/y)) {
+      if (p.match(/\s+[a-zA-Z]/y)) {
         sp = p.eatMatchTrivia(_);
       }
     }
@@ -84,7 +85,7 @@ const grammar = class SpamexMiniparserGrammar {
 
   // @Cover
   Attribute(p) {
-    if (p.match(/\w+\s*=/y)) {
+    if (p.match(/[a-zA-Z]+\s*=/y)) {
       p.eatProduction('MappingAttribute');
     } else {
       p.eatProduction('BooleanAttribute');
@@ -93,14 +94,14 @@ const grammar = class SpamexMiniparserGrammar {
 
   // @Node
   BooleanAttribute(p) {
-    p.eat(/\w+/y, LIT, { path: 'key' });
+    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
   }
 
   // @Node
   MappingAttribute(p) {
-    p.eat(/\w+/y, LIT, { path: 'key' });
+    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
     p.eatMatchTrivia(_);
-    p.eat('=', PN, { path: 'mapOperator' });
+    p.eat('=', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
     p.eatProduction('AttributeValue', { path: 'value' });
   }
@@ -125,7 +126,7 @@ const grammar = class SpamexMiniparserGrammar {
 
   // @Node
   Identifier(p) {
-    p.eatLiteral(/\w+/y);
+    p.eatLiteral(/[a-zA-Z]+/y);
   }
 };
 

package/lib/miniparser.js

@@ -10,6 +10,8 @@ const { set, isRegex, isArray, getPrototypeOf, buildNode } = require('./utils.js
 
 class TemplateParser {
   constructor(rootLanguage, quasis, expressions) {
+    if (!quasis) throw new Error();
+
     this.rootLanguage = rootLanguage;
     this.spans = [];
     this.quasis = quasis;

package/lib/path.js

@@ -15,7 +15,7 @@ const stripPathBraces = (str) => (str.endsWith('[]') ? str.slice(0, -2) : str);
 const parsePath = (str) => {
   const name = stripPathBraces(str);
 
-  if (!/^\w+$/.test(name)) throw new Error();
+  if (!/[a-zA-Z]+$/.test(name)) throw new Error();
 
   return { isArray: name !== str, name };
 };

package/lib/print.js

@@ -84,7 +84,7 @@ const buildDoctypeTag = () => {
   return freeze({ type: 'DoctypeTag', value: { doctype: 'cstml', version: 0 } });
 };
 
-const buildNodeOpenTag = (flags, language, type, attributes = {}) => {
+const buildNodeOpenTag = (flags = {}, language = null, type = null, attributes = {}) => {
   let { token, trivia, escape } = flags;
 
   token = !!token;
@@ -97,27 +97,17 @@ const buildNodeOpenTag = (flags, language, type, attributes = {}) => {
   });
 };
 
-const nodeFlags = freeze({ escape: false, trivia: false, token: false });
-
-const buildFragmentOpenTag = (flags = nodeFlags) => {
-  return freeze({ type: 'OpenFragmentTag', value: freeze({ flags: freeze(flags) }) });
-};
-
 const buildNodeCloseTag = (type = null, language = null) => {
   return freeze({ type: 'CloseNodeTag', value: freeze({ language, type }) });
 };
 
-const buildFragmentCloseTag = () => {
-  return freeze({ type: 'CloseFragmentTag', value: freeze({}) });
-};
-
 function* streamFromTree(rootNode) {
   if (!rootNode || rootNode.type === 'Gap') {
     return rootNode;
   }
 
   yield buildDoctypeTag();
-  yield buildFragmentOpenTag(undefined, rootNode.language[0]);
+  yield buildNodeOpenTag(undefined, rootNode.language[0]);
 
   let stack = emptyStack.push(buildFrame(rootNode));
 
@@ -173,7 +163,7 @@ function* streamFromTree(rootNode) {
 
     stack = stack.pop();
   }
-  yield buildFragmentCloseTag();
+  yield buildNodeCloseTag();
 }
 
 const printExpression = (expr) => {
@@ -262,19 +252,10 @@ const printTerminal = (terminal) => {
       return `<${printFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
     }
 
-    case 'OpenFragmentTag': {
-      const { flags } = terminal.value;
-      return `<${printFlags(flags)}>`;
-    }
-
     case 'CloseNodeTag': {
       return `</>`;
     }
 
-    case 'CloseFragmentTag': {
-      return `</>`;
-    }
-
     default:
       throw new Error();
   }
@@ -296,7 +277,7 @@ const printPrettyCSTML = (tree, indent = '  ') => {
       printed += '\n';
     }
 
-    if (['CloseNodeTag', 'CloseFragmentTag'].includes(terminal.type)) {
+    if (terminal.type === 'CloseNodeTag') {
       indentLevel--;
     }
 
@@ -307,7 +288,7 @@ const printPrettyCSTML = (tree, indent = '  ') => {
     }
     printed += printTerminal(terminal);
 
-    if (['OpenFragmentTag', 'OpenNodeTag'].includes(terminal.type)) {
+    if (terminal.type === 'OpenNodeTag') {
       indentLevel++;
     }
 

package/package.json

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

package/shorthand.macro.js

@@ -213,7 +213,7 @@ const topTypes = {
   spam: 'Matcher',
   str: 'String',
   num: 'Integer',
-  cst: 'Fragment',
+  cst: 'Node',
 };
 
 const miniLanguages = {