@bablr/boot 0.8.1 → 0.9.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,11 +30,21 @@ 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;
       };
     },
   });

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 { isArray } from 'iter-tools-es';
 
 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 {
@@ -80,6 +80,22 @@ 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);
@@ -90,9 +106,12 @@ export const grammar = class CSTMLMiniparserGrammar {
       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[]' });
         p.eatMatchTrivia(_);
+        if (p.idx === lastIndex) break;
+        lastIndex = p.idx;
       }
     }
 
@@ -104,6 +123,10 @@ export const grammar = class CSTMLMiniparserGrammar {
   NodeChild(p, props) {
     const { token } = props || {};
 
+    if (p.match('{')) {
+      p.eatProduction('AttributeDefinition');
+    }
+
     if (token) {
       if (p.match(/<\*?@/y)) {
         p.eatProduction('Node');
@@ -111,9 +134,7 @@ export const grammar = class CSTMLMiniparserGrammar {
         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.eatProduction('Property');
       } else if (p.match(/['"]/y)) {
         p.eatProduction('LiteralTag');
@@ -121,16 +142,37 @@ export const grammar = class CSTMLMiniparserGrammar {
     }
   }
 
+  // @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' });
+    if (p.match(/[a-zA-Z`\\\u{80}-\u{10ffff}.]|[.#@]/uy)) {
+      p.eatProduction('ReferenceTag', { path: 'reference' });
+    }
     p.eatMatchTrivia(_);
+    if (p.match(':')) {
+      p.eatProduction('BindingTag', { path: 'binding' });
+      p.eatMatchTrivia(_);
+    }
     p.eatProduction('PropertyValue', { path: 'value' });
   }
 
   PropertyValue(p) {
     if (p.match('null')) {
       p.eatProduction('NullTag');
+    } else if (p.match(/\[\]|undefined/y)) {
+      p.eatProduction('InitializerTag');
     } else if (p.match('<//>')) {
       p.eatProduction('GapTag');
     } else {
@@ -164,7 +206,7 @@ export const grammar = class CSTMLMiniparserGrammar {
     }
 
     if (!flags.properties.fragmentToken) {
-      p.eatProduction('TagType', { path: 'type' });
+      p.eatProduction('Identifier', { path: 'type' });
 
       sp = p.eatMatchTrivia(_);
 
@@ -181,7 +223,7 @@ export const grammar = class CSTMLMiniparserGrammar {
       }
 
       if (p.match('{') || p.atExpression) {
-        p.eatProduction('Object');
+        p.eatProduction('JSON:Object');
         sp = p.eatMatchTrivia(_);
       }
 
@@ -197,25 +239,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) {
@@ -268,24 +298,12 @@ export const grammar = class CSTMLMiniparserGrammar {
   ReferenceTag(p) {
     let name;
     if ((name = p.match(/[.#@]/y))) {
-      p.eat(name, PN, { path: 'name' });
+      p.eat(name, PN, { path: 'type' });
     } else {
       p.eatProduction('Identifier', { path: 'name' });
     }
     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 });
-    }
-    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';
@@ -68,7 +68,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) {

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

@@ -26,6 +26,7 @@ export const covers = new Map([
       'ArrayNodeMatcher',
       'NullNodeMatcher',
       'ReferenceMatcher',
+      'BindingMatcher',
       'OpenNodeMatcher',
       'CloseNodeMatcher',
       'Literal',
@@ -44,7 +45,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,6 +81,12 @@ export const grammar = class SpamexMiniparserGrammar {
 
     p.eatMatchTrivia(_);
 
+    if (p.match(':')) {
+      p.eatProduction('BindingMatcher', { path: 'bindingMatcher' });
+    }
+
+    p.eatMatchTrivia(_);
+
     p.eatProduction('NodeMatcher', { path: 'nodeMatcher' });
   }
 
@@ -87,7 +94,7 @@ export const grammar = class SpamexMiniparserGrammar {
   ReferenceMatcher(p) {
     let name;
     if ((name = p.match(/[.#@]/y))) {
-      name = p.eat(name, PN, { path: 'name' });
+      name = p.eat(name, PN, { path: 'type' });
     } else if (p.match(/[A-Za-z]/y)) {
       name = p.eatProduction('CSTML:Identifier', { path: 'name' });
     }
@@ -108,6 +115,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');
@@ -152,14 +168,12 @@ 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(_);

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 sumtree from '@bablr/agast-helpers/children';
+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,7 +176,7 @@ 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) {
@@ -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.children = sumtree.push(node.children, buildOpenNodeTag(nodeFlags, node.type));
       }
 
       const result = getPrototypeOf(grammar)[type].call(grammar, this, props);
@@ -220,18 +217,26 @@ export class TemplateParser {
           node.children = sumtree.replaceAt(
             0,
             node.children,
-            buildOpenNodeTag(nodeFlags, node.language, node.type, result.attrs),
+            buildOpenNodeTag(nodeFlags, node.type, result.attrs),
           );
         }
 
         node.children = sumtree.push(node.children, 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;
@@ -245,7 +250,6 @@ export class TemplateParser {
         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 = sumtree.getAt(-3, node.children);
 
     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;

package/lib/path.js

@@ -1,18 +1,6 @@
-import { buildReferenceTag } from '@bablr/agast-helpers/tree';
-
-const { hasOwn, freeze } = Object;
+const { hasOwn } = 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;

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.9.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",
+    "@bablr/agast-helpers": "0.8.0",
+    "@bablr/agast-vm-helpers": "0.8.0",
     "@iter-tools/imm-stack": "1.1.0",
     "escape-string-regexp": "5.0.0",
-    "iter-tools": "^7.5.3"
+    "iter-tools-es": "^7.0.2"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.0",