@bablr/helpers 0.22.1 → 0.24.0

package/lib/builders.js

@@ -1,47 +1,40 @@
-// import { i } from '@bablr/boot/shorthand.macro';
 import { interpolateFragment, buildFilledGapFunction } from '@bablr/agast-helpers/template';
 import {
   buildNullNode,
-  isNull,
+  get,
+  getRootArray,
   treeFromStreamSync as treeFromStream,
 } from '@bablr/agast-helpers/tree';
 import { buildLiteralTag as agastBuildLiteralTag } from '@bablr/agast-helpers/builders';
 import * as t from '@bablr/agast-helpers/shorthand';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
+import * as Tags from '@bablr/agast-helpers/tags';
 import * as l from '@bablr/agast-vm-helpers/languages';
 import { concat } from '@bablr/agast-vm-helpers/iterable';
 
-const { getPrototypeOf, freeze, hasOwn } = Object;
+const { freeze } = Object;
 const { isArray } = Array;
 
 const when = (condition, value) => (condition ? value : { *[Symbol.iterator]() {} });
 
 const isString = (val) => typeof val === 'string';
 
-export const buildReferenceTag = (
-  name,
-  isArray = false,
-  flags = t.referenceFlags,
-  index = null,
-) => {
+export const buildReferenceTag = (name, isArray = false, flags = t.referenceFlags) => {
   let expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'ReferenceTag'),
+      t.nodeOpen(t.nodeFlags, 'ReferenceTag'),
       t.ref`name`,
       gap(name ? buildIdentifier(name) : buildNullNode()),
       t.ref`openIndexToken`,
-      gap(isArray ? buildToken(l.CSTML, 'Punctuator', '[') : buildNullNode()),
-      t.ref`index`,
-      gap(index || buildNullNode()),
+      gap(isArray ? buildToken('Punctuator', '[') : buildNullNode()),
       t.ref`closeIndexToken`,
-      gap(isArray ? buildToken(l.CSTML, 'Punctuator', ']') : buildNullNode()),
+      gap(isArray ? buildToken('Punctuator', ']') : buildNullNode()),
       t.ref`flags`,
       gap(flags ? buildReferenceFlags(flags) : buildNullNode()),
       t.ref`sigilToken`,
-      gap(buildToken(l.CSTML, 'Punctuator', ':')),
+      gap(buildToken('Punctuator', ':')),
       t.nodeClose(),
     ],
     { expressions },
@@ -54,9 +47,9 @@ export const buildGapTag = () => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'ShiftTag'),
+      t.nodeOpen(t.nodeFlags, 'ShiftTag'),
       t.ref`sigilToken`,
-      gap(buildToken(l.CSTML, 'Punctuator', '<//>')),
+      gap(buildToken('Punctuator', '<//>')),
       t.nodeClose(),
     ],
     { expressions },
@@ -69,9 +62,9 @@ export const buildShiftTag = () => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'ShiftTag'),
+      t.nodeOpen(t.nodeFlags, 'ShiftTag'),
       t.ref`sigilToken`,
-      gap(buildToken(l.CSTML, 'Punctuator', '^^^')),
+      gap(buildToken('Punctuator', '^^^')),
       t.nodeClose(),
     ],
     { expressions },
@@ -85,11 +78,11 @@ export const buildReferenceFlags = (flags = t.referenceFlags) => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'ReferenceFlags'),
+      t.nodeOpen(t.nodeFlags, 'ReferenceFlags'),
       t.ref`expressionToken`,
-      gap(expression ? buildToken(l.CSTML, 'Punctuator', '+') : buildNullNode()),
+      gap(expression ? buildToken('Punctuator', '+') : buildNullNode()),
       t.ref`hasGapToken`,
-      gap(hasGap ? buildToken(l.CSTML, 'Punctuator', '$') : buildNullNode()),
+      gap(hasGap ? buildToken('Punctuator', '$') : buildNullNode()),
       t.nodeClose(),
     ],
     { expressions },
@@ -97,17 +90,21 @@ export const buildReferenceFlags = (flags = t.referenceFlags) => {
 };
 
 export const buildNodeFlags = (flags = t.nodeFlags) => {
-  const { token = null, hasGap = null } = flags;
+  const { token = null, hasGap = null, fragment = null, cover = null } = flags;
   let expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'NodeFlags'),
-      t.ref`triviaToken`,
-      gap(token ? buildToken(l.CSTML, 'Punctuator', '*') : buildNullNode()),
+      t.nodeOpen(t.nodeFlags, 'NodeFlags'),
+      t.ref`tokenToken`,
+      gap(token ? buildToken('Punctuator', '*') : buildNullNode()),
       t.ref`hasGapToken`,
-      gap(hasGap ? buildToken(l.CSTML, 'Punctuator', '$') : buildNullNode()),
+      gap(hasGap ? buildToken('Punctuator', '$') : buildNullNode()),
+      t.ref`fragmentToken`,
+      gap(fragment ? buildToken('Punctuator', '_') : buildNullNode()),
+      t.ref`multiFragmentToken`,
+      gap(!cover ? buildToken('Punctuator', '_') : buildNullNode()),
       t.nodeClose(),
     ],
     { expressions },
@@ -115,59 +112,42 @@ export const buildNodeFlags = (flags = t.nodeFlags) => {
 };
 
 export const buildSpamMatcher = (type = null, value = null, attributes = null) => {
-  return buildOpenNodeMatcher(t.nodeFlags, null, type, value, attributes);
+  return buildOpenNodeMatcher(buildNodeFlags(t.nodeFlags), null, type, value, attributes);
 };
 
-export const buildOpenNodeMatcher = (flags, language, type, intrinsicValue, attributes = null) => {
+export const buildOpenNodeMatcher = (flags, type, literalValue, attributes = null) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
-  let language_;
-
   if (!type) throw new Error();
 
-  if (isString(language)) {
-    language_ = language;
-  } else {
-    let lArr = isString(language) ? language : language ? [...language] : [];
-
-    language_ = lArr.length === 0 ? null : lArr;
-  }
-
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Spamex, 'OpenNodeMatcher');
+      yield t.nodeOpen(t.nodeFlags, 'OpenNodeMatcher');
       yield t.ref`openToken`;
-      yield gap(buildToken(l.CSTML, 'Punctuator', '<'));
+      yield gap(buildToken('Punctuator', '<'));
       yield t.ref`flags`;
-      yield gap(buildNodeFlags(flags));
-      yield t.ref`language`;
-      yield gap(language_ ? buildLanguage(language_) : buildNullNode());
-      yield t.ref`languageSeparator`;
-      yield gap(language_ && type ? buildToken(l.CSTML, 'Punctuator', ':') : buildNullNode());
+      yield gap(flags);
       yield t.ref`type`;
-      yield gap(
-        typeof type === 'string'
-          ? ['.', '#', '@'].includes(type)
-            ? buildKeyword(type)
-            : buildIdentifier(type)
-          : type,
-      );
+      yield gap(typeof type === 'string' ? buildIdentifier(type) : type);
+
+      yield* when(literalValue, [t.ref`#`, ...buildSpace().tags]);
 
-      yield* when(intrinsicValue, [t.ref`#`, ...buildSpace().children]);
+      yield t.ref`literalValue`;
+      yield gap(literalValue ? buildString(literalValue) : buildNullNode());
 
-      yield t.ref`intrinsicValue`;
-      yield gap(intrinsicValue ? buildString(intrinsicValue) : buildNullNode());
+      let rootArr = getRootArray(attributes);
 
-      yield* when(attributes?.properties['.'].length, [t.ref`#`, ...buildSpace().children]);
-      if (attributes?.properties['.'].length) {
+      if (rootArr.length) {
+        yield t.ref`#`;
+        yield* buildSpace().tags;
         yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
       }
 
-      yield t.ref`selfClosingTagToken`;
-      yield gap(buildToken(l.CSTML, 'Punctuator', '/'));
+      yield t.ref`selfClosingToken`;
+      yield gap(buildToken('Punctuator', '/'));
       yield t.ref`closeToken`;
-      yield gap(buildToken(l.CSTML, 'Punctuator', '>'));
+      yield gap(buildToken('Punctuator', '>'));
       yield t.nodeClose();
     })(),
     { expressions },
@@ -179,95 +159,88 @@ export const buildBasicNodeMatcher = (open) => {
   const gap = buildFilledGapFunction(expressions);
 
   return treeFromStream(
-    [t.nodeOpen(t.nodeFlags, l.Spamex, 'BasicNodeMatcher'), t.ref`open`, gap(open), t.nodeClose()],
+    [t.nodeOpen(t.nodeFlags, 'BasicNodeMatcher'), t.ref`open`, gap(open), t.nodeClose()],
     { expressions },
   );
 };
 
-export const buildReferenceMatcher = (name, isArray, flags) => {
+export const buildReferenceMatcher = (type, name, isArray, flags) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Spamex, 'ReferenceMatcher');
+      yield t.nodeOpen(t.nodeFlags, 'ReferenceMatcher');
+      yield t.ref`type`;
+      yield gap(type && buildKeyword(type));
       yield t.ref`name`;
-      yield gap(['#', '@', '.'].includes(name) ? buildKeyword(name) : buildIdentifier(name));
+      yield gap(name && buildIdentifier(name));
       yield* (function* () {
         if (isArray) {
           yield t.ref`openIndexToken`;
-          yield gap(buildToken(l.CSTML, 'Punctuator', '['));
+          yield gap(buildToken('Punctuator', '['));
           yield t.ref`closeIndexToken`;
-          yield gap(buildToken(l.CSTML, 'Punctuator', ']'));
+          yield gap(buildToken('Punctuator', ']'));
         }
       })();
       yield t.ref`flags`;
       yield gap(flags);
       yield t.ref`sigilToken`;
-      yield gap(buildToken(l.CSTML, 'Punctuator', ':'));
+      yield gap(buildToken('Punctuator', ':'));
       yield t.ref`#`;
-      yield* sumtree.traverse(buildSpace().children);
+      yield* Tags.traverse(buildSpace().tags);
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export const buildFragmentMatcher = (flags) => {
+export const buildFragmentMatcher = (flags = buildNodeFlags({ fragment: true, cover: true })) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
+  if (!flags) throw new Error();
+
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Spamex, 'FragmentMatcher');
+      yield t.nodeOpen(t.fragmentFlags, 'FragmentMatcher');
       yield t.ref`openToken`;
-      yield gap(buildToken(l.CSTML, 'Punctuator', '<'));
+      yield gap(buildToken('Punctuator', '<'));
       yield t.ref`flags`;
       yield gap(flags);
-      yield t.ref`#`;
-      yield* sumtree.traverse(buildSpace().children);
       yield t.ref`closeToken`;
-      yield gap(buildToken(l.CSTML, 'Punctuator', '/>'));
+      yield gap(buildToken('Punctuator', '/>'));
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export const buildToken = (language, type, value, attributes = {}) => {
-  return treeFromStream([
-    t.nodeOpen(t.tokenFlags, language, type, attributes),
-    t.lit(value),
-    t.nodeClose(),
-  ]);
+export const buildToken = (type, value, attributes = {}) => {
+  return treeFromStream([t.nodeOpen(t.tokenFlags, type, attributes), t.lit(value), t.nodeClose()]);
 };
 
-export const buildPunctuator = (language, value, attributes = {}) => {
-  return buildToken(language, 'Punctuator', value, attributes);
+export const buildPunctuator = (value, attributes = {}) => {
+  return buildToken('Punctuator', value, attributes);
 };
 
-export const buildOpenNodeTag = (flags, language, type = null, attributes) => {
+export const buildOpenNodeTag = (flags, type = null, attributes) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
-  let language_ = !language || language.length === 0 ? null : language;
-
   return treeFromStream(
     (function* () {
       yield t.ref`openToken`;
-      yield gap(buildPunctuator(l.CSTML, '<'));
+      yield gap(buildPunctuator('<'));
       yield t.ref`flags`;
       yield gap(buildNodeFlags(flags));
-      yield t.ref`language`;
-      yield gap(language_ && type ? buildLanguage(language_) : buildNullNode());
-      yield t.ref`languageSeparator`;
-      yield gap(language_ && type ? buildPunctuator(l.CSTML, ':') : buildNullNode());
       yield t.ref`type`;
       yield gap(type ? buildIdentifier(type) : buildNullNode());
-      yield* when(attributes.properties['.'].length, [t.ref`#`, gap(buildSpace())]);
+      let rootArr = getRootArray(attributes);
+      yield* when(rootArr.length, [t.ref`#`, gap(buildSpace())]);
       yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
       yield t.ref`closeToken`;
-      yield gap(buildPunctuator(l.CSTML, '>'));
+      yield gap(buildPunctuator('>'));
     })(),
     { expressions },
   );
@@ -279,22 +252,22 @@ export const buildDoctypeTag = (attributes) => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.CSTML, 'DoctypeTag');
+      yield t.nodeOpen(t.nodeFlags, 'DoctypeTag');
       yield t.ref`openToken`;
-      yield gap(buildPunctuator(l.CSTML, 'Punctuator', '<!'));
+      yield gap(buildPunctuator('Punctuator', '<!'));
       yield t.ref`version`;
-      yield gap(buildToken(l.CSTML, 'PositiveInteger', '0'));
+      yield gap(buildToken('PositiveInteger', '0'));
       yield t.ref`versionSeparator`;
-      yield gap(buildPunctuator(l.CSTML, 'Punctuator', ':'));
+      yield gap(buildPunctuator('Punctuator', ':'));
       yield t.ref`doctype`;
-      yield gap(buildKeyword(l.CSTML, 'cstml'));
+      yield gap(buildKeyword('cstml'));
       yield t.nodeClose();
 
-      yield* when(attributes.properties['.'].length, [t.ref`#`, ...buildSpace().children]);
+      yield* when(getRootArray(attributes).length, [t.ref`#`, ...buildSpace().tags]);
       yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
 
       yield t.ref`closeToken`;
-      yield gap(buildToken(l.CSTML, 'Punctuator', '>'));
+      yield gap(buildToken('Punctuator', '>'));
     })(),
     { expressions },
   );
@@ -311,7 +284,7 @@ export const buildIdentifierPath = (path) => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.CSTML, 'IdentifierPath');
+      yield t.nodeOpen(t.nodeFlags, 'IdentifierPath');
       yield t.ref`segments[]`;
       yield t.arr();
       yield t.ref`separatorTokens[]`;
@@ -322,7 +295,7 @@ export const buildIdentifierPath = (path) => {
           t.ref`segments[]`,
           gap(buildIdentifier(name)),
           t.ref`separatorTokens[]`,
-          gap(buildToken(l.CSTML, 'Punctuator', '.')),
+          gap(buildToken('Punctuator', '.')),
         ])
         .slice(0, -1);
 
@@ -338,23 +311,17 @@ export const buildLanguage = (language) => {
     : buildIdentifierPath(language);
 };
 
-export const buildCloseNodeTag = (type, language) => {
+export const buildCloseNodeTag = () => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'CloseNodeTag'),
+      t.nodeOpen(t.nodeFlags, 'CloseNodeTag'),
       t.ref`openToken`,
-      gap(buildToken(l.CSTML, 'Punctuator', '</')),
-      t.ref`language`,
-      t.gap(language ? buildLanguage(language) : buildNullNode()),
-      t.ref`languageSeparator`,
-      gap(language && type ? buildToken(l.CSTML, 'Punctuator', ':') : buildNullNode()),
-      t.ref`type`,
-      gap(type ? buildIdentifier(type) : buildNullNode()),
+      gap(buildToken('Punctuator', '</')),
       t.ref`closeToken`,
-      gap(buildToken(l.CSTML, 'Punctuator', '>')),
+      gap(buildToken('Punctuator', '>')),
       t.nodeClose(),
     ],
     { expressions },
@@ -363,7 +330,7 @@ export const buildCloseNodeTag = (type, language) => {
 
 export const buildLiteralTag = (value) => {
   return treeFromStream([
-    t.nodeOpen(t.nodeFlags, l.Instruction, 'LiteralTag'),
+    t.nodeOpen(t.nodeFlags, 'LiteralTag'),
     t.ref`value`,
     t.lit(value),
     t.nodeClose(),
@@ -371,38 +338,87 @@ export const buildLiteralTag = (value) => {
 };
 
 export const buildTerminalProps = (matcher) => {
-  const { attributes, value } = matcher.properties;
+  const value = get('value', matcher);
+  const attributes = get('attributes', matcher);
 
   return buildObject({ value, attributes });
 };
 
 export const buildSpace = () => {
-  return buildToken(l.Space, 'Space', ' ');
+  return buildToken('Space', ' ');
 };
 
 export const buildIdentifier = (name) => {
-  if (!/^[a-zA-Z_]+$/.test(name)) throw new Error();
-
+  let unquoted = /^[a-zA-Z\u{80}-\u{10ffff}][a-zA-Z0-9_\u{80}-\u{10ffff}-]*$/uy.test(name);
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
-  return treeFromStream(
-    [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'Identifier'),
-      t.ref`content`,
-      gap(buildIdentifierContent(name)),
-      t.nodeClose(),
-    ],
-    { expressions },
-  );
+  if (unquoted) {
+    return treeFromStream(
+      [
+        t.nodeOpen(t.nodeFlags, 'Identifier'),
+        t.ref`content`,
+        gap(buildIdentifierContent(name)),
+        t.nodeClose(),
+      ],
+      { expressions },
+    );
+  } else {
+    return treeFromStream(
+      (function* () {
+        yield t.nodeOpen(t.nodeFlags, 'Identifier');
+
+        yield t.ref`openToken`;
+        yield gap(buildToken('Punctuator', '`'));
+        yield t.ref`content`;
+        yield t.nodeOpen(t.tokenFlags, 'IdentifierContent');
+
+        let lit = '';
+
+        let pieces = name.split(/[\\`]/g);
+
+        for (const piece of pieces) {
+          if (/[\\`]/y.test(piece)) {
+            let chr = piece;
+            if (lit) {
+              yield agastBuildLiteralTag(lit);
+              lit = '';
+            }
+
+            let value = buildKeyword(chr);
+
+            yield t.ref`@`;
+            yield t.nodeOpen(t.nodeFlags, 'EscapeSequence', { cooked: chr });
+            yield t.ref`escape`;
+            yield gap(buildToken('Punctuator', '\\'));
+            yield t.ref`value`;
+            yield gap(value);
+            yield t.nodeClose();
+          } else {
+            lit += piece;
+          }
+        }
+
+        if (lit) yield agastBuildLiteralTag(lit);
+        lit = '';
+
+        yield t.nodeClose();
+
+        yield t.ref`closeToken`;
+        yield gap(buildToken('Punctuator', '`'));
+        yield t.nodeClose();
+      })(),
+      { expressions },
+    );
+  }
 };
 
 export const buildIdentifierContent = (value) => {
-  return buildToken(l.CSTML, 'IdentifierContent', value);
+  return buildToken('IdentifierContent', value);
 };
 
 export const buildKeyword = (name) => {
-  return buildToken(l.Instruction, 'Keyword', name);
+  return buildToken('Keyword', name);
 };
 
 export const buildCall = (verb, args) => {
@@ -411,7 +427,7 @@ export const buildCall = (verb, args) => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.Instruction, 'Call'),
+      t.nodeOpen(t.nodeFlags, 'Call'),
       t.ref`verb`,
       gap(verb),
       t.ref`arguments`,
@@ -428,11 +444,11 @@ export const buildProperty = (key, value) => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Instruction, 'Property');
+      yield t.nodeOpen(t.nodeFlags, 'Property');
       yield t.ref`key`;
       yield gap(key);
       yield t.ref`mapOperator`;
-      yield gap(buildToken(l.Instruction, 'Punctuator', ':'));
+      yield gap(buildToken('Punctuator', ':'));
       yield t.ref`#`;
       yield gap(buildSpace());
       yield t.ref`value`;
@@ -451,7 +467,7 @@ const escapables = {
 };
 
 export const buildDigit = (value) => {
-  return buildToken(l.CSTML, 'Digit', value);
+  return buildToken('Digit', value);
 };
 
 export const buildInteger = (value, base = 10) => {
@@ -462,7 +478,7 @@ export const buildInteger = (value, base = 10) => {
 
   return treeFromStream(
     concat(
-      [t.nodeOpen(t.nodeFlags, l.CSTML, 'Integer'), t.ref`digits[]`, t.arr()],
+      [t.nodeOpen(t.nodeFlags, 'Integer'), t.ref`digits[]`, t.arr()],
       digits.flatMap((digit) => [t.ref`digits[]`, gap(buildDigit(digit))]),
       [t.nodeClose()],
     ),
@@ -486,11 +502,11 @@ export const buildInfinity = (value) => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'Infinity'),
+      t.nodeOpen(t.nodeFlags, 'Infinity'),
       t.ref`sign`,
-      gap(buildToken(l.CSTML, 'Punctuator', sign)),
+      gap(buildToken('Punctuator', sign)),
       t.ref`value`,
-      gap(buildToken(l.CSTML, 'Keyword', 'Infinity')),
+      gap(buildToken('Keyword', 'Infinity')),
       t.nodeClose(),
     ],
     { expressions },
@@ -506,6 +522,7 @@ export const buildNumber = (value) => {
 };
 
 export const buildString = (value) => {
+  if (value == null) throw new Error();
   const pieces = isArray(value) ? value : [value];
   let lit = '';
 
@@ -514,13 +531,13 @@ export const buildString = (value) => {
     const gap = buildFilledGapFunction(expressions);
     return treeFromStream(
       [
-        t.nodeOpen(t.nodeFlags, l.JSON, 'String'),
+        t.nodeOpen(t.nodeFlags, 'String'),
         t.ref`openToken`,
-        gap(buildToken(l.JSON, 'Punctuator', '"')),
+        gap(buildToken('Punctuator', '"')),
         t.ref`content`,
-        gap(buildToken(l.JSON, 'StringContent', value)),
+        gap(buildToken('StringContent', value)),
         t.ref`closeToken`,
-        gap(buildToken(l.JSON, 'Punctuator', '"')),
+        gap(buildToken('Punctuator', '"')),
         t.nodeClose(),
       ],
       { expressions },
@@ -532,12 +549,12 @@ export const buildString = (value) => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.JSON, 'String');
+      yield t.nodeOpen(t.nodeFlags, 'String');
       yield t.ref`openToken`;
-      const tok = buildToken(l.JSON, 'Punctuator', "'");
+      const tok = buildToken('Punctuator', "'");
       yield gap(tok);
       yield t.ref`content`;
-      yield t.nodeOpen(t.tokenFlags, l.JSON, 'StringContent');
+      yield t.nodeOpen(t.tokenFlags, 'StringContent');
 
       for (const piece of pieces) {
         if (isString(piece)) {
@@ -566,7 +583,7 @@ export const buildString = (value) => {
 
                 value = treeFromStream(
                   [
-                    t.nodeOpen(t.nodeFlags, l.JSON, 'EscapeCode'),
+                    t.nodeOpen(t.nodeFlags, 'EscapeCode'),
                     t.ref`sigilToken`,
                     gap(buildKeyword(escapables[chr])),
                     t.ref`digits[]`,
@@ -582,7 +599,7 @@ export const buildString = (value) => {
 
                 value = treeFromStream(
                   [
-                    t.nodeOpen(t.nodeFlags, l.JSON, 'EscapeCode'),
+                    t.nodeOpen(t.nodeFlags, 'EscapeCode'),
                     t.ref`sigilToken`,
                     gap(buildKeyword('u')),
                     t.ref`digits[]`,
@@ -597,9 +614,9 @@ export const buildString = (value) => {
               }
 
               yield t.ref`@`;
-              yield t.nodeOpen(t.nodeFlags, l.JSON, 'EscapeSequence', { cooked: chr });
+              yield t.nodeOpen(t.nodeFlags, 'EscapeSequence', { cooked: chr });
               yield t.ref`escape`;
-              yield gap(buildToken(l.JSON, 'Punctuator', '\\'));
+              yield gap(buildToken('Punctuator', '\\'));
               yield t.ref`value`;
               yield gap(value);
               yield t.nodeClose();
@@ -626,7 +643,7 @@ export const buildString = (value) => {
 
       yield t.nodeClose();
       yield t.ref`closeToken`;
-      yield gap(buildToken(l.JSON, 'Punctuator', "'"));
+      yield gap(buildToken('Punctuator', "'"));
       yield t.nodeClose();
     })(),
     { expressions },
@@ -639,9 +656,9 @@ export const buildBoolean = (value) => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.Instruction, 'Boolean'),
+      t.nodeOpen(t.nodeFlags, 'Boolean'),
       t.ref`sigilToken`,
-      gap(buildToken(l.Instruction, 'Keyword', value ? 'true' : 'false')),
+      gap(buildToken('Keyword', value ? 'true' : 'false')),
       t.nodeClose(),
     ],
     { expressions },
@@ -654,9 +671,24 @@ export const buildNull = () => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.Instruction, 'Null'),
+      t.nodeOpen(t.nodeFlags, 'Null'),
+      t.ref`sigilToken`,
+      gap(buildToken('Keyword', 'null')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
+};
+
+export const buildUndefined = () => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, 'Undefined'),
       t.ref`sigilToken`,
-      gap(buildToken(l.Instruction, 'Keyword', 'null')),
+      gap(buildToken('Keyword', 'undefined')),
       t.nodeClose(),
     ],
     { expressions },
@@ -669,9 +701,9 @@ export const buildNullTag = () => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.CSTML, 'NullTag'),
+      t.nodeOpen(t.nodeFlags, 'NullTag'),
       t.ref`sigilToken`,
-      gap(buildToken(l.CSTML, 'Keyword', 'null')),
+      gap(buildToken('Keyword', 'null')),
       t.nodeClose(),
     ],
     { expressions },
@@ -684,12 +716,12 @@ export const buildArray = (elements) => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Instruction, 'Array');
+      yield t.nodeOpen(t.nodeFlags, 'Array');
       yield t.ref`openToken`;
-      yield gap(buildToken(l.Instruction, 'Punctuator', '['));
+      yield gap(buildToken('Punctuator', '['));
       yield* interpolateFragment(elements, t.ref`elements[]`, expressions);
       yield t.ref`closeToken`;
-      yield gap(buildToken(l.Instruction, 'Punctuator', ']'));
+      yield gap(buildToken('Punctuator', ']'));
       yield t.nodeClose();
     })(),
     { expressions },
@@ -702,14 +734,14 @@ export const buildArrayElements = (values) => {
     (function* () {
       yield t.doctype({ bablrLanguage: l.Instruction });
       yield t.nodeOpen(t.nodeFlags);
-      yield* buildSpaceSeparatedList(values, t.ref`.[]`, expressions);
+      yield* buildCommaSeparatedList(values, t.ref`.[]`, expressions);
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export function* buildSpaceSeparatedList(values, ref, expressions) {
+export function* buildCommaSeparatedList(values, ref, expressions) {
   const gap = buildFilledGapFunction(expressions);
 
   if (!ref.value.isArray) throw new Error();
@@ -720,8 +752,8 @@ export function* buildSpaceSeparatedList(values, ref, expressions) {
   let first = true;
   for (const value of values) {
     if (!first) {
-      yield t.buildReferenceTag('#', false);
-      yield gap(buildSpace());
+      yield t.buildReferenceTag('#');
+      yield gap(buildToken('Punctuator', ','));
     }
     yield freeze({ ...ref });
     yield gap(value || buildNullNode());
@@ -735,7 +767,7 @@ export const buildObjectProperties = (properties) => {
   return treeFromStream(
     concat(
       [t.doctype({ bablrLanguage: l.Instruction }), t.nodeOpen(t.nodeFlags)],
-      buildSpaceSeparatedList(properties, t.ref`properties[]`, expressions),
+      buildCommaSeparatedList(properties, t.ref`properties[]`, expressions),
       [t.nodeClose()],
     ),
     { expressions },
@@ -748,14 +780,14 @@ export const buildObject = (properties) => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Instruction, 'Object');
+      yield t.nodeOpen(t.nodeFlags, 'Object');
       yield t.ref`openToken`;
-      yield gap(buildToken(l.Instruction, 'Punctuator', '{'));
+      yield gap(buildToken('Punctuator', '{'));
 
       yield* interpolateFragment(properties, t.ref`properties[]`, expressions);
 
       yield t.ref`closeToken`;
-      yield gap(buildToken(l.Instruction, 'Punctuator', '}'));
+      yield gap(buildToken('Punctuator', '}'));
       yield t.nodeClose();
     })(),
     { expressions },
@@ -768,14 +800,36 @@ export const buildPattern = (alternatives, flags) => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Regex, 'Pattern');
+      yield t.nodeOpen(t.nodeFlags, 'Pattern');
+      yield t.ref`openToken`;
+      yield gap(buildToken('Punctuator', '/'));
+
+      yield* interpolateFragment(alternatives, t.ref`alternatives[]`, expressions);
+
+      yield t.ref`closeToken`;
+      yield gap(buildToken('Punctuator', '/'));
+      yield t.ref`flags`;
+      yield gap(flags || buildReferenceFlags());
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
+};
+
+export const buildRegexGroup = (alternatives, flags) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, 'Group');
       yield t.ref`openToken`;
-      yield gap(buildToken(l.Regex, 'Punctuator', '/'));
+      yield gap(buildToken('Punctuator', '('));
 
       yield* interpolateFragment(alternatives, t.ref`alternatives[]`, expressions);
 
       yield t.ref`closeToken`;
-      yield gap(buildToken(l.Regex, 'Punctuator', '/'));
+      yield gap(buildToken('Punctuator', ')'));
       yield t.ref`flags`;
       yield gap(flags || buildReferenceFlags());
       yield t.nodeClose();
@@ -799,12 +853,12 @@ export const buildRegexFlags = (flags = '') => {
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, l.Regex, 'Flags');
+      yield t.nodeOpen(t.nodeFlags, 'Flags');
 
       for (const { 0: name, 1: chr } of Object.entries(flagCharacters)) {
         yield t.buildReferenceTag(name + 'Token');
 
-        yield gap(flags.includes(chr) ? buildToken(l.CSTML, 'Punctuator', chr) : buildNullNode());
+        yield gap(flags.includes(chr) ? buildToken('Punctuator', chr) : buildNullNode());
       }
       yield t.nodeClose();
     })(),
@@ -817,7 +871,7 @@ export const buildAlternative = (elements) => {
 
   return treeFromStream(
     concat(
-      [t.nodeOpen(t.nodeFlags, l.Regex, 'Alternative')],
+      [t.nodeOpen(t.nodeFlags, 'Alternative')],
       interpolateFragment(elements, t.ref`elements[]+`, expressions),
       [t.nodeClose()],
     ),
@@ -831,7 +885,7 @@ export const buildAlternatives = (alternatives = []) => {
 
   return treeFromStream(
     (function* () {
-      yield t.doctype({ bablrLanguage: l.Regex });
+      yield t.doctype({ bablrLanguage: l.Instruction });
       yield t.nodeOpen(t.nodeFlags);
       yield t.ref`.[]`;
       yield t.arr();
@@ -843,7 +897,7 @@ export const buildAlternatives = (alternatives = []) => {
           t.ref`.[]`,
           gap(alt),
           t.ref`separatorTokens[]`,
-          gap(buildPunctuator(l.Regex, '|')),
+          gap(buildPunctuator('|')),
         ])
         .slice(0, -2);
 
@@ -859,11 +913,11 @@ export const buildRegexGap = () => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.Regex, 'Gap'),
+      t.nodeOpen(t.nodeFlags, 'Gap'),
       t.ref`escapeToken`,
-      gap(buildToken(l.Regex, 'Punctuator', '\\')),
+      gap(buildToken('Punctuator', '\\')),
       t.ref`value`,
-      gap(buildToken(l.Regex, 'Keyword', 'g')),
+      gap(buildToken('Keyword', 'g')),
       t.nodeClose(),
     ],
     { expressions },
@@ -876,7 +930,7 @@ export const buildElements = (elements) => {
 
   return treeFromStream(
     concat(
-      [t.doctype({ bablrLanguage: l.Regex }), t.nodeOpen(t.nodeFlags), t.ref`.[]+`, t.arr()],
+      [t.doctype({ bablrLanguage: l.Instruction }), t.nodeOpen(t.nodeFlags), t.ref`.[]+`, t.arr()],
       elements.flatMap((el) => [t.ref`.[]+`, gap(el)]),
       [t.nodeClose()],
     ),
@@ -884,41 +938,45 @@ export const buildElements = (elements) => {
   );
 };
 
-export const buildExpression = (expr) => {
-  throw new Error('unimplemented');
-
-  if (isNull(expr)) return buildNullTag();
+export const buildJSExpressionDeep = (expr) => {
+  if (expr === null) {
+    return buildNull();
+  } else if (expr === undefined) {
+    return buildUndefined();
+  }
 
   switch (typeof expr) {
-    case 'symbol':
     case 'boolean':
       return buildBoolean(expr);
+
     case 'string':
       return buildString(expr);
+
     case 'number':
       return buildInteger(expr);
+
     case 'object': {
-      switch (getPrototypeOf(expr)) {
+      switch (Object.getPrototypeOf(expr)) {
         case Array.prototype:
-          return buildArray(buildArrayElements(expr));
+          return buildArray(buildArrayElements(expr.map((e) => buildJSExpressionDeep(e))));
+
         case Object.prototype:
-          if (
-            hasOwn(expr, 'type') &&
-            hasOwn(expr, 'language') &&
-            hasOwn(expr, 'children') &&
-            hasOwn(expr, 'properties')
-          ) {
-            return expr;
-          }
           return buildObject(
             buildObjectProperties(
-              Object.entries(expr).map((e) => buildProperty(buildIdentifier(e[0]), e[1])),
+              Object.entries(expr).map((e) =>
+                buildProperty(
+                  /^[a-zA-Z_]+$/.test(e[0]) ? buildIdentifier(e[0]) : buildString(e[0]),
+                  buildJSExpressionDeep(e[1]),
+                ),
+              ),
             ),
           );
+
         default:
           throw new Error();
       }
     }
+
     default:
       throw new Error();
   }
@@ -930,15 +988,15 @@ export const buildTaggedString = (tag, content) => {
 
   return treeFromStream(
     [
-      t.buildOpenNodeTag(t.nodeFlags, l.Spamex, 'SpamexString'),
+      t.buildOpenNodeTag(t.nodeFlags, 'SpamexString'),
       t.buildReferenceTag('sigilToken'),
-      gap(buildToken(l.Instruction, 'Keyword', tag)),
+      gap(buildToken('Keyword', tag)),
       t.buildReferenceTag('openToken'),
-      gap(buildToken(l.Instruction, 'Punctuator', "'")),
+      gap(buildToken('Punctuator', "'")),
       t.buildReferenceTag('content'),
       gap(content),
       t.buildReferenceTag('closeToken'),
-      gap(buildToken(l.Instruction, 'Punctuator', "'")),
+      gap(buildToken('Punctuator', "'")),
       t.buildCloseNodeTag(),
     ],
     { expressions },
@@ -953,15 +1011,17 @@ export const buildRegexString = (content) => {
   return buildTaggedString('re', content);
 };
 
-export const buildPropertyMatcher = (refMatcher, nodeMatcher) => {
+export const buildPropertyMatcher = (refMatcher, bindingMatcher, nodeMatcher) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, l.Spamex, 'PropertyMatcher'),
+      t.nodeOpen(t.nodeFlags, 'PropertyMatcher'),
       t.ref`refMatcher`,
       gap(refMatcher || buildNullNode()),
+      t.ref`bindingMatcher`,
+      gap(bindingMatcher || buildNullNode()),
       t.ref`nodeMatcher`,
       gap(nodeMatcher),
       t.nodeClose(),
@@ -971,5 +1031,5 @@ export const buildPropertyMatcher = (refMatcher, nodeMatcher) => {
 };
 
 export const buildGapNodeMatcher = () => {
-  return buildToken(l.Spamex, 'GapNodeMatcher', '<//>');
+  return buildToken('GapNodeMatcher', '<//>');
 };