@bablr/boot 0.8.1 → 0.10.0

package/lib/index.js

@@ -6,12 +6,22 @@ import * as instruction from './languages/instruction.js';
 import { TemplateParser } from './miniparser.js';
 import { buildEmbeddedMatcher, buildEmbeddedRegex } from '@bablr/agast-vm-helpers/builders';
 
+const trees = new WeakMap();
+
 export const buildTag = (language, defaultType) => {
   const defaultTag = (quasis, ...exprs) => {
-    return new TemplateParser(language, quasis.raw, exprs).eval({
-      language: language.name,
-      type: defaultType,
-    });
+    let tree;
+    if (trees.has(quasis) && !exprs.length) {
+      tree = trees.get(quasis);
+    } else {
+      tree = new TemplateParser(language, quasis.raw, exprs).eval({
+        language: language.name,
+        type: defaultType,
+      });
+
+      trees.set(quasis, tree);
+    }
+    return tree;
   };
 
   return new Proxy(defaultTag, {
@@ -20,18 +30,29 @@ export const buildTag = (language, defaultType) => {
     },
 
     get(_, type) {
+      const trees = new WeakMap();
+
       return (quasis, ...exprs) => {
-        return new TemplateParser(language, quasis.raw, exprs).eval({
-          language: language.name,
-          type,
-        });
+        let tree;
+        if (trees.has(quasis) && !exprs.length) {
+          tree = trees.get(quasis);
+        } else {
+          tree = new TemplateParser(language, quasis.raw, exprs).eval({
+            language: language.name,
+            type,
+          });
+
+          trees.set(quasis, tree);
+        }
+        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).eval({
     language: language.name,
     type,
   });

package/lib/languages/cstml.js

@@ -1,5 +1,6 @@
 import * as sym from '@bablr/agast-vm-helpers/symbols';
 import * as JSON from './json.js';
+import { get, sourceTextFor } from '@bablr/agast-helpers/tree';
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
@@ -33,16 +34,15 @@ export const covers = new Map([
       'OpenNodeTag',
       'CloseNodeTag',
       'LiteralTag',
-      'Trivia',
+      'BindingTag',
+      'InitializerTag',
+      'AttributeDefinition',
       'Number',
       'Digit',
       'Content',
       'NodeFlags',
     ]),
   ],
-  ['TagType', new Set(['Identifier', 'GlobalIdentifier'])],
-  ['Tag', new Set(['LiteralTag', 'Trivia'])],
-  ['PropertyValue', new Set(['GapTag', 'Node', 'NullTag'])],
 ]);
 
 export const grammar = class CSTMLMiniparserGrammar {
@@ -50,7 +50,7 @@ export const grammar = class CSTMLMiniparserGrammar {
   Document(p) {
     p.eatProduction('DoctypeTag', { path: 'doctype' });
     p.eatMatchTrivia(_);
-    p.eatProduction('Node', { path: 'tree' }, { fragment: true });
+    p.eatProduction('Node', { path: 'tree' }, { forceFragment: true });
   }
 
   // @Node
@@ -80,61 +80,104 @@ export const grammar = class CSTMLMiniparserGrammar {
     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);
+    let open = p.eatProduction('OpenNodeTag', { path: 'open', noInterpolate: true }, props);
 
     p.eatMatchTrivia(_);
 
-    if (open.properties.flags?.token) {
-      p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
-      p.eatMatchTrivia(_);
-    } else if (!open.properties.selfClosingTagToken) {
-      while (!(p.match('</') || p.done)) {
-        p.eatProduction('NodeChild', { path: 'children[]' });
+    if (open.attributes.balanced) {
+      let token = !!get(['flags', 'token'], open);
+
+      while (p.atExpression || !(p.match(/<\/[^/]/y) || p.done)) {
+        p.eatProduction('NodeChild', { path: 'children[]' }, { token });
         p.eatMatchTrivia(_);
       }
-    }
 
-    if (!open.properties.selfClosingTagToken) {
-      p.eatProduction('CloseNodeTag', { path: 'close' });
+      p.eatProduction('CloseNodeTag', { path: 'close', noInterpolate: true });
     }
   }
 
   NodeChild(p, props) {
     const { token } = props || {};
 
+    if (p.match('{')) {
+      p.eatProduction('AttributeDefinition');
+    }
+
     if (token) {
       if (p.match(/<\*?@/y)) {
-        p.eatProduction('Node');
+        p.eatProduction('Property');
       } else {
         p.eatProduction('LiteralTag');
       }
     } else {
-      if (p.match(/<\*?#/y)) {
-        p.eatProduction('Node');
-      } 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.eatMatchTrivia(_);
+    p.eatProduction('IdentifierPath', { path: 'key' });
+    p.eatMatchTrivia(_);
+    p.eat(':', PN, { path: 'sigilToken' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('JSON:Expression', { path: 'value' });
+    p.eatMatchTrivia(_);
+    p.eat('}', PN, { path: 'closeToken', balancer: true });
+  }
+
   // @Node
   Property(p) {
-    p.eatProduction('ReferenceTag', { path: 'reference' });
+    let ref = null;
+    if (p.match(/[a-zA-Z`\\\u{80}-\u{10ffff}.]|[.#@_]/uy)) {
+      ref = p.eatProduction('ReferenceTag', { path: 'reference' });
+    }
     p.eatMatchTrivia(_);
-    p.eatProduction('PropertyValue', { path: 'value' });
+    if (p.match(':')) {
+      p.eatProduction('BindingTag', { path: 'binding' });
+      p.eatMatchTrivia(_);
+    }
+    let refType = ref && get('type', ref);
+    p.eatProduction('PropertyValue', {
+      path: 'value',
+      allowFragment: refType && sourceTextFor(refType) === '_',
+    });
   }
 
-  PropertyValue(p) {
+  PropertyValue(p, { allowFragment }) {
     if (p.match('null')) {
       p.eatProduction('NullTag');
+    } else if (p.match(/\[\]|undefined/y)) {
+      p.eatProduction('InitializerTag');
     } else if (p.match('<//>')) {
       p.eatProduction('GapTag');
     } else {
-      p.eatProduction('Node');
+      p.eatProduction('Node', { allowFragment, propertyValue: true });
     }
   }
 
@@ -143,11 +186,16 @@ export const grammar = class CSTMLMiniparserGrammar {
     p.eatMatch('*', PN, { path: 'tokenToken' });
     p.eatMatch('$', PN, { path: 'hasGapToken' });
     p.eatMatch('_', PN, { path: 'fragmentToken' });
-    p.eatMatch('_', PN, { path: 'coverFragmentToken' });
+    p.eatMatch('_', PN, { path: 'multiFragmentToken' });
   }
 
   // @Node
-  OpenNodeTag(p, { fragment } = {}) {
+  OpenNodeTag(p, { forceFragment = false, allowFragment = true, propertyValue = false } = {}) {
+    if (p.match(/['"]/y)) {
+      p.eatProduction('JSON:String', { path: 'literalValue' });
+      return;
+    }
+
     p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
 
     let flags = null;
@@ -157,38 +205,48 @@ export const grammar = class CSTMLMiniparserGrammar {
 
     let sp = null;
 
-    if (fragment && !flags.properties.fragmentToken) throw new Error();
+    let fragmentFlag = get('fragmentToken', flags);
+    let multiFragmentFlag = get('multiFragmentFlag', flags);
+    let tokenFlag = get('tokenToken', flags);
 
-    if (!flags.properties.fragmentToken && !p.match(/./sy)) {
+    if (propertyValue && fragmentFlag && !multiFragmentFlag) throw new Error();
+
+    if (forceFragment && !fragmentFlag) throw new Error();
+
+    if (!fragmentFlag && !p.match(/./sy)) {
+      throw new Error();
+    }
+
+    if (fragmentFlag && !allowFragment) {
       throw new Error();
     }
 
-    if (!flags.properties.fragmentToken) {
-      p.eatProduction('TagType', { path: 'type' });
+    if (!fragmentFlag) {
+      p.eatProduction('Identifier', { path: 'type' });
 
       sp = p.eatMatchTrivia(_);
 
       let iv;
 
       if (sp && (p.match(/['"]/y) || p.atExpression)) {
-        iv = p.eatProduction('JSON:String', { path: 'intrinsicValue' });
+        iv = p.eatProduction('JSON:String', { path: 'literalValue' });
 
         sp = p.eatMatchTrivia(_);
       }
 
-      if (!flags.properties.tokenToken && iv) {
-        throw new Error();
-      }
-
       if (p.match('{') || p.atExpression) {
-        p.eatProduction('Object');
+        p.eatProduction('JSON:Object', { path: 'attributes' });
         sp = p.eatMatchTrivia(_);
       }
 
       p.eatMatchTrivia(_);
     }
-    p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
+    let sc = p.eatMatch('/', PN, { path: 'selfClosingToken' });
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+
+    const balanced = !sc && (p.path.depth > 0 || p.span.type !== 'Bare');
+
+    return { attrs: { balanced } };
   }
 
   // @Node
@@ -197,25 +255,13 @@ export const grammar = class CSTMLMiniparserGrammar {
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
-  TagType(p) {
-    if (
-      p.match(/['"]|[a-zA-Z`\\\u{80}-\u{10ffff}.]+:/uy) ||
-      (p.atExpression && p.quasis[p.quasiIdx + 1][0] === ':')
-    ) {
-      p.eatProduction('LanguageReference', { path: 'language' });
-      p.eat(':', PN, { path: 'namespaceSeparatorToken' });
-      p.eatProduction('Identifier', { path: 'type' });
-    } else {
-      p.eatProduction('Identifier', { path: 'type' });
-    }
-  }
-
-  LanguageReference(p) {
-    if (p.match(/['"]/y)) {
-      p.eatProduction('JSON:String');
-    } else {
+  // @Node
+  BindingTag(p) {
+    p.eat(':', PN, { path: 'openToken', startSpan: 'Tag', balanced: ':' });
+    if (!p.match(':')) {
       p.eatProduction('IdentifierPath');
     }
+    p.eat(':', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
   IdentifierPath(p) {
@@ -244,7 +290,7 @@ export const grammar = class CSTMLMiniparserGrammar {
     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);
@@ -266,26 +312,16 @@ export const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   ReferenceTag(p) {
-    let name;
-    if ((name = p.match(/[.#@]/y))) {
-      p.eat(name, PN, { path: 'name' });
-    } else {
-      p.eatProduction('Identifier', { path: 'name' });
+    let type;
+    if ((type = p.match(/[.#@_]/y))) {
+      p.eat(type, PN, { path: 'type' });
     }
-    p.eatMatchTrivia(_);
-    let open = p.eatMatch('[', PN, { path: 'openIndex', startSpan: 'Index', balanced: ']' });
 
-    if (open) {
-      p.eatMatchTrivia(_);
-
-      if (p.match(/\d/)) {
-        p.eatProduction('UnsignedInteger', { path: 'index' });
-      }
-
-      p.eatMatchTrivia(_);
-      p.eat(']', PN, { path: 'closeIndex', endSpan: 'Index', balancer: true });
+    if (!type || type === '#') {
+      p.eatProduction('Identifier', { path: 'name' });
     }
     p.eatMatchTrivia(_);
+
     if (p.match(/[+$]/y)) {
       p.eatProduction('ReferenceFlags', { path: 'flags' });
       p.eatMatchTrivia(_);

package/lib/languages/json.js

@@ -1,4 +1,4 @@
-import objectEntries from 'iter-tools/methods/object-entries';
+import objectEntries from 'iter-tools-es/methods/object-entries';
 import * as sym from '@bablr/agast-vm-helpers/symbols';
 import * as Spamex from './spamex.js';
 import * as CSTML from './cstml.js';
@@ -7,7 +7,7 @@ import * as Regex from './regex.js';
 const _ = /\s+/y;
 const PN = 'Punctuator';
 const KW = 'Keyword';
-const ID = 'Identifier';
+const LIT = 'Identifier';
 
 export const name = 'JSON';
 
@@ -34,6 +34,7 @@ export const covers = new Map([
       'Integer',
       'String',
       'StringContent',
+      'Identifier',
     ]),
   ],
   ['Expression', new Set(['Object', 'Array', 'Boolean', 'Null', 'Number', 'String'])],
@@ -68,7 +69,7 @@ export const cookEscape = (escape, span) => {
     return String.fromCodePoint(parseInt(hexMatch[1], 16));
   }
 
-  const litPattern = span === 'Single' ? /\\([\\gnrt0'])/y : /\\([\\gnrt0"])/y;
+  const litPattern = span.type === 'Single' ? /\\([\\gnrt0'])/y : /\\([\\gnrt0"])/y;
   const litMatch = litPattern.exec(escape);
 
   if (litMatch) {
@@ -125,7 +126,11 @@ export const grammar = class JSONMiniparserGrammar {
 
   // @Node
   Property(p) {
-    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
+    if (p.match(/['"]/y)) {
+      p.eatProduction('String', { path: 'key' });
+    } else {
+      p.eatProduction('Identifier', { path: 'key' });
+    }
     p.eatMatchTrivia(_);
     p.eat(':', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
@@ -216,6 +221,11 @@ export const grammar = class JSONMiniparserGrammar {
     p.eatLiteral(/\d/y);
   }
 
+  // @Node
+  Identifier(p) {
+    p.eat(/[a-zA-Z]+/y, LIT, { path: 'content' });
+  }
+
   // @Node
   String(p) {
     const q = p.match(/['"]/y) || '"';

package/lib/languages/regex.js

@@ -1,5 +1,5 @@
 import * as sym from '@bablr/agast-vm-helpers/symbols';
-import when from 'iter-tools/methods/when';
+import when from 'iter-tools-es/methods/when';
 import { escapables } from './json.js';
 
 export const name = 'Regex';
@@ -91,7 +91,7 @@ const unique = (flags) => flags.length === new Set(flags).size;
 const getSpecialPattern = (span) => {
   const { type } = span;
   if (type === 'Bare') {
-    return /[*+{}\[\]()\.^$|\\\n\/><]/y;
+    return /[*+?{}\[\]()\.^$|\\\n\/><]/y;
   } else if (type === 'CharacterClass') {
     return /[\]\\]/y;
   } else if (type === 'CharacterClass:First') {
@@ -206,7 +206,7 @@ export const grammar = class RegexMiniparserGrammar {
     }
 
     if (p.match(/[*+?]|{/y)) {
-      p.shiftProduction('Quantifier');
+      return { shift: 'Quantifier' };
     }
   }
 

package/lib/languages/spamex.js

@@ -2,6 +2,7 @@ import * as sym from '@bablr/agast-vm-helpers/symbols';
 import * as Regex from './regex.js';
 import * as CSTML from './cstml.js';
 import * as JSON from './json.js';
+import { get } from '@bablr/agast-helpers/path';
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
@@ -26,6 +27,7 @@ export const covers = new Map([
       'ArrayNodeMatcher',
       'NullNodeMatcher',
       'ReferenceMatcher',
+      'BindingMatcher',
       'OpenNodeMatcher',
       'CloseNodeMatcher',
       'Literal',
@@ -44,7 +46,7 @@ export const covers = new Map([
 export const grammar = class SpamexMiniparserGrammar {
   // @Cover
   Matcher(p) {
-    if (p.match(/[a-zA-Z.#@<]/y)) {
+    if (p.match(/[a-zA-Z.#@<:]/y)) {
       p.eatProduction('PropertyMatcher');
     } else if (p.match(/['"/]/y)) {
       p.eatProduction('StringMatcher');
@@ -80,20 +82,29 @@ export const grammar = class SpamexMiniparserGrammar {
 
     p.eatMatchTrivia(_);
 
+    if (p.match(':')) {
+      p.eatProduction('BindingMatcher', { path: 'bindingMatcher' });
+    }
+
+    p.eatMatchTrivia(_);
+
     p.eatProduction('NodeMatcher', { path: 'nodeMatcher' });
   }
 
   // @Node
   ReferenceMatcher(p) {
-    let name;
-    if ((name = p.match(/[.#@]/y))) {
-      name = p.eat(name, PN, { path: 'name' });
-    } else if (p.match(/[A-Za-z]/y)) {
+    let name, type;
+    if ((type = p.match(/[.#@]/y))) {
+      p.eat(type, PN, { path: 'type' });
+    }
+
+    if ((!type || type === '#') && p.match(/[A-Za-z]/y)) {
       name = p.eatProduction('CSTML:Identifier', { path: 'name' });
     }
 
     let open =
-      name && p.eatMatch('[', PN, { path: 'openIndexToken', startSpan: 'Index', balanced: ']' });
+      (name || type) &&
+      p.eatMatch('[', PN, { path: 'openIndexToken', startSpan: 'Index', balanced: ']' });
 
     if (open) {
       p.eatMatchTrivia(_);
@@ -108,6 +119,15 @@ export const grammar = class SpamexMiniparserGrammar {
     p.eat(':', PN, { path: 'mapToken' });
   }
 
+  // @Node
+  BindingMatcher(p) {
+    p.eat(':', PN, { path: 'openToken' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('CSTML:IdentifierPath', { path: 'languagePath' });
+    p.eatMatchTrivia(_);
+    p.eat(':', PN, { path: 'closeToken' });
+  }
+
   NodeMatcher(p) {
     if (p.match('<//>')) {
       p.eatProduction('GapNodeMatcher');
@@ -127,10 +147,10 @@ export const grammar = class SpamexMiniparserGrammar {
   BasicNodeMatcher(p) {
     let open = p.eatProduction('OpenNodeMatcher', { path: 'open' });
 
-    if (!open.properties.selfClosingTagToken) {
+    if (!get('selfClosingToken', open)) {
       p.eatMatchTrivia(_);
 
-      if (open.properties.flags?.token) {
+      if (get('flags', open)?.token) {
         // p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
         // p.eatMatchTrivia(_);
       } else {
@@ -152,20 +172,18 @@ export const grammar = class SpamexMiniparserGrammar {
       p.eatProduction('CSTML:NodeFlags', { path: 'flags' });
     }
 
-    if (p.match(/['"]|[a-zA-Z]+:/y) || p.atExpression) {
-      p.eatProduction('CSTML:TagType', { path: 'type', noInterpolate: true });
+    if (p.match(/[a-zA-Z]/y) || p.atExpression) {
+      p.eatProduction('CSTML:Identifier', { path: 'type' });
     } else if (p.match('?')) {
       p.eat('?', PN, { path: 'type' });
-    } else if (p.match(' ')) {
-      p.eatMatchTrivia(_);
-    } else {
-      p.eatProduction('CSTML:Identifier', { path: 'type' });
+    } else if (p.match('_')) {
+      p.eat('_', PN, { path: 'type' });
     }
 
     let sp = p.eatMatchTrivia(_);
 
     if (sp && ((p.match(/['"/]/y) && !p.match('/>')) || p.atExpression)) {
-      p.eatProduction('StringMatcher', { path: 'intrinsicValue' });
+      p.eatProduction('StringMatcher', { path: 'literalValue' });
 
       sp = p.eatMatchTrivia(_);
     }
@@ -176,7 +194,7 @@ export const grammar = class SpamexMiniparserGrammar {
     }
 
     p.eatMatchTrivia(_);
-    p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
+    p.eatMatch('/', PN, { path: 'selfClosingToken' });
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 

package/lib/match.js

@@ -51,8 +51,7 @@ export class Match {
 
     if (isNode && !isCover) {
       path.node = createNode();
-      path.node.type = type;
-      path.node.language = resolvedLanguage.canonicalURL;
+      path.node.type = Symbol.for(type);
     }
 
     return new Match(null, resolvedLanguage, id, attrs, path);
@@ -78,7 +77,6 @@ export class Match {
       }
       path.node = createNode();
       path.node.type = Symbol.for(type);
-      path.node.language = resolvedLanguage.canonicalURL;
     }
 
     return new Match(this, resolvedLanguage, id, { ...baseAttrs, ...attrs }, path);

package/lib/miniparser.js

@@ -1,12 +1,11 @@
 import escapeRegex from 'escape-string-regexp';
-import arrayLast from 'iter-tools/methods/array-last';
-import isString from 'iter-tools/methods/is-string';
-import isObject from 'iter-tools/methods/is-object';
-import find from 'iter-tools/methods/find';
-import every from 'iter-tools/methods/every';
+import arrayLast from 'iter-tools-es/methods/array-last';
+import isString from 'iter-tools-es/methods/is-string';
+import isObject from 'iter-tools-es/methods/is-object';
+import find from 'iter-tools-es/methods/find';
+import every from 'iter-tools-es/methods/every';
 import * as sym from '@bablr/agast-vm-helpers/symbols';
 import { Match } from './match.js';
-import { parsePath } from './path.js';
 import { isRegex, isArray, getPrototypeOf } from './utils.js';
 import { ReferenceTag, LiteralTag } from '@bablr/agast-helpers/symbols';
 import {
@@ -16,9 +15,10 @@ import {
   buildReferenceTag,
   nodeFlags,
 } from '@bablr/agast-helpers/builders';
-import { add, buildToken } from '@bablr/agast-helpers/tree';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
-import { get } from '@bablr/agast-helpers/path';
+import { add, buildToken, shift } from '@bablr/agast-helpers/tree';
+import * as Tags from '@bablr/agast-helpers/tags';
+import { buildPathSegment, get } from '@bablr/agast-helpers/path';
+import { parseReference } from '@bablr/agast-helpers/shorthand';
 
 const Escape = Symbol.for('Escape');
 
@@ -138,7 +138,7 @@ export class TemplateParser {
     }
   }
 
-  eval(id, attrs = {}, props = {}, shift = null) {
+  eval(id, attrs = {}, props = {}, shift_ = null) {
     const parentMatch = this.m;
     const parentPath = this.path?.node ? this.path : this.path?.parent;
     const { type } = id;
@@ -176,16 +176,16 @@ export class TemplateParser {
 
       if (parentPath?.node && (isNode || covers.has(type))) {
         const { node } = parentPath;
-        const path = parsePath(this.m.attrs.path);
+        const path = parseReference(this.m.attrs.path);
 
         if (isArray(result)) {
           for (const value of result) {
-            node.children = sumtree.push(node.children, path);
+            node.tags = Tags.push(node.tags, path);
 
             add(node, path, value);
           }
         } else {
-          node.children = sumtree.push(node.children, path);
+          node.tags = Tags.push(node.tags, path);
 
           add(node, path, result);
         }
@@ -201,10 +201,7 @@ export class TemplateParser {
 
       if (isNode) {
         let { node } = this.path;
-        node.children = sumtree.push(
-          node.children,
-          buildOpenNodeTag(nodeFlags, node.language, node.type),
-        );
+        node.tags = Tags.push(node.tags, buildOpenNodeTag(nodeFlags, node.type));
       }
 
       const result = getPrototypeOf(grammar)[type].call(grammar, this, props);
@@ -217,21 +214,29 @@ export class TemplateParser {
         const { node } = this.path;
         if (result?.attrs) {
           node.attributes = result.attrs;
-          node.children = sumtree.replaceAt(
+          node.tags = Tags.replaceAt(
             0,
-            node.children,
-            buildOpenNodeTag(nodeFlags, node.language, node.type, result.attrs),
+            node.tags,
+            buildOpenNodeTag(nodeFlags, node.type, result.attrs),
           );
         }
 
-        node.children = sumtree.push(node.children, buildCloseNodeTag());
+        node.tags = Tags.push(node.tags, buildCloseNodeTag());
 
         if (parentPath?.node && !covers.has(type)) {
-          const path = parsePath(this.m.attrs.path);
+          const path = parseReference(this.m.attrs.path);
 
-          add(parentPath.node, path, node, shift);
+          if (shift_ == null) {
+            add(parentPath.node, path, node);
+          } else {
+            shift(parentPath.node, path, node);
+          }
         }
       }
+
+      if (result?.shift) {
+        this.shiftProduction(result.shift);
+      }
     }
 
     this.m = this.m.parent;
@@ -239,13 +244,12 @@ export class TemplateParser {
     if (this.path?.node) {
       const isTag = (child) => [LiteralTag, Escape].includes(child.type);
 
-      const { children } = this.path.node;
+      const { tags } = this.path.node;
 
-      if (find(isTag, sumtree.traverse(children)) && every(isTag, sumtree.traverse(children))) {
+      if (find(isTag, Tags.traverse(tags)) && every(isTag, Tags.traverse(tags))) {
         throw new Error('strings must be wrapped in nodes');
       }
     }
-
     return path.node;
   }
 
@@ -289,21 +293,20 @@ export class TemplateParser {
 
     this.held = null;
 
-    const path = parsePath(attrs.path);
+    const path = parseReference(attrs.path);
 
-    add(node, path, held, 0);
+    add(node, path, held);
 
     return held;
   }
 
   shiftProduction(id, attrs = {}, props = {}) {
     const { node } = this;
-    const { properties } = node;
     // don't push a new path onto the stack
 
     // get the most recently produced node and detach it from its parent
 
-    const ref = sumtree.getAt(-2, node.children);
+    const ref = Tags.getAt(-1, node.tags).value.tags[0];
 
     if (!ref.value.flags.expression) throw new Error();
 
@@ -311,13 +314,13 @@ export class TemplateParser {
       throw new Error();
     }
 
-    this.held = get(ref, node);
+    this.held = get(buildPathSegment(ref.value.name, -1), node);
 
     let id_ = this.buildId(id);
 
     const shifted = this.eval(id_, attrs, props, 1);
 
-    // add(node, ref, shifted, 1);
+    // shift(node, ref, shifted);
 
     return shifted;
   }
@@ -336,10 +339,9 @@ export class TemplateParser {
 
     this.updateSpans(attrs);
 
-    const path_ = parsePath(attrs.path);
-    const language = this.language.canonicalURL;
+    const path_ = parseReference(attrs.path);
 
-    add(this.node, path_, buildToken(language, type, result, _attrs));
+    add(this.node, path_, buildToken(type, result, _attrs));
 
     return result;
   }
@@ -360,10 +362,9 @@ export class TemplateParser {
 
       this.idx += result.length;
 
-      const path = parsePath(attrs.path);
-      const language = this.language.canonicalURL;
+      const path = parseReference(attrs.path);
 
-      add(this.node, path, buildToken(language, type, result));
+      add(this.node, path, buildToken(type, result));
     }
     return result;
   }
@@ -375,11 +376,7 @@ export class TemplateParser {
 
     this.idx += result.length;
 
-    add(
-      this.node,
-      buildReferenceTag('#'),
-      buildToken('https://bablr.org/languages/core/en/space-tab-newline', 'Space', result),
-    );
+    add(this.node, buildReferenceTag('#'), buildToken('Space', result));
 
     return result;
   }
@@ -390,11 +387,7 @@ export class TemplateParser {
     if (result) {
       this.idx += result.length;
 
-      add(
-        this.node,
-        buildReferenceTag('#'),
-        buildToken('https://bablr.org/languages/core/en/space-tab-newline', 'Space', result),
-      );
+      add(this.node, buildReferenceTag('#'), buildToken('Space', result));
     }
 
     return result;
@@ -411,11 +404,7 @@ export class TemplateParser {
     const cooked = this.language.cookEscape(result, this.span);
     const attributes = { cooked };
 
-    add(
-      this.node,
-      buildReferenceTag('@'),
-      buildToken(this.language.canonicalURL, 'Escape', raw, attributes),
-    );
+    add(this.node, buildReferenceTag('@'), buildToken('Escape', raw, attributes));
 
     return result;
   }
@@ -430,11 +419,7 @@ export class TemplateParser {
       const cooked = this.language.cookEscape(result, this.span);
       const attributes = { cooked };
 
-      add(
-        this.node,
-        buildReferenceTag('@'),
-        buildToken(this.language.canonicalURL, 'Escape', raw, attributes),
-      );
+      add(this.node, buildReferenceTag('@'), buildToken('Escape', raw, attributes));
     }
 
     return result;
@@ -447,7 +432,7 @@ export class TemplateParser {
 
     this.idx += result.length;
 
-    this.node.children = sumtree.push(this.node.children, buildLiteralTag(result));
+    this.node.tags = Tags.push(this.node.tags, buildLiteralTag(result));
 
     return result;
   }
@@ -458,7 +443,7 @@ export class TemplateParser {
     if (result) {
       this.idx += result.length;
 
-      this.node.children = sumtree.push(this.node.children, buildLiteralTag(result));
+      this.node.tags = Tags.push(this.node.tags, buildLiteralTag(result));
     }
 
     return result;

package/lib/path.js

@@ -1,23 +1,9 @@
-import { buildReferenceTag } from '@bablr/agast-helpers/tree';
-
-const { hasOwn, freeze } = Object;
-const { isArray } = Array;
-
-export const parsePath = (str) => {
-  const match = /^([a-zA-Z]+)(\[\])?(\+)?(\$)?$/.exec(str);
-
-  if (!match) throw new Error();
-
-  let flags = freeze({ expression: !!match[3], hasGap: !!match[4] });
-
-  return buildReferenceTag(match[1], !!match[2], flags);
-};
-
 export class Path {
   constructor(id, attributes, parent = null) {
     this.id = id;
     this.attributes = attributes;
     this.parent = parent;
+    this.depth = parent ? parent.depth + 1 : 0
 
     this.node = null;
   }
@@ -46,36 +32,3 @@ export class Path {
     return new Path(id, attrs);
   }
 }
-
-export class PathResolver {
-  constructor(node) {
-    this.node = node;
-    this.counters = {};
-  }
-
-  get(path) {
-    const { node, counters } = this;
-
-    const { isArray: pathIsArray, name } = path;
-
-    if (!hasOwn(node.properties, name)) {
-      throw new Error(`cannot resolve {path: ${name}}`);
-    }
-
-    let value = node.properties[name];
-
-    if (pathIsArray) {
-      if (!isArray(value)) {
-        throw new Error(`cannot resolve {path: ${name}}: not an array`);
-      }
-
-      const counter = counters[name] ?? 0;
-
-      counters[name] = counter + 1;
-
-      value = value[counter];
-    }
-
-    return value;
-  }
-}

package/lib/utils.js

@@ -1,5 +1,5 @@
-import isArray from 'iter-tools/methods/is-array';
-import isString from 'iter-tools/methods/is-string';
+import isArray from 'iter-tools-es/methods/is-array';
+import isString from 'iter-tools-es/methods/is-string';
 
 const { getPrototypeOf } = Object;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"
@@ -20,11 +20,11 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.7.1",
-    "@bablr/agast-vm-helpers": "0.7.1",
-    "@iter-tools/imm-stack": "1.1.0",
+    "@bablr/agast-helpers": "0.9.0",
+    "@bablr/agast-vm-helpers": "0.9.0",
+    "@iter-tools/imm-stack": "1.2.0",
     "escape-string-regexp": "5.0.0",
-    "iter-tools": "^7.5.3"
+    "iter-tools-es": "^7.0.2"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.0",