@bablr/agast-vm-helpers 0.3.2 → 0.5.0

package/lib/builders.js

@@ -1,11 +1,9 @@
 // import { i } from '@bablr/boot/shorthand.macro';
-import {
-  interpolateArray,
-  interpolateArrayChildren,
-  interpolateString,
-} from '@bablr/agast-helpers/template';
+import { interpolateFragmentChildren, interpolateString } from '@bablr/agast-helpers/template';
 import { isNull } 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 './languages.js';
 
 const { getPrototypeOf, freeze } = Object;
@@ -20,54 +18,83 @@ function* repeat(times, ...values) {
   for (let i = 0; i < times; i++) for (const value of values) yield value;
 }
 
-export const buildReference = (name, isArray) => {
+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,
-    'Reference',
-    [t.ref`name`, ...when(isArray, [t.ref`arrayOperatorToken`]), t.ref`sigilToken`],
+    '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 buildGap = () => {
-  return t.node(l.CSTML, 'Gap', [t.ref`sigilToken`], {
+export const buildGapTag = () => {
+  return t.node(l.CSTML, 'GapTag', [t.ref`sigilToken`], {
     sigilToken: t.s_node(l.CSTML, 'Punctuator', '<//>'),
   });
 };
 
-export const buildShift = () => {
-  return t.node(l.CSTML, 'Shift', [t.ref`sigilToken`], {
+export const buildShiftTag = () => {
+  return t.node(l.CSTML, 'ShiftTag', [t.ref`sigilToken`], {
     sigilToken: t.s_node(l.CSTML, 'Punctuator', '^^^'),
   });
 };
 
 export const buildFlags = (flags = {}) => {
-  const { intrinsic = null, token = null, escape = null, trivia = null, expression = null } = flags;
+  const { token = null, escape = null, trivia = null, expression = null, hasGap = null } = flags;
 
   if ((trivia && escape) || (expression && (trivia || escape))) {
     throw new Error('invalid flags');
   }
 
-  return {
-    children: [
-      ...when(trivia, [t.ref`triviaToken`]),
-      ...when(intrinsic, [t.ref`intrinsicToken`]),
-      ...when(token, [t.ref`tokenToken`]),
-      ...when(escape, [t.ref`escapeToken`]),
-      ...when(expression, [t.ref`expressionToken`]),
-    ],
-    properties: {
+  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(),
-      intrinsicToken: intrinsic ? 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 buildSpamMatcher = (type = null, value = null, attributes = {}) => {
@@ -93,30 +120,35 @@ export const buildFullyQualifiedSpamMatcher = (
     language_ = lArr.length === 0 ? null : lArr;
   }
 
-  return t.node(
-    l.Spamex,
-    'NodeMatcher',
-    [
-      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())]),
-      ...interpolateArrayChildren(attributes, t.ref`attributes[]`, t.embedded(buildSpace())),
-      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_,
-      closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
-    },
-  );
+  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', '>'),
+      },
+    ),
+  });
 };
 
 export const buildNodeOpenTag = (flags, language, type = null, attributes = {}) => {
@@ -127,22 +159,23 @@ export const buildNodeOpenTag = (flags, language, type = null, attributes = {})
   return t.node(
     l.CSTML,
     'OpenNodeTag',
-    [
-      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())]),
-      ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
-      t.ref`closeToken`,
-    ],
+    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_,
+      attributes: attributes_.properties['.'],
       closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );
@@ -154,21 +187,20 @@ export const buildDoctypeTag = (attributes) => {
   return t.node(
     l.CSTML,
     'DoctypeTag',
-    [
-      t.ref`openToken`,
-      t.ref`version`,
-      t.ref`versionSeparator`,
-      t.ref`doctype`,
-      ...when(attributes_.length, [t.embedded(buildSpace())]),
-      ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
-      t.ref`closeToken`,
-    ],
+    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_,
+      attributes: attributes_.properties['.'],
       closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );
@@ -186,7 +218,13 @@ export const buildIdentifierPath = (path) => {
   return t.node(
     l.CSTML,
     'IdentifierPath',
-    [...repeat(segments.length, t.ref`segments[]`, t.ref`separators[]`)].slice(0, -1),
+    btree.fromValues(
+      concat(
+        [t.ref`segments[]`, t.arr()],
+        repeat(segments.length - 1, t.ref`segments[]`, t.ref`separators[]`),
+        [t.ref`segments[]`],
+      ),
+    ),
     {
       segments,
       separators,
@@ -204,13 +242,15 @@ export const buildNodeCloseTag = (type, language) => {
   return t.node(
     l.CSTML,
     'CloseNodeTag',
-    [
-      t.ref`openToken`,
-      ...when(language, [t.ref`language`]),
-      ...when(type && language, [t.ref`languageSeparator`]),
-      ...when(type, [t.ref`type`]),
-      t.ref`closeToken`,
-    ],
+    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(),
@@ -221,8 +261,8 @@ export const buildNodeCloseTag = (type, language) => {
   );
 };
 
-export const buildLiteral = (value) => {
-  return t.node(l.CSTML, 'Literal', [t.ref`value`], { value });
+export const buildLiteralTag = (value) => {
+  return t.node(l.CSTML, 'LiteralTag', [t.ref`value`], { value });
 };
 
 export const buildTerminalProps = (matcher) => {
@@ -254,7 +294,7 @@ export const buildProperty = (key, value) => {
   return t.node(
     l.Instruction,
     'Property',
-    [t.ref`key`, t.ref`mapOperator`, t.embedded(buildSpace()), t.ref`value`],
+    btree.from(t.ref`key`, t.ref`mapOperator`, t.embedded(buildSpace()), t.ref`value`),
     {
       key: buildIdentifier(key),
       mapOperator: t.s_node(l.Instruction, 'Punctuator', ':'),
@@ -280,8 +320,15 @@ export const buildInteger = (value, base = 10) => {
   return t.node(
     l.CSTML,
     'Integer',
-    digits.map((d) => t.ref`digits[]`),
-    { digits: digits.map((digit) => buildDigit(digit)) },
+    btree.fromValues(
+      concat(
+        [t.ref`digits[]`, t.arr()],
+        digits.map(() => t.ref`digits[]`),
+      ),
+    ),
+    {
+      digits: digits.map((digit) => buildDigit(digit)),
+    },
   );
 };
 
@@ -309,24 +356,22 @@ export const buildNumber = (value) => {
   }
 };
 
-const buildLiteralTerminal = (lit) => freeze({ type: 'Literal', value: lit });
-
 export const buildString = (value) => {
   const pieces = isArray(value) ? value : [value];
-  const terminals = [];
+  const tags = [];
   let lit = '';
 
   if (pieces.length === 1 && pieces[0] === "'") {
-    return t.node(l.CSTML, 'String', [t.ref`openToken`, t.ref`content`, t.ref`closeToken`], {
-      openToken: t.s_node(l.CSTML, 'Punctuator', '"'),
-      content: interpolateString(
-        freeze({
-          type: 'Literal',
-          value,
-        }),
-      ),
-      closeToken: t.s_node(l.CSTML, 'Punctuator', '"'),
-    });
+    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', '"'),
+      },
+    );
   }
 
   for (const piece of pieces) {
@@ -344,7 +389,7 @@ export const buildString = (value) => {
           chr.charCodeAt(0) < 32
         ) {
           if (lit) {
-            terminals.push(buildLiteralTerminal(lit));
+            tags.push(agastBuildLiteralTag(lit));
             lit = '';
           }
 
@@ -360,7 +405,12 @@ export const buildString = (value) => {
             value = t.node(
               l.CSTML,
               'EscapeCode',
-              [t.ref`sigilToken`, ...[...hexDigits].map((d) => t.ref`digits[]`)],
+              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)),
@@ -370,7 +420,7 @@ export const buildString = (value) => {
             value = buildKeyword(chr);
           }
 
-          terminals.push(
+          tags.push(
             t.buildEmbeddedNode(
               t.e_node(
                 l.CSTML,
@@ -389,27 +439,32 @@ export const buildString = (value) => {
         }
       }
     } else {
-      terminals.push(buildLiteralTerminal(lit));
+      tags.push(agastBuildLiteralTag(lit));
       lit = '';
 
       if (piece == null) {
         throw new Error('not implemented');
       } else if (isString(piece.type)) {
-        terminals.push(piece);
+        tags.push(piece);
       } else {
         throw new Error();
       }
     }
   }
 
-  if (lit) terminals.push(buildLiteralTerminal(lit));
+  if (lit) tags.push(agastBuildLiteralTag(lit));
   lit = '';
 
-  return t.node(l.CSTML, 'String', [t.ref`openToken`, t.ref`content`, t.ref`closeToken`], {
-    openToken: t.s_node(l.CSTML, 'Punctuator', "'"),
-    content: interpolateString(terminals),
-    closeToken: t.s_node(l.CSTML, 'Punctuator', "'"),
-  });
+  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', "'"),
+    },
+  );
 };
 
 export const buildBoolean = (value) => {
@@ -418,80 +473,87 @@ export const buildBoolean = (value) => {
   });
 };
 
-export const buildNull = () => {
+export const buildNullTag = () => {
   return t.node(l.Instruction, 'Null', [t.ref`sigilToken`], {
     sigilToken: t.s_node(l.Instruction, 'Keyword', 'null'),
   });
 };
 
 export const buildArray = (elements) => {
+  const elements_ = buildArrayElements(elements);
   return t.node(
     l.Instruction,
     'Array',
-    [
-      t.ref`openToken`,
-      ...interpolateArrayChildren(
-        elements,
-        t.ref`elements[]`,
-        t.embedded(
-          t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
-        ),
-      ),
-      t.ref`closeToken`,
-    ],
+    btree.fromValues(
+      concat([t.ref`openToken`], interpolateFragmentChildren(elements_, t.ref`elements[]`), [
+        t.ref`closeToken`,
+      ]),
+    ),
     {
       openToken: t.s_node(l.Instruction, 'Punctuator', '['),
-      elements: [...interpolateArray(elements)],
+      elements: elements_.properties['.'],
       closeToken: t.s_node(l.Instruction, 'Punctuator', ']'),
     },
   );
 };
 
+export const buildArrayElements = (values) => {
+  return buildSpaceSeparatedList(values.map((value) => buildExpression(value)));
+};
+
+export const buildTupleValues = buildArrayElements;
+
 export const buildTuple = (values) => {
+  const values_ = buildTupleValues(values);
   return t.node(
     l.Instruction,
     'Tuple',
-    [
-      t.ref`openToken`,
-      ...interpolateArrayChildren(
-        values,
-        t.ref`values[]`,
-        t.embedded(
-          t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
-        ),
-      ),
-      t.ref`closeToken`,
-    ],
+    btree.fromValues(
+      concat([t.ref`openToken`], interpolateFragmentChildren(values_, t.ref`values[]`), [
+        t.ref`closeToken`,
+      ]),
+    ),
     {
       openToken: t.s_node(l.Instruction, 'Punctuator', '('),
-      values: [...interpolateArray(values)],
+      values: values_.properties['.'],
       closeToken: t.s_node(l.Instruction, 'Punctuator', ')'),
     },
   );
 };
 
+export const buildSpaceSeparatedList = (values) => {
+  return t.frag(
+    btree.fromValues(
+      concat(
+        [t.ref`.`, t.arr()],
+        buildSeparatedListChildren(values, t.ref`.`, t.embedded(buildSpace())),
+      ),
+    ),
+    {
+      ['.']: values,
+    },
+  );
+};
+
+export const buildObjectProperties = (properties) => {
+  return buildSpaceSeparatedList(
+    Object.entries(properties).map(({ 0: key, 1: value }) => buildProperty(key, value)),
+  );
+};
+
 export const buildObject = (properties) => {
+  const properties_ = buildObjectProperties(properties);
   return t.node(
     l.Instruction,
     'Object',
-    [
-      t.ref`openToken`,
-      ...interpolateArrayChildren(
-        Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
-        t.ref`properties[]`,
-        t.embedded(
-          t.t_node(l.Comment, null, [t.embedded(t.t_node('Space', 'Space', [t.lit(' ')]))]),
-        ),
-      ),
-      t.ref`closeToken`,
-    ],
+    btree.fromValues(
+      concat([t.ref`openToken`], interpolateFragmentChildren(properties_, t.ref`properties[]`), [
+        t.ref`closeToken`,
+      ]),
+    ),
     {
       openToken: t.s_node(l.Instruction, 'Punctuator', '{'),
-      properties: [
-        ...interpolateArray(
-          Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
-        ),
-      ],
+      properties: properties_.properties['.'],
       closeToken: t.s_node(l.Instruction, 'Punctuator', '}'),
     },
     {},
@@ -499,11 +561,16 @@ export const buildObject = (properties) => {
 };
 
 export const buildMappingAttribute = (key, value) => {
-  return t.node(l.CSTML, 'MappingAttribute', [t.ref`key`, t.ref`mapOperator`, t.ref`value`], {
-    key: buildIdentifier(key),
-    mapOperator: t.s_node(l.CSTML, 'Punctuator', '='),
-    value: buildExpression(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 buildBooleanAttribute = (key, value) => {
@@ -517,8 +584,44 @@ export const buildAttribute = (key, value) => {
   return isBoolean(value) ? buildBooleanAttribute(key, value) : buildMappingAttribute(key, value);
 };
 
+export const buildPattern = (alternatives, flags) => {
+  return t.node(
+    l.Regex,
+    'Pattern',
+    btree.fromValues(
+      concat(
+        [t.ref`openToken`],
+        buildSeparatedListChildren(alternatives, t.ref`alternatives[]`, t.ref`separators[]`),
+        [t.ref`closeToken`, t.ref`flags`],
+      ),
+    ),
+    {
+      openToken: t.s_node(l.Regex, 'Punctuator', '/'),
+      alternatives,
+      separators: alternatives.slice(0, -1).map((alt) => t.s_node(l.Regex, 'Punctuator', '|')),
+      closeToken: t.s_node(l.Regex, 'Punctuator', '/'),
+      flags: buildFlags(flags),
+    },
+  );
+};
+
+export const buildAlternative = (elements) => {
+  return t.node(
+    l.Regex,
+    'Pattern',
+    btree.fromValues(
+      concat([t.ref`openToken`], buildSeparatedListChildren(elements, t.ref`elements[]`), [
+        t.ref`closeToken`,
+      ]),
+    ),
+    {
+      elements,
+    },
+  );
+};
+
 export const buildExpression = (expr) => {
-  if (isNull(expr)) return buildNull();
+  if (isNull(expr)) return buildNullTag();
 
   switch (typeof expr) {
     case 'boolean':
@@ -546,12 +649,22 @@ export const buildExpression = (expr) => {
 };
 
 export const buildAttributes = (attributes = {}) => {
-  return Object.entries(attributes).map(({ 0: key, 1: value }) => buildAttribute(key, value));
-};
+  const attributes_ = Object.entries(attributes).map(({ 0: key, 1: value }) =>
+    buildAttribute(key, value),
+  );
 
-export const buildNodeMatcher = (flags, language, type, attributes = {}) => {
-  const attributes_ = buildAttributes(attributes);
+  return t.frag(
+    btree.fromValues(
+      [t.ref`.[]`, t.arr()],
+      buildSeparatedListChildren(attributes_, t.ref`.[]`, t.embedded(buildSpace())),
+    ),
+    {
+      ['.']: attributes_,
+    },
+  );
+};
 
+export const buildNodeMatcher = (flags, language, type, attributes) => {
   let language_ = !language || language.length === 0 ? null : language;
 
   const flags_ = buildFlags(flags);
@@ -559,22 +672,24 @@ export const buildNodeMatcher = (flags, language, type, attributes = {}) => {
   return t.node(
     l.Spamex,
     'NodeMatcher',
-    [
-      t.ref`openToken`,
-      ...when(flags_, [t.ref`flags`]),
-      ...when(language_, [t.ref`language`, t.ref`languageSeparator`]),
-      t.ref`type`,
-      ...when(attributes_.length, [t.embedded(buildSpace())]),
-      ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
-      t.ref`closeToken`,
-    ],
+    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_,
+      attributes: attributes.properties.attributes,
       closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
     },
   );

package/lib/deembed.js

@@ -1,3 +1,5 @@
+import { EmbeddedExpression } from '@bablr/agast-helpers/symbols';
+
 const { isArray } = Array;
 const isString = (val) => typeof val === 'string';
 const isNumber = (val) => typeof val === 'number';
@@ -18,6 +20,6 @@ export const deembedExpression = (expr) => {
 
 export const getEmbeddedExpression = (expr) => {
   if (!expr) return expr;
-  if (expr.type !== 'EmbeddedExpression') throw new Error();
+  if (expr.type !== EmbeddedExpression) throw new Error();
   return expr.value;
 };

package/lib/index.js

@@ -1,5 +1,18 @@
-import { getCooked, isNull } from '@bablr/agast-helpers/tree';
+import { sourceTextFor, getCooked, isNull, nodeFlags } from '@bablr/agast-helpers/tree';
+import * as btree from '@bablr/agast-helpers/btree';
 import * as sym from '@bablr/agast-helpers/symbols';
+import { buildNodeCloseTag, buildLiteralTag, buildDoctypeTag } from '@bablr/agast-helpers/builders';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+} from '@bablr/agast-helpers/symbols';
 
 export * from './builders.js';
 
@@ -29,14 +42,14 @@ export const shouldBranch = (effects) => {
 };
 
 const reifyFlags = (flags) => {
-  let { triviaToken, escapeToken, tokenToken, expressionToken, intrinsicToken } = flags.properties;
+  let { triviaToken, escapeToken, tokenToken, expressionToken, hasGapToken } = flags.properties;
 
   return {
-    token: reifyExpression(tokenToken),
-    escape: reifyExpression(escapeToken),
-    trivia: reifyExpression(triviaToken),
-    intrinsic: reifyExpression(intrinsicToken),
-    expression: reifyExpression(expressionToken),
+    token: !!reifyExpression(tokenToken),
+    escape: !!reifyExpression(escapeToken),
+    trivia: !!reifyExpression(triviaToken),
+    expression: !!reifyExpression(expressionToken),
+    hasGap: !!reifyExpression(hasGapToken),
   };
 };
 
@@ -46,39 +59,149 @@ export const reifyLanguage = (language) => {
   return typeof value === 'string' && !value.startsWith('https://') ? [value] : value;
 };
 
+export const reifyProperties = (properties = []) => {
+  const built = {};
+  for (const property of btree.traverse(properties)) {
+    switch (property.type) {
+      case 'Property': {
+        let { reference, value } = property.properties;
+
+        reference = reifyExpression(reference);
+        value = reifyExpression(value);
+
+        if (reference.value.isArray) {
+          built[reference.value.name] ||= [];
+          built[reference.value.name].push(value);
+        } else {
+          built[reference.value.name] = value;
+        }
+        break;
+      }
+      default:
+        throw new Error();
+    }
+  }
+  return built;
+};
+
+export const buildChildren = (node) => {
+  let { open, children = [], close } = node.properties;
+
+  const selfClosing = !!open.properties.selfClosingTagToken;
+  const { intrinsicValue } = open.properties;
+  let built = [];
+
+  open = reifyExpression(open);
+  close = reifyExpression(close);
+
+  if (selfClosing) {
+    built = btree.push(built, open);
+    if (intrinsicValue) {
+      built = btree.push(built, buildLiteralTag(intrinsicValue));
+    }
+    built = btree.push(built, buildNodeCloseTag());
+  } else {
+    built = btree.push(built, open);
+    for (const child of btree.traverse(children)) {
+      if (child.type !== 'Property') throw new Error('umimplemented');
+
+      let { reference } = child.properties;
+
+      reference = reifyExpression(reference);
+
+      built = btree.push(built, reference);
+    }
+
+    built = btree.push(built, close);
+  }
+
+  return built;
+};
+
 export const reifyExpression = (node) => {
   if (node instanceof Promise) throw new Error();
 
   if (!node || node.type === sym.null) return null;
 
+  if (!node.type) {
+    node = node.properties['.'];
+  }
+
   if (node.language === 'https://bablr.org/languages/core/en/cstml') {
-    switch (node.type) {
+    switch (node.type?.description || node.type) {
+      case 'Document': {
+        let { doctype, tree } = node.properties;
+
+        doctype = reifyExpression(doctype);
+        tree = reifyExpression(tree);
+
+        let { attributes } = doctype.value;
+        let { properties } = tree;
+
+        return {
+          flags: nodeFlags,
+          language: attributes['bablr-language'],
+          type: null,
+          children: btree.addAt(
+            0,
+            buildChildren(node.properties.tree),
+            buildDoctypeTag(attributes),
+          ),
+          properties,
+          attributes,
+        };
+      }
+
+      case 'Node': {
+        let { open, children } = node.properties;
+
+        open = reifyExpression(open);
+
+        let { flags, language, type, attributes } = open.value;
+
+        const properties = reifyProperties(children);
+
+        return {
+          flags,
+          language,
+          type,
+          children: buildChildren(node),
+          properties,
+          attributes,
+        };
+      }
+
       case 'DoctypeTag': {
         let { doctype, version, attributes } = node.properties;
         return {
-          type: 'DoctypeTag',
+          type: DoctypeTag,
           value: {
             doctype: getCooked(doctype),
-            version: parseInt(getCooked(version), 10),
+            version: parseInt(sourceTextFor(version), 10),
             attributes: reifyAttributes(attributes),
           },
         };
       }
 
-      case 'Reference': {
-        let { name, arrayOperatorToken } = node.properties;
+      case 'ReferenceTag': {
+        let { name, arrayOperatorToken, hasGapToken } = node.properties;
 
         name = reifyExpression(name);
 
-        return { type: 'Reference', value: { name, isArray: !isNull(arrayOperatorToken) } };
+        return {
+          type: ReferenceTag,
+          value: { name, isArray: !isNull(arrayOperatorToken), hasGap: !isNull(hasGapToken) },
+        };
       }
 
-      case 'Literal': {
+      case 'LiteralTag': {
         let { value } = node.properties;
 
-        return { type: 'Literal', value: getCooked(value.properties.content) };
+        return { type: LiteralTag, value: getCooked(value.properties.content) };
+      }
+      case 'Identifier': {
+        return getCooked(node);
       }
-
       case 'IdentifierPath': {
         return node.properties.segments.map((segment) => reifyExpression(segment));
       }
@@ -92,7 +215,7 @@ export const reifyExpression = (node) => {
         attributes = reifyAttributes(attributes);
 
         return {
-          type: 'OpenNodeTag',
+          type: OpenNodeTag,
           value: { flags, language, type, attributes },
         };
       }
@@ -103,7 +226,7 @@ export const reifyExpression = (node) => {
         language = reifyLanguage(language);
         type = reifyExpression(type);
 
-        return { type: 'CloseNodeTag', value: { language, type } };
+        return { type: CloseNodeTag, value: { language, type } };
       }
 
       case 'Integer': {
@@ -122,11 +245,17 @@ export const reifyExpression = (node) => {
       case 'String':
         return node.properties.content ? getCooked(node.properties.content) : '';
 
-      case 'Gap':
-        return { type: 'Gap', value: undefined };
+      case 'GapTag':
+        return { type: GapTag, value: undefined };
+
+      case 'ArrayTag':
+        return { type: ArrayTag, value: undefined };
+
+      case 'NullTag':
+        return { type: NullTag, value: undefined };
 
-      case 'Shift':
-        return { type: 'Shift', value: undefined };
+      case 'ShiftTag':
+        return { type: ShiftTag, value: undefined };
 
       default:
         throw new Error();
@@ -145,7 +274,7 @@ export const reifyExpression = (node) => {
 
   switch (node.type) {
     case 'NodeMatcher':
-      let { flags, language, type, attributes, intrinsicValue } = node.properties;
+      let { flags, language, type, attributes, intrinsicValue } = node.properties.open.properties;
 
       flags = reifyFlags(flags);
       language = reifyLanguage(language);
@@ -164,7 +293,7 @@ export const reifyExpression = (node) => {
       const { properties } = node.properties;
 
       return Object.fromEntries(
-        properties.map(({ properties: { key, value } }) => [
+        [...btree.traverse(properties)].map(({ properties: { key, value } }) => [
           getCooked(key),
           reifyExpression(value),
         ]),
@@ -174,16 +303,16 @@ export const reifyExpression = (node) => {
     case 'Tuple': {
       const { values = [] } = node.properties;
 
-      return [...values.map((el) => reifyExpression(el))];
+      return [...btree.traverse(values)].map((el) => reifyExpression(el));
     }
 
     case 'Array': {
-      const { elements } = node.properties;
+      const { elements = [] } = node.properties;
 
-      return [...elements.map((el) => reifyExpression(el))];
+      return [...btree.traverse(elements)].map((el) => reifyExpression(el));
     }
 
-    case 'Literal':
+    case 'LiteralTag':
     case 'Identifier':
       return getCooked(node);
 
@@ -221,15 +350,18 @@ export const reifyExpressionShallow = (node) => {
       const { properties } = node.properties;
 
       return Object.fromEntries(
-        properties.map(({ properties: { key, value } }) => [getCooked(key), value]),
+        [...btree.traverse(properties)].map(({ properties: { key, value } }) => [
+          getCooked(key),
+          value,
+        ]),
       );
     }
 
     case 'Array':
-      return [...node.properties.elements];
+      return [...btree.traverse(node.properties.elements)];
 
     case 'Tuple':
-      return [...node.properties.values];
+      return [...btree.traverse(node.properties.values)];
 
     default:
       return reifyExpression(node);
@@ -240,7 +372,7 @@ export const reifyAttributes = (attributes) => {
   if (attributes == null) return {};
 
   return Object.fromEntries(
-    attributes.map((attr) => {
+    [...btree.traverse(attributes)].map((attr) => {
       if (attr.type === 'MappingAttribute') {
         return [reifyExpression(attr.properties.key), reifyExpression(attr.properties.value)];
       } else if (attr.type === 'BooleanAttribute') {

package/package.json

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