@bablr/boot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Conrad Buck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+## @bablr/boot
+
+What a great name. BABLR is defined in terms of BABLR, so this repo helps BABLR boot up without getting stuck in dependency cycles!

package/lib/index.js

@@ -0,0 +1,38 @@
+const instruction = require('./languages/instruction.js');
+const regex = require('./languages/regex.js');
+const spamex = require('./languages/spamex.js');
+const string = require('./languages/string.js');
+const cstml = require('./languages/cstml.js');
+const { TemplateParser } = require('./miniparser.js');
+
+const buildTag = (language, defaultType) => {
+  const defaultTag = (quasis, ...exprs) => {
+    return new TemplateParser(language, quasis.raw, exprs).eval({
+      language: language.name,
+      type: defaultType,
+    });
+  };
+
+  return new Proxy(defaultTag, {
+    apply(defaultTag, receiver, argsList) {
+      return defaultTag.apply(receiver, argsList);
+    },
+
+    get(_, type) {
+      return (quasis, ...exprs) => {
+        return new TemplateParser(language, quasis.raw, exprs).eval({
+          language: language.name,
+          type,
+        });
+      };
+    },
+  });
+};
+
+const i = buildTag(instruction, 'Call');
+const spam = buildTag(spamex, 'Matcher');
+const re = buildTag(regex, 'Pattern');
+const str = buildTag(string, 'String');
+const cst = buildTag(cstml, 'Node');
+
+module.exports = { re, spam, str, i, cst };

package/lib/languages/cstml.js

@@ -0,0 +1,131 @@
+const Regex = require('./regex.js');
+const StringLanguage = require('./string.js');
+const { buildCovers } = require('../utils.js');
+const sym = require('../symbols.js');
+
+const _ = /\s+/y;
+const PN = 'Punctuator';
+const ID = 'Identifier';
+
+const name = 'CSTML';
+
+const dependencies = { Regex, String: StringLanguage };
+
+const covers = buildCovers({
+  [sym.node]: ['Attribute', 'Property', 'TagType', 'Node', 'OpenNodeTag', 'CloseNodeTag'],
+  [sym.fragment]: ['Attributes'],
+  Attribute: ['StringAttribute', 'BooleanAttribute'],
+  TagType: ['Identifier', 'GlobalIdentifier'],
+});
+
+const grammar = class CSTMLMiniparserGrammar {
+  Fragment(p) {
+    p.eatMatchTrivia(_);
+    while (p.match(/<[^/]/y) || p.atExpression) {
+      p.eatProduction('Property', { path: 'properties' });
+      p.eatMatchTrivia(_);
+    }
+  }
+
+  // @Node
+  Property(p) {
+    p.eat(/\w+/y, ID, { path: 'key' });
+    p.eatMatchTrivia(_);
+    p.eat(':', PN, { path: 'mapOperator' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('Node', { path: 'value' });
+  }
+
+  // @Node
+  Node(p) {
+    p.eatProduction('OpenNodeTag', { path: 'open' });
+    p.eatProduction('Fragment');
+    p.eatProduction('CloseNodeTag', { path: 'close' });
+  }
+
+  // @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(_);
+    }
+
+    p.eatMatchTrivia(_);
+    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+  }
+
+  // @Node
+  CloseNodeTag(p) {
+    p.eat('</', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
+
+    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+  }
+
+  // @Fragment
+  Attributes(p) {
+    let sp = true;
+    while (sp && (p.match(/\w+/y) || p.atExpression)) {
+      if (p.atExpression) {
+        p.eatProduction('Attributes'); // ??
+      } else {
+        p.eatProduction('Attribute', { path: '[attributes]' });
+      }
+      if (p.match(/\s+\w/y) || (p.match(/\s+$/y) && !p.quasisDone)) {
+        sp = p.eatMatchTrivia(_);
+      } else {
+        sp = false;
+      }
+    }
+  }
+
+  // @Cover
+  Attribute(p) {
+    if (p.match(/\w+\s*=/y)) {
+      p.eatProduction('StringAttribute');
+    } else {
+      p.eatProduction('BooleanAttribute');
+    }
+  }
+
+  // @Node
+  BooleanAttribute(p) {
+    p.eat(/\w+/y, ID, { path: 'key' });
+  }
+
+  // @Node
+  StringAttribute(p) {
+    p.eat(/\w+/y, ID, { path: 'key' });
+    p.eatMatchTrivia(_);
+    p.eat('=', PN, { path: 'mapOperator' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('String:String', { path: 'value' });
+  }
+
+  // @Cover
+  TagType(p) {
+    if (p.match(/\w+:/y)) {
+      p.eatProduction('GlobalIdentifier');
+    } else {
+      p.eat(/\w+/y, ID, { path: 'type' });
+    }
+  }
+
+  // @Node
+  GlobalIdentifier(p) {
+    p.eat(/\w+/y, ID, { path: 'language' });
+    p.eat(':', PN, { path: 'namespaceOperator' });
+    p.eat(/\w+/y, ID, { path: 'type' });
+  }
+
+  // @Node
+  Identifier(p) {
+    p.eatLiteral(/\w+/y);
+  }
+};
+
+module.exports = { name, dependencies, covers, grammar };

package/lib/languages/instruction.js

@@ -0,0 +1,135 @@
+const Spamex = require('./spamex.js');
+const Regex = require('./regex.js');
+const StringLanguage = require('./string.js');
+const { node } = require('../symbols.js');
+const { buildCovers } = require('../utils.js');
+
+const _ = /\s+/y;
+const PN = 'Punctuator';
+const ID = 'Identifier';
+const KW = 'Keyword';
+const LIT = 'Literal';
+
+const name = 'Instruction';
+
+const dependencies = { Spamex, Regex, String: StringLanguage };
+
+const covers = buildCovers({
+  [node]: ['Call', 'Punctuator', 'Property', 'Expression'],
+  Expression: [
+    'Object',
+    'Array',
+    'Tuple',
+    'Identifier',
+    'String:String',
+    'Regex:Pattern',
+    'Boolean',
+    'Null',
+    'Spamex:Matcher',
+  ],
+});
+
+const grammar = class InstructionMiniparserGrammar {
+  // @Node
+  Call(p) {
+    p.eat(/\w+/y, ID, { path: 'verb' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('Tuple', { path: 'arguments' });
+  }
+
+  // @Cover
+  Expression(p) {
+    if (p.match('[')) {
+      p.eatProduction('Array');
+    } else if (p.match('{')) {
+      p.eatProduction('Object');
+    } else if (p.match('(')) {
+      p.eatProduction('Tuple');
+    } else if (p.match(/['"]/y)) {
+      p.eatProduction('String:String');
+    } else if (p.match('/')) {
+      p.eatProduction('Regex:Pattern');
+    } else if (p.match(/true|false/y)) {
+      p.eatProduction('Boolean');
+    } else if (p.match('null')) {
+      p.eatProduction('Null');
+    } else if (p.match(/\w/y)) {
+      p.eat(/\w+/y, ID, p.m.attributes);
+    } else if (p.match('<')) {
+      p.eatProduction('Spamex:Matcher');
+    }
+  }
+
+  // @Node
+  Object(p) {
+    p.eat('{', PN, { path: 'open', balanced: '}' });
+
+    p.eatMatchTrivia(_);
+
+    let first = true;
+    let sep;
+    while (first || (sep && (p.match(/./y) || p.atExpression))) {
+      p.eatProduction('Property', { path: '[properties]' });
+      sep = p.eatMatchTrivia(_);
+      first = false;
+    }
+
+    p.eatMatchTrivia(_);
+
+    p.eat('}', PN, { path: 'close', balancer: true });
+  }
+
+  // @Node
+  Property(p) {
+    p.eat(/\w+/y, LIT, { path: 'key' });
+    p.eatMatchTrivia(_);
+    p.eat(':', PN, { path: 'mapOperator' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('Expression', { path: 'value' });
+  }
+
+  // @Node
+  Array(p) {
+    p.eat('[', PN, { path: 'open', balanced: ']' });
+
+    p.eatMatchTrivia(_);
+
+    let first = true;
+    let sep;
+    while (first || (sep && (p.match(/./y) || p.atExpression))) {
+      p.eatProduction('Expression', { path: '[elements]' });
+      sep = p.eatMatchTrivia(_);
+      first = false;
+    }
+
+    p.eat(']', PN, { path: 'close', balancer: true });
+  }
+
+  // @Node
+  Tuple(p) {
+    p.eat('(', PN, { path: 'open', balanced: ')' });
+
+    let sep = p.eatMatchTrivia(_);
+
+    let i = 0;
+    while (i === 0 || (sep && (p.match(/./y) || p.atExpression))) {
+      p.eatProduction('Expression', { path: '[values]' });
+      sep = p.eatMatchTrivia(_);
+      i++;
+    }
+
+    p.eat(')', PN, { path: 'close', balancer: true });
+  }
+
+  // @Node
+  Boolean(p) {
+    p.eat(/true|false/y, KW, { path: 'value' });
+  }
+
+  // @Node
+  Null(p) {
+    p.eat(/null/y, KW, { path: 'value' });
+  }
+};
+
+module.exports = { name, dependencies, covers, grammar };

package/lib/languages/regex.js

@@ -0,0 +1,319 @@
+const when = require('iter-tools-es/methods/when');
+const { escapables } = require('./string.js');
+const { buildCovers } = require('../utils.js');
+const { node } = require('../symbols.js');
+
+const name = 'Regex';
+
+const dependencies = {};
+
+const covers = buildCovers({
+  [node]: [
+    'RegExpLiteral',
+    'Flag',
+    'Pattern',
+    'Alternative',
+    'Group',
+    'CapturingGroup',
+    'Assertion',
+    'Character',
+    'CharacterClass',
+    'CharacterClassRange',
+    'CharacterSet',
+    'Quantifier',
+    'Punctuator',
+    'Keyword',
+    'Escape',
+    'Number',
+  ],
+  CharacterClassElement: ['CharacterClassRange', 'Character'],
+});
+
+const flags = {
+  global: 'g',
+  ignoreCase: 'i',
+  multiline: 'm',
+  dotAll: 's',
+  unicode: 'u',
+  sticky: 'y',
+};
+const flagsReverse = Object.fromEntries(Object.entries(flags).map(([key, value]) => [value, key]));
+
+const PN = 'Punctuator';
+const KW = 'Keyword';
+const ESC = 'Escape';
+
+const unique = (flags) => flags.length === new Set(flags).size;
+
+const getSpecialPattern = (span) => {
+  const { type } = span;
+  if (type === 'Bare') {
+    return /[*+{}\[\]()\.^$|\\\n\/]/y;
+  } else if (type === 'CharacterClass') {
+    return /[\]\\\.]/y;
+  } else if (type === 'CharacterClass:First') {
+    return /[\]^\\\.]/y;
+  } else if (type === 'Quantifier') {
+    return /[{}]/;
+  } else {
+    throw new Error();
+  }
+};
+
+const cookEscape = (escape, span) => {
+  let hexMatch;
+
+  if (!escape.startsWith('\\')) {
+    throw new Error('regex escape must start with \\');
+  }
+
+  if ((hexMatch = /\\x([0-9a-f]{2})/iy.exec(escape))) {
+    //continue
+  } else 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 parseInt(hexMatch[1], 16);
+  }
+
+  let litMatch = /\\([nrt0])/y.exec(escape);
+
+  if (litMatch) {
+    return escapables.get(litMatch[1]);
+  }
+
+  let specialMatch = getSpecialPattern(span).exec(escape.slice(1));
+
+  if (specialMatch) {
+    return specialMatch[0];
+  }
+
+  throw new Error('unable to cook regex escape');
+};
+
+const grammar = class RegexMiniparserGrammar {
+  // @Node
+  Pattern(p) {
+    p.eat('/', PN, { path: 'open', balanced: '/' });
+    p.eatProduction('Alternatives', { path: '[alternatives]' });
+    p.eat('/', PN, { path: 'close', balancer: true });
+    p.eatProduction('Flags', { path: '[flags]' });
+  }
+
+  Flags(p) {
+    const flags = p.match(/[gimsuy]+/y) || '';
+
+    if (!unique(flags)) throw new Error('flags must be unique');
+
+    for (const _ of flags) {
+      p.eatProduction('Flag');
+    }
+  }
+
+  // @Node
+  Flag(p) {
+    const flag = p.eatMatch(/[gimsuy]/y, KW, { path: 'value' });
+
+    return { attrs: { kind: flagsReverse[flag] } };
+  }
+
+  Alternatives(p) {
+    do {
+      p.eatProduction('Alternative');
+    } while (p.eatMatch('|', PN, { path: '[separators]' }));
+  }
+
+  // @Node
+  Alternative(p) {
+    p.eatProduction('Elements', { path: '[elements]' });
+  }
+
+  Elements(p) {
+    while (p.match(/[^|]/y)) {
+      p.eatProduction('Element');
+    }
+  }
+
+  // @Cover
+  Element(p) {
+    if (p.match('[')) {
+      p.eatProduction('CharacterClass');
+    } else if (p.match('(?:')) {
+      p.eatProduction('Group');
+    } else if (p.match(/\(\?<?[=!]/y)) {
+      throw new Error('Lookahead and lookbehind are not supported');
+    } else if (p.match('(')) {
+      p.eatProduction('CapturingGroup');
+    } else if (p.match(/[$^]|\\b|/iy)) {
+      p.eatProduction('Assertion');
+    } else if (p.match(/\.|\\[dswp]/iy)) {
+      p.eatProduction('CharacterSet');
+    } else {
+      p.eatProduction('Character');
+    }
+
+    if (p.match(/[*+?]|{/y)) {
+      p.shiftProduction('Quantifier');
+    }
+  }
+
+  // @Node
+  Group(p) {
+    p.eat('(?:', PN, { path: 'open', balanced: ')' });
+    p.eatProduction('Alternatives', { path: '[alternatives]' });
+    p.eat(')', PN, { path: 'close', balancer: true });
+  }
+
+  // @Node
+  CapturingGroup(p) {
+    p.eat('(', PN, { path: 'open', balanced: ')' });
+    p.eatProduction('Alternatives', { path: '[alternatives]' });
+    p.eat(')', PN, { path: 'close', balancer: true });
+  }
+
+  // @Node
+  Assertion(p) {
+    let attrs = {};
+    if (p.eatMatch('^', PN, { path: 'value' })) {
+      attrs = { kind: 'start' };
+    } else if (p.eatMatch('$', KW, { path: 'value' })) {
+      attrs = { kind: 'end' };
+    } else {
+      if (p.eatMatch('\\', ESC, { path: 'escape' })) {
+        const m = p.eat(/b/iy, KW, { path: 'value' });
+        attrs = { kind: 'word', negate: m === 'B' };
+      } else {
+        throw new Error('invalid boundary');
+      }
+    }
+    return { attrs };
+  }
+
+  // @Node
+  Character(p) {
+    const specialPattern = getSpecialPattern(p.span);
+
+    if (p.match('\\')) {
+      if (
+        p.eatMatchEscape(
+          new RegExp(
+            String.raw`\\(u(\{\d{1,6}\}|\d{4})|x[0-9a-fA-F]{2}|[nrt0]|${specialPattern.source})`,
+            'y',
+          ),
+        )
+      ) {
+        // done
+      } else {
+        throw new Error('escape required');
+      }
+    } else {
+      if (p.match(new RegExp(specialPattern, 'y'))) {
+        throw new Error('escape required');
+      } else {
+        p.eatLiteral(/./sy);
+      }
+    }
+  }
+
+  // @Node
+  CharacterClass(p) {
+    p.eat('[', PN, { path: 'open', balanced: ']', startSpan: 'CharacterClass' });
+
+    const negate = !!p.eatMatch('^', KW, { path: 'negate', boolean: true });
+
+    let first = !negate;
+    while (p.match(/./sy)) {
+      p.eatProduction('CharacterClassElement', { path: '[elements]' }, { first });
+      first = false;
+    }
+
+    p.eat(']', PN, { path: 'close', balancer: true, endSpan: 'CharacterClass' });
+  }
+
+  // @Cover
+  CharacterClassElement(p, { first }) {
+    if (p.match(/.-[^\]\n]/y)) {
+      p.eatProduction('CharacterClassRange', undefined, { first });
+    } else if (p.match(/\.|\\[dswp]/iy)) {
+      p.eatProduction('CharacterSet');
+    } else {
+      p.eatProduction('Character', when(first, { span: 'CharacterClass:First' }));
+    }
+  }
+
+  // @Node
+  CharacterClassRange(p, { first }) {
+    p.eatProduction('Character', {
+      path: 'min',
+      ...when(first, { span: 'CharacterClass:First' }),
+    });
+    p.eat('-', PN, { path: 'rangeOperator' });
+    p.eatProduction('Character', { path: 'max' });
+  }
+
+  // @Node
+  CharacterSet(p) {
+    if (p.eatMatch('.', KW, { path: 'value' })) {
+      return { attrs: { kind: 'any' } };
+    }
+
+    p.eat('\\', PN, { path: 'escape' });
+
+    let attrs;
+
+    if (p.eatMatch('d', KW, { path: 'value' })) {
+      attrs = { kind: 'digit' };
+    } else if (p.eatMatch('D', KW, { path: 'value' })) {
+      attrs = { kind: 'digit', negate: true };
+    } else if (p.eatMatch('s', KW, { path: 'value' })) {
+      attrs = { kind: 'space' };
+    } else if (p.eatMatch('S', KW, { path: 'value' })) {
+      attrs = { kind: 'space', negate: true };
+    } else if (p.eatMatch('w', KW, { path: 'value' })) {
+      attrs = { kind: 'word' };
+    } else if (p.eatMatch('W', KW, { path: 'value' })) {
+      attrs = { kind: 'word', negate: true };
+    } else if (p.match(/p/iy)) {
+      throw new Error('unicode property character sets are not supported yet');
+    } else {
+      throw new Error('unknown character set kind');
+    }
+
+    return { attrs };
+  }
+
+  // @Node
+  Quantifier(p) {
+    p.eatHeldProduction('Element', { path: 'element' });
+
+    let attrs;
+
+    if (p.eatMatch('*', KW, { path: 'value' })) {
+      attrs = { min: 0, max: Infinity };
+    } else if (p.eatMatch('+', KW, { path: 'value' })) {
+      attrs = { min: 1, max: Infinity };
+    } else if (p.eatMatch('?', KW, { path: 'value' })) {
+      attrs = { min: 0, max: 1 };
+    } else if (p.match('{')) {
+      p.eat('{', PN, { path: 'open', balanced: '}' });
+
+      let max;
+      let min = p.eat(/\d+/y, 'Number', { path: 'min' });
+
+      if (p.eatMatch(',', PN, { path: 'separator' })) {
+        max = p.eatMatch(/\d+/y, 'Number', { path: 'max' });
+      }
+
+      attrs = { min, max };
+
+      p.eat('}', PN, { path: 'close', balancer: true });
+    }
+
+    return { attrs };
+  }
+};
+
+module.exports = { name, dependencies, covers, grammar, cookEscape };