@bablr/boot 0.9.0 → 0.11.0

package/lib/index.js

@@ -1,26 +1,39 @@
-import * as cstmll from './languages/cstml.js';
-import * as spamex from './languages/spamex.js';
-import * as regex from './languages/regex.js';
-import * as instruction from './languages/instruction.js';
+import cstmll from './languages/cstml.js';
+import spamex from './languages/spamex.js';
+import regex from './languages/regex.js';
+import instruction from './languages/instruction.js';
 
 import { TemplateParser } from './miniparser.js';
 import { buildEmbeddedMatcher, buildEmbeddedRegex } from '@bablr/agast-vm-helpers/builders';
+import { reifyExpression } from '@bablr/agast-vm-helpers';
+import { interpolate } from '@bablr/agast-helpers/template';
+import { buildGapTag } from '@bablr/agast-helpers/builders';
+import { buildNode } from '@bablr/agast-helpers/path';
 
 const trees = new WeakMap();
 
 export const buildTag = (language, defaultType) => {
   const defaultTag = (quasis, ...exprs) => {
     let tree;
-    if (trees.has(quasis) && !exprs.length) {
+    if (trees.has(quasis)) {
       tree = trees.get(quasis);
     } else {
-      tree = new TemplateParser(language, quasis.raw, exprs).eval({
+      tree = new TemplateParser(
+        language,
+        quasis.raw,
+        exprs.map((e) => buildNode(buildGapTag())),
+      ).eatProduction({
         language: language.name,
-        type: defaultType,
+        name: defaultType,
       });
 
       trees.set(quasis, tree);
     }
+
+    if (exprs.length) {
+      tree = interpolate(tree, exprs);
+    }
+
     return tree;
   };
 
@@ -29,29 +42,39 @@ export const buildTag = (language, defaultType) => {
       return defaultTag.apply(receiver, argsList);
     },
 
-    get(_, type) {
+    get(_, name) {
       const trees = new WeakMap();
 
       return (quasis, ...exprs) => {
         let tree;
-        if (trees.has(quasis) && !exprs.length) {
+        if (trees.has(quasis)) {
           tree = trees.get(quasis);
         } else {
-          tree = new TemplateParser(language, quasis.raw, exprs).eval({
+          tree = new TemplateParser(
+            language,
+            quasis.raw,
+            exprs.map((e) => buildNode(buildGapTag())),
+          ).eatProduction({
             language: language.name,
-            type,
+            name,
           });
 
           trees.set(quasis, tree);
         }
+
+        if (exprs.length) {
+          tree = interpolate(tree, exprs);
+        }
+
         return tree;
       };
     },
   });
 };
 
-export const parse = (language, type, sourceText) => {
-  return new TemplateParser(language, [sourceText], []).eval({
+export const parse = (language, type, sourceText, expressions = []) => {
+  let source = Array.isArray(sourceText) ? sourceText : [sourceText];
+  return new TemplateParser(language, source, expressions).eatProduction({
     language: language.name,
     type,
   });
@@ -59,12 +82,19 @@ export const parse = (language, type, sourceText) => {
 
 export const str = buildTag(cstmll, 'String');
 export const num = buildTag(cstmll, 'Integer');
-export const cst = buildTag(cstmll, 'Node');
+export const cst = buildTag(cstmll, 'Document');
+export const t_ = buildTag(cstmll, 'Tag');
 export const cstml = cst;
-export const spam_ = buildTag(spamex, 'Matcher');
+export const spam_ = buildTag(spamex, 'PropertyMatcher');
 export const re_ = buildTag(regex, 'Pattern');
 export const i = buildTag(instruction, 'Call');
 
+export const t = new Proxy(t_, {
+  apply(tag, _, args) {
+    return reifyExpression(tag(...args));
+  },
+});
+
 export const spam = new Proxy(spam_, {
   apply(tag, _, args) {
     return buildEmbeddedMatcher(tag(...args));

package/lib/languages/cstml.js

@@ -1,9 +1,8 @@
-import * as sym from '@bablr/agast-vm-helpers/symbols';
-import * as JSON from './json.js';
-import { isArray } from 'iter-tools-es';
+import JSON from './json.js';
+import { get } from '@bablr/agast-helpers/tree';
 
 const _ = /\s+/y;
-const PN = 'Punctuator';
+const PN = null;
 const KW = 'Keyword';
 
 export const name = 'CSTML';
@@ -16,11 +15,11 @@ export const dependencies = {
 
 export const covers = new Map([
   [
-    sym.node,
+    Symbol.for('@bablr/node'),
     new Set([
       'Document',
-      'DocumentVersion',
       'DoctypeTag',
+      'BoundNode',
       'Property',
       'ReferenceTag',
       'ReferenceFlags',
@@ -29,31 +28,50 @@ export const covers = new Map([
       'GlobalIdentifier',
       'NullTag',
       'GapTag',
-      'Node',
+      'ShiftTag',
+      'TreeNode',
+      'NullNode',
+      'GapNode',
       'IdentifierPath',
+      'BindingSegment',
       'OpenNodeTag',
       'CloseNodeTag',
       'LiteralTag',
       'BindingTag',
-      'InitializerTag',
       'AttributeDefinition',
       'Number',
       'Digit',
-      'Content',
       'NodeFlags',
     ]),
   ],
+  [
+    'Tag',
+    new Set([
+      'DoctypeTag',
+      'ReferenceTag',
+      'NullTag',
+      'GapTag',
+      'ShiftTag',
+      'OpenNodeTag',
+      'CloseNodeTag',
+      'LiteralTag',
+      'BindingTag',
+      'AttributeDefinition',
+    ]),
+  ],
+  [
+    'Expression',
+    new Set(['ShiftExpression', 'BindingExpression', 'TreeNode', 'NullNode', 'GapNode']),
+  ],
 ]);
 
 export const grammar = class CSTMLMiniparserGrammar {
-  // @Node
   Document(p) {
     p.eatProduction('DoctypeTag', { path: 'doctype' });
     p.eatMatchTrivia(_);
-    p.eatProduction('Node', { path: 'tree' }, { fragment: true });
+    p.eatProduction('Expression', { path: 'tree' });
   }
 
-  // @Node
   DoctypeTag(p) {
     p.eat('<!', PN, { path: 'openToken' });
     p.eatProduction('JSON:UnsignedInteger', { path: 'version' });
@@ -70,53 +88,32 @@ export const grammar = class CSTMLMiniparserGrammar {
     p.eat('>', PN, { path: 'closeToken' });
   }
 
-  // @Node
   NullTag(p) {
     p.eat('null', KW, { path: 'sigilToken' });
   }
 
-  // @Node
   GapTag(p) {
     p.eat('<//>', PN, { path: 'sigilToken' });
   }
 
-  // @Node
   LiteralTag(p) {
     p.eatProduction('JSON:String', { path: 'value' });
   }
 
-  //@Node
-  InitializerTag(p) {
-    let isArray;
-    if ((isArray = p.match('['))) {
-      p.eat('[]', PN, { path: 'sigilToken' });
-    } else {
-      p.eat('undefined', PN, { path: 'sigilToken' });
-    }
-    return { attrs: { isArray } };
-  }
-
-  // @Node
-  Node(p, props) {
-    let open = p.eatProduction('OpenNodeTag', { path: 'open' }, props);
+  TreeNode(p, props) {
+    let open = p.eatProduction('OpenNodeTag', { path: 'openTag', noInterpolate: true }, props);
 
     p.eatMatchTrivia(_);
 
-    if (open.properties.flags?.token) {
-      p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
-      p.eatMatchTrivia(_);
-    } else if (!open.properties.selfClosingTagToken) {
-      let lastIndex = p.idx;
-      while (!(p.match('</') || p.done)) {
-        p.eatProduction('NodeChild', { path: 'children[]' });
+    if (open.value.attributes.selfClosing) {
+      let token = !!get(['flags', 'token'], open);
+
+      while (p.atExpression || !(p.match(/<\/[^/]/y) || p.done)) {
+        p.eatProduction('NodeChild', { path: 'children[]' }, { token });
         p.eatMatchTrivia(_);
-        if (p.idx === lastIndex) break;
-        lastIndex = p.idx;
       }
-    }
 
-    if (!open.properties.selfClosingTagToken) {
-      p.eatProduction('CloseNodeTag', { path: 'close' });
+      p.eatProduction('CloseNodeTag', { path: 'closeTag', noInterpolate: true });
     }
   }
 
@@ -129,22 +126,23 @@ export const grammar = class CSTMLMiniparserGrammar {
 
     if (token) {
       if (p.match(/<\*?@/y)) {
-        p.eatProduction('Node');
+        p.eatProduction('Property');
       } else {
         p.eatProduction('LiteralTag');
       }
     } else {
-      if (p.match(/[:<a-zA-Z`\\\u{80}-\u{10ffff}.]|[.#@]/uy)) {
+      if (p.match(/[:<a-zA-Z`\\\u{80}-\u{10ffff}.]|[.#@_]/uy) || p.atExpression) {
         p.eatProduction('Property');
       } else if (p.match(/['"]/y)) {
-        p.eatProduction('LiteralTag');
+        p.eatProduction('Property');
+      } else {
+        p.fail();
       }
     }
   }
 
-  // @Node
   AttributeDefinition(p) {
-    p.eat('{', PN, { path: 'openToken', balanced: '}' });
+    p.eat('{', PN, { path: 'openToken' });
     p.eatMatchTrivia(_);
     p.eatProduction('IdentifierPath', { path: 'key' });
     p.eatMatchTrivia(_);
@@ -152,129 +150,184 @@ export const grammar = class CSTMLMiniparserGrammar {
     p.eatMatchTrivia(_);
     p.eatProduction('JSON:Expression', { path: 'value' });
     p.eatMatchTrivia(_);
-    p.eat('}', PN, { path: 'closeToken', balancer: true });
+    p.eat('}', PN, { path: 'closeToken' });
   }
 
-  // @Node
   Property(p) {
-    if (p.match(/[a-zA-Z`\\\u{80}-\u{10ffff}.]|[.#@]/uy)) {
-      p.eatProduction('ReferenceTag', { path: 'reference' });
+    if (p.match(/[a-zA-Z`\\\u{80}-\u{10ffff}.#@_]/uy)) {
+      p.eatProduction('ReferenceTag', { path: 'referenceTag' });
     }
     p.eatMatchTrivia(_);
-    if (p.match(':')) {
-      p.eatProduction('BindingTag', { path: 'binding' });
-      p.eatMatchTrivia(_);
-    }
-    p.eatProduction('PropertyValue', { path: 'value' });
+    p.eatProduction('Expression', {
+      path: 'value',
+    });
   }
 
-  PropertyValue(p) {
+  NullNode(p) {
+    p.eatProduction('NullTag', { path: 'sigilTag' });
+  }
+
+  GapNode(p) {
+    p.eatProduction('GapTag', { path: 'sigilTag' });
+  }
+
+  Node(p) {
     if (p.match('null')) {
-      p.eatProduction('NullTag');
-    } else if (p.match(/\[\]|undefined/y)) {
-      p.eatProduction('InitializerTag');
+      p.eatProduction('NullNode');
     } else if (p.match('<//>')) {
-      p.eatProduction('GapTag');
+      p.eatProduction('GapNode');
+    } else if (p.match('</>') || p.match('<!')) {
+      p.fail();
     } else {
-      p.eatProduction('Node');
+      p.eatProduction('TreeNode', { propertyValue: true });
     }
   }
 
-  // @Node
-  NodeFlags(p) {
-    p.eatMatch('*', PN, { path: 'tokenToken' });
-    p.eatMatch('$', PN, { path: 'hasGapToken' });
-    p.eatMatch('_', PN, { path: 'fragmentToken' });
-    p.eatMatch('_', PN, { path: 'coverFragmentToken' });
+  NodeFlags(p, props) {
+    let token = !!(p.eatMatch('*', PN, { path: 'tokenToken' }) || props.token);
+    let hasGap = !!p.eatMatch('$', PN, { path: 'hasGapToken' });
+
+    return { attrs: { token, hasGap } };
   }
 
-  // @Node
-  OpenNodeTag(p, { fragment } = {}) {
-    p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
+  OpenNodeTag(p) {
+    if (p.match(/['"]/y)) {
+      p.eatProduction('NodeFlags', { path: 'flags' }, { token: true });
+      p.eatProduction('JSON:String', { path: 'literalValue' });
+      return;
+    }
+
+    p.eat('<', PN, { path: 'openToken' });
 
-    let flags = null;
     if (!p.atExpression) {
-      flags = p.eatProduction('NodeFlags', { path: 'flags' });
+      p.eatProduction('NodeFlags', { path: 'flags' });
     }
 
     let sp = null;
 
-    if (fragment && !flags.properties.fragmentToken) throw new Error();
+    let type;
+    if ((type = p.match(/__|_/y))) {
+      p.eat(type, null, { path: 'type' });
+    }
 
-    if (!flags.properties.fragmentToken && !p.match(/./sy)) {
+    if (!type && !p.match(/./sy)) {
       throw new Error();
     }
 
-    if (!flags.properties.fragmentToken) {
-      p.eatProduction('Identifier', { path: 'type' });
-
-      sp = p.eatMatchTrivia(_);
+    if (type !== '__' && p.match(/[a-zA-Z`u{80}-\u{10ffff}]/uy)) {
+      p.eatProduction('Identifier', { path: 'name' });
+    }
 
-      let iv;
+    sp = p.eatMatchTrivia(_);
 
+    if (!type) {
       if (sp && (p.match(/['"]/y) || p.atExpression)) {
-        iv = p.eatProduction('JSON:String', { path: 'intrinsicValue' });
+        p.eatProduction('JSON:String', { path: 'literalValue' });
 
         sp = p.eatMatchTrivia(_);
       }
 
-      if (!flags.properties.tokenToken && iv) {
-        throw new Error();
-      }
-
       if (p.match('{') || p.atExpression) {
-        p.eatProduction('JSON:Object');
+        p.eatProduction('JSON:Object', { path: 'attributes' });
         sp = p.eatMatchTrivia(_);
       }
 
       p.eatMatchTrivia(_);
     }
-    p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
-    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+    let sc = p.eatMatch('/', PN, { path: 'selfClosingToken' });
+    p.eat('>', PN, { path: 'closeToken' });
+
+    const selfClosing = !sc && (p.path.depth > 0 || p.span.type !== 'Bare');
+
+    return { attrs: { selfClosing } };
   }
 
-  // @Node
   CloseNodeTag(p) {
-    p.eat('</', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+    p.eat('</', PN, { path: 'openToken' });
+    p.eat('>', PN, { path: 'closeToken' });
+  }
+
+  Expression(p) {
+    p.eatProduction('BoundNode');
+
+    p.eatMatchTrivia('_');
+
+    if (p.match('^^^')) {
+      return { shift: 'ShiftExpression' };
+    }
+  }
+
+  BoundNode(p) {
+    while (p.match(':')) {
+      p.eatProduction('BindingTag', { path: 'bindingTags' });
+      p.eatMatchTrivia(_);
+    }
+    p.eatProduction('Node', { path: 'node' });
+  }
+
+  ShiftExpression(p) {
+    p.eatProduction('BoundNode', { path: 'original' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('ShiftTag', { path: 'sigilTag' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('TreeNode', { path: 'value' });
   }
 
-  // @Node
   BindingTag(p) {
-    p.eat(':', PN, { path: 'openToken', startSpan: 'Tag', balanced: ':' });
-    if (!p.match(':')) {
-      p.eatProduction('IdentifierPath');
+    p.eat(':', PN, { path: 'openToken' });
+
+    p.eatMatchTrivia(_);
+    let first = true;
+    while (!p.match(':') && (first || p.match('/'))) {
+      if (!first) {
+        p.eat('/', PN, { path: '#separatorTokens' });
+      }
+      p.eatProduction('BindingSegment', { path: 'segments[]' });
+      p.eatMatchTrivia(_);
+      first = false;
     }
-    p.eat(':', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+    p.eat(':', PN, { path: 'closeToken' });
+  }
+
+  BindingSegment(p) {
+    p.eatMatchTrivia(_);
+    if (p.match('..')) {
+      p.eat('..', PN, { path: 'path' });
+    } else {
+      p.eatProduction('Identifier', { path: 'path' });
+    }
+    p.eatMatchTrivia(_);
   }
 
   IdentifierPath(p) {
-    p.eatProduction('Identifier', { path: 'segments[]' });
-    while (p.match('.')) {
-      p.eat('.', PN, { path: 'separatorTokens[]' });
+    let first = true;
+    while (first || p.match('.')) {
+      if (!first) {
+        p.eat('.', PN, { path: '#separatorTokens' });
+      }
+
       p.eatProduction('Identifier', { path: 'segments[]' });
+      first = false;
     }
   }
 
-  // @Node
   Identifier(p) {
     let res, q;
     q = p.match('`');
-    if (q) p.eat('`', PN, { path: 'openToken', balanced: '`' });
+    if (q) p.eat('`', PN, { path: 'openToken' });
 
-    p.eatProduction('IdentifierContent', { path: 'content', span: 'Identifier' }, { quoted: !!q });
+    p.eatProduction('IdentifierContent', { path: 'content' }, { quoted: !!q });
 
-    if (q) p.eat('`', PN, { path: 'closeToken', balancer: true });
+    if (q) p.eat('`', PN, { path: 'closeToken' });
   }
 
-  // @Node
   IdentifierContent(p, props) {
     let { quoted = false } = props || {};
 
     let lit, esc;
     do {
       if ((esc = p.match('\\'))) {
-        p.eatMatchEscape(/\\(u(\{[0-9a-fA-F]\}|\d{4}))/y);
+        p.eatEscape(/\\(u(\{[0-9a-fA-F]\}|\d{4}))/y);
       } else {
         if (!quoted) {
           lit = p.eatMatchLiteral(/[a-zA-Z\u{80}-\u{10ffff}][a-zA-Z0-9_\u{80}-\u{10ffff}-]*/uy);
@@ -285,35 +338,61 @@ export const grammar = class CSTMLMiniparserGrammar {
     } while (lit || esc);
   }
 
-  // @Cover
   Tag(p) {
-    if (p.match(/['"]/y)) {
+    p.eatMatchTrivia(_);
+    if (p.match('{')) {
+      p.eatProduction('AttributeDefinition');
+    } else if (p.match('null')) {
+      p.eatProduction('NullTag');
+    } else if (p.match(/[.#@_a-zA-Z\u0060\u{80}-\u{10ffff}]/uy)) {
+      p.eatProduction('ReferenceTag');
+    } else if (p.match(':')) {
+      p.eatProduction('BindingTag');
+    } else if (p.match('<!')) {
+      p.eatProduction('DoctypeTag');
+    } else if (p.match('<//>')) {
+      p.eatProduction('GapTag');
+    } else if (p.match('^^^')) {
+      p.eatProduction('ShiftTag');
+    } else if (p.match('</')) {
+      p.eatProduction('CloseNodeTag');
+    } else if (p.match('<')) {
+      p.eatProduction('OpenNodeTag');
+    } else if (p.match(/['"]/y)) {
       p.eatProduction('LiteralTag');
     } else {
       throw new Error();
     }
+    p.eatMatchTrivia(_);
   }
 
-  // @Node
   ReferenceTag(p) {
-    let name;
-    if ((name = p.match(/[.#@]/y))) {
-      p.eat(name, PN, { path: 'type' });
-    } else {
+    let type;
+    if ((type = p.match(/\.\.|[.#@_]/y))) {
+      p.eat(type, PN, { path: 'type' });
+    }
+
+    if (!type || type === '#') {
       p.eatProduction('Identifier', { path: 'name' });
     }
     p.eatMatchTrivia(_);
 
-    if (p.match(/[+$]/y)) {
-      p.eatProduction('ReferenceFlags', { path: 'flags' });
-      p.eatMatchTrivia(_);
-    }
+    p.eatProduction('ReferenceFlags', { path: 'flags' });
+    p.eatMatchTrivia(_);
     p.eat(':', PN, { path: 'mapToken' });
   }
 
-  // @Node
   ReferenceFlags(p) {
+    p.eatMatch('[]', PN, { path: 'arrayToken' });
     p.eatMatch('+', PN, { path: 'expressionToken' });
-    p.eatMatch('$', PN, { path: 'hasGapToken' });
+    let i = p.eatMatch('*', PN, { path: 'intrinsicToken' });
+    let g = p.eatMatch('$', PN, { path: 'hasGapToken' });
+    if (i && g) p.fail();
+  }
+
+  ShiftTag(p) {
+    p.eat('^^^', PN, { path: 'sigilToken' });
   }
 };
+
+export default { name, canonicalURL, dependencies, covers, grammar };