@bablr/boot 0.9.0 → 0.11.0

package/lib/languages/instruction.js

@@ -1,11 +1,10 @@
-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';
-import * as BaseJSON from './json.js';
+import Spamex from './spamex.js';
+import CSTML from './cstml.js';
+import Regex from './regex.js';
+import BaseJSON from './json.js';
 
 const _ = /\s+/y;
-const PN = 'Punctuator';
+const PN = null;
 const ID = 'Identifier';
 const KW = 'Keyword';
 
@@ -31,7 +30,7 @@ const JSON = {
 export const dependencies = { Spamex, CSTML, Regex, JSON };
 
 export const covers = new Map([
-  [sym.node, new Set(['Call', 'Punctuator'])],
+  [Symbol.for('@bablr/node'), new Set(['Call'])],
   [
     'Expression',
     new Set([
@@ -42,7 +41,8 @@ export const covers = new Map([
       'CSTML:GapTag',
       'RegexString',
       'SpamexString',
-      'CSTMLString',
+      'TagString',
+      'NodeString',
       'Boolean',
       'Null',
     ]),
@@ -50,12 +50,11 @@ export const covers = new Map([
 ]);
 
 export const grammar = class InstructionMiniparserGrammar {
-  // @Node
   Call(p) {
     p.eat(/[a-zA-Z]+/y, ID, { path: 'verb' });
     p.eatMatchTrivia(_);
 
-    p.eat('(', PN, { path: 'openToken', balanced: ')' });
+    p.eat('(', PN, { path: 'openToken' });
 
     let sep = p.eatMatchTrivia(_);
 
@@ -66,40 +65,45 @@ export const grammar = class InstructionMiniparserGrammar {
       i++;
     }
 
-    p.eat(')', PN, { path: 'closeToken', balancer: true });
+    p.eat(')', PN, { path: 'closeToken' });
   }
 
-  // @Node
   SpamexString(p) {
     p.eat('m', KW, { path: 'sigilToken' });
     let quot = p.match(/['"`]/);
-    p.eat(quot, PN, { path: 'openToken', balanced: quot });
+    p.eat(quot, PN, { path: 'openToken' });
     p.eatProduction('Spamex:Matcher', { path: 'content' });
 
-    p.eat(quot, PN, { path: 'closeToken', balancer: true });
+    p.eat(quot, PN, { path: 'closeToken' });
   }
 
-  // @Node
-  CSTMLString(p) {
+  TagString(p) {
     p.eat('t', KW, { path: 'sigilToken' });
     let quot = p.match(/['"`]/);
-    p.eat(quot, PN, { path: 'openToken', balanced: quot });
+    p.eat(quot, PN, { path: 'openToken' });
     p.eatProduction('CSTML:Tag', { path: 'content' });
 
-    p.eat(quot, PN, { path: 'closeToken', balancer: true });
+    p.eat(quot, PN, { path: 'closeToken' });
+  }
+
+  NodeString(p) {
+    p.eat('n', KW, { path: 'sigilToken' });
+    let quot = p.match(/['"`]/);
+    p.eat(quot, PN, { path: 'openToken' });
+    p.eatProduction('CSTML:Node', { path: 'content' });
+
+    p.eat(quot, PN, { path: 'closeToken' });
   }
 
-  // @Node
   RegexString(p) {
     p.eat('re', KW, { path: 'sigilToken' });
     let quot = p.match(/['"`]/);
-    p.eat(quot, PN, { path: 'openToken', balanced: quot });
+    p.eat(quot, PN, { path: 'openToken' });
     p.eatProduction('Regex:Pattern', { path: 'content' });
 
-    p.eat(quot, PN, { path: 'closeToken', balancer: true });
+    p.eat(quot, PN, { path: 'closeToken' });
   }
 
-  // @Cover
   Expression(p) {
     if (p.match('[')) {
       p.eatProduction('JSON:Array');
@@ -111,6 +115,10 @@ export const grammar = class InstructionMiniparserGrammar {
       p.eatProduction('RegexString');
     } else if (p.match(/m['"`]/y)) {
       p.eatProduction('SpamexString');
+    } else if (p.match(/t['"`]/y)) {
+      p.eatProduction('TagString');
+    } else if (p.match(/n['"`]/y)) {
+      p.eatProduction('NodeString');
     } else if (p.match(/true|false/y)) {
       p.eatProduction('JSON:Boolean');
     } else if (p.match('null')) {
@@ -118,3 +126,5 @@ export const grammar = class InstructionMiniparserGrammar {
     }
   }
 };
+
+export default { name, canonicalURL, dependencies, covers, grammar };

package/lib/languages/json.js

@@ -1,25 +1,20 @@
 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 ID = 'Identifier';
+const LIT = 'Identifier';
 
 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',
@@ -34,6 +29,7 @@ export const covers = new Map([
       'Integer',
       'String',
       'StringContent',
+      'Identifier',
     ]),
   ],
   ['Expression', new Set(['Object', 'Array', 'Boolean', 'Null', 'Number', 'String'])],
@@ -83,7 +79,6 @@ export const cookEscape = (escape, span) => {
 };
 
 export const grammar = class JSONMiniparserGrammar {
-  // @Cover
   Expression(p) {
     if (p.match('[')) {
       p.eatProduction('Array');
@@ -102,9 +97,8 @@ export const grammar = class JSONMiniparserGrammar {
     }
   }
 
-  // @Node
   Object(p) {
-    p.eat('{', PN, { path: 'openToken', balanced: '}' });
+    p.eat('{', PN, { path: 'openToken' });
 
     p.eatMatchTrivia(_);
 
@@ -120,21 +114,23 @@ export const grammar = class JSONMiniparserGrammar {
 
     p.eatMatchTrivia(_);
 
-    p.eat('}', PN, { path: 'closeToken', balancer: true });
+    p.eat('}', PN, { path: 'closeToken' });
   }
 
-  // @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(_);
     p.eatProduction('Expression', { path: 'value' });
   }
 
-  // @Node
   Array(p) {
-    p.eat('[', PN, { path: 'openToken', balanced: ']' });
+    p.eat('[', PN, { path: 'openToken' });
 
     p.eatMatchTrivia(_);
 
@@ -149,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' });
   }
@@ -178,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' });
   }
@@ -211,12 +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' });
+  }
+
   String(p) {
     const q = p.match(/['"]/y) || '"';
 
@@ -229,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;
@@ -249,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 };