@bablr/agast-vm-helpers 0.1.0 → 0.1.2

package/lib/builders.js

@@ -30,8 +30,8 @@ export const buildGap = () => {
   return t.node(l.CSTML, 'Gap', [t.ref`value`], { value: t.s_node(l.CSTML, 'Punctuator', '<//>') });
 };
 
-const buildFlags = (flags) => {
-  const { token = null, escape = null, trivia = null, expression = null } = flags;
+export const buildFlags = (flags) => {
+  const { intrinsic = null, token = null, escape = null, trivia = null, expression = null } = flags;
 
   if ((trivia && escape) || (expression && (trivia || escape))) {
     throw new Error('invalid flags');
@@ -39,16 +39,18 @@ const buildFlags = (flags) => {
 
   return {
     children: [
-      ...when(trivia, [t.ref`triviaFlag`]),
-      ...when(token, [t.ref`tokenFlag`]),
-      ...when(escape, [t.ref`escapeFlag`]),
-      ...when(expression, [t.ref`expressionFlag`]),
+      ...when(trivia, [t.ref`triviaToken`]),
+      ...when(intrinsic, [t.ref`intrinsicToken`]),
+      ...when(token, [t.ref`tokenToken`]),
+      ...when(escape, [t.ref`escapeToken`]),
+      ...when(expression, [t.ref`expressionToken`]),
     ],
     properties: {
-      triviaFlag: trivia && t.s_node(l.CSTML, 'Punctuator', '#'),
-      tokenFlag: token && t.s_node(l.CSTML, 'Punctuator', '*'),
-      escapeFlag: escape && t.s_node(l.CSTML, 'Punctuator', '@'),
-      expressionFlag: expression && t.s_node(l.CSTML, 'Punctuator', '+'),
+      triviaToken: trivia && t.s_node(l.CSTML, 'Punctuator', '#'),
+      intrinsicToken: intrinsic && t.s_node(l.CSTML, 'Punctuator', '~'),
+      tokenToken: token && t.s_node(l.CSTML, 'Punctuator', '*'),
+      escapeToken: escape && t.s_node(l.CSTML, 'Punctuator', '@'),
+      expressionToken: expression && t.s_node(l.CSTML, 'Punctuator', '+'),
     },
   };
 };
@@ -64,134 +66,102 @@ export const buildFullyQualifiedSpamMatcher = (
   intrinsicValue,
   attributes = {},
 ) => {
-  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
-    buildAttribute(key, value),
-  );
+  const attributes_ = buildAttributes(attributes);
 
   const lArr = language ? [...language] : [];
 
   let language_ = lArr.length === 0 ? null : lArr;
 
-  const flags_ = buildFlags(flags);
   return t.node(
     l.Spamex,
     'NodeMatcher',
     [
-      t.ref`open`,
-      ...flags_.children,
+      t.ref`openToken`,
+      t.ref`flags`,
       ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
       t.ref`type`,
       ...when(intrinsicValue, [t.embedded(buildSpace()), t.ref`intrinsicValue`]),
       ...when(attributes_.length, [t.embedded(buildSpace())]),
       ...interpolateArrayChildren(attributes, t.ref`attributes[]`, t.embedded(buildSpace())),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.CSTML, 'Punctuator', '<'),
-      ...flags_.properties,
+      openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
+      flags: buildFlags(flags),
       language: buildLanguage(language_),
       languageSeparator: language_ && type && t.s_node(l.CSTML, 'Punctuator', ':'),
       type: buildIdentifier(type),
       intrinsicValue: intrinsicValue && buildString(intrinsicValue),
       attributes: attributes_,
-      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );
 };
 
 export const buildNodeOpenTag = (flags, language, type, intrinsicValue = null, attributes = {}) => {
-  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
-    buildAttribute(key, value),
-  );
+  const attributes_ = buildAttributes(attributes);
 
   let language_ = !language || language.length === 0 ? null : language;
 
-  const flags_ = buildFlags(flags);
-
   return t.node(
     l.CSTML,
     'OpenNodeTag',
     [
-      t.ref`open`,
-      ...flags_.children,
+      t.ref`openToken`,
+      t.ref`flags`,
       ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
       t.ref`type`,
       ...when(intrinsicValue, [t.embedded(buildSpace()), t.ref`intrinsicValue`]),
       ...when(attributes_.length, [t.embedded(buildSpace())]),
       ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
       when(intrinsicValue, [t.embedded(buildSpace), t.ref`selfClosingToken`]),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.CSTML, 'Punctuator', '<'),
-      ...flags_.properties,
+      openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
+      flags: buildFlags(flags),
       language: buildLanguage(language_),
       languageSeparator: language_ && type && t.s_node(l.CSTML, 'Punctuator', ':'),
       type: buildIdentifier(type),
       intrinsicValue: intrinsicValue && buildString(intrinsicValue),
       attributes: attributes_,
       selfClosingToken: intrinsicValue && t.s_node(l.CSTML, 'Punctuator', '/'),
-      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );
 };
 
 export const buildDoctypeTag = (attributes) => {
-  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
-    buildAttribute(key, value),
-  );
+  const attributes_ = buildAttributes(attributes);
 
   return t.node(
     l.CSTML,
     'DoctypeTag',
     [
-      t.ref`open`,
+      t.ref`openToken`,
       t.ref`version`,
       t.ref`versionSeparator`,
       t.ref`doctype`,
       ...when(attributes_.length, [t.embedded(buildSpace())]),
       ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.CSTML, 'Punctuator', '<!'),
+      openToken: t.s_node(l.CSTML, 'Punctuator', '<!'),
       version: t.s_node(l.CSTML, 'PositiveInteger', '0'),
       versionSeparator: t.s_node(l.CSTML, 'Punctuator', ':'),
       doctype: t.s_node(l.CSTML, 'Keyword', 'cstml'),
       attributes: attributes_,
-      close: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
-  );
-};
-
-export const buildFragmentFlags = (flags = {}) => {
-  const { escape = null, trivia = null } = flags;
-  if (!(escape || trivia)) {
-    return null;
-  }
-
-  return t.node(
-    l.CSTML,
-    'NodeFlags',
-    [...when(trivia, [t.ref`trivia`]), ...when(escape, [t.ref`escape`])],
-    {
-      trivia: trivia && t.s_node(l.CSTML, 'Punctuator', '#'),
-      escape: escape && t.s_node(l.CSTML, 'Punctuator', '@'),
+      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );
 };
 
-export const buildFragmentOpenTag = (flags) => {
-  return t.node(
-    l.CSTML,
-    'OpenFragmentTag',
-    [t.ref`open`, ...when(flags, [t.ref`flags`]), t.ref`close`],
-    {
-      open: t.s_node(l.CSTML, 'Punctuator', '<'),
-      flags: buildFragmentFlags(flags),
-      close: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
-  );
+export const buildFragmentOpenTag = () => {
+  return t.node(l.CSTML, 'OpenFragmentTag', [t.ref`openToken`, t.ref`closeToken`], {
+    openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
+    closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
+  });
 };
 
 export const buildIdentifierPath = (path) => {
@@ -223,26 +193,26 @@ export const buildNodeCloseTag = (type, language) => {
     l.CSTML,
     'CloseNodeTag',
     [
-      t.ref`open`,
+      t.ref`openToken`,
       ...when(language, [t.ref`language`]),
       ...when(type && language, [t.ref`languageSeparator`]),
       ...when(type, [t.ref`type`]),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.CSTML, 'Punctuator', '</'),
+      openToken: t.s_node(l.CSTML, 'Punctuator', '</'),
       language: buildLanguage(language),
       languageSeparator: language && type ? t.s_node(l.CSTML, 'Punctuator', ':') : null,
       type: type && buildIdentifier(type),
-      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );
 };
 
 export const buildFragmentCloseTag = () => {
-  return t.node(l.CSTML, 'CloseFragmentTag', [t.ref`open`, t.ref`close`], {
-    open: t.s_node(l.CSTML, 'Punctuator', '</'),
-    close: t.s_node(l.CSTML, 'Punctuator', '>'),
+  return t.node(l.CSTML, 'CloseFragmentTag', [t.ref`openToken`, t.ref`closeToken`], {
+    openToken: t.s_node(l.CSTML, 'Punctuator', '</'),
+    closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
   });
 };
 
@@ -261,7 +231,11 @@ export const buildSpace = () => {
 };
 
 export const buildIdentifier = (name) => {
-  return t.node(l.Instruction, 'Identifier', [t.lit(name)]);
+  return t.s_node(l.Instruction, 'Identifier', name);
+};
+
+export const buildKeyword = (name) => {
+  return t.s_node(l.Instruction, 'Identifier', name);
 };
 
 export const buildCall = (verb, ...args) => {
@@ -295,8 +269,8 @@ export const buildDigit = (value) => {
   return t.s_node(l.CSTML, 'Digit', value);
 };
 
-export const buildInteger = (value) => {
-  const digits = value.toString(10).split('');
+export const buildInteger = (value, base = 10) => {
+  const digits = value.toString(base).split('');
 
   return t.node(
     l.CSTML,
@@ -330,21 +304,23 @@ export const buildNumber = (value) => {
   }
 };
 
+const buildLiteralTerminal = (lit) => freeze({ type: 'Literal', value: lit });
+
 export const buildString = (value) => {
   const pieces = isArray(value) ? value : [value];
   const terminals = [];
   let lit = '';
 
   if (pieces.length === 1 && pieces[0] === "'") {
-    return t.node(l.CSTML, 'String', [t.ref`open`, t.ref`content`, t.ref`close`], {
-      open: t.s_node(l.CSTML, 'Punctuator', '"'),
+    return t.node(l.CSTML, 'String', [t.ref`openToken`, t.ref`content`, t.ref`closeToken`], {
+      openToken: t.s_node(l.CSTML, 'Punctuator', '"'),
       content: interpolateString(
         freeze({
           type: 'Literal',
           value,
         }),
       ),
-      close: t.s_node(l.CSTML, 'Punctuator', '"'),
+      closeToken: t.s_node(l.CSTML, 'Punctuator', '"'),
     });
   }
 
@@ -359,22 +335,45 @@ export const buildString = (value) => {
           chr === '\n' ||
           chr === '\r' ||
           chr === '\t' ||
-          chr === '\0'
+          chr === '\0' ||
+          chr.charCodeAt(0) < 32
         ) {
           if (lit) {
-            terminals.push(freeze({ type: 'Literal', value: lit }));
+            terminals.push(buildLiteralTerminal(lit));
             lit = '';
           }
 
+          let value;
+
+          if (escapables[chr]) {
+            value = t.node(l.CSTML, 'EscapeCode', [t.ref`sigilToken`], {
+              sigilToken: buildKeyword(escapables[chr]),
+              digits: null,
+            });
+          } else if (chr.charCodeAt(0) < 32) {
+            const hexDigits = chr.charCodeAt(0).toString(16).padStart(4, '0');
+            value = t.node(
+              l.CSTML,
+              'EscapeCode',
+              [t.ref`sigilToken`, ...[...hexDigits].map((d) => t.ref`digits[]`)],
+              {
+                sigilToken: buildKeyword('u'),
+                digits: [...hexDigits].map((digit) => buildDigit(digit)),
+              },
+            );
+          } else {
+            value = buildKeyword(chr);
+          }
+
           terminals.push(
             t.buildEmbedded(
               t.e_node(
                 l.CSTML,
-                'Escape',
-                [t.ref`escape`, t.ref`escapee`],
+                'EscapeSequence',
+                [t.ref`escape`, t.ref`value`],
                 {
                   escape: t.s_node(l.CSTML, 'Punctuator', '\\'),
-                  escapee: t.s_node(l.CSTML, 'Literal', escapables[chr] || chr),
+                  value,
                 },
                 { cooked: chr },
               ),
@@ -385,11 +384,11 @@ export const buildString = (value) => {
         }
       }
     } else {
-      terminals.push(freeze({ type: 'Literal', value: lit }));
+      terminals.push(buildLiteralTerminal(lit));
       lit = '';
 
       if (piece == null) {
-        throw new Error('not impelemented');
+        throw new Error('not implemented');
       } else if (isString(piece.type)) {
         terminals.push(piece);
       } else {
@@ -398,25 +397,25 @@ export const buildString = (value) => {
     }
   }
 
-  if (lit) terminals.push(freeze({ type: 'Literal', value: lit }));
+  if (lit) terminals.push(buildLiteralTerminal(lit));
   lit = '';
 
-  return t.node(l.CSTML, 'String', [t.ref`open`, t.ref`content`, t.ref`close`], {
-    open: t.s_node(l.CSTML, 'Punctuator', "'"),
+  return t.node(l.CSTML, 'String', [t.ref`openToken`, t.ref`content`, t.ref`closeToken`], {
+    openToken: t.s_node(l.CSTML, 'Punctuator', "'"),
     content: interpolateString(terminals),
-    close: t.s_node(l.CSTML, 'Punctuator', "'"),
+    closeToken: t.s_node(l.CSTML, 'Punctuator', "'"),
   });
 };
 
 export const buildBoolean = (value) => {
-  return t.node(l.Instruction, 'Boolean', [t.ref`value`], {
-    value: t.s_node(l.Instruction, 'Keyword', value ? 'true' : 'false'),
+  return t.node(l.Instruction, 'Boolean', [t.ref`sigilToken`], {
+    sigilToken: t.s_node(l.Instruction, 'Keyword', value ? 'true' : 'false'),
   });
 };
 
 export const buildNull = () => {
-  return t.node(l.Instruction, 'Null', [t.ref`value`], {
-    value: t.s_node(l.Instruction, 'Keyword', 'null'),
+  return t.node(l.Instruction, 'Null', [t.ref`sigilToken`], {
+    sigilToken: t.s_node(l.Instruction, 'Keyword', 'null'),
   });
 };
 
@@ -425,7 +424,7 @@ export const buildArray = (elements) => {
     l.Instruction,
     'Array',
     [
-      t.ref`open`,
+      t.ref`openToken`,
       ...interpolateArrayChildren(
         elements,
         t.ref`elements[]`,
@@ -433,12 +432,12 @@ export const buildArray = (elements) => {
           t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
         ),
       ),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.Instruction, 'Punctuator', '['),
+      openToken: t.s_node(l.Instruction, 'Punctuator', '['),
       elements: [...interpolateArray(elements)],
-      close: t.s_node(l.Instruction, 'Punctuator', ']'),
+      closeToken: t.s_node(l.Instruction, 'Punctuator', ']'),
     },
   );
 };
@@ -448,7 +447,7 @@ export const buildTuple = (values) => {
     l.Instruction,
     'Tuple',
     [
-      t.ref`open`,
+      t.ref`openToken`,
       ...interpolateArrayChildren(
         values,
         t.ref`values[]`,
@@ -456,12 +455,12 @@ export const buildTuple = (values) => {
           t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
         ),
       ),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.Instruction, 'Punctuator', '('),
+      openToken: t.s_node(l.Instruction, 'Punctuator', '('),
       values: [...interpolateArray(values)],
-      close: t.s_node(l.Instruction, 'Punctuator', ')'),
+      closeToken: t.s_node(l.Instruction, 'Punctuator', ')'),
     },
   );
 };
@@ -471,7 +470,7 @@ export const buildObject = (properties) => {
     l.Instruction,
     'Object',
     [
-      t.ref`open`,
+      t.ref`openToken`,
       ...interpolateArrayChildren(
         Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
         t.ref`properties[]`,
@@ -479,16 +478,16 @@ export const buildObject = (properties) => {
           t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
         ),
       ),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.Instruction, 'Punctuator', '{'),
+      openToken: t.s_node(l.Instruction, 'Punctuator', '{'),
       properties: [
         ...interpolateArray(
           Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
         ),
       ],
-      close: t.s_node(l.Instruction, 'Punctuator', '}'),
+      closeToken: t.s_node(l.Instruction, 'Punctuator', '}'),
     },
     {},
   );
@@ -503,8 +502,8 @@ export const buildMappingAttribute = (key, value) => {
 };
 
 export const buildBooleanAttribute = (key, value) => {
-  return t.node(l.CSTML, 'BooleanAttribute', [...when(!value, [t.ref`negateSigil`]), t.ref`key`], {
-    negateSigil: !value ? t.s_node(l.CSTML, 'Puncutator', '!') : null,
+  return t.node(l.CSTML, 'BooleanAttribute', [...when(!value, [t.ref`negateToken`]), t.ref`key`], {
+    negateToken: !value ? t.s_node(l.CSTML, 'Puncutator', '!') : null,
     key: buildIdentifier(key),
   });
 };
@@ -521,6 +520,8 @@ export const buildExpression = (expr) => {
       return buildBoolean(expr);
     case 'string':
       return buildString(expr);
+    case 'number':
+      return buildInteger(expr);
     case 'object': {
       switch (getPrototypeOf(expr)) {
         case Array.prototype:
@@ -539,10 +540,12 @@ export const buildExpression = (expr) => {
   }
 };
 
+export const buildAttributes = (attributes = {}) => {
+  return Object.entries(attributes).map(({ 0: key, 1: value }) => buildAttribute(key, value));
+};
+
 export const buildNodeMatcher = (flags, language, type, attributes = {}) => {
-  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
-    buildAttribute(key, value),
-  );
+  const attributes_ = buildAttributes(attributes);
 
   let language_ = !language || language.length === 0 ? null : language;
 
@@ -552,22 +555,22 @@ export const buildNodeMatcher = (flags, language, type, attributes = {}) => {
     l.Spamex,
     'NodeMatcher',
     [
-      t.ref`open`,
+      t.ref`openToken`,
       ...when(flags_, [t.ref`flags`]),
       ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
       t.ref`type`,
       ...when(attributes_.length, [t.embedded(buildSpace())]),
       ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
-      t.ref`close`,
+      t.ref`closeToken`,
     ],
     {
-      open: t.s_node(l.CSTML, 'Punctuator', '<'),
+      openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
       language: buildLanguage(language_),
       languageSeparator: language_ && type && t.s_node(l.CSTML, 'Punctuator', ':'),
       flags: flags_,
       type: buildIdentifier(type),
       attributes: attributes_,
-      close: t.s_node(l.CSTML, 'Punctuator', '>'),
+      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );
 };

package/lib/index.js

@@ -27,15 +27,15 @@ export const shouldBranch = (effects) => {
   return effects ? effects.success === 'none' || effects.failure === 'none' : false;
 };
 
-const reifyFlags = (node) => {
-  let { triviaFlag, escapeFlag, tokenFlag, expressionFlag, intrinsicValue } = node.properties || {};
+const reifyFlags = (flags) => {
+  let { triviaToken, escapeToken, tokenToken, expressionToken, intrinsicToken } = flags.properties;
 
   return {
-    token: !!tokenFlag,
-    escape: !!escapeFlag,
-    trivia: !!triviaFlag,
-    intrinsic: !!intrinsicValue,
-    expression: !!expressionFlag,
+    token: !!tokenToken,
+    escape: !!escapeToken,
+    trivia: !!triviaToken,
+    intrinsic: !!intrinsicToken,
+    expression: !!expressionToken,
   };
 };
 
@@ -95,9 +95,9 @@ export const reifyExpression = (node) => {
       }
 
       case 'OpenNodeTag': {
-        let { language, type, attributes, intrinsicValue } = node.properties;
+        let { flags, language, type, attributes, intrinsicValue } = node.properties;
 
-        let flags = reifyFlags(node);
+        flags = reifyFlags(flags);
         language = reifyLanguage(language);
         type = reifyExpression(type);
         attributes = reifyAttributes(attributes);
@@ -150,9 +150,9 @@ export const reifyExpression = (node) => {
 
   switch (node.type) {
     case 'NodeMatcher':
-      let { language, type, attributes, intrinsicValue } = node.properties;
+      let { flags, language, type, attributes, intrinsicValue } = node.properties;
 
-      let flags = reifyFlags(node);
+      flags = reifyFlags(flags);
       language = reifyExpression(language);
       type = reifyExpression(type);
       attributes = reifyAttributes(attributes);
@@ -194,7 +194,7 @@ export const reifyExpression = (node) => {
 
     case 'Boolean': {
       // prettier-ignore
-      switch (getCooked(node.properties.value)) {
+      switch (getCooked(node.properties.sigilToken)) {
         case 'true': return true;
         case 'false': return false;
         default: throw new Error();
@@ -249,7 +249,7 @@ export const reifyAttributes = (attributes) => {
       if (attr.type === 'MappingAttribute') {
         return [reifyExpression(attr.properties.key), reifyExpression(attr.properties.value)];
       } else if (attr.type === 'BooleanAttribute') {
-        return [reifyExpression(attr.properties.key), !attr.properties.negateSigil];
+        return [reifyExpression(attr.properties.key), !attr.properties.negateToken];
       } else {
         throw new Error();
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm-helpers",
   "description": "Helper functions for working with the BABLR VM",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -15,7 +15,7 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.1.0"
+    "@bablr/agast-helpers": "0.1.5"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",