@bablr/boot 0.1.8 → 0.2.0

package/lib/languages/cstml.js

@@ -1,118 +1,198 @@
-const Regex = require('./regex.js');
-const StringLanguage = require('./string.js');
-const Number = require('./number.js');
+const objectEntries = require('iter-tools-es/methods/object-entries');
+
 const { buildCovers } = require('../utils.js');
 const sym = require('../symbols.js');
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
 const ID = 'Identifier';
+const KW = 'Keyword';
 const LIT = 'Literal';
 
 const name = 'CSTML';
 
-const dependencies = { Regex, String: StringLanguage, Number };
+const canonicalURL = 'https://bablr.org/languages/core/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);
+
+  if (litMatch) {
+    if (litMatch[1] === 'g') {
+      return null;
+    } else {
+      return escapables.get(litMatch[1]) || litMatch[1];
+    }
+  }
+
+  throw new Error('unable to cook string escape');
+};
 
 const covers = buildCovers({
   [sym.node]: [
+    'Document',
+    'DocumentVersion',
+    'DoctypeTag',
     'Attribute',
     'Property',
+    'Reference',
     'TagType',
+    'Null',
+    'Gap',
     'Node',
-    'OpenFragmentNodeTag',
-    'OpenTerminalNodeTag',
+    'IdentifierPath',
+    'OpenFragmentTag',
     'OpenNodeTag',
     'CloseNodeTag',
+    'CloseFragmentTag',
     'Terminal',
+    'Number',
+    'Digit',
+    'String',
+    'Content',
+    'UnsignedInteger',
   ],
   [sym.fragment]: ['Attributes', 'Fragment'],
   Attribute: ['MappingAttribute', 'BooleanAttribute'],
-  AttributeValue: ['String:String', 'Number:Number'],
+  AttributeValue: ['String', 'Number'],
   TagType: ['Identifier', 'GlobalIdentifier'],
   Terminal: ['Literal', 'Trivia', 'Escape'],
+  PropertyValue: ['Gap', 'Node', 'Null'],
   EmbeddedTerminal: ['Literal', 'Escape'],
+  Number: ['Integer', 'Infinity'],
 });
 
 const grammar = class CSTMLMiniparserGrammar {
   Fragment(p) {
     p.eatMatchTrivia(_);
-    p.eatProduction('OpenFragmentNodeTag', { path: 'open' });
-    p.eatProduction('FragmentChildren');
-    p.eatProduction('CloseNodeTag', { path: 'close' });
-    p.eatMatchTrivia(_);
-  }
-
-  FragmentChildren(p) {
+    p.eatProduction('OpenFragmentTag', { path: 'open' });
     p.eatMatchTrivia(_);
-    while (p.match(/#['"]|\w/y) || p.atExpression) {
-      if (p.match(/#['"]/y)) {
-        p.eatProduction('Trivia', { path: 'children[]' });
-      } else {
-        p.eatProduction('Property', { path: 'children[]' });
-      }
+    while (p.match(/<[^/]/y) || p.atExpression) {
+      p.eatProduction('Node', { path: 'root' });
       p.eatMatchTrivia(_);
     }
+    p.eatProduction('CloseFragmentTag', { path: 'close' });
+    p.eatMatchTrivia(_);
   }
 
   // @Node
-  Node(p) {
-    const openType = p.match('<|') ? 'OpenTerminalNodeTag' : 'OpenNodeTag';
-    const childrenType = openType === 'OpenNodeTag' ? 'NodeChildren' : 'TerminalNodeChildren';
+  Document(p) {
+    p.eatProduction('DoctypeTag', { path: 'doctype' });
+    p.eatProduction('Fragment', { path: 'tree' });
+  }
 
-    if (p.match('<>')) throw new Error('Fragment is not a node');
+  // @Node
+  DoctypeTag(p) {
+    p.eat('<!', PN, { path: 'open' });
+    p.eatProduction('UnsignedInteger', { path: 'version' });
+    p.eat(':', PN, { path: 'versionSeparator' });
+    p.eat('cstml', KW, { path: 'doctype' });
 
-    const open = p.eatProduction(openType, { path: 'open' });
-    if (!open.attributes.selfClosing) {
-      p.eatProduction(childrenType);
-      p.eatProduction('CloseNodeTag', { path: 'close' });
+    let sp = p.eatMatchTrivia(_);
+
+    if ((sp && p.match(/\w+/y)) || p.atExpression) {
+      p.eatProduction('Attributes');
+      sp = p.eatMatchTrivia(_);
     }
+
+    p.eat('>', PN, { path: 'close' });
+  }
+
+  // @Node
+  Null(p) {
+    p.eat('null', KW, { path: 'value' });
+  }
+
+  // @Node
+  Gap(p) {
+    p.eat('<//>', PN, { path: 'value' });
   }
 
-  NodeChildren(p) {
-    let properties = 0;
+  // @Node
+  Node(p) {
+    if (p.match('<>')) throw new Error('Fragment is not a node');
+
+    let open = p.eatProduction('OpenNodeTag', { path: 'open' });
 
     p.eatMatchTrivia(_);
-    while (p.match(/#['"]|\w/y) || p.atExpression) {
-      if (p.match(/#['"]/y)) {
-        p.eatProduction('Trivia', { path: 'children[]' });
-      } else {
-        p.eatProduction('Property', { path: 'children[]' });
-        properties++;
-      }
+
+    if (open.properties.flags?.token) {
+      p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
       p.eatMatchTrivia(_);
+    } else {
+      while (!p.match('</')) {
+        p.eatProduction('NodeChild', { path: 'children[]' });
+        p.eatMatchTrivia(_);
+      }
     }
 
-    if (!properties) throw new Error('Nodes must match text');
+    p.eatProduction('CloseNodeTag', { path: 'close' });
   }
 
-  TerminalNodeChildren(p) {
-    let properties = 0;
+  NodeChild(p, _, props) {
+    const { token } = props || {};
 
-    p.eatMatchTrivia(_);
-    while (p.match(/[!#]?['"]|\w/y) || p.atExpression) {
-      if (p.match(/[!#]?['"]/y)) {
-        p.eatProduction('Terminal', { path: 'children[]' });
-      } else {
-        p.eatProduction('Property', { path: 'children[]' });
-        properties++;
+    if (token) {
+      p.eatProduction('Literal');
+    } else {
+      if (p.match(/<\*?#/y)) {
+        p.eatProduction('Node');
+      } else if (p.match(/\w/y)) {
+        p.eatProduction('Property');
+      } else if (p.match(/['"]/y)) {
+        p.eatProduction('Literal');
       }
-      p.eatMatchTrivia(_);
     }
-
-    if (!properties) throw new Error('Nodes must match text');
   }
 
   // @Node
   Property(p) {
-    p.eat(/\w+/y, ID, { path: 'key' });
+    p.eatProduction('Reference', { path: 'reference' });
     p.eatMatchTrivia(_);
     p.eat(':', PN, { path: 'mapOperator' });
     p.eatMatchTrivia(_);
-    p.eatProduction('Node', { path: 'value' });
+    p.eatProduction('PropertyValue', { path: 'value' });
+  }
+
+  PropertyValue(p) {
+    if (p.match('null')) {
+      p.eatProduction('Null');
+    } else if (p.match('<//>')) {
+      p.eatProduction('Gap');
+    } else {
+      p.eatProduction('Node');
+    }
   }
 
   // @Node
-  OpenFragmentNodeTag(p) {
+  OpenFragmentTag(p) {
     p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
     p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
   }
@@ -120,30 +200,22 @@ const grammar = class CSTMLMiniparserGrammar {
   // @Node
   OpenNodeTag(p) {
     p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    p.eatProduction('TagType', { path: 'type' });
 
-    let sp = p.eatMatchTrivia(_);
-
-    if ((sp && p.match(/\w+/y)) || p.atExpression) {
-      p.eatProduction('Attributes');
-      sp = p.eatMatchTrivia(_);
-    }
+    let tr = p.eatMatch('#', PN, { path: 'triviaFlag' });
+    let tok = p.eatMatch('*', PN, { path: 'tokenFlag' });
+    let esc = p.eatMatch('@', PN, { path: 'escapeFlag' });
+    let exp = p.eatMatch('+', PN, { path: 'expressionFlag' });
 
-    p.eatMatchTrivia(_);
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
-  }
+    if ((tr && esc) || (exp && (tr || esc))) throw new Error();
 
-  // @Node
-  OpenTerminalNodeTag(p) {
-    p.eat('<|', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    p.eatMatchTrivia(_);
     p.eatProduction('TagType', { path: 'type' });
 
     let sp = p.eatMatchTrivia(_);
 
-    let value;
-    if (sp && p.match(/['"/]/y)) {
-      value = p.eatProduction('EmbeddedTerminal', { path: 'value' });
+    let iv;
+    if (tok && sp && (p.match(/['"/]/y) || p.atExpression)) {
+      iv = p.eatProduction('String', { path: 'intrinsicValue' });
+
       sp = p.eatMatchTrivia(_);
     }
 
@@ -153,15 +225,21 @@ const grammar = class CSTMLMiniparserGrammar {
     }
 
     p.eatMatchTrivia(_);
-    p.eat('|>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
-
-    return { attrs: { selfClosing: !!value } };
+    if (iv) {
+      p.eat('/', PN, { path: 'selfClosingToken' });
+    }
+    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
   }
 
   // @Node
   CloseNodeTag(p) {
     p.eat('</', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    // TODO permit .type
+    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+  }
+
+  // @Node
+  CloseFragmentTag(p) {
+    p.eat('</', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
     p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
   }
 
@@ -184,7 +262,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Cover
   Attribute(p) {
-    if (p.match(/\w+\s*=/y)) {
+    if (p.match(/\w[\w-_]*\s*=/y)) {
       p.eatProduction('MappingAttribute');
     } else {
       p.eatProduction('BooleanAttribute');
@@ -193,6 +271,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   BooleanAttribute(p) {
+    p.eat('!', KW, { path: 'negated' });
     p.eat(/\w+/y, ID, { path: 'key' });
   }
 
@@ -208,31 +287,41 @@ const grammar = class CSTMLMiniparserGrammar {
   // @Cover
   AttributeValue(p) {
     if (p.match(/['"]/y)) {
-      p.eatProduction('String:String');
-    } else if (p.match(/-|\d/y)) {
-      p.eatProduction('Number:Number');
+      p.eatProduction('String');
+    } else if (p.match(/[\d+-]/y)) {
+      p.eatProduction('Number');
     }
   }
 
-  // @Cover
   TagType(p) {
-    if (p.match(/\w+:/y)) {
-      p.eatProduction('GlobalIdentifier');
+    if (p.match(/[\w.]+:/y)) {
+      p.eatProduction('LanguageReference', { path: 'language' });
+      p.eat(':', PN, { path: 'namespaceOperator' });
+      p.eatProduction('Identifier', { path: 'type' });
     } else {
-      p.eat(/\w+/y, ID, { path: 'type' });
+      p.eatProduction('Identifier', { path: 'type' });
     }
   }
 
-  // @Node
-  GlobalIdentifier(p) {
-    p.eat(/\w+/y, ID, { path: 'language' });
-    p.eat(':', PN, { path: 'namespaceOperator' });
-    p.eat(/\w+/y, ID, { path: 'type' });
+  LanguageReference(p) {
+    if (p.match(/['"]/y)) {
+      p.eatProduction('String');
+    } else {
+      p.eatProduction('IdentifierPath');
+    }
+  }
+
+  IdentifierPath(p) {
+    p.eatProduction('Identifier', { path: 'segments[]' });
+    while (p.match('.')) {
+      p.eat('.', PN, { path: 'separators[]' });
+      p.eatProduction('Identifier', { path: 'segments[]' });
+    }
   }
 
   // @Node
   Identifier(p) {
-    p.eatLiteral(/\w+/y);
+    p.eatLiteral(/\w[\w-_]*/y);
   }
 
   // @Cover
@@ -248,6 +337,13 @@ const grammar = class CSTMLMiniparserGrammar {
     }
   }
 
+  // @Node
+  Reference(p) {
+    p.eatProduction('Identifier', { path: 'name' });
+    p.eatMatchTrivia(_);
+    p.eatMatch('[]', PN, { path: 'arrayOperator' });
+  }
+
   // @Cover
   EmbeddedTerminal(p) {
     if (p.match(/!['"]/y)) {
@@ -262,22 +358,91 @@ const grammar = class CSTMLMiniparserGrammar {
   // @Node
   Escape(p) {
     p.eat('!', PN, { path: 'escapeOperator' });
-    p.eatProduction('String:String', { path: 'rawValue' });
+    p.eatProduction('String', { path: 'rawValue' });
     p.eatMatchTrivia(_);
     p.eat(':', PN, { path: 'rawOperator' });
-    p.eatProduction('String:String', { path: 'value' });
+    p.eatProduction('String', { path: 'value' });
   }
 
   // @Node
   Trivia(p) {
     p.eat('#', PN, { path: 'trivializeOperator' });
-    p.eatProduction('String:String', { path: 'value' });
+    p.eatProduction('String', { path: 'value' });
   }
 
   // @Node
   Literal(p) {
-    p.eatProduction('String:String', { path: 'value' });
+    p.eatProduction('String', { path: 'value' });
+  }
+
+  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: 'open', startSpan: span, balanced: q });
+    while (p.match(/./sy) || p.atExpression) {
+      p.eatProduction('Content', { path: 'content' });
+    }
+    p.eat(q, PN, { path: 'close', endSpan: span, balancer: true });
+  }
+
+  // @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');
+    }
   }
 };
 
-module.exports = { name, dependencies, covers, grammar };
+module.exports = { name, canonicalURL, dependencies, covers, grammar, cookEscape, escapables };

package/lib/languages/instruction.js

@@ -1,6 +1,6 @@
 const Spamex = require('./spamex.js');
+const CSTML = require('./cstml.js');
 const Regex = require('./regex.js');
-const StringLanguage = require('./string.js');
 const { node } = require('../symbols.js');
 const { buildCovers } = require('../utils.js');
 
@@ -12,7 +12,9 @@ const LIT = 'Literal';
 
 const name = 'Instruction';
 
-const dependencies = { Spamex, Regex, String: StringLanguage };
+const canonicalURL = 'https://bablr.org/languages/core/bablr-vm-instruction';
+
+const dependencies = { Spamex, CSTML, Regex };
 
 const covers = buildCovers({
   [node]: ['Call', 'Punctuator', 'Property', 'Expression'],
@@ -21,7 +23,8 @@ const covers = buildCovers({
     'Array',
     'Tuple',
     'Identifier',
-    'String:String',
+    'CSTML:String',
+    'CSTML:Gap',
     'Regex:Pattern',
     'Boolean',
     'Null',
@@ -47,7 +50,9 @@ const grammar = class InstructionMiniparserGrammar {
     } else if (p.match('(')) {
       p.eatProduction('Tuple');
     } else if (p.match(/['"]/y)) {
-      p.eatProduction('String:String');
+      p.eatProduction('CSTML:String');
+    } else if (p.match('<//>')) {
+      p.eatProduction('CSTML:Gap');
     } else if (p.match('/')) {
       p.eatProduction('Regex:Pattern');
     } else if (p.match(/true|false/y)) {
@@ -133,4 +138,4 @@ const grammar = class InstructionMiniparserGrammar {
   }
 };
 
-module.exports = { name, dependencies, covers, grammar };
+module.exports = { name, canonicalURL, dependencies, covers, grammar };