@bablr/boot 0.6.3 → 0.7.1

package/lib/languages/cstml.js

@@ -1,132 +1,69 @@
-const objectEntries = require('iter-tools/methods/object-entries');
-
-const { buildCovers } = require('../utils.js');
-const sym = require('@bablr/boot-helpers/symbols');
+import * as sym from '@bablr/agast-helpers/symbols';
+import * as JSON from './json.js';
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
-const ID = 'Identifier';
 const KW = 'Keyword';
-const LIT = 'Literal';
-
-const name = 'CSTML';
-
-const canonicalURL = 'https://bablr.org/languages/core/en/cstml';
-
-const dependencies = {};
-
-const escapables = new Map(
-  objectEntries({
-    n: '\n',
-    r: '\r',
-    t: '\t',
-    0: '\0',
-  }),
-);
-
-const cookEscape = (escape, span) => {
-  let hexMatch;
-
-  if (!escape.startsWith('\\')) {
-    throw new Error('string escape must start with \\');
-  }
-
-  if ((hexMatch = /\\u([0-9a-f]{4})/iy.exec(escape))) {
-    //continue
-  } else if ((hexMatch = /\\u{([0-9a-f]+)}/iy.exec(escape))) {
-    //continue
-  }
 
-  if (hexMatch) {
-    return String.fromCodePoint(parseInt(hexMatch[1], 16));
-  }
-
-  const litPattern = span === 'Single' ? /\\([\\gnrt0'])/y : /\\([\\gnrt0"])/y;
-  const litMatch = litPattern.exec(escape);
+export const name = 'CSTML';
 
-  if (litMatch) {
-    if (litMatch[1] === 'g') {
-      return null;
-    } else {
-      return escapables.get(litMatch[1]) || litMatch[1];
-    }
-  }
+export const canonicalURL = 'https://bablr.org/languages/core/en/cstml';
 
-  throw new Error('unable to cook string escape');
+export const dependencies = {
+  JSON,
 };
 
-const covers = buildCovers({
-  [sym.node]: [
-    'Document',
-    'DocumentVersion',
-    'DoctypeTag',
-    'Attribute',
-    'Property',
-    'ReferenceTag',
-    'TagType',
-    'NullTag',
-    'GapTag',
-    'Node',
-    'Fragment',
-    'IdentifierPath',
-    'OpenNodeTag',
-    'CloseNodeTag',
-    'OpenFragmentTag',
-    'CloseFragmentTag',
-    'Tag',
-    'Number',
-    'Digit',
-    'String',
-    'Content',
-    'UnsignedInteger',
-    'Flags',
-    'Array',
-    'Object',
-    'Boolean',
-    'Null',
-    'Identifier',
-    'JSONProperty',
-    'JSONExpression',
+export const covers = new Map([
+  [
+    sym.node,
+    new Set([
+      'Document',
+      'DocumentVersion',
+      'DoctypeTag',
+      'Property',
+      'ReferenceTag',
+      'ReferenceFlags',
+      'Identifier',
+      'GlobalIdentifier',
+      'NullTag',
+      'GapTag',
+      'Node',
+      'IdentifierPath',
+      'OpenNodeTag',
+      'CloseNodeTag',
+      'LiteralTag',
+      'Trivia',
+      'Number',
+      'Digit',
+      'Content',
+      'NodeFlags',
+    ]),
   ],
-  [sym.fragment]: ['Attributes'],
-  Attribute: ['MappingAttribute', 'BooleanAttribute'],
-  JSONExpression: [
-    'Boolean',
-    'Null',
-    'Number',
-    'String',
-    'Array',
-    'Object',
-    'Identifier',
-    'Separator',
-  ],
-  TagType: ['Identifier', 'GlobalIdentifier'],
-  Tag: ['LiteralTag', 'Trivia'],
-  PropertyValue: ['GapTag', 'Node', 'NullTag'],
-  EmbeddedTag: ['LiteralTag'],
-  Number: ['Integer', 'Infinity'],
-});
-
-const grammar = class CSTMLMiniparserGrammar {
+  ['TagType', new Set(['Identifier', 'GlobalIdentifier'])],
+  ['Tag', new Set(['LiteralTag', 'Trivia'])],
+  ['PropertyValue', new Set(['GapTag', 'Node', 'NullTag'])],
+]);
+
+export const grammar = class CSTMLMiniparserGrammar {
   // @Node
   Document(p) {
     p.eatProduction('DoctypeTag', { path: 'doctype' });
     p.eatMatchTrivia(_);
-    p.eatProduction('Fragment', { path: 'tree' });
+    p.eatProduction('Node', { path: 'tree' });
   }
 
   // @Node
   DoctypeTag(p) {
     p.eat('<!', PN, { path: 'openToken' });
-    p.eatProduction('UnsignedInteger', { path: 'version' });
+    p.eatProduction('JSON:UnsignedInteger', { path: 'version' });
     p.eat(':', PN, { path: 'versionSeparatorToken' });
     p.eat('cstml', KW, { path: 'doctypeToken' });
 
-    let sp = p.eatMatchTrivia(_);
+    p.eatMatchTrivia(_);
 
-    if ((sp && p.match(/!?[a-zA-Z]/y)) || p.atExpression) {
-      p.eatProduction('Attributes');
-      sp = p.eatMatchTrivia(_);
+    if (p.match('{') || p.atExpression) {
+      p.eatProduction('JSON:Object', { path: 'attributes' });
+      p.eatMatchTrivia(_);
     }
 
     p.eat('>', PN, { path: 'closeToken' });
@@ -175,7 +112,7 @@ const grammar = class CSTMLMiniparserGrammar {
     } else {
       if (p.match(/<\*?#/y)) {
         p.eatProduction('Node');
-      } else if (p.match(/[a-zA-Z]|\./y)) {
+      } else if (p.match(/[a-zA-Z]|[.#@]/y)) {
         p.eatProduction('Property');
       } else if (p.match(/['"]/y)) {
         p.eatProduction('LiteralTag');
@@ -183,25 +120,6 @@ const grammar = class CSTMLMiniparserGrammar {
     }
   }
 
-  // @Node
-  Fragment(p) {
-    let open = p.eatProduction('OpenFragmentTag', { path: 'open' });
-
-    p.eatMatchTrivia(_);
-
-    if (open.properties.flags?.token) {
-      p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
-      p.eatMatchTrivia(_);
-    }
-
-    while (!(p.match('</') || p.done)) {
-      p.eatProduction('NodeChild', { path: 'children[]' });
-      p.eatMatchTrivia(_);
-    }
-
-    p.eatProduction('CloseFragmentTag', { path: 'close' });
-  }
-
   // @Node
   Property(p) {
     p.eatProduction('ReferenceTag', { path: 'reference' });
@@ -220,14 +138,9 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   // @Node
-  Flags(p) {
-    let tr = p.eatMatch('#', PN, { path: 'triviaToken' });
+  NodeFlags(p) {
     p.eatMatch('*', PN, { path: 'tokenToken' });
-    let esc = p.eatMatch('@', PN, { path: 'escapeToken' });
-    let exp = p.eatMatch('+', PN, { path: 'expressionToken' });
     p.eatMatch('$', PN, { path: 'hasGapToken' });
-
-    if ((tr && esc) || (exp && (tr || esc))) throw new Error();
   }
 
   // @Node
@@ -236,36 +149,36 @@ const grammar = class CSTMLMiniparserGrammar {
 
     let flags = null;
     if (!p.atExpression) {
-      flags = p.eatProduction('Flags', { path: 'flags' });
+      flags = p.eatProduction('NodeFlags', { path: 'flags' });
     }
 
-    if (p.done) {
-      p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
-      return;
-    }
+    let sp = null;
+    let isFragment = !p.match(/['"a-zA-Z]/y);
 
-    p.eatProduction('TagType', { path: 'type' });
+    if (!isFragment) {
+      p.eatProduction('TagType', { path: 'type' });
 
-    let sp = p.eatMatchTrivia(_);
+      sp = p.eatMatchTrivia(_);
 
-    let iv;
+      let iv;
 
-    if (sp && (p.match(/['"]/y) || p.atExpression)) {
-      iv = p.eatProduction('String', { path: 'intrinsicValue' });
+      if (sp && (p.match(/['"]/y) || p.atExpression)) {
+        iv = p.eatProduction('JSON:String', { path: 'intrinsicValue' });
 
-      sp = p.eatMatchTrivia(_);
-    }
+        sp = p.eatMatchTrivia(_);
+      }
 
-    if (!flags.properties.tokenToken && iv) {
-      throw new Error();
-    }
+      if (!flags.properties.tokenToken && iv) {
+        throw new Error();
+      }
 
-    if ((sp && p.match(/[a-zA-Z]+/y)) || p.atExpression) {
-      p.eatProduction('Attributes');
-      sp = p.eatMatchTrivia(_);
-    }
+      if (p.match('{') || p.atExpression) {
+        p.eatProduction('Object');
+        sp = p.eatMatchTrivia(_);
+      }
 
-    p.eatMatchTrivia(_);
+      p.eatMatchTrivia(_);
+    }
     p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
@@ -276,87 +189,8 @@ const grammar = class CSTMLMiniparserGrammar {
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
-  // @Node
-  OpenFragmentTag(p) {
-    p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
-
-    let flags = null;
-    if (!p.atExpression) {
-      flags = p.eatProduction('Flags', { path: 'flags' });
-    }
-
-    if (p.done) {
-      p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
-      return;
-    }
-  }
-
-  // @Node
-  CloseFragmentTag(p) {
-    p.eat('</', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
-  }
-
-  // @Fragment
-  Attributes(p) {
-    let sp = true;
-    while (sp && (p.match(/!?[a-zA-Z]/y) || p.atExpression)) {
-      if (p.atExpression) {
-        p.eatProduction('Attributes'); // ??
-      } else {
-        p.eatProduction('Attribute', { path: 'attributes[]' });
-      }
-      if (p.match(/\s+!?[a-zA-Z]/y) || (p.match(/\s+$/y) && !p.quasisDone)) {
-        sp = p.eatMatchTrivia(_);
-      } else {
-        sp = false;
-      }
-    }
-  }
-
-  // @Cover
-  Attribute(p) {
-    if (p.match(/[a-zA-Z][a-zA-Z-_]*\s*=/y)) {
-      p.eatProduction('MappingAttribute');
-    } else {
-      p.eatProduction('BooleanAttribute');
-    }
-  }
-
-  // @Node
-  BooleanAttribute(p) {
-    p.eatMatch('!', KW, { path: 'negateToken' });
-    p.eat(/[a-zA-Z][a-zA-Z-_]*/y, ID, { path: 'key' });
-  }
-
-  // @Node
-  MappingAttribute(p) {
-    p.eat(/[a-zA-Z][a-zA-Z-_]*/y, ID, { path: 'key' });
-    p.eatMatchTrivia(_);
-    p.eat('=', PN, { path: 'mapToken' });
-    p.eatMatchTrivia(_);
-    p.eatProduction('JSONExpression', { path: 'value' });
-  }
-
-  // @Cover
-  JSONExpression(p) {
-    if (p.match(/['"]/y)) {
-      p.eatProduction('String');
-    } else if (p.match(/[\d+-]/y)) {
-      p.eatProduction('Number');
-    } else if (p.match('[')) {
-      p.eatProduction('Array');
-    } else if (p.match('{')) {
-      p.eatProduction('Object');
-    } else if (p.match(/true|false/y)) {
-      p.eatProduction('Boolean');
-    } else if (p.match('null')) {
-      p.eatProduction('Null');
-    }
-  }
-
   TagType(p) {
-    if (p.match(/['"]|[a-zA-Z\.]+:/y)) {
+    if (p.match(/['"]|[a-zA-Z.]+:/y) || (p.atExpression && p.quasis[p.quasiIdx + 1][0] === ':')) {
       p.eatProduction('LanguageReference', { path: 'language' });
       p.eat(':', PN, { path: 'namespaceSeparatorToken' });
       p.eatProduction('Identifier', { path: 'type' });
@@ -367,7 +201,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   LanguageReference(p) {
     if (p.match(/['"]/y)) {
-      p.eatProduction('String');
+      p.eatProduction('JSON:String');
     } else {
       p.eatProduction('IdentifierPath');
     }
@@ -376,7 +210,7 @@ const grammar = class CSTMLMiniparserGrammar {
   IdentifierPath(p) {
     p.eatProduction('Identifier', { path: 'segments[]' });
     while (p.match('.')) {
-      p.eat('.', PN, { path: 'separators[]' });
+      p.eat('.', PN, { path: 'separatorTokens[]' });
       p.eatProduction('Identifier', { path: 'segments[]' });
     }
   }
@@ -397,164 +231,41 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   ReferenceTag(p) {
-    if (p.match('.')) {
-      p.eat('.', PN, { path: 'name' });
+    let name;
+    if ((name = p.match(/[.#@]/y))) {
+      p.eat(name, PN, { path: 'name' });
     } else {
       p.eatProduction('Identifier', { path: 'name' });
     }
     p.eatMatchTrivia(_);
-    p.eatMatch('[]', PN, { path: 'arrayToken' });
-    p.eatMatchTrivia(_);
-    p.eat(':', PN, { path: 'mapToken' });
-  }
-
-  // @Cover
-  EmbeddedTag(p) {
-    if (p.match(/!['"]/y)) {
-      p.eatProduction('Escape');
-    } else if (p.match(/['"]/y)) {
-      p.eatProduction('LiteralTag');
-    } else {
-      throw new Error();
-    }
-  }
+    let open = p.eatMatch('[', PN, { path: 'openIndex', startSpan: 'Index', balanced: ']' });
 
-  // @Node
-  Array(p) {
-    p.eat('[', PN, { path: 'openToken', balanced: ']' });
-
-    p.eatMatchTrivia(_);
+    if (open) {
+      p.eatMatchTrivia(_);
 
-    let first = true;
-    let sep;
-    while (first || (sep && (p.match(/./y) || p.atExpression))) {
-      p.eatProduction('JSONExpression', { path: 'elements[]' });
-      if (p.match(/\s*,?/y)) {
-        sep = p.eatProduction('Separator', { path: 'separators[]' });
+      if (p.match(/\d/)) {
+        p.eatProduction('UnsignedInteger', { path: 'index' });
       }
 
-      first = false;
+      p.eatMatchTrivia(_);
+      p.eat(']', PN, { path: 'closeIndex', endSpan: 'Index', balancer: true });
     }
-
-    p.eat(']', PN, { path: 'closeToken', balancer: true });
-  }
-
-  // @Node
-  Object(p) {
-    p.eat('{', PN, { path: 'openToken', balanced: '}' });
-
     p.eatMatchTrivia(_);
-
-    let first = true;
-    let sep;
-    while (first || (sep && (p.match(/./y) || p.atExpression))) {
-      p.eatProduction('JSONProperty', { path: 'properties[]' });
-      if (p.match(/\s*,?/y)) {
-        sep = p.eatProduction('Separator', { path: 'separators[]' });
-      }
-      first = false;
+    if (p.match(/[+$]/y)) {
+      p.eatProduction('ReferenceFlags', { path: 'flags' });
+      p.eatMatchTrivia(_);
     }
-
-    p.eatMatchTrivia(_);
-
-    p.eat('}', PN, { path: 'closeToken', balancer: true });
-  }
-
-  // @Node
-  JSONProperty(p) {
-    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
-    p.eatMatchTrivia(_);
     p.eat(':', PN, { path: 'mapToken' });
-    p.eatMatchTrivia(_);
-    p.eatProduction('JSONExpression', { path: 'value' });
-  }
-
-  // @Node
-  Boolean(p) {
-    p.eat(/true|false/y, KW, { path: 'sigilToken' });
-  }
-
-  // @Node
-  Null(p) {
-    p.eat('null', KW, { path: 'sigilToken' });
-  }
-
-  //@Node
-  Separator(p) {
-    p.eatMatchTrivia(_);
-    p.eatMatch(/,/y, PN, { path: 'separators[]' });
-    p.eatMatchTrivia(_);
-  }
-
-  //@Node
-  Number(p) {
-    if (p.match(/-?\d/y)) {
-      p.eatProduction('Integer');
-    } else {
-      p.eatProduction('Infinity');
-    }
   }
 
   // @Node
-  Integer(p) {
-    p.eatMatch('-', 'Punctuator', { path: 'negative' });
-    p.eatProduction('Digits', { path: 'digits[]' });
-  }
-
-  // @Node
-  UnsignedInteger(p) {
-    p.eatProduction('Digits', { path: 'digits[]' });
-  }
-
-  // @Node
-  Infinity(p) {
-    p.eatMatch(/[+-]/, 'Punctuator', { path: 'sign' });
-    p.eat('Infinity', 'Keyword', { path: 'value' });
-  }
-
-  Digits(p) {
-    while (p.match(/\d/y)) {
-      p.eatProduction('Digit');
-    }
-  }
-
-  // @Node
-  Digit(p) {
-    p.eatLiteral(/\d/y);
-  }
-
-  // @Node
-  String(p) {
-    const q = p.match(/['"]/y) || '"';
-
-    const span = q === '"' ? 'Double' : 'Single';
-
-    p.eat(q, PN, { path: 'openToken', startSpan: span, balanced: q });
-    while (p.match(/./sy) || p.atExpression) {
-      p.eatProduction('Content', { path: 'content' });
-    }
-    p.eat(q, PN, { path: 'closeToken', endSpan: span, balancer: true });
+  ReferenceFlags(p) {
+    p.eatMatch('+', PN, { path: 'expressionToken' });
+    p.eatMatch('$', PN, { path: 'hasGapToken' });
   }
 
   // @Node
-  Content(p) {
-    let esc, lit;
-    let i = 0;
-    do {
-      esc =
-        p.span.type === 'Single'
-          ? p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|[\\gnrt0'])/y)
-          : p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|[\\gnrt0"])/y);
-      lit =
-        p.span.type === 'Single'
-          ? p.eatMatchLiteral(/[^\r\n\0\\']+/y)
-          : p.eatMatchLiteral(/[^\r\n\0\\"]+/y);
-      i++;
-    } while (esc || lit);
-    if (i === 1 && !esc && !lit) {
-      throw new Error('Invalid string content');
-    }
+  Literal(p) {
+    p.eatProduction('JSON:String', { path: 'value' });
   }
 };
-
-module.exports = { name, canonicalURL, dependencies, covers, grammar, cookEscape, escapables };