@bablr/helpers 0.20.6 → 0.21.0

package/lib/builders.js

@@ -1,117 +1,130 @@
 // import { i } from '@bablr/boot/shorthand.macro';
-import { interpolateFragmentChildren, interpolateString } from '@bablr/agast-helpers/template';
-import { getRoot, isNull } from '@bablr/agast-helpers/tree';
+import { interpolateFragment, buildFilledGapFunction } from '@bablr/agast-helpers/template';
+import {
+  buildNullNode,
+  isNull,
+  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 btree from '@bablr/agast-helpers/btree';
 import * as l from '@bablr/agast-vm-helpers/languages';
+import { concat } from '@bablr/agast-vm-helpers/iterable';
 
-const { getPrototypeOf, freeze } = Object;
+const { getPrototypeOf, freeze, hasOwn } = Object;
 const { isArray } = Array;
 
 const when = (condition, value) => (condition ? value : { *[Symbol.iterator]() {} });
 
 const isString = (val) => typeof val === 'string';
-const isBoolean = (val) => typeof val === 'boolean';
 
-function* repeat(times, ...values) {
-  for (let i = 0; i < times; i++) for (const value of values) yield value;
-}
-
-function* concat(...iterables) {
-  for (const iterable of iterables) yield* iterable;
-}
-
-export const buildSeparatedListChildren = (list, ref, sep) => {
-  const children = [];
-  let first = true;
-  for (const _ of list) {
-    if (!first && sep) {
-      children.push(freeze({ ...sep }));
-    }
-    children.push(freeze({ ...ref }));
-    first = false;
-  }
-  return children;
-};
-
-export const buildReferenceTag = (name, isArray, hasGap) => {
-  return t.node(
-    l.CSTML,
-    'ReferenceTag',
-    btree.fromValues(
-      concat(
-        [t.ref`name`],
-        when(isArray, [t.ref`arrayOperatorToken`]),
-        when(hasGap, [t.ref`hasGapToken`]),
-        [t.ref`sigilToken`],
-      ),
-    ),
-    {
-      name: buildIdentifier(name),
-      arrayOperatorToken: isArray ? t.s_node(l.CSTML, 'Punctuator', '[]') : t.null_node(),
-      hasGapToken: hasGap ? t.s_node(l.CSTML, 'Punctuator', '$') : t.null_node(),
-      sigilToken: t.s_node(l.CSTML, 'Punctuator', ':'),
-    },
+export const buildReferenceTag = (
+  name,
+  isArray = false,
+  flags = t.referenceFlags,
+  index = null,
+) => {
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, '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()),
+      t.ref`closeIndexToken`,
+      gap(isArray ? buildToken(l.CSTML, 'Punctuator', ']') : buildNullNode()),
+      t.ref`flags`,
+      gap(flags ? buildReferenceFlags(flags) : buildNullNode()),
+      t.ref`sigilToken`,
+      gap(buildToken(l.CSTML, 'Punctuator', ':')),
+      t.nodeClose(),
+    ],
+    { expressions },
   );
 };
 
 export const buildGapTag = () => {
-  return t.node(l.CSTML, 'GapTag', [t.ref`sigilToken`], {
-    sigilToken: t.s_node(l.CSTML, 'Punctuator', '<//>'),
-  });
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, 'ShiftTag'),
+      t.ref`sigilToken`,
+      gap(buildToken(l.CSTML, 'Punctuator', '<//>')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
 };
 
 export const buildShiftTag = () => {
-  return t.node(l.CSTML, 'ShiftTag', [t.ref`sigilToken`], {
-    sigilToken: t.s_node(l.CSTML, 'Punctuator', '^^^'),
-  });
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, 'ShiftTag'),
+      t.ref`sigilToken`,
+      gap(buildToken(l.CSTML, 'Punctuator', '^^^')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
 };
 
-export const buildFlags = (flags = {}) => {
-  const { token = null, escape = null, trivia = null, expression = null, hasGap = null } = flags;
-
-  if ((trivia && escape) || (expression && (trivia || escape))) {
-    throw new Error('invalid flags');
-  }
+export const buildReferenceFlags = (flags = t.referenceFlags) => {
+  const { expression = null, hasGap = null } = flags;
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, 'ReferenceFlags'),
+      t.ref`expressionToken`,
+      gap(expression ? buildToken(l.CSTML, 'Punctuator', '+') : buildNullNode()),
+      t.ref`hasGapToken`,
+      gap(hasGap ? buildToken(l.CSTML, 'Punctuator', '$') : buildNullNode()),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
+};
 
-  return t.node(
-    l.CSTML,
-    'Flags',
-    btree.fromValues(
-      concat(
-        when(trivia, [t.ref`triviaToken`]),
-        when(token, [t.ref`tokenToken`]),
-        when(escape, [t.ref`escapeToken`]),
-        when(expression, [t.ref`expressionToken`]),
-        when(hasGap, [t.ref`hasGapToken`]),
-      ),
-    ),
-    {
-      triviaToken: trivia ? t.s_node(l.CSTML, 'Punctuator', '#') : t.null_node(),
-      tokenToken: token ? t.s_node(l.CSTML, 'Punctuator', '*') : t.null_node(),
-      escapeToken: escape ? t.s_node(l.CSTML, 'Punctuator', '@') : t.null_node(),
-      expressionToken: expression ? t.s_node(l.CSTML, 'Punctuator', '+') : t.null_node(),
-      hasGapToken: hasGap ? t.s_node(l.CSTML, 'Punctuator', '$') : t.null_node(),
-    },
+export const buildNodeFlags = (flags = t.nodeFlags) => {
+  const { token = null, hasGap = 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.ref`hasGapToken`,
+      gap(hasGap ? buildToken(l.CSTML, 'Punctuator', '$') : buildNullNode()),
+      t.nodeClose(),
+    ],
+    { expressions },
   );
 };
 
-export const buildSpamMatcher = (type = null, value = null, attributes = {}) => {
-  return buildFullyQualifiedSpamMatcher({}, null, type, value, attributes);
+export const buildSpamMatcher = (type = null, value = null, attributes = null) => {
+  return buildOpenNodeMatcher(t.nodeFlags, null, type, value, attributes);
 };
 
-export const buildFullyQualifiedSpamMatcher = (
-  flags,
-  language,
-  type,
-  intrinsicValue,
-  attributes = {},
-) => {
-  const attributes_ = buildAttributes(attributes);
+export const buildOpenNodeMatcher = (flags, language, type, intrinsicValue, attributes = null) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
 
   let language_;
 
+  if (!type) throw new Error();
+
   if (isString(language)) {
     language_ = language;
   } else {
@@ -120,115 +133,195 @@ export const buildFullyQualifiedSpamMatcher = (
     language_ = lArr.length === 0 ? null : lArr;
   }
 
-  return t.node(l.Spamex, 'NodeMatcher', [t.ref`open`], {
-    open: t.node(
-      l.Spamex,
-      'NodeMatcher',
-      btree.fromValues(
-        concat(
-          [t.ref`openToken`, t.ref`flags`],
-          when(language_, [t.ref`language`, t.ref`languageSeparator`]),
-          when(type, [t.ref`type`]),
-          when(intrinsicValue, [t.embedded(buildSpace()), t.ref`intrinsicValue`]),
-          when(attributes_.length, [t.embedded(buildSpace())]),
-          interpolateFragmentChildren(attributes_, t.ref`attributes[]`),
-          when(!type, [t.embedded(buildSpace())]),
-          [t.ref`selfClosingTagToken`, t.ref`closeToken`],
-        ),
-      ),
-      {
-        openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
-        flags: buildFlags(flags),
-        language: language_ ? buildLanguage(language_) : t.null_node(),
-        languageSeparator: language_ && type ? t.s_node(l.CSTML, 'Punctuator', ':') : t.null_node(),
-        type: type ? buildIdentifier(type) : t.null_node(),
-        intrinsicValue: intrinsicValue ? buildString(intrinsicValue) : t.null_node(),
-        attributes: attributes_.properties['.'],
-        selfClosingTagToken: t.s_node(l.CSTML, 'Punctuator', '/'),
-        closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
-      },
-    ),
-  });
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Spamex, 'OpenNodeMatcher');
+      yield t.ref`openToken`;
+      yield gap(buildToken(l.CSTML, '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 t.ref`type`;
+      yield gap(typeof type === 'string' ? buildIdentifier(type) : type);
+
+      yield* when(intrinsicValue, [t.ref`#`, ...buildSpace().children]);
+
+      yield t.ref`intrinsicValue`;
+      yield gap(intrinsicValue ? buildString(intrinsicValue) : buildNullNode());
+
+      yield* when(attributes?.properties['.'].length, [t.ref`#`, ...buildSpace().children]);
+      if (attributes?.properties['.'].length) {
+        yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
+      }
+
+      yield t.ref`selfClosingTagToken`;
+      yield gap(buildToken(l.CSTML, 'Punctuator', '/'));
+      yield t.ref`closeToken`;
+      yield gap(buildToken(l.CSTML, 'Punctuator', '>'));
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
 };
 
-export const buildNodeOpenTag = (flags, language, type = null, attributes = {}) => {
-  const attributes_ = buildAttributes(attributes);
+export const buildBasicNodeMatcher = (open) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [t.nodeOpen(t.nodeFlags, l.Spamex, 'BasicNodeMatcher'), t.ref`open`, gap(open), t.nodeClose()],
+    { expressions },
+  );
+};
+
+export const buildReferenceMatcher = (name, isArray, flags) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Spamex, 'ReferenceMatcher');
+      yield t.ref`name`;
+      yield gap(buildToken(l.CSTML, 'Identifier', name));
+      yield* (function* () {
+        if (isArray) {
+          yield t.ref`openIndexToken`;
+          yield gap(buildToken(l.CSTML, 'Punctuator', '['));
+          yield t.ref`closeIndexToken`;
+          yield gap(buildToken(l.CSTML, 'Punctuator', ']'));
+        }
+      })();
+      yield t.ref`flags`;
+      yield gap(flags);
+      yield t.ref`sigilToken`;
+      yield gap(buildToken(l.CSTML, 'Punctuator', ':'));
+      yield t.ref`#`;
+      yield* buildSpace().children;
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
+};
+
+export const buildFragmentMatcher = (flags) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Spamex, 'FragmentMatcher');
+      yield t.ref`openToken`;
+      yield gap(buildToken(l.CSTML, 'Punctuator', '<'));
+      yield t.ref`flags`;
+      yield gap(flags);
+      yield t.ref`#`;
+      yield* buildSpace().children;
+      yield t.ref`closeToken`;
+      yield gap(buildToken(l.CSTML, '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 buildPunctuator = (language, value, attributes = {}) => {
+  return buildToken(language, 'Punctuator', value, attributes);
+};
+
+export const buildOpenNodeTag = (flags, language, type = null, attributes) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
 
   let language_ = !language || language.length === 0 ? null : language;
 
-  return t.node(
-    l.CSTML,
-    'OpenNodeTag',
-    btree.fromValues(
-      concat(
-        [t.ref`openToken`, t.ref`flags`],
-        when(language_, [t.ref`language`, t.ref`languageSeparator`]),
-        when(type, [t.ref`type`]),
-        when(attributes_.length, [t.embedded(buildSpace())]),
-        interpolateFragmentChildren(attributes_, t.ref`attributes[]`),
-        [t.ref`closeToken`],
-      ),
-    ),
-    {
-      openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
-      flags: buildFlags(flags),
-      language: language_ && type ? buildLanguage(language_) : t.null_node(),
-      languageSeparator: language_ && type ? t.s_node(l.CSTML, 'Punctuator', ':') : t.null_node(),
-      type: type ? buildIdentifier(type) : t.null_node(),
-      attributes: attributes_.properties['.'],
-      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
+  return treeFromStream(
+    (function* () {
+      yield t.ref`openToken`;
+      yield gap(buildPunctuator(l.CSTML, '<'));
+      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())]);
+      yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
+      yield t.ref`closeToken`;
+      yield gap(buildPunctuator(l.CSTML, '>'));
+    })(),
+    { expressions },
   );
 };
 
 export const buildDoctypeTag = (attributes) => {
-  const attributes_ = buildAttributes(attributes);
-
-  return t.node(
-    l.CSTML,
-    'DoctypeTag',
-    btree.fromValues(
-      concat(
-        [t.ref`openToken`, t.ref`version`, t.ref`versionSeparator`, t.ref`doctype`],
-        when(attributes_.length, [t.embedded(buildSpace())]),
-        interpolateFragmentChildren(attributes_, t.ref`attributes[]`),
-        [t.ref`closeToken`],
-      ),
-    ),
-    {
-      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_.properties['.'],
-      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.CSTML, 'DoctypeTag');
+      yield t.ref`openToken`;
+      yield gap(buildPunctuator(l.CSTML, 'Punctuator', '<!'));
+      yield t.ref`version`;
+      yield gap(buildToken(l.CSTML, 'PositiveInteger', '0'));
+      yield t.ref`versionSeparator`;
+      yield gap(buildPunctuator(l.CSTML, 'Punctuator', ':'));
+      yield t.ref`doctype`;
+      yield gap(buildKeyword(l.CSTML, 'cstml'));
+      yield t.nodeClose();
+
+      yield* when(attributes.properties['.'].length, [t.ref`#`, ...buildSpace().children]);
+      yield* interpolateFragment(attributes, t.ref`attributes[]`, expressions);
+
+      yield t.ref`closeToken`;
+      yield gap(buildToken(l.CSTML, 'Punctuator', '>'));
+    })(),
+    { expressions },
   );
 };
 
 export const buildIdentifierPath = (path) => {
   const path_ = isString(path) ? [path] : [...path];
-  const segments = path_.map((name) => buildIdentifier(name));
-  const separators = path_.slice(0, -1).map((_) => t.s_node(l.CSTML, 'Punctuator', '.'));
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
 
   if (!path_.length) {
     return null;
   }
 
-  return t.node(
-    l.CSTML,
-    'IdentifierPath',
-    btree.fromValues(
-      concat(
-        [t.ref`segments[]`, t.arr()],
-        repeat(segments.length - 1, t.ref`segments[]`, t.ref`separators[]`),
-        [t.ref`segments[]`],
-      ),
-    ),
-    {
-      segments,
-      separators,
-    },
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.CSTML, 'IdentifierPath');
+      yield t.ref`segments[]`;
+      yield t.arr();
+      yield t.ref`separatorTokens[]`;
+      yield t.arr();
+
+      yield* path_
+        .flatMap((name) => [
+          t.ref`segments[]`,
+          gap(buildIdentifier(name)),
+          t.ref`separatorTokens[]`,
+          gap(buildToken(l.CSTML, 'Punctuator', '.')),
+        ])
+        .slice(0, -1);
+
+      yield t.nodeClose();
+    })(),
+    { expressions },
   );
 };
 
@@ -238,31 +331,36 @@ export const buildLanguage = (language) => {
     : buildIdentifierPath(language);
 };
 
-export const buildNodeCloseTag = (type, language) => {
-  return t.node(
-    l.CSTML,
-    'CloseNodeTag',
-    btree.fromValues(
-      concat(
-        [t.ref`openToken`],
-        when(language, [t.ref`language`]),
-        when(type && language, [t.ref`languageSeparator`]),
-        when(type, [t.ref`type`]),
-        [t.ref`closeToken`],
-      ),
-    ),
-    {
-      openToken: t.s_node(l.CSTML, 'Punctuator', '</'),
-      language: language ? buildLanguage(language) : t.null_node(),
-      languageSeparator: language && type ? t.s_node(l.CSTML, 'Punctuator', ':') : t.null_node(),
-      type: type ? buildIdentifier(type) : t.null_node(),
-      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
+export const buildCloseNodeTag = (type, language) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, '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()),
+      t.ref`closeToken`,
+      gap(buildToken(l.CSTML, 'Punctuator', '>')),
+      t.nodeClose(),
+    ],
+    { expressions },
   );
 };
 
 export const buildLiteralTag = (value) => {
-  return t.node(l.CSTML, 'LiteralTag', [t.ref`value`], { value });
+  return treeFromStream([
+    t.nodeOpen(t.nodeFlags, l.Instruction, 'LiteralTag'),
+    t.ref`value`,
+    t.lit(value),
+    t.nodeClose(),
+  ]);
 };
 
 export const buildTerminalProps = (matcher) => {
@@ -272,34 +370,54 @@ export const buildTerminalProps = (matcher) => {
 };
 
 export const buildSpace = () => {
-  return t.t_node(l.Comment, null, [t.embedded(t.t_node(l.Space, 'Space', [t.lit(' ')]))]);
+  return buildToken(l.Space, 'Space', ' ');
 };
 
 export const buildIdentifier = (name) => {
-  return t.s_node(l.Instruction, 'Identifier', name);
-};
+  if (!/^[a-zA-Z]+$/.test(name)) throw new Error();
 
-export const buildKeyword = (name) => {
-  return t.s_node(l.Instruction, 'Identifier', name);
+  return buildToken(l.Instruction, 'Identifier', name);
 };
 
-export const buildCall = (verb, ...args) => {
-  return t.node(l.Instruction, 'Call', [t.ref`verb`, t.ref`arguments`], {
-    verb: buildIdentifier(verb),
-    arguments: buildTuple(args),
-  });
+export const buildKeyword = (name) => {
+  return buildToken(l.Instruction, 'Keyword', name);
+};
+
+export const buildCall = (verb, args) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.Instruction, 'Call'),
+      t.ref`verb`,
+      gap(verb),
+      t.ref`arguments`,
+      gap(args),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
 };
 
 export const buildProperty = (key, value) => {
-  return t.node(
-    l.Instruction,
-    'Property',
-    btree.from(t.ref`key`, t.ref`mapOperator`, t.embedded(buildSpace()), t.ref`value`),
-    {
-      key: buildIdentifier(key),
-      mapOperator: t.s_node(l.Instruction, 'Punctuator', ':'),
-      value: buildExpression(value),
-    },
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Instruction, 'Property');
+      yield t.ref`key`;
+      yield gap(key);
+      yield t.ref`mapOperator`;
+      yield gap(buildToken(l.Instruction, 'Punctuator', ':'));
+      yield t.ref`#`;
+      yield gap(buildSpace());
+      yield t.ref`value`;
+      yield gap(value);
+      yield t.nodeClose();
+    })(),
+    { expressions },
   );
 };
 
@@ -311,24 +429,23 @@ const escapables = {
 };
 
 export const buildDigit = (value) => {
-  return t.s_node(l.CSTML, 'Digit', value);
+  return buildToken(l.CSTML, 'Digit', value);
 };
 
 export const buildInteger = (value, base = 10) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
   const digits = value.toString(base).split('');
 
-  return t.node(
-    l.CSTML,
-    'Integer',
-    btree.fromValues(
-      concat(
-        [t.ref`digits[]`, t.arr()],
-        digits.map(() => t.ref`digits[]`),
-      ),
+  return treeFromStream(
+    concat(
+      [t.nodeOpen(t.nodeFlags, l.CSTML, 'Integer'), t.ref`digits[]`, t.arr()],
+      digits.flatMap((digit) => [t.ref`digits[]`, gap(buildDigit(digit))]),
+      [t.nodeClose()],
     ),
-    {
-      digits: digits.map((digit) => buildDigit(digit)),
-    },
+
+    { expressions },
   );
 };
 
@@ -342,10 +459,20 @@ export const buildInfinity = (value) => {
     throw new Error();
   }
 
-  return t.node(l.CSTML, 'Infinity', [t.ref`sign`, t.ref`value`], {
-    sign: t.s_node(l.CSTML, 'Punctuator', sign),
-    value: t.s_node(l.CSTML, 'Keyword', 'Infinity'),
-  });
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, 'Infinity'),
+      t.ref`sign`,
+      gap(buildToken(l.CSTML, 'Punctuator', sign)),
+      t.ref`value`,
+      gap(buildToken(l.CSTML, 'Keyword', 'Infinity')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
 };
 
 export const buildNumber = (value) => {
@@ -358,297 +485,390 @@ export const buildNumber = (value) => {
 
 export const buildString = (value) => {
   const pieces = isArray(value) ? value : [value];
-  const tags = [];
   let lit = '';
 
   if (pieces.length === 1 && pieces[0] === "'") {
-    return t.node(
-      l.CSTML,
-      'String',
-      btree.from(t.ref`openToken`, t.ref`content`, t.ref`closeToken`),
-      {
-        openToken: t.s_node(l.CSTML, 'Punctuator', '"'),
-        content: interpolateString(agastBuildLiteralTag(value)),
-        closeToken: t.s_node(l.CSTML, 'Punctuator', '"'),
-      },
+    const expressions = [];
+    const gap = buildFilledGapFunction(expressions);
+    return treeFromStream(
+      [
+        t.nodeOpen(t.nodeFlags, l.JSON, 'String'),
+        t.ref`openToken`,
+        gap(buildToken(l.JSON, 'Punctuator', '"')),
+        t.ref`content`,
+        gap(buildToken(l.JSON, 'StringContent', value)),
+        t.ref`closeToken`,
+        gap(buildToken(l.JSON, 'Punctuator', '"')),
+        t.nodeClose(),
+      ],
+      { expressions },
     );
   }
 
-  for (const piece of pieces) {
-    if (isString(piece)) {
-      const value = piece;
-
-      for (const chr of value) {
-        if (
-          chr === '\\' ||
-          chr === "'" ||
-          chr === '\n' ||
-          chr === '\r' ||
-          chr === '\t' ||
-          chr === '\0' ||
-          chr.charCodeAt(0) < 32
-        ) {
-          if (lit) {
-            tags.push(agastBuildLiteralTag(lit));
-            lit = '';
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.JSON, 'String');
+      yield t.ref`openToken`;
+      const tok = buildToken(l.JSON, 'Punctuator', "'");
+      yield gap(tok);
+      yield t.ref`content`;
+      yield t.nodeOpen(t.tokenFlags, l.JSON, 'StringContent');
+
+      for (const piece of pieces) {
+        if (isString(piece)) {
+          const value = piece;
+
+          for (const chr of value) {
+            if (
+              chr === '\\' ||
+              chr === "'" ||
+              chr === '\n' ||
+              chr === '\r' ||
+              chr === '\t' ||
+              chr === '\0' ||
+              chr.charCodeAt(0) < 32
+            ) {
+              if (lit) {
+                yield agastBuildLiteralTag(lit);
+                lit = '';
+              }
+
+              let value;
+
+              if (escapables[chr]) {
+                const expressions = [];
+                const gap = buildFilledGapFunction(expressions);
+
+                value = treeFromStream(
+                  [
+                    t.nodeOpen(t.nodeFlags, l.JSON, 'EscapeCode'),
+                    t.ref`sigilToken`,
+                    gap(buildKeyword(escapables[chr])),
+                    t.ref`digits[]`,
+                    t.arr(),
+                    t.nodeClose(),
+                  ],
+                  { expressions },
+                );
+              } else if (chr.charCodeAt(0) < 32) {
+                const hexDigits = chr.charCodeAt(0).toString(16).padStart(4, '0');
+                const expressions = [];
+                const gap = buildFilledGapFunction(expressions);
+
+                value = treeFromStream(
+                  [
+                    t.nodeOpen(t.nodeFlags, l.JSON, 'EscapeCode'),
+                    t.ref`sigilToken`,
+                    gap(buildKeyword('u')),
+                    t.ref`digits[]`,
+                    t.arr(),
+                    [...hexDigits].flatMap((digit) => [t.ref`digits[]`, gap(buildDigit(digit))]),
+                    t.nodeClose(),
+                  ],
+                  { expressions },
+                );
+              } else {
+                value = buildKeyword(chr);
+              }
+
+              yield t.ref`@`;
+              yield t.nodeOpen(t.nodeFlags, l.JSON, 'EscapeSequence', { cooked: chr });
+              yield t.ref`escape`;
+              yield gap(buildToken(l.JSON, 'Punctuator', '\\'));
+              yield t.ref`value`;
+              yield gap(value);
+              yield t.nodeClose();
+            } else {
+              lit += chr;
+            }
           }
+        } else {
+          yield agastBuildLiteralTag(lit);
+          lit = '';
 
-          let value;
-
-          if (escapables[chr]) {
-            value = t.node(l.CSTML, 'EscapeCode', [t.ref`sigilToken`], {
-              sigilToken: buildKeyword(escapables[chr]),
-              digits: t.null_node(),
-            });
-          } else if (chr.charCodeAt(0) < 32) {
-            const hexDigits = chr.charCodeAt(0).toString(16).padStart(4, '0');
-            value = t.node(
-              l.CSTML,
-              'EscapeCode',
-              btree.fromValues(
-                concat(
-                  [t.ref`sigilToken`, t.ref`digits[]`, t.arr()],
-                  [...hexDigits].map((d) => t.ref`digits[]`),
-                ),
-              ),
-              {
-                sigilToken: buildKeyword('u'),
-                digits: [...hexDigits].map((digit) => buildDigit(digit)),
-              },
-            );
+          if (piece == null) {
+            throw new Error('not implemented');
+          } else if (isString(piece.type)) {
+            yield piece;
           } else {
-            value = buildKeyword(chr);
+            throw new Error();
           }
-
-          tags.push(
-            t.buildEmbeddedNode(
-              t.e_node(
-                l.CSTML,
-                'EscapeSequence',
-                [t.ref`escape`, t.ref`value`],
-                {
-                  escape: t.s_node(l.CSTML, 'Punctuator', '\\'),
-                  value,
-                },
-                { cooked: chr },
-              ),
-            ),
-          );
-        } else {
-          lit += chr;
         }
       }
-    } else {
-      tags.push(agastBuildLiteralTag(lit));
-      lit = '';
-
-      if (piece == null) {
-        throw new Error('not implemented');
-      } else if (isString(piece.type)) {
-        tags.push(piece);
-      } else {
-        throw new Error();
-      }
-    }
-  }
 
-  if (lit) tags.push(agastBuildLiteralTag(lit));
-  lit = '';
+      if (lit) yield agastBuildLiteralTag(lit);
+      lit = '';
 
-  return t.node(
-    l.CSTML,
-    'String',
-    btree.from(t.ref`openToken`, t.ref`content`, t.ref`closeToken`),
-    {
-      openToken: t.s_node(l.CSTML, 'Punctuator', "'"),
-      content: interpolateString(tags),
-      closeToken: t.s_node(l.CSTML, 'Punctuator', "'"),
-    },
+      yield t.nodeClose();
+      yield t.ref`closeToken`;
+      yield gap(buildToken(l.JSON, 'Punctuator', "'"));
+      yield t.nodeClose();
+    })(),
+    { expressions },
   );
 };
 
 export const buildBoolean = (value) => {
-  return t.node(l.Instruction, 'Boolean', [t.ref`sigilToken`], {
-    sigilToken: t.s_node(l.Instruction, 'Keyword', value ? 'true' : 'false'),
-  });
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.Instruction, 'Boolean'),
+      t.ref`sigilToken`,
+      gap(buildToken(l.Instruction, 'Keyword', value ? 'true' : 'false')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
+};
+
+export const buildNull = () => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.Instruction, 'Null'),
+      t.ref`sigilToken`,
+      gap(buildToken(l.Instruction, 'Keyword', 'null')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
 };
 
 export const buildNullTag = () => {
-  return t.node(l.Instruction, 'Null', [t.ref`sigilToken`], {
-    sigilToken: t.s_node(l.Instruction, 'Keyword', 'null'),
-  });
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, 'NullTag'),
+      t.ref`sigilToken`,
+      gap(buildToken(l.CSTML, 'Keyword', 'null')),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
 };
 
 export const buildArray = (elements) => {
-  const elements_ = buildArrayElements(elements);
-  return t.node(
-    l.Instruction,
-    'Array',
-    btree.fromValues(
-      concat([t.ref`openToken`], interpolateFragmentChildren(elements_, t.ref`elements[]`), [
-        t.ref`closeToken`,
-      ]),
-    ),
-    {
-      openToken: t.s_node(l.Instruction, 'Punctuator', '['),
-      elements: elements_.properties['.'],
-      closeToken: t.s_node(l.Instruction, 'Punctuator', ']'),
-    },
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Instruction, 'Array');
+      yield t.ref`openToken`;
+      yield gap(buildToken(l.Instruction, 'Punctuator', '['));
+      yield* interpolateFragment(elements, t.ref`elements[]`, expressions);
+      yield t.ref`closeToken`;
+      yield gap(buildToken(l.Instruction, 'Punctuator', ']'));
+      yield t.nodeClose();
+    })(),
+    { expressions },
   );
 };
 
 export const buildArrayElements = (values) => {
-  return buildSpaceSeparatedList(values.map((value) => buildExpression(value)));
+  const expressions = [];
+  return treeFromStream(
+    (function* () {
+      yield t.doctype({ bablrLanguage: l.Instruction });
+      yield t.nodeOpen(t.nodeFlags);
+      yield* buildSpaceSeparatedList(values, t.ref`.[]`, expressions);
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
 };
 
-export const buildTupleValues = buildArrayElements;
+export function* buildSpaceSeparatedList(values, ref, expressions) {
+  const gap = buildFilledGapFunction(expressions);
 
-export const buildTuple = (values) => {
-  const values_ = buildTupleValues(values);
-  return t.node(
-    l.Instruction,
-    'Tuple',
-    btree.fromValues(
-      concat([t.ref`openToken`], interpolateFragmentChildren(values_, t.ref`values[]`), [
-        t.ref`closeToken`,
-      ]),
-    ),
-    {
-      openToken: t.s_node(l.Instruction, 'Punctuator', '('),
-      values: values_.properties['.'],
-      closeToken: t.s_node(l.Instruction, 'Punctuator', ')'),
-    },
-  );
-};
+  if (!ref.value.isArray) throw new Error();
 
-export const buildSpaceSeparatedList = (values) => {
-  return t.frag(
-    btree.fromValues(
-      concat(
-        [t.ref`.`, t.arr()],
-        buildSeparatedListChildren(values, t.ref`.`, t.embedded(buildSpace())),
-      ),
-    ),
-    {
-      ['.']: values,
-    },
-  );
-};
+  yield freeze({ ...ref });
+  yield t.arr();
+
+  let first = true;
+  for (const value of values) {
+    if (!first) {
+      yield t.buildReferenceTag('#', false);
+      yield gap(buildSpace());
+    }
+    yield freeze({ ...ref });
+    yield gap(value || buildNullNode());
+    first = false;
+  }
+}
 
 export const buildObjectProperties = (properties) => {
-  return buildSpaceSeparatedList(
-    Object.entries(properties).map(({ 0: key, 1: value }) => buildProperty(key, value)),
+  const expressions = [];
+
+  return treeFromStream(
+    concat(
+      [t.doctype({ bablrLanguage: l.Instruction }), t.nodeOpen(t.nodeFlags)],
+      buildSpaceSeparatedList(properties, t.ref`properties[]`, expressions),
+      [t.nodeClose()],
+    ),
+    { expressions },
   );
 };
 
 export const buildObject = (properties) => {
-  const properties_ = buildObjectProperties(properties);
-  return t.node(
-    l.Instruction,
-    'Object',
-    btree.fromValues(
-      concat([t.ref`openToken`], interpolateFragmentChildren(properties_, t.ref`properties[]`), [
-        t.ref`closeToken`,
-      ]),
-    ),
-    {
-      openToken: t.s_node(l.Instruction, 'Punctuator', '{'),
-      properties: properties_.properties['.'],
-      closeToken: t.s_node(l.Instruction, 'Punctuator', '}'),
-    },
-    {},
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Instruction, 'Object');
+      yield t.ref`openToken`;
+      yield gap(buildToken(l.Instruction, 'Punctuator', '{'));
+
+      yield* interpolateFragment(properties, t.ref`properties[]`, expressions);
+
+      yield t.ref`closeToken`;
+      yield gap(buildToken(l.Instruction, 'Punctuator', '}'));
+      yield t.nodeClose();
+    })(),
+    { expressions },
   );
 };
 
-export const buildMappingAttribute = (key, value) => {
-  return t.node(
-    l.CSTML,
-    'MappingAttribute',
-    btree.from(t.ref`key`, t.ref`mapOperator`, t.ref`value`),
-    {
-      key: buildIdentifier(key),
-      mapOperator: t.s_node(l.CSTML, 'Punctuator', '='),
-      value: buildExpression(value),
-    },
+export const buildPattern = (alternatives, flags) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Regex, 'Pattern');
+      yield t.ref`openToken`;
+      yield gap(buildToken(l.Regex, 'Punctuator', '/'));
+
+      yield* interpolateFragment(alternatives, t.ref`alternatives[]`, expressions);
+
+      yield t.ref`closeToken`;
+      yield gap(buildToken(l.Regex, 'Punctuator', '/'));
+      yield t.ref`flags`;
+      yield gap(flags || buildReferenceFlags());
+      yield t.nodeClose();
+    })(),
+    { expressions },
   );
 };
 
-export const buildBooleanAttribute = (key, value) => {
-  return t.node(l.CSTML, 'BooleanAttribute', [...when(!value, [t.ref`negateToken`]), t.ref`key`], {
-    negateToken: !value ? t.s_node(l.CSTML, 'Puncutator', '!') : t.null_node(),
-    key: buildIdentifier(key),
-  });
+const flagCharacters = {
+  global: 'g',
+  ignoreCase: 'i',
+  multiline: 'm',
+  dotAll: 's',
+  unicode: 'u',
+  sticky: 'y',
 };
 
-export const buildAttribute = (key, value) => {
-  return isBoolean(value) ? buildBooleanAttribute(key, value) : buildMappingAttribute(key, value);
-};
+export const buildRegexFlags = (flags = '') => {
+  let expressions = [];
+  const gap = buildFilledGapFunction(expressions);
 
-export const buildPattern = (alternatives, flags) => {
-  return t.node(
-    l.Regex,
-    'Pattern',
-    btree.fromValues(
-      concat([t.ref`openToken`], interpolateFragmentChildren(alternatives, t.ref`alternatives[]`), [
-        t.ref`closeToken`,
-        t.ref`flags`,
-      ]),
-    ),
-    {
-      openToken: t.s_node(l.Regex, 'Punctuator', '/'),
-      separators: alternatives.properties.separators,
-      alternatives: alternatives.properties['.'],
-      closeToken: t.s_node(l.Regex, 'Punctuator', '/'),
-      flags: buildFlags(flags),
-    },
+  return treeFromStream(
+    (function* () {
+      yield t.nodeOpen(t.nodeFlags, l.Regex, '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 t.nodeClose();
+    })(),
+    { expressions },
   );
 };
 
 export const buildAlternative = (elements) => {
-  const elementsArray = getRoot(elements);
-  return t.node(
-    l.Regex,
-    'Alternative',
-    btree.fromValues(interpolateFragmentChildren(elements, t.ref`elements[]`), {
-      elements: elementsArray,
-    }),
-    { elements: elementsArray },
-  );
-};
-
-export const buildAlternatives = (alternatives = {}) => {
-  return t.frag(
-    btree.fromValues(
-      concat(
-        [t.ref`.[]`, t.arr(), t.ref`separators[]`, t.arr()],
-        buildSeparatedListChildren(alternatives, t.ref`.[]`, t.ref`separators[]`),
-      ),
+  const expressions = [];
+
+  return treeFromStream(
+    concat(
+      [t.nodeOpen(t.nodeFlags, l.Regex, 'Alternative')],
+      interpolateFragment(elements, t.ref`elements[]+`, expressions),
+      [t.nodeClose()],
     ),
-    {
-      ['.']: alternatives,
-      separators: alternatives.slice(0, -1).map((alt) => t.s_node(l.Regex, 'Punctuator', '|')),
-    },
+    { expressions },
+  );
+};
+
+export const buildAlternatives = (alternatives = []) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    (function* () {
+      yield t.doctype({ bablrLanguage: l.Regex });
+      yield t.nodeOpen(t.nodeFlags);
+      yield t.ref`.[]`;
+      yield t.arr();
+      yield t.ref`separatorTokens[]`;
+      yield t.arr();
+
+      yield* alternatives
+        .flatMap((alt) => [
+          t.ref`.[]`,
+          gap(alt),
+          t.ref`separatorTokens[]`,
+          gap(buildPunctuator(l.Regex, '|')),
+        ])
+        .slice(0, -2);
+
+      yield t.nodeClose();
+    })(),
+    { expressions },
+  );
+};
+
+export const buildRegexGap = () => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.Regex, 'Gap'),
+      t.ref`escapeToken`,
+      gap(buildToken(l.Regex, 'Punctuator', '\\')),
+      t.ref`value`,
+      gap(buildToken(l.Regex, 'Keyword', 'g')),
+      t.nodeClose(),
+    ],
+    { expressions },
   );
 };
 
 export const buildElements = (elements) => {
-  return t.frag(
-    btree.fromValues(
-      concat(
-        [t.ref`.[]`, t.arr()],
-        elements.map((el) => t.ref`.[]`),
-      ),
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    concat(
+      [t.doctype({ bablrLanguage: l.Regex }), t.nodeOpen(t.nodeFlags), t.ref`.[]+`, t.arr()],
+      elements.flatMap((el) => [t.ref`.[]+`, gap(el)]),
+      [t.nodeClose()],
     ),
-    {
-      ['.']: elements,
-    },
+    { expressions },
   );
 };
 
 export const buildExpression = (expr) => {
+  throw new Error('unimplemented');
+
   if (isNull(expr)) return buildNullTag();
 
   switch (typeof expr) {
+    case 'symbol':
     case 'boolean':
       return buildBoolean(expr);
     case 'string':
@@ -658,12 +878,21 @@ export const buildExpression = (expr) => {
     case 'object': {
       switch (getPrototypeOf(expr)) {
         case Array.prototype:
-          return buildArray(expr);
+          return buildArray(buildArrayElements(expr));
         case Object.prototype:
-          if (expr.type && expr.language && expr.children && expr.properties) {
+          if (
+            hasOwn(expr, 'type') &&
+            hasOwn(expr, 'language') &&
+            hasOwn(expr, 'children') &&
+            hasOwn(expr, 'properties')
+          ) {
             return expr;
           }
-          return buildObject(expr);
+          return buildObject(
+            buildObjectProperties(
+              Object.entries(expr).map((e) => buildProperty(buildIdentifier(e[0]), e[1])),
+            ),
+          );
         default:
           throw new Error();
       }
@@ -673,49 +902,52 @@ export const buildExpression = (expr) => {
   }
 };
 
-export const buildAttributes = (attributes = {}) => {
-  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
-    buildAttribute(key, value),
+export const buildTaggedString = (tag, content) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.buildOpenNodeTag(t.nodeFlags, l.Spamex, 'SpamexString'),
+      t.buildReferenceTag('sigilToken'),
+      gap(buildToken(l.Instruction, 'Keyword', tag)),
+      t.buildReferenceTag('openToken'),
+      gap(buildToken(l.Instruction, 'Punctuator', "'")),
+      t.buildReferenceTag('content'),
+      gap(content),
+      t.buildReferenceTag('closeToken'),
+      gap(buildToken(l.Instruction, 'Punctuator', "'")),
+      t.buildCloseNodeTag(),
+    ],
+    { expressions },
   );
+};
 
-  return t.frag(
-    btree.fromValues(
-      [t.ref`.[]`, t.arr()],
-      buildSeparatedListChildren(attributes_, t.ref`.[]`, t.embedded(buildSpace())),
-    ),
-    {
-      ['.']: attributes_,
-    },
-  );
+export const buildSpamexString = (content) => {
+  return buildTaggedString('m', content);
 };
 
-export const buildNodeMatcher = (flags, language, type, attributes) => {
-  let language_ = !language || language.length === 0 ? null : language;
+export const buildRegexString = (content) => {
+  return buildTaggedString('re', content);
+};
 
-  const flags_ = buildFlags(flags);
-
-  return t.node(
-    l.Spamex,
-    'NodeMatcher',
-    btree.fromValues(
-      concat(
-        [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())]),
-        [...btree.traverse(attributes.children)].slice(1, -1),
-        [t.ref`closeToken`],
-      ),
-    ),
-    {
-      openToken: t.s_node(l.CSTML, 'Punctuator', '<'),
-      language: buildLanguage(language_),
-      languageSeparator: language_ && type ? t.s_node(l.CSTML, 'Punctuator', ':') : t.null_node(),
-      flags: flags_,
-      type: buildIdentifier(type),
-      attributes: attributes.properties.attributes,
-      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
+export const buildPropertyMatcher = (refMatcher, nodeMatcher) => {
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.Spamex, 'PropertyMatcher'),
+      t.ref`refMatcher`,
+      gap(refMatcher || buildNullNode()),
+      t.ref`nodeMatcher`,
+      gap(nodeMatcher),
+      t.nodeClose(),
+    ],
+    { expressions },
   );
 };
+
+export const buildGapNodeMatcher = () => {
+  return buildToken(l.Spamex, 'GapNodeMatcher', '<//>');
+};