@bablr/boot 0.10.0 → 0.11.0

package/lib/languages/json.js

@@ -1,11 +1,7 @@
 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';
-import * as Regex from './regex.js';
 
 const _ = /\s+/y;
-const PN = 'Punctuator';
+const PN = null;
 const KW = 'Keyword';
 const LIT = 'Identifier';
 
@@ -13,13 +9,12 @@ export const name = 'JSON';
 
 export const canonicalURL = 'https://bablr.org/languages/core/en/cstml-json';
 
-export const dependencies = { Spamex, CSTML, Regex };
+export const dependencies = {};
 
 export const covers = new Map([
   [
-    sym.node,
+    Symbol.for('@bablr/node'),
     new Set([
-      'Punctuator',
       'Property',
       'Object',
       'Array',
@@ -84,7 +79,6 @@ export const cookEscape = (escape, span) => {
 };
 
 export const grammar = class JSONMiniparserGrammar {
-  // @Cover
   Expression(p) {
     if (p.match('[')) {
       p.eatProduction('Array');
@@ -103,9 +97,8 @@ export const grammar = class JSONMiniparserGrammar {
     }
   }
 
-  // @Node
   Object(p) {
-    p.eat('{', PN, { path: 'openToken', balanced: '}' });
+    p.eat('{', PN, { path: 'openToken' });
 
     p.eatMatchTrivia(_);
 
@@ -121,10 +114,9 @@ export const grammar = class JSONMiniparserGrammar {
 
     p.eatMatchTrivia(_);
 
-    p.eat('}', PN, { path: 'closeToken', balancer: true });
+    p.eat('}', PN, { path: 'closeToken' });
   }
 
-  // @Node
   Property(p) {
     if (p.match(/['"]/y)) {
       p.eatProduction('String', { path: 'key' });
@@ -137,9 +129,8 @@ export const grammar = class JSONMiniparserGrammar {
     p.eatProduction('Expression', { path: 'value' });
   }
 
-  // @Node
   Array(p) {
-    p.eat('[', PN, { path: 'openToken', balanced: ']' });
+    p.eat('[', PN, { path: 'openToken' });
 
     p.eatMatchTrivia(_);
 
@@ -154,15 +145,13 @@ export const grammar = class JSONMiniparserGrammar {
       first = false;
     }
 
-    p.eat(']', PN, { path: 'closeToken', balancer: true });
+    p.eat(']', PN, { path: 'closeToken' });
   }
 
-  // @Node
   Boolean(p) {
     p.eat(/true|false/y, KW, { path: 'sigilToken' });
   }
 
-  // @Node
   Null(p) {
     p.eat('null', KW, { path: 'sigilToken' });
   }
@@ -183,29 +172,24 @@ export const grammar = class JSONMiniparserGrammar {
     }
   }
 
-  // @Node
   Integer(p) {
-    p.eatMatch('-', 'Punctuator', { path: 'negative' });
+    p.eatMatch('-', PN, { path: 'negative' });
     p.eatProduction('Digits', { path: 'digits[]' });
   }
 
-  // @Node
   UnsignedInteger(p) {
     p.eatProduction('Digits', { path: 'digits[]' });
   }
 
-  // @Node
   Infinity(p) {
-    p.eatMatch(/[+-]/, 'Punctuator', { path: 'sign' });
+    p.eatMatch(/[+-]/y, PN, { path: 'sign' });
     p.eat('Infinity', 'Keyword', { path: 'sigilToken' });
   }
 
-  // @Node
   NotANumber(p) {
     p.eat('NaN', 'Keyword', { path: 'sigilToken' });
   }
 
-  // @Node
   Undefined(p) {
     p.eat('undefined', 'Keyword', { path: 'sigilToken' });
   }
@@ -216,17 +200,14 @@ export const grammar = class JSONMiniparserGrammar {
     }
   }
 
-  // @Node
   Digit(p) {
     p.eatLiteral(/\d/y);
   }
 
-  // @Node
   Identifier(p) {
     p.eat(/[a-zA-Z]+/y, LIT, { path: 'content' });
   }
 
-  // @Node
   String(p) {
     const q = p.match(/['"]/y) || '"';
 
@@ -239,7 +220,6 @@ export const grammar = class JSONMiniparserGrammar {
     p.eat(q, PN, { path: 'closeToken', endSpan: span, balancer: true });
   }
 
-  // @Node
   StringContent(p) {
     let esc, lit;
     let i = 0;
@@ -259,3 +239,5 @@ export const grammar = class JSONMiniparserGrammar {
     }
   }
 };
+
+export default { name, canonicalURL, dependencies, covers, grammar, cookEscape };

package/lib/languages/regex.js

@@ -1,4 +1,3 @@
-import * as sym from '@bablr/agast-vm-helpers/symbols';
 import when from 'iter-tools-es/methods/when';
 import { escapables } from './json.js';
 
@@ -10,7 +9,7 @@ export const dependencies = {};
 
 export const covers = new Map([
   [
-    sym.node,
+    Symbol.for('@bablr/node'),
     new Set([
       'RegExpLiteral',
       'Flags',
@@ -29,7 +28,6 @@ export const covers = new Map([
       'SpaceCharacterSet',
       'DigitCharacterSet',
       'Quantifier',
-      'Punctuator',
       'Keyword',
       'Escape',
       'Number',
@@ -82,7 +80,7 @@ const flags = {
   sticky: 'y',
 };
 
-const PN = 'Punctuator';
+const PN = null;
 const KW = 'Keyword';
 const ESC = 'Escape';
 
@@ -138,7 +136,6 @@ export const cookEscape = (escape, span) => {
 };
 
 export const grammar = class RegexMiniparserGrammar {
-  // @Node
   Pattern(p) {
     p.eat('/', PN, { path: 'openToken', balanced: '/' });
     p.eatProduction('Alternatives', { path: 'alternatives[]' });
@@ -149,7 +146,6 @@ export const grammar = class RegexMiniparserGrammar {
     }
   }
 
-  // @Node
   Flags(p) {
     const flagsStr = p.match(/[gimsuy]+/y) || '';
 
@@ -171,10 +167,9 @@ export const grammar = class RegexMiniparserGrammar {
   Alternatives(p) {
     do {
       p.eatProduction('Alternative');
-    } while (p.eatMatch('|', PN, { path: 'separatorTokens[]' }));
+    } while (p.eatMatch('|', PN, { path: '#separatorTokens' }));
   }
 
-  // @Node
   Alternative(p) {
     p.eatProduction('Elements', { path: 'elements[]+' });
   }
@@ -185,7 +180,6 @@ export const grammar = class RegexMiniparserGrammar {
     }
   }
 
-  // @Cover
   Element(p) {
     if (p.match('[')) {
       p.eatProduction('CharacterClass');
@@ -210,14 +204,12 @@ export const grammar = class RegexMiniparserGrammar {
     }
   }
 
-  // @Node
   Group(p) {
     p.eat('(?:', PN, { path: 'openToken', balanced: ')' });
     p.eatProduction('Alternatives', { path: 'alternatives[]' });
     p.eat(')', PN, { path: 'closeToken', balancer: true });
   }
 
-  // @Node
   CapturingGroup(p) {
     p.eat('(', PN, { path: 'openToken', balanced: ')' });
     p.eatProduction('Alternatives', { path: 'alternatives[]' });
@@ -234,20 +226,14 @@ export const grammar = class RegexMiniparserGrammar {
     }
   }
 
-  // @CoveredBy('Assertion')
-  // @Node
   StartOfInputAssertion(p) {
     p.eat('^', KW, { path: 'sigilToken' });
   }
 
-  // @CoveredBy('Assertion')
-  // @Node
   EndOfInputAssertion(p) {
     p.eat('$', KW, { path: 'sigilToken' });
   }
 
-  // @CoveredBy('Assertion')
-  // @Node
   WordBoundaryAssertion(p) {
     let attrs;
     if (p.eatMatch('\\', ESC, { path: 'escapeToken' })) {
@@ -259,7 +245,6 @@ export const grammar = class RegexMiniparserGrammar {
     return { attrs };
   }
 
-  // @Node
   Character(p) {
     const specialPattern = getSpecialPattern(p.span);
 
@@ -287,14 +272,13 @@ export const grammar = class RegexMiniparserGrammar {
     }
   }
 
-  // @Node
   CharacterClass(p) {
     p.eat('[', PN, { path: 'openToken', balanced: ']', startSpan: 'CharacterClass' });
 
     const negate = !!p.eatMatch('^', KW, { path: 'negateToken', boolean: true });
 
     let first = !negate;
-    while (p.match(/./sy)) {
+    while (p.match(/./sy) || p.atExpression) {
       p.eatProduction('CharacterClassElement', { path: 'elements[]' }, { first });
       first = false;
     }
@@ -304,7 +288,6 @@ export const grammar = class RegexMiniparserGrammar {
     return { attrs: { negate } };
   }
 
-  // @Cover
   CharacterClassElement(p, { first }) {
     if (p.match(/(.|\\(u(\{[0-9a-fA-F]{1,6}\}|[0-9a-fA-F]{4})|x[0-9a-fA-F]{2}|\w))-[^\]\n]/y)) {
       p.eatProduction('CharacterClassRange', undefined, { first });
@@ -317,13 +300,11 @@ export const grammar = class RegexMiniparserGrammar {
     }
   }
 
-  // @Node
   Gap(p) {
     p.eat('\\', PN, { path: 'escapeToken' });
     p.eat('g', KW, { path: 'value' });
   }
 
-  // @Node
   CharacterClassRange(p, { first }) {
     p.eatProduction('Character', {
       path: 'min',
@@ -353,14 +334,10 @@ export const grammar = class RegexMiniparserGrammar {
     return { attrs };
   }
 
-  // @CoveredBy('CharacterSet')
-  // @Node
   AnyCharacterSet(p) {
     p.eat('.', KW, { path: 'sigilToken' });
   }
 
-  // @CoveredBy('CharacterSet')
-  // @Node
   WordCharacterSet(p) {
     p.eat('\\', PN, { path: 'escapeToken' });
 
@@ -375,8 +352,6 @@ export const grammar = class RegexMiniparserGrammar {
     return { attrs };
   }
 
-  // @CoveredBy('CharacterSet')
-  // @Node
   SpaceCharacterSet(p) {
     p.eat('\\', PN, { path: 'escapeToken' });
 
@@ -391,8 +366,6 @@ export const grammar = class RegexMiniparserGrammar {
     return { attrs };
   }
 
-  // @CoveredBy('CharacterSet')
-  // @Node
   DigitCharacterSet(p) {
     p.eat('\\', PN, { path: 'escapeToken' });
 
@@ -407,7 +380,6 @@ export const grammar = class RegexMiniparserGrammar {
     return { attrs };
   }
 
-  // @Node
   Quantifier(p) {
     p.eatHeldProduction('Element', { path: 'element+' });
 
@@ -441,3 +413,5 @@ export const grammar = class RegexMiniparserGrammar {
     return { attrs };
   }
 };
+
+export default { name, canonicalURL, dependencies, covers, grammar, cookEscape };

package/lib/languages/spamex.js

@@ -1,12 +1,10 @@
-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 Regex from './regex.js';
+import CSTML from './cstml.js';
+import JSON from './json.js';
 import { get } from '@bablr/agast-helpers/path';
 
 const _ = /\s+/y;
-const PN = 'Punctuator';
-const ID = 'Identifier';
+const PN = null;
 
 export const name = 'Spamex';
 
@@ -16,85 +14,56 @@ export const dependencies = { CSTML, JSON, Regex };
 
 export const covers = new Map([
   [
-    sym.node,
+    Symbol.for('@bablr/node'),
     new Set([
       'CSTML:Identifier',
       'PropertyMatcher',
       'JSON:String',
       'Regex:Pattern',
-      'BasicNodeMatcher',
+      'TreeNodeMatcher',
       'GapNodeMatcher',
-      'ArrayNodeMatcher',
       'NullNodeMatcher',
       'ReferenceMatcher',
+      'BoundNodeMatcher',
       'BindingMatcher',
-      'OpenNodeMatcher',
-      'CloseNodeMatcher',
+      'TreeNodeMatcherOpen',
+      'TreeNodeMatcherClose',
       'Literal',
       'CSTML:NodeFlags',
     ]),
   ],
   ['AttributeValue', new Set(['JSON:String', 'CSTML:Number'])],
-  ['Matcher', new Set(['PropertyMatcher', 'JSON:String', 'Regex:Pattern'])],
-  [
-    'NodeMatcher',
-    new Set(['BasicNodeMatcher', 'GapNodeMatcher', 'ArrayNodeMatcher', 'NullNodeMatcher']),
-  ],
+  ['Matcher', new Set(['BoundNodeMatcher'])],
+  ['NodeMatcher', new Set(['TreeNodeMatcher', 'GapNodeMatcher', 'NullNodeMatcher'])],
   ['StringMatcher', new Set(['JSON:String', 'Regex:Pattern'])],
 ]);
 
 export const grammar = class SpamexMiniparserGrammar {
-  // @Cover
   Matcher(p) {
-    if (p.match(/[a-zA-Z.#@<:]/y)) {
-      p.eatProduction('PropertyMatcher');
-    } else if (p.match(/['"/]/y)) {
-      p.eatProduction('StringMatcher');
-    } else {
-      throw new Error(`Unexpected character ${p.chr}`);
-    }
+    p.eatProduction('BoundNodeMatcher');
   }
 
-  // @Node
-  // @CoveredBy('NodeMatcher')
   GapNodeMatcher(p) {
     p.eat('<//>', PN, { path: 'sigilToken' });
   }
 
-  // @Node
-  // @CoveredBy('NodeMatcher')
-  ArrayNodeMatcher(p) {
-    p.eat('[]', PN, { path: 'sigilToken' });
-  }
-
-  // @Node
-  // @CoveredBy('NodeMatcher')
   NullNodeMatcher(p) {
     p.eat('null', PN, { path: 'sigilToken' });
   }
 
-  // @Node
-  // @CoveredBy('Matcher')
   PropertyMatcher(p) {
-    if (p.match(/[a-zA-Z.#@]/y)) {
+    if (p.match(/[a-zA-Z.#@_]/y) || p.atExpression || null) {
       p.eatProduction('ReferenceMatcher', { path: 'refMatcher' });
     }
 
     p.eatMatchTrivia(_);
 
-    if (p.match(':')) {
-      p.eatProduction('BindingMatcher', { path: 'bindingMatcher' });
-    }
-
-    p.eatMatchTrivia(_);
-
-    p.eatProduction('NodeMatcher', { path: 'nodeMatcher' });
+    p.eatProduction('BoundNodeMatcher', { path: 'valueMatcher' });
   }
 
-  // @Node
   ReferenceMatcher(p) {
     let name, type;
-    if ((type = p.match(/[.#@]/y))) {
+    if ((type = p.match(/\.\.|[.#@_]/y))) {
       p.eat(type, PN, { path: 'type' });
     }
 
@@ -102,50 +71,64 @@ export const grammar = class SpamexMiniparserGrammar {
       name = p.eatProduction('CSTML:Identifier', { path: 'name' });
     }
 
-    let open =
-      (name || type) &&
-      p.eatMatch('[', PN, { path: 'openIndexToken', startSpan: 'Index', balanced: ']' });
-
-    if (open) {
-      p.eatMatchTrivia(_);
-      p.eat(']', PN, { path: 'closeIndexToken', endSpan: 'Index', balancer: true });
-    }
-
     p.eatMatchTrivia(_);
-    if (p.match(/[+$]/y)) {
+    if (!['#', '@'].includes(type)) {
       p.eatProduction('CSTML:ReferenceFlags', { path: 'flags' });
       p.eatMatchTrivia(_);
     }
     p.eat(':', PN, { path: 'mapToken' });
   }
 
-  // @Node
+  BoundNodeMatcher(p) {
+    while (p.match(':')) {
+      p.eatProduction('BindingMatcher', { path: 'bindingMatchers[]' });
+      p.eatMatchTrivia(_);
+    }
+
+    p.eatProduction('NodeMatcher', { path: 'nodeMatcher', noInterpolate: true });
+  }
+
   BindingMatcher(p) {
     p.eat(':', PN, { path: 'openToken' });
+
     p.eatMatchTrivia(_);
-    p.eatProduction('CSTML:IdentifierPath', { path: 'languagePath' });
-    p.eatMatchTrivia(_);
+    let first = true;
+    while (!p.match(':') && (first || p.match('/'))) {
+      if (!first) {
+        p.eat('/', PN, { path: '#separatorTokens' });
+      }
+      p.eatProduction('CSTML:BindingSegment', { path: 'segments[]' });
+      p.eatMatchTrivia(_);
+      first = false;
+    }
     p.eat(':', PN, { path: 'closeToken' });
   }
 
   NodeMatcher(p) {
-    if (p.match('<//>')) {
-      p.eatProduction('GapNodeMatcher');
-    } else if (p.match('<')) {
-      p.eatProduction('BasicNodeMatcher');
-    } else if (p.match('[')) {
-      p.eatProduction('ArrayNodeMatcher');
-    } else if (p.match('null')) {
-      p.eatProduction('NullNodeMatcher');
-    } else {
-      p.fail();
+    let chrs = p.match(/<\/\/?>|<|null/y);
+    switch (chrs) {
+      case '<//>':
+        p.eatProduction('GapNodeMatcher');
+        break;
+      case '</>':
+        p.fail();
+        break;
+      case 'null':
+        p.eatProduction('NullNodeMatcher');
+        break;
+      default:
+        p.eatProduction('TreeNodeMatcher', { noInterpolate: true });
+        break;
     }
   }
 
-  // @Node
-  // @CoveredBy('NodeMatcher')
-  BasicNodeMatcher(p) {
-    let open = p.eatProduction('OpenNodeMatcher', { path: 'open' });
+  TreeNodeMatcher(p) {
+    if (p.match(/[a-zA-Z.#@]/y) || p.atExpression) {
+      p.eatProduction('PropertyMatcher', { path: 'children[]', noInterpolate: true });
+      return;
+    }
+
+    let open = p.eatProduction('TreeNodeMatcherOpen', { path: 'open' });
 
     if (!get('selfClosingToken', open)) {
       p.eatMatchTrivia(_);
@@ -160,24 +143,31 @@ export const grammar = class SpamexMiniparserGrammar {
         // }
       }
 
-      p.eatProduction('CloseNodeMatcher', { path: 'close' });
+      p.eatProduction('TreeNodeMatcherClose', { path: 'close' });
     }
   }
 
-  // @Node
-  OpenNodeMatcher(p) {
-    p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
+  TreeNodeMatcherOpen(p) {
+    if (p.match(/['"/]/y)) {
+      p.eatProduction('CSTML:NodeFlags', { path: 'flags', token: true });
+      p.eatProduction('StringMatcher', { path: 'literalValue' });
+
+      return { attrs: { selfClosing: true } };
+    }
+
+    p.eat('<', PN, { path: 'openToken' });
 
     if (!p.atExpression) {
       p.eatProduction('CSTML:NodeFlags', { path: 'flags' });
     }
 
+    let type;
+    if ((type = p.match(/[?]|__?/y))) {
+      p.eat(type, PN, { path: 'type' });
+    }
+
     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.eat('_', PN, { path: 'type' });
+      p.eatProduction('CSTML:Identifier', { path: 'name' });
     }
 
     let sp = p.eatMatchTrivia(_);
@@ -194,16 +184,17 @@ export const grammar = class SpamexMiniparserGrammar {
     }
 
     p.eatMatchTrivia(_);
-    p.eatMatch('/', PN, { path: 'selfClosingToken' });
-    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+    let sc = p.eatMatch('/', PN, { path: 'selfClosingToken' });
+    p.eat('>', PN, { path: 'closeToken' });
+
+    return { attrs: { selfClosing: !!sc } };
   }
 
-  CloseNodeMatcher(p) {
-    p.eat('</', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+  TreeNodeMatcherClose(p) {
+    p.eat('</', PN, { path: 'openToken' });
+    p.eat('>', PN, { path: 'closeToken' });
   }
 
-  // @Cover
   StringMatcher(p) {
     if (p.match(/['"]/y)) {
       p.eatProduction('JSON:String');
@@ -212,3 +203,5 @@ export const grammar = class SpamexMiniparserGrammar {
     }
   }
 };
+
+export default { name, canonicalURL, dependencies, covers, grammar };

package/lib/match.js

@@ -1,7 +1,8 @@
-import { createNode } from '@bablr/agast-helpers/tree';
 import { Path } from './path.js';
 import { resolveDependentLanguage } from './utils.js';
 import * as sym from '@bablr/agast-vm-helpers/symbols';
+import { buildOpenCoverTag, buildOpenNodeTag, nodeFlags } from '@bablr/agast-helpers/builders';
+import { buildNode } from '@bablr/agast-helpers/path';
 
 export class Match {
   constructor(parent, resolvedLanguage, id, attributes, path) {
@@ -18,10 +19,10 @@ export class Match {
   }
 
   get isNode() {
-    const { type, resolvedLanguage } = this;
+    const { name, resolvedLanguage } = this;
     const { covers } = resolvedLanguage;
 
-    return covers.get(sym.node).has(type) && !covers.has(type);
+    return covers.get(Symbol.for('@bablr/node')).has(name) && !covers.has(name);
   }
 
   get language() {
@@ -32,6 +33,10 @@ export class Match {
     return this.id.type;
   }
 
+  get name() {
+    return this.id.name;
+  }
+
   get attrs() {
     return this.attributes;
   }
@@ -39,20 +44,19 @@ export class Match {
   static from(language, id, attrs = {}) {
     const resolvedLanguage = resolveDependentLanguage(language, id.language);
     const { covers } = resolvedLanguage;
-    const { type } = id;
-    const isCover = covers.has(type);
-    const isNode = covers.get(sym.node).has(type);
+    const { name } = id;
+    const isCover = covers.has(name);
+    const isNode = covers.get(Symbol.for('@bablr/node')).has(name);
 
     if (!isNode && !isCover) {
-      throw new Error(`Top {type: ${type}} must be a node or fragment`);
+      throw new Error(`Top {type: ${name}} must be a node or fragment`);
     }
 
     const path = Path.from(id, attrs);
 
-    if (isNode && !isCover) {
-      path.node = createNode();
-      path.node.type = Symbol.for(type);
-    }
+    path.node = buildNode(
+      isCover ? buildOpenCoverTag(nodeFlags, name) : buildOpenNodeTag(nodeFlags, name),
+    );
 
     return new Match(null, resolvedLanguage, id, attrs, path);
   }
@@ -60,9 +64,9 @@ export class Match {
   generate(id, attrs) {
     const resolvedLanguage = resolveDependentLanguage(this.resolvedLanguage, id.language);
     const { covers } = resolvedLanguage;
-    const { type } = id;
-    const isCover = covers.has(type);
-    const isNode = covers.get(sym.node).has(type) && !isCover;
+    const { name } = id;
+    const isCover = covers.has(name);
+    const isNode = covers.get(Symbol.for('@bablr/node')).has(name) && !isCover;
 
     const baseAttrs = this.isNode ? {} : this.attrs;
 
@@ -75,8 +79,7 @@ export class Match {
       } else {
         path = path.generate(id, attrs);
       }
-      path.node = createNode();
-      path.node.type = Symbol.for(type);
+      path.node = buildNode(buildOpenNodeTag(nodeFlags, name));
     }
 
     return new Match(this, resolvedLanguage, id, { ...baseAttrs, ...attrs }, path);