@bablr/helpers 0.23.0 → 0.25.0

package/lib/builders.js

@@ -1,15 +1,11 @@
-// import { i } from '@bablr/boot/shorthand.macro';
 import { interpolateFragment, buildFilledGapFunction } from '@bablr/agast-helpers/template';
-import {
-  buildNullNode,
-  getRootArray,
-  treeFromStreamSync as treeFromStream,
-} from '@bablr/agast-helpers/tree';
+import { get, isEmpty, 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/children';
+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';
+import { buildNullNode } from '@bablr/agast-helpers/path';
 
 const { freeze } = Object;
 const { isArray } = Array;
@@ -18,7 +14,7 @@ const when = (condition, value) => (condition ? value : { *[Symbol.iterator]() {
 
 const isString = (val) => typeof val === 'string';
 
-export const buildReferenceTag = (name, isArray = false, flags = t.referenceFlags) => {
+export const buildReferenceTag = (name, flags = t.referenceFlags) => {
   let expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
@@ -27,14 +23,102 @@ export const buildReferenceTag = (name, isArray = false, flags = t.referenceFlag
       t.nodeOpen(t.nodeFlags, 'ReferenceTag'),
       t.ref`name`,
       gap(name ? buildIdentifier(name) : buildNullNode()),
-      t.ref`openIndexToken`,
-      gap(isArray ? buildToken('Punctuator', '[') : buildNullNode()),
-      t.ref`closeIndexToken`,
-      gap(isArray ? buildToken('Punctuator', ']') : buildNullNode()),
       t.ref`flags`,
       gap(flags ? buildReferenceFlags(flags) : buildNullNode()),
       t.ref`sigilToken`,
-      gap(buildToken('Punctuator', ':')),
+      gap(buildToken(null, ':')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
+};
+
+export const buildBindingMatcher = (segments) => {
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    concat(
+      [t.nodeOpen(t.nodeFlags, 'BindingMatcher')],
+      segments.flatMap((segment) => [t.ref`segments[]`, gap(buildBindingSegment(segment))]),
+      [t.nodeClose()],
+    ),
+    { expressions },
+  );
+};
+
+export const buildBindingMatchers = (matchers) => {
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    concat(
+      [t.fragOpen()],
+      matchers.flatMap((matcher) => [
+        t.ref`bindingMatchers[]`,
+        gap(buildBindingMatcher(matcher.segments)),
+      ]),
+      [t.nodeClose()],
+    ),
+    { expressions },
+  );
+};
+
+export const buildBoundNodeMatcher = (bindingMatchers, valueMatcher) => {
+  if (valueMatcher.value.name.description === 'BoundNodeMatcher') throw new Error();
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, 'BoundNodeMatcher');
+      if (bindingMatchers.length) {
+        yield* interpolateFragment(
+          buildBindingMatchers(bindingMatchers),
+          t.ref`bindingMatchers`,
+          expressions,
+        );
+      }
+      yield t.ref`nodeMatcher`;
+      yield gap(valueMatcher);
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
+};
+
+export const buildPropertyMatcher = (refMatcher, valueMatcher) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, 'PropertyMatcher');
+      yield t.ref`refMatcher`;
+      yield gap(refMatcher || buildNullNode());
+      yield t.ref`valueMatcher`;
+      yield gap(valueMatcher || buildNullNode());
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
+};
+
+export const buildBindingSegment = (segment) => {
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  let { type, name } = segment;
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, 'BindingSegment'),
+      t.ref`openToken`,
+      gap(buildToken(null, ':')),
+      t.ref`path`,
+      gap(type ? buildToken(null, type) : buildIdentifier(name)),
+      t.ref`closeToken`,
+      gap(buildToken(null, ':')),
       t.nodeClose(),
     ],
     { expressions },
@@ -47,9 +131,9 @@ export const buildGapTag = () => {
 
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, 'ShiftTag'),
+      t.nodeOpen(t.nodeFlags, 'GapTag'),
       t.ref`sigilToken`,
-      gap(buildToken('Punctuator', '<//>')),
+      gap(buildToken(null, '<//>')),
       t.nodeClose(),
     ],
     { expressions },
@@ -64,7 +148,7 @@ export const buildShiftTag = () => {
     [
       t.nodeOpen(t.nodeFlags, 'ShiftTag'),
       t.ref`sigilToken`,
-      gap(buildToken('Punctuator', '^^^')),
+      gap(buildToken(null, '^^^')),
       t.nodeClose(),
     ],
     { expressions },
@@ -72,17 +156,21 @@ export const buildShiftTag = () => {
 };
 
 export const buildReferenceFlags = (flags = t.referenceFlags) => {
-  const { expression = null, hasGap = null } = flags;
+  const { array, expression, intrinsic, hasGap } = flags;
   let expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
   return treeFromStream(
     [
       t.nodeOpen(t.nodeFlags, 'ReferenceFlags'),
+      t.ref`arrayToken`,
+      gap(array ? buildToken(null, '[]') : buildNullNode()),
       t.ref`expressionToken`,
-      gap(expression ? buildToken('Punctuator', '+') : buildNullNode()),
+      gap(expression ? buildToken(null, '+') : buildNullNode()),
+      t.ref`intrinsicToken`,
+      gap(intrinsic ? buildToken(null, '*') : buildNullNode()),
       t.ref`hasGapToken`,
-      gap(hasGap ? buildToken('Punctuator', '$') : buildNullNode()),
+      gap(hasGap ? buildToken(null, '$') : buildNullNode()),
       t.nodeClose(),
     ],
     { expressions },
@@ -90,86 +178,113 @@ export const buildReferenceFlags = (flags = t.referenceFlags) => {
 };
 
 export const buildNodeFlags = (flags = t.nodeFlags) => {
-  const { token = null, hasGap = null, fragment = null, cover = null } = flags;
+  const { token = null, hasGap = null } = flags;
   let expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
+  let flags_ = { token, hasGap };
+  let attributes = flags_;
+
   return treeFromStream(
     [
-      t.nodeOpen(t.nodeFlags, 'NodeFlags'),
+      t.nodeOpen(t.nodeFlags, 'NodeFlags', null, attributes),
       t.ref`tokenToken`,
-      gap(token ? buildToken('Punctuator', '*') : buildNullNode()),
+      gap(token ? buildToken(null, '*') : buildNullNode()),
       t.ref`hasGapToken`,
-      gap(hasGap ? buildToken('Punctuator', '$') : buildNullNode()),
-      t.ref`fragmentToken`,
-      gap(fragment ? buildToken('Punctuator', '_') : buildNullNode()),
-      t.ref`coverFragmentToken`,
-      gap(cover ? buildToken('Punctuator', '_') : buildNullNode()),
+      gap(hasGap ? buildToken(null, '$') : buildNullNode()),
       t.nodeClose(),
     ],
     { expressions },
   );
 };
 
-export const buildSpamMatcher = (type = null, value = null, attributes = null) => {
-  return buildOpenNodeMatcher(buildNodeFlags(t.nodeFlags), null, type, value, attributes);
+export const buildSpamMatcher = (name = null, value = null, attributes = null) => {
+  return buildTreeNodeMatcherOpen(buildNodeFlags(t.nodeFlags), null, name, value, attributes);
 };
 
-export const buildOpenNodeMatcher = (flags, type, intrinsicValue, attributes = null) => {
+export const buildTreeNodeMatcherOpen = (flags, type, name, literalValue, attributes = null) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
-  let language_;
-
-  if (!type) throw new Error();
+  if (!type && !name) throw new Error();
 
   return treeFromStream(
     (function* () {
-      yield t.nodeOpen(t.nodeFlags, 'OpenNodeMatcher');
+      yield t.nodeOpen(t.nodeFlags, 'TreeNodeMatcherOpen');
       yield t.ref`openToken`;
-      yield gap(buildToken('Punctuator', '<'));
+      yield gap(buildToken(null, '<'));
       yield t.ref`flags`;
       yield gap(flags);
       yield t.ref`type`;
-      yield gap(typeof type === 'string' ? buildIdentifier(type) : type);
-
-      yield* when(intrinsicValue, [t.ref`#`, ...buildSpace().children]);
+      yield gap(typeof type === 'string' ? buildToken(null, type) : type);
+      yield t.ref`name`;
+      yield gap(typeof name === 'string' ? buildIdentifier(name) : name);
 
-      yield t.ref`intrinsicValue`;
-      yield gap(intrinsicValue ? buildString(intrinsicValue) : buildNullNode());
+      yield* when(literalValue, [t.ref`#`, ...Tags.traverse(buildSpace().value.tags)]);
 
-      let rootArr = getRootArray(attributes);
+      yield t.ref`literalValue`;
+      yield gap(literalValue ? buildString(literalValue) : buildNullNode());
 
-      if (rootArr.length) {
+      if (!isEmpty(attributes)) {
         yield t.ref`#`;
-        yield* buildSpace().children;
+        yield* buildSpace().value.tags;
         yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
       }
 
-      yield t.ref`selfClosingTagToken`;
-      yield gap(buildToken('Punctuator', '/'));
+      yield t.ref`selfClosingToken`;
+      yield gap(buildToken(null, '/'));
       yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', '>'));
+      yield gap(buildToken(null, '>'));
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export const buildBasicNodeMatcher = (open) => {
+export const buildTreeNodeMatcher = (open, children) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
+  let children_ = children;
+
+  if (children_) {
+    throw new Error('not implemented');
+    // if (isArray(children_)) {
+    //   children_ = buildTreeNodeMatcherChildren(children_);
+    // }
+  }
+
   return treeFromStream(
-    [t.nodeOpen(t.nodeFlags, 'BasicNodeMatcher'), t.ref`open`, gap(open), t.nodeClose()],
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, 'TreeNodeMatcher');
+      yield t.ref`open`;
+      yield gap(open);
+      if (!isEmpty(children_)) {
+        yield* interpolateFragment(children_, t.ref`children[]`, expressions);
+      }
+      yield t.nodeClose();
+    })(),
     { expressions },
   );
 };
 
-export const buildReferenceMatcher = (type, name, isArray, flags) => {
+export const buildReferenceMatcher = (type = '.', name, flags) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
+  if (isString(flags)) {
+    let array = flags.includes('[');
+    let intrinsic = flags.includes('*');
+    let hasGap = flags.includes('$');
+    let expression = flags.includes('+');
+
+    return buildReferenceMatcher(
+      type,
+      name,
+      buildReferenceFlags({ array, intrinsic, hasGap, expression }),
+    );
+  }
+
   return treeFromStream(
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'ReferenceMatcher');
@@ -177,56 +292,31 @@ export const buildReferenceMatcher = (type, name, isArray, flags) => {
       yield gap(type && buildKeyword(type));
       yield t.ref`name`;
       yield gap(name && buildIdentifier(name));
-      yield* (function* () {
-        if (isArray) {
-          yield t.ref`openIndexToken`;
-          yield gap(buildToken('Punctuator', '['));
-          yield t.ref`closeIndexToken`;
-          yield gap(buildToken('Punctuator', ']'));
-        }
-      })();
       yield t.ref`flags`;
       yield gap(flags);
       yield t.ref`sigilToken`;
-      yield gap(buildToken('Punctuator', ':'));
+      yield gap(buildToken(null, ':'));
       yield t.ref`#`;
-      yield* sumtree.traverse(buildSpace().children);
+      yield* Tags.traverse(buildSpace().value.tags);
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export const buildFragmentMatcher = (flags = buildNodeFlags({ fragment: true })) => {
-  const expressions = [];
-  const gap = buildFilledGapFunction(expressions);
-
-  if (!flags) throw new Error();
-
-  return treeFromStream(
-    (function* () {
-      yield t.nodeOpen(t.nodeFlags, 'FragmentMatcher');
-      yield t.ref`openToken`;
-      yield gap(buildToken('Punctuator', '<'));
-      yield t.ref`flags`;
-      yield gap(flags);
-      yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', '/>'));
-      yield t.nodeClose();
-    })(),
-    { expressions },
-  );
-};
-
-export const buildToken = (type, value, attributes = {}) => {
-  return treeFromStream([t.nodeOpen(t.tokenFlags, type, attributes), t.lit(value), t.nodeClose()]);
+export const buildToken = (name, value, attributes = {}) => {
+  return treeFromStream([
+    t.nodeOpen(t.tokenFlags, name, null, attributes),
+    t.lit(value),
+    t.nodeClose(),
+  ]);
 };
 
 export const buildPunctuator = (value, attributes = {}) => {
-  return buildToken('Punctuator', value, attributes);
+  return buildToken(null, value, attributes);
 };
 
-export const buildOpenNodeTag = (flags, type = null, attributes) => {
+export const buildOpenNodeTag = (flags, name = null, attributes) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
 
@@ -236,10 +326,9 @@ export const buildOpenNodeTag = (flags, type = null, attributes) => {
       yield gap(buildPunctuator('<'));
       yield t.ref`flags`;
       yield gap(buildNodeFlags(flags));
-      yield t.ref`type`;
-      yield gap(type ? buildIdentifier(type) : buildNullNode());
-      let rootArr = getRootArray(attributes);
-      yield* when(rootArr.length, [t.ref`#`, gap(buildSpace())]);
+      yield t.ref`name`;
+      yield gap(name ? buildIdentifier(name) : buildNullNode());
+      yield* when(!isEmpty(attributes), [t.ref`#`, gap(buildSpace())]);
       yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
       yield t.ref`closeToken`;
       yield gap(buildPunctuator('>'));
@@ -256,20 +345,20 @@ export const buildDoctypeTag = (attributes) => {
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'DoctypeTag');
       yield t.ref`openToken`;
-      yield gap(buildPunctuator('Punctuator', '<!'));
+      yield gap(buildPunctuator('<!'));
       yield t.ref`version`;
       yield gap(buildToken('PositiveInteger', '0'));
       yield t.ref`versionSeparator`;
-      yield gap(buildPunctuator('Punctuator', ':'));
+      yield gap(buildPunctuator(':'));
       yield t.ref`doctype`;
       yield gap(buildKeyword('cstml'));
       yield t.nodeClose();
 
-      yield* when(getRootArray(attributes).length, [t.ref`#`, ...buildSpace().children]);
+      yield* when(!isEmpty(attributes), [t.ref`#`, ...buildSpace().value.tags]);
       yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
 
       yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', '>'));
+      yield gap(buildToken(null, '>'));
     })(),
     { expressions },
   );
@@ -287,19 +376,15 @@ export const buildIdentifierPath = (path) => {
   return treeFromStream(
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'IdentifierPath');
-      yield t.ref`segments[]`;
-      yield t.arr();
-      yield t.ref`separatorTokens[]`;
-      yield t.arr();
 
       yield* path_
-        .flatMap((name) => [
+        .flatMap((segment) => [
           t.ref`segments[]`,
-          gap(buildIdentifier(name)),
-          t.ref`separatorTokens[]`,
-          gap(buildToken('Punctuator', '.')),
+          gap(segment.type ? buildPunctuator(segment.type) : buildIdentifier(segment.name)),
+          t.ref`#separatorTokens`,
+          gap(buildToken(null, '.')),
         ])
-        .slice(0, -1);
+        .slice(0, -2);
 
       yield t.nodeClose();
     })(),
@@ -321,9 +406,9 @@ export const buildCloseNodeTag = () => {
     [
       t.nodeOpen(t.nodeFlags, 'CloseNodeTag'),
       t.ref`openToken`,
-      gap(buildToken('Punctuator', '</')),
+      gap(buildToken(null, '</')),
       t.ref`closeToken`,
-      gap(buildToken('Punctuator', '>')),
+      gap(buildToken(null, '>')),
       t.nodeClose(),
     ],
     { expressions },
@@ -340,7 +425,8 @@ 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 });
 };
@@ -350,20 +436,68 @@ export const buildSpace = () => {
 };
 
 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, '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(null, '`'));
+        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', null, { cooked: chr });
+            yield t.ref`escape`;
+            yield gap(buildToken(null, '\\'));
+            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(null, '`'));
+        yield t.nodeClose();
+      })(),
+      { expressions },
+    );
+  }
 };
 
 export const buildIdentifierContent = (value) => {
@@ -371,7 +505,7 @@ export const buildIdentifierContent = (value) => {
 };
 
 export const buildKeyword = (name) => {
-  return buildToken('Keyword', name);
+  return buildToken(null, name);
 };
 
 export const buildCall = (verb, args) => {
@@ -401,7 +535,7 @@ export const buildProperty = (key, value) => {
       yield t.ref`key`;
       yield gap(key);
       yield t.ref`mapOperator`;
-      yield gap(buildToken('Punctuator', ':'));
+      yield gap(buildToken(null, ':'));
       yield t.ref`#`;
       yield gap(buildSpace());
       yield t.ref`value`;
@@ -431,7 +565,7 @@ export const buildInteger = (value, base = 10) => {
 
   return treeFromStream(
     concat(
-      [t.nodeOpen(t.nodeFlags, 'Integer'), t.ref`digits[]`, t.arr()],
+      [t.nodeOpen(t.nodeFlags, 'Integer')],
       digits.flatMap((digit) => [t.ref`digits[]`, gap(buildDigit(digit))]),
       [t.nodeClose()],
     ),
@@ -457,9 +591,9 @@ export const buildInfinity = (value) => {
     [
       t.nodeOpen(t.nodeFlags, 'Infinity'),
       t.ref`sign`,
-      gap(buildToken('Punctuator', sign)),
+      gap(buildToken(null, sign)),
       t.ref`value`,
-      gap(buildToken('Keyword', 'Infinity')),
+      gap(buildToken(null, 'Infinity')),
       t.nodeClose(),
     ],
     { expressions },
@@ -486,11 +620,11 @@ export const buildString = (value) => {
       [
         t.nodeOpen(t.nodeFlags, 'String'),
         t.ref`openToken`,
-        gap(buildToken('Punctuator', '"')),
+        gap(buildToken(null, '"')),
         t.ref`content`,
         gap(buildToken('StringContent', value)),
         t.ref`closeToken`,
-        gap(buildToken('Punctuator', '"')),
+        gap(buildToken(null, '"')),
         t.nodeClose(),
       ],
       { expressions },
@@ -504,7 +638,7 @@ export const buildString = (value) => {
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'String');
       yield t.ref`openToken`;
-      const tok = buildToken('Punctuator', "'");
+      const tok = buildToken(null, "'");
       yield gap(tok);
       yield t.ref`content`;
       yield t.nodeOpen(t.tokenFlags, 'StringContent');
@@ -539,8 +673,6 @@ export const buildString = (value) => {
                     t.nodeOpen(t.nodeFlags, 'EscapeCode'),
                     t.ref`sigilToken`,
                     gap(buildKeyword(escapables[chr])),
-                    t.ref`digits[]`,
-                    t.arr(),
                     t.nodeClose(),
                   ],
                   { expressions },
@@ -555,8 +687,6 @@ export const buildString = (value) => {
                     t.nodeOpen(t.nodeFlags, 'EscapeCode'),
                     t.ref`sigilToken`,
                     gap(buildKeyword('u')),
-                    t.ref`digits[]`,
-                    t.arr(),
                     [...hexDigits].flatMap((digit) => [t.ref`digits[]`, gap(buildDigit(digit))]),
                     t.nodeClose(),
                   ],
@@ -567,9 +697,9 @@ export const buildString = (value) => {
               }
 
               yield t.ref`@`;
-              yield t.nodeOpen(t.nodeFlags, 'EscapeSequence', { cooked: chr });
+              yield t.nodeOpen(t.nodeFlags, 'EscapeSequence', null, { cooked: chr });
               yield t.ref`escape`;
-              yield gap(buildToken('Punctuator', '\\'));
+              yield gap(buildToken(null, '\\'));
               yield t.ref`value`;
               yield gap(value);
               yield t.nodeClose();
@@ -596,7 +726,7 @@ export const buildString = (value) => {
 
       yield t.nodeClose();
       yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', "'"));
+      yield gap(buildToken(null, "'"));
       yield t.nodeClose();
     })(),
     { expressions },
@@ -611,7 +741,7 @@ export const buildBoolean = (value) => {
     [
       t.nodeOpen(t.nodeFlags, 'Boolean'),
       t.ref`sigilToken`,
-      gap(buildToken('Keyword', value ? 'true' : 'false')),
+      gap(buildToken(null, value ? 'true' : 'false')),
       t.nodeClose(),
     ],
     { expressions },
@@ -626,7 +756,22 @@ export const buildNull = () => {
     [
       t.nodeOpen(t.nodeFlags, 'Null'),
       t.ref`sigilToken`,
-      gap(buildToken('Keyword', 'null')),
+      gap(buildToken(null, '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(null, 'undefined')),
       t.nodeClose(),
     ],
     { expressions },
@@ -641,7 +786,7 @@ export const buildNullTag = () => {
     [
       t.nodeOpen(t.nodeFlags, 'NullTag'),
       t.ref`sigilToken`,
-      gap(buildToken('Keyword', 'null')),
+      gap(buildToken(null, 'null')),
       t.nodeClose(),
     ],
     { expressions },
@@ -656,10 +801,14 @@ export const buildArray = (elements) => {
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'Array');
       yield t.ref`openToken`;
-      yield gap(buildToken('Punctuator', '['));
-      yield* interpolateFragment(elements, t.ref`elements[]`, expressions);
+      yield gap(buildToken(null, '['));
+      yield* interpolateFragment(
+        isArray(elements) ? buildArrayElements(elements) : elements,
+        t.ref`elements[]`,
+        expressions,
+      );
       yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', ']'));
+      yield gap(buildToken(null, ']'));
       yield t.nodeClose();
     })(),
     { expressions },
@@ -670,28 +819,24 @@ export const buildArrayElements = (values) => {
   const expressions = [];
   return treeFromStream(
     (function* () {
-      yield t.doctype({ bablrLanguage: l.Instruction });
-      yield t.nodeOpen(t.nodeFlags);
-      yield* buildSpaceSeparatedList(values, t.ref`.[]`, expressions);
+      yield t.fragOpen();
+      yield* buildSeparatedList(',', values, t.ref`elements[]`, expressions);
       yield t.nodeClose();
     })(),
     { expressions },
   );
 };
 
-export function* buildSpaceSeparatedList(values, ref, expressions) {
+export function* buildSeparatedList(separator, values, ref, expressions) {
   const gap = buildFilledGapFunction(expressions);
 
-  if (!ref.value.isArray) throw new Error();
-
-  yield freeze({ ...ref });
-  yield t.arr();
+  if (!ref.value.flags.array) throw new Error();
 
   let first = true;
   for (const value of values) {
     if (!first) {
-      yield t.buildReferenceTag('#');
-      yield gap(buildSpace());
+      yield t.buildReferenceTag('#', 'separatorTokens');
+      yield gap(buildToken(null, separator));
     }
     yield freeze({ ...ref });
     yield gap(value || buildNullNode());
@@ -704,8 +849,8 @@ export const buildObjectProperties = (properties) => {
 
   return treeFromStream(
     concat(
-      [t.doctype({ bablrLanguage: l.Instruction }), t.nodeOpen(t.nodeFlags)],
-      buildSpaceSeparatedList(properties, t.ref`properties[]`, expressions),
+      [t.doctype({ 'bablr-lang': l.Instruction }), t.fragOpen(t.nodeFlags)],
+      buildSeparatedList(',', properties, t.ref`properties[]`, expressions),
       [t.nodeClose()],
     ),
     { expressions },
@@ -720,12 +865,16 @@ export const buildObject = (properties) => {
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'Object');
       yield t.ref`openToken`;
-      yield gap(buildToken('Punctuator', '{'));
+      yield gap(buildToken(null, '{'));
 
-      yield* interpolateFragment(properties, t.ref`properties[]`, expressions);
+      yield* interpolateFragment(
+        isArray(properties) ? buildObjectProperties(properties) : properties,
+        t.ref`properties[]`,
+        expressions,
+      );
 
       yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', '}'));
+      yield gap(buildToken(null, '}'));
       yield t.nodeClose();
     })(),
     { expressions },
@@ -740,14 +889,14 @@ export const buildPattern = (alternatives, flags) => {
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'Pattern');
       yield t.ref`openToken`;
-      yield gap(buildToken('Punctuator', '/'));
+      yield gap(buildToken(null, '/'));
 
       yield* interpolateFragment(alternatives, t.ref`alternatives[]`, expressions);
 
       yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', '/'));
+      yield gap(buildToken(null, '/'));
       yield t.ref`flags`;
-      yield gap(flags || buildReferenceFlags());
+      yield gap(flags || buildRegexFlags());
       yield t.nodeClose();
     })(),
     { expressions },
@@ -762,12 +911,12 @@ export const buildRegexGroup = (alternatives, flags) => {
     (function* () {
       yield t.nodeOpen(t.nodeFlags, 'Group');
       yield t.ref`openToken`;
-      yield gap(buildToken('Punctuator', '('));
+      yield gap(buildToken(null, '(?:'));
 
       yield* interpolateFragment(alternatives, t.ref`alternatives[]`, expressions);
 
       yield t.ref`closeToken`;
-      yield gap(buildToken('Punctuator', ')'));
+      yield gap(buildToken(null, ')'));
       yield t.ref`flags`;
       yield gap(flags || buildReferenceFlags());
       yield t.nodeClose();
@@ -794,9 +943,9 @@ export const buildRegexFlags = (flags = '') => {
       yield t.nodeOpen(t.nodeFlags, 'Flags');
 
       for (const { 0: name, 1: chr } of Object.entries(flagCharacters)) {
-        yield t.buildReferenceTag(name + 'Token');
+        yield t.buildReferenceTag(null, name + 'Token');
 
-        yield gap(flags.includes(chr) ? buildToken('Punctuator', chr) : buildNullNode());
+        yield gap(flags.includes(chr) ? buildToken(null, chr) : buildNullNode());
       }
       yield t.nodeClose();
     })(),
@@ -823,18 +972,13 @@ export const buildAlternatives = (alternatives = []) => {
 
   return treeFromStream(
     (function* () {
-      yield t.doctype({ bablrLanguage: l.Instruction });
-      yield t.nodeOpen(t.nodeFlags);
-      yield t.ref`.[]`;
-      yield t.arr();
-      yield t.ref`separatorTokens[]`;
-      yield t.arr();
+      yield t.fragOpen();
 
       yield* alternatives
         .flatMap((alt) => [
-          t.ref`.[]`,
+          t.ref`alternatives[]`,
           gap(alt),
-          t.ref`separatorTokens[]`,
+          t.ref`#separatorTokens`,
           gap(buildPunctuator('|')),
         ])
         .slice(0, -2);
@@ -853,9 +997,9 @@ export const buildRegexGap = () => {
     [
       t.nodeOpen(t.nodeFlags, 'Gap'),
       t.ref`escapeToken`,
-      gap(buildToken('Punctuator', '\\')),
+      gap(buildToken(null, '\\')),
       t.ref`value`,
-      gap(buildToken('Keyword', 'g')),
+      gap(buildToken(null, 'g')),
       t.nodeClose(),
     ],
     { expressions },
@@ -868,14 +1012,77 @@ export const buildElements = (elements) => {
 
   return treeFromStream(
     concat(
-      [t.doctype({ bablrLanguage: l.Instruction }), t.nodeOpen(t.nodeFlags), t.ref`.[]+`, t.arr()],
-      elements.flatMap((el) => [t.ref`.[]+`, gap(el)]),
+      [t.doctype({ 'bablr-lang': l.Instruction }), t.fragOpen()],
+      elements.flatMap((el) => [t.ref`elements[]+`, gap(el)]),
       [t.nodeClose()],
     ),
     { expressions },
   );
 };
 
+export const buildCharacterClass = (elements, negate = false) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, 'CharacterClass', null, { negate });
+      yield t.ref`openToken`;
+      yield gap(buildToken(null, '['));
+
+      yield* interpolateFragment(elements, t.ref`elements[]`, expressions);
+      yield t.ref`closeToken`;
+      yield gap(buildToken(null, ']'));
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
+};
+
+export const buildJSExpressionDeep = (expr) => {
+  if (expr === null) {
+    return buildNull();
+  } else if (expr === undefined) {
+    return buildUndefined();
+  }
+
+  switch (typeof expr) {
+    case 'boolean':
+      return buildBoolean(expr);
+
+    case 'string':
+      return buildString(expr);
+
+    case 'number':
+      return buildInteger(expr);
+
+    case 'object': {
+      switch (Object.getPrototypeOf(expr)) {
+        case Array.prototype:
+          return buildArray(buildArrayElements(expr.map((e) => buildJSExpressionDeep(e))));
+
+        case Object.prototype:
+          return buildObject(
+            buildObjectProperties(
+              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();
+  }
+};
+
 export const buildTaggedString = (tag, content) => {
   const expressions = [];
   const gap = buildFilledGapFunction(expressions);
@@ -884,13 +1091,13 @@ export const buildTaggedString = (tag, content) => {
     [
       t.buildOpenNodeTag(t.nodeFlags, 'SpamexString'),
       t.buildReferenceTag('sigilToken'),
-      gap(buildToken('Keyword', tag)),
+      gap(buildToken(null, tag)),
       t.buildReferenceTag('openToken'),
-      gap(buildToken('Punctuator', "'")),
+      gap(buildToken(null, "'")),
       t.buildReferenceTag('content'),
       gap(content),
       t.buildReferenceTag('closeToken'),
-      gap(buildToken('Punctuator', "'")),
+      gap(buildToken(null, "'")),
       t.buildCloseNodeTag(),
     ],
     { expressions },
@@ -905,25 +1112,6 @@ export const buildRegexString = (content) => {
   return buildTaggedString('re', content);
 };
 
-export const buildPropertyMatcher = (refMatcher, bindingMatcher, nodeMatcher) => {
-  const expressions = [];
-  const gap = buildFilledGapFunction(expressions);
-
-  return treeFromStream(
-    [
-      t.nodeOpen(t.nodeFlags, 'PropertyMatcher'),
-      t.ref`refMatcher`,
-      gap(refMatcher || buildNullNode()),
-      t.ref`bindingMatcher`,
-      gap(bindingMatcher || buildNullNode()),
-      t.ref`nodeMatcher`,
-      gap(nodeMatcher),
-      t.nodeClose(),
-    ],
-    { expressions },
-  );
-};
-
 export const buildGapNodeMatcher = () => {
   return buildToken('GapNodeMatcher', '<//>');
 };