@bablr/agast-vm-helpers 0.4.0 → 0.5.0

package/lib/builders.js

@@ -1,11 +1,12 @@
 // import { i } from '@bablr/boot/shorthand.macro';
-import { 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 } = Object;
+const { getPrototypeOf, freeze } = Object;
 const { isArray } = Array;
 
 const when = (condition, value) => (condition ? value : { *[Symbol.iterator]() {} });
@@ -17,13 +18,39 @@ function* repeat(times, ...values) {
   for (let i = 0; i < times; i++) for (const value of values) yield value;
 }
 
-export const buildReferenceTag = (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,
     'ReferenceTag',
-    [t.ref`name`, ...when(isArray, [t.ref`arrayOperatorToken`]), t.ref`sigilToken`],
+    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', ':'),
     },
   );
@@ -42,7 +69,7 @@ export const buildShiftTag = () => {
 };
 
 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');
@@ -51,19 +78,21 @@ export const buildFlags = (flags = {}) => {
   return t.node(
     l.CSTML,
     'Flags',
-    [
-      ...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`]),
-    ],
+    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(),
     },
   );
 };
@@ -95,20 +124,18 @@ export const buildFullyQualifiedSpamMatcher = (
     open: 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())]),
-        t.ref`attributes[]`,
-        t.arr(),
-        ...interpolateArrayChildren(attributes_, t.ref`attributes[]`, t.embedded(buildSpace())),
-        ...when(!type, [t.embedded(buildSpace())]),
-        t.ref`selfClosingTagToken`,
-        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(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),
@@ -116,7 +143,7 @@ export const buildFullyQualifiedSpamMatcher = (
         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_,
+        attributes: attributes_.properties['.'],
         selfClosingTagToken: t.s_node(l.CSTML, 'Punctuator', '/'),
         closeToken: t.s_node(l.CSTML, 'Punctuator', '>'),
       },
@@ -132,24 +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())]),
-      t.ref`attributes[]`,
-      t.arr(),
-      ...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', '>'),
     },
   );
@@ -161,23 +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())]),
-      t.ref`attributes[]`,
-      t.arr(),
-      ...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', '>'),
     },
   );
@@ -195,11 +218,13 @@ export const buildIdentifierPath = (path) => {
   return t.node(
     l.CSTML,
     'IdentifierPath',
-    [
-      t.ref`segments[]`,
-      t.arr(),
-      ...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,
@@ -217,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(),
@@ -267,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', ':'),
@@ -293,7 +320,12 @@ export const buildInteger = (value, base = 10) => {
   return t.node(
     l.CSTML,
     'Integer',
-    [t.ref`digits[]`, t.arr(), ...digits.map((d) => t.ref`digits[]`)],
+    btree.fromValues(
+      concat(
+        [t.ref`digits[]`, t.arr()],
+        digits.map(() => t.ref`digits[]`),
+      ),
+    ),
     {
       digits: digits.map((digit) => buildDigit(digit)),
     },
@@ -330,11 +362,16 @@ export const buildString = (value) => {
   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(agastBuildLiteralTag(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) {
@@ -368,12 +405,12 @@ export const buildString = (value) => {
             value = t.node(
               l.CSTML,
               'EscapeCode',
-              [
-                t.ref`sigilToken`,
-                t.ref`digits[]`,
-                t.arr(),
-                ...[...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)),
@@ -418,11 +455,16 @@ export const buildString = (value) => {
   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(tags),
-    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) => {
@@ -438,75 +480,80 @@ export const buildNullTag = () => {
 };
 
 export const buildArray = (elements) => {
+  const elements_ = buildArrayElements(elements);
   return t.node(
     l.Instruction,
     'Array',
-    [
-      t.ref`openToken`,
-      t.ref`elements[]`,
-      t.arr(),
-      ...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,
+      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`,
-      t.ref`values[]`,
-      t.arr(),
-      ...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,
+      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`,
-      t.ref`properties[]`,
-      t.arr(),
-      ...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: Object.entries(properties).map(([key, value]) => buildProperty(key, value)),
+      properties: properties_.properties['.'],
       closeToken: t.s_node(l.Instruction, 'Punctuator', '}'),
     },
     {},
@@ -514,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) => {
@@ -532,6 +584,42 @@ 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 buildNullTag();
 
@@ -561,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);
@@ -574,24 +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())]),
-      t.ref`attributes[]`,
-      t.arr(),
-      ...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/index.js

@@ -1,7 +1,7 @@
 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 } from '@bablr/agast-helpers/builders';
+import { buildNodeCloseTag, buildLiteralTag, buildDoctypeTag } from '@bablr/agast-helpers/builders';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -42,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),
+    hasGap: !!reifyExpression(hasGapToken),
   };
 };
 
@@ -89,17 +89,19 @@ export const buildChildren = (node) => {
 
   const selfClosing = !!open.properties.selfClosingTagToken;
   const { intrinsicValue } = open.properties;
-  const built = [];
+  let built = [];
 
   open = reifyExpression(open);
   close = reifyExpression(close);
 
   if (selfClosing) {
-    built.push(open);
-    if (intrinsicValue) built.push(buildLiteralTag(intrinsicValue));
-    built.push(buildNodeCloseTag());
+    built = btree.push(built, open);
+    if (intrinsicValue) {
+      built = btree.push(built, buildLiteralTag(intrinsicValue));
+    }
+    built = btree.push(built, buildNodeCloseTag());
   } else {
-    built.push(open);
+    built = btree.push(built, open);
     for (const child of btree.traverse(children)) {
       if (child.type !== 'Property') throw new Error('umimplemented');
 
@@ -107,10 +109,10 @@ export const buildChildren = (node) => {
 
       reference = reifyExpression(reference);
 
-      built.push(reference);
+      built = btree.push(built, reference);
     }
 
-    built.push(close);
+    built = btree.push(built, close);
   }
 
   return built;
@@ -121,8 +123,12 @@ export const reifyExpression = (node) => {
 
   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;
 
@@ -130,13 +136,17 @@ export const reifyExpression = (node) => {
         tree = reifyExpression(tree);
 
         let { attributes } = doctype.value;
-        let { children, properties } = tree;
+        let { properties } = tree;
 
         return {
           flags: nodeFlags,
           language: attributes['bablr-language'],
-          type: sym.fragment,
-          children,
+          type: null,
+          children: btree.addAt(
+            0,
+            buildChildren(node.properties.tree),
+            buildDoctypeTag(attributes),
+          ),
           properties,
           attributes,
         };
@@ -174,11 +184,14 @@ export const reifyExpression = (node) => {
       }
 
       case 'ReferenceTag': {
-        let { name, arrayOperatorToken } = node.properties;
+        let { name, arrayOperatorToken, hasGapToken } = node.properties;
 
         name = reifyExpression(name);
 
-        return { type: ReferenceTag, value: { name, isArray: !isNull(arrayOperatorToken) } };
+        return {
+          type: ReferenceTag,
+          value: { name, isArray: !isNull(arrayOperatorToken), hasGap: !isNull(hasGapToken) },
+        };
       }
 
       case 'LiteralTag': {

package/package.json

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