@bablr/boot 0.1.8 → 0.1.9

package/lib/index.js

@@ -34,7 +34,7 @@ const i = buildTag(instruction, 'Call');
 const spam = buildTag(spamex, 'Matcher');
 const re = buildTag(regex, 'Pattern');
 const str = buildTag(string, 'String');
-const num = buildTag(number, 'Number');
+const num = buildTag(number, 'Integer');
 const cst = buildTag(cstml, 'Fragment');
 
 module.exports = { re, spam, str, num, i, cst };

package/lib/languages/cstml.js

@@ -20,7 +20,7 @@ const covers = buildCovers({
     'TagType',
     'Node',
     'OpenFragmentNodeTag',
-    'OpenTerminalNodeTag',
+    'TerminalNodeShorthandTag',
     'OpenNodeTag',
     'CloseNodeTag',
     'Terminal',
@@ -56,7 +56,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   Node(p) {
-    const openType = p.match('<|') ? 'OpenTerminalNodeTag' : 'OpenNodeTag';
+    const openType = p.match('<|') ? 'TerminalNodeShorthandTag' : 'OpenNodeTag';
     const childrenType = openType === 'OpenNodeTag' ? 'NodeChildren' : 'TerminalNodeChildren';
 
     if (p.match('<>')) throw new Error('Fragment is not a node');
@@ -134,7 +134,7 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   // @Node
-  OpenTerminalNodeTag(p) {
+  TerminalNodeShorthandTag(p) {
     p.eat('<|', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
     p.eatMatchTrivia(_);
     p.eatProduction('TagType', { path: 'type' });
@@ -154,14 +154,11 @@ const grammar = class CSTMLMiniparserGrammar {
 
     p.eatMatchTrivia(_);
     p.eat('|>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
-
-    return { attrs: { selfClosing: !!value } };
   }
 
   // @Node
   CloseNodeTag(p) {
     p.eat('</', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    // TODO permit .type
     p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
   }
 

package/lib/languages/number.js

@@ -7,18 +7,18 @@ const dependencies = {};
 
 const covers = buildCovers({
   [sym.node]: ['Number', 'Digit'],
-  Number: ['LiteralNumber', 'SymbolicNumber'],
+  Number: ['Integer', 'Infinity'],
 });
 
 const grammar = class NumberMiniparserGrammar {
   // @Node
-  LiteralNumber(p) {
+  Integer(p) {
     p.eatMatch('-', 'Punctuator', { path: 'negative' });
     p.eatProduction('Digits', { path: 'digits[]' });
   }
 
   // @Node
-  SymbolicNumber(p) {
+  Infinity(p) {
     p.eatMatch('-', 'Punctuator', { path: 'negative' });
     p.eat('Infinity', 'Keyword', { path: 'value' });
   }

package/lib/languages/string.js

@@ -28,9 +28,7 @@ const cookEscape = (escape, span) => {
     throw new Error('string 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))) {
+  if ((hexMatch = /\\u([0-9a-f]{4})/iy.exec(escape))) {
     //continue
   } else if ((hexMatch = /\\u{([0-9a-f]+)}/iy.exec(escape))) {
     //continue
@@ -71,8 +69,8 @@ const grammar = class StringMiniparserGrammar {
     do {
       esc =
         p.span.type === 'Single'
-          ? p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|x[0-9a-fA-F]{2}|[\\nrt0'])/y)
-          : p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|x[0-9a-fA-F]{2}|[\\nrt0"])/y);
+          ? p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|[\\nrt0'])/y)
+          : p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|[\\nrt0"])/y);
       lit =
         p.span.type === 'Single'
           ? p.eatMatchLiteral(/[^\r\n\0\\']+/y)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"

package/shorthand.macro.js

@@ -63,20 +63,34 @@ const getASTValue = (v, exprs, bindings) => {
     : generateNode(v, exprs, bindings);
 };
 
+const escapeReplacer = (esc) => {
+  if (esc === '\r') {
+    return '\\r';
+  } else if (esc === '\n') {
+    return '\\n';
+  } else if (esc === '\0') {
+    return '\\0';
+  } else {
+    return `\\${esc}`;
+  }
+};
+const printTemplateString = (str) => {
+  return `\`${str.replace(/[`\\\0\r\n]/g, escapeReplacer)}\``;
+};
+
 const generateNodeChild = (child, bindings) => {
   if (child.type === 'Reference') {
     const { pathName, pathIsArray } = child.value;
     const printedRef = pathIsArray ? `${pathName}[]` : pathName;
     return expression(`%%t%%.ref\`${printedRef}\``)({ t: bindings.t });
   } else if (child.type === 'Literal') {
-    return expression(`%%t%%.lit\`${child.value.replace(/\\/g, '\\\\')}\``)({ t: bindings.t });
+    return expression(`%%t%%.lit${printTemplateString(child.value)}`)({ t: bindings.t });
   } else if (child.type === 'Trivia') {
-    return expression(`%%t%%.trivia\` \``)({ t: bindings.t });
+    return expression(`%%t%%.trivia${printTemplateString(child.value)}`)({ t: bindings.t });
   } else if (child.type === 'Escape') {
-    return expression(`%%t%%.esc(%%cooked%%, %%raw%%)`)({
+    const {cooked, raw} = child.value
+    return expression(`%%t%%.esc(${printTemplateString(raw)}, ${printTemplateString(cooked)})`)({
       t: bindings.t,
-      cooked: child.cooked,
-      raw: child.raw,
     });
   } else {
     throw new Error(`Unknown child type ${child.type}`);
@@ -159,7 +173,7 @@ const topTypes = {
   re: 'Pattern',
   spam: 'Matcher',
   str: 'String',
-  num: 'Number',
+  num: 'Integer',
   cst: 'Fragment',
 };