@bablr/boot 0.9.0 → 0.10.0

package/lib/index.js

@@ -50,8 +50,9 @@ export const buildTag = (language, defaultType) => {
   });
 };
 
-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,6 +1,6 @@
 import * as sym from '@bablr/agast-vm-helpers/symbols';
 import * as JSON from './json.js';
-import { isArray } from 'iter-tools-es';
+import { get, sourceTextFor } from '@bablr/agast-helpers/tree';
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
@@ -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
@@ -98,25 +98,19 @@ export const grammar = class CSTMLMiniparserGrammar {
 
   // @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) {
-      let lastIndex = p.idx;
-      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 (p.idx === lastIndex) break;
-        lastIndex = p.idx;
       }
-    }
 
-    if (!open.properties.selfClosingTagToken) {
-      p.eatProduction('CloseNodeTag', { path: 'close' });
+      p.eatProduction('CloseNodeTag', { path: 'close', noInterpolate: true });
     }
   }
 
@@ -129,15 +123,17 @@ 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();
       }
     }
   }
@@ -157,18 +153,23 @@ export const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   Property(p) {
-    if (p.match(/[a-zA-Z`\\\u{80}-\u{10ffff}.]|[.#@]/uy)) {
-      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(_);
     if (p.match(':')) {
       p.eatProduction('BindingTag', { path: 'binding' });
       p.eatMatchTrivia(_);
     }
-    p.eatProduction('PropertyValue', { path: 'value' });
+    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)) {
@@ -176,7 +177,7 @@ export const grammar = class CSTMLMiniparserGrammar {
     } else if (p.match('<//>')) {
       p.eatProduction('GapTag');
     } else {
-      p.eatProduction('Node');
+      p.eatProduction('Node', { allowFragment, propertyValue: true });
     }
   }
 
@@ -185,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;
@@ -199,13 +205,23 @@ 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 (propertyValue && fragmentFlag && !multiFragmentFlag) throw new Error();
 
-    if (!flags.properties.fragmentToken && !p.match(/./sy)) {
+    if (forceFragment && !fragmentFlag) throw new Error();
+
+    if (!fragmentFlag && !p.match(/./sy)) {
+      throw new Error();
+    }
+
+    if (fragmentFlag && !allowFragment) {
       throw new Error();
     }
 
-    if (!flags.properties.fragmentToken) {
+    if (!fragmentFlag) {
       p.eatProduction('Identifier', { path: 'type' });
 
       sp = p.eatMatchTrivia(_);
@@ -213,24 +229,24 @@ export const grammar = class CSTMLMiniparserGrammar {
       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('JSON: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
@@ -274,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);
@@ -296,10 +312,12 @@ export const grammar = class CSTMLMiniparserGrammar {
 
   // @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(_);

package/lib/languages/json.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'])],
@@ -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/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';
@@ -92,15 +93,18 @@ export const grammar = class SpamexMiniparserGrammar {
 
   // @Node
   ReferenceMatcher(p) {
-    let name;
-    if ((name = p.match(/[.#@]/y))) {
-      name = p.eat(name, PN, { path: 'type' });
-    } 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(_);
@@ -143,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 {
@@ -179,7 +183,7 @@ export const grammar = class SpamexMiniparserGrammar {
     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(_);
     }
@@ -190,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

@@ -16,7 +16,7 @@ import {
   nodeFlags,
 } from '@bablr/agast-helpers/builders';
 import { add, buildToken, shift } from '@bablr/agast-helpers/tree';
-import * as sumtree from '@bablr/agast-helpers/children';
+import * as Tags from '@bablr/agast-helpers/tags';
 import { buildPathSegment, get } from '@bablr/agast-helpers/path';
 import { parseReference } from '@bablr/agast-helpers/shorthand';
 
@@ -180,12 +180,12 @@ export class TemplateParser {
 
         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,7 +201,7 @@ export class TemplateParser {
 
       if (isNode) {
         let { node } = this.path;
-        node.children = sumtree.push(node.children, buildOpenNodeTag(nodeFlags, node.type));
+        node.tags = Tags.push(node.tags, buildOpenNodeTag(nodeFlags, node.type));
       }
 
       const result = getPrototypeOf(grammar)[type].call(grammar, this, props);
@@ -214,14 +214,14 @@ 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,
+            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 = parseReference(this.m.attrs.path);
@@ -244,9 +244,9 @@ 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');
       }
     }
@@ -306,7 +306,7 @@ export class TemplateParser {
 
     // get the most recently produced node and detach it from its parent
 
-    const ref = sumtree.getAt(-3, node.children);
+    const ref = Tags.getAt(-1, node.tags).value.tags[0];
 
     if (!ref.value.flags.expression) throw new Error();
 
@@ -432,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;
   }
@@ -443,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,11 +1,9 @@
-const { hasOwn } = Object;
-const { isArray } = Array;
-
 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;
   }
@@ -34,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"
@@ -20,9 +20,9 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.8.0",
-    "@bablr/agast-vm-helpers": "0.8.0",
-    "@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-es": "^7.0.2"
   },