@bablr/agast-vm-helpers 0.8.0 → 0.10.0

package/lib/builders.js

@@ -1,16 +1,21 @@
-import {
-  EmbeddedNode,
-  EmbeddedMatcher,
-  EmbeddedRegex,
-  EmbeddedTag,
-  EmbeddedObject,
-  EmbeddedInstruction,
-} from './symbols.js';
+import { isNode } from '@bablr/agast-helpers/path';
+import { Matcher, Regex, Tag, EmbeddedObject, Instruction, Node } from './symbols.js';
 
 const isObject = (val) => val !== null && typeof val === 'object';
 
 const { freeze } = Object;
 
+export const buildOptions = (options) => {
+  let { shift, bind, allowEmpty, internal } = options;
+
+  let s = !shift ? 'S' : ' ';
+  let b = bind ? 'b' : ' ';
+  let e = allowEmpty ? 'e' : ' ';
+  let i = internal ? 'i' : ' ';
+
+  return `${s}${b}${e}${i}`;
+};
+
 export const buildCall = (verb, ...args) => {
   return freeze({ verb, arguments: freeze(args) });
 };
@@ -20,29 +25,29 @@ export const buildEmbeddedObject = (obj) => {
   return freeze({ type: EmbeddedObject, value: freeze(obj) });
 };
 
-export const buildEmbeddedNode = (node) => {
-  if (!isObject(node)) throw new Error();
-  return freeze({ type: EmbeddedNode, value: freeze(node) });
-};
-
 export const buildEmbeddedMatcher = (matcher) => {
   if (!isObject(matcher)) throw new Error();
-  return freeze({ type: EmbeddedMatcher, value: matcher });
+  return freeze({ type: Matcher, value: matcher });
 };
 
 export const buildEmbeddedInstruction = (instr) => {
   if (!isObject(instr)) throw new Error();
-  return freeze({ type: EmbeddedInstruction, value: instr });
+  return freeze({ type: Instruction, value: instr });
 };
 
 export const buildEmbeddedRegex = (re) => {
   if (!isObject(re)) throw new Error();
-  return freeze({ type: EmbeddedRegex, value: re });
+  return freeze({ type: Regex, value: re });
 };
 
 export const buildEmbeddedTag = (tag) => {
   if (!isObject(tag)) throw new Error();
-  return freeze({ type: EmbeddedTag, value: tag });
+  return freeze({ type: Tag, value: tag });
+};
+
+export const buildEmbeddedNode = (node) => {
+  if (!isNode(node)) throw new Error();
+  return freeze({ type: Node, value: node });
 };
 
 export const buildEffect = (value) => {

package/lib/deembed.js

@@ -1,11 +1,4 @@
-import {
-  EmbeddedNode,
-  EmbeddedObject,
-  EmbeddedTag,
-  EmbeddedMatcher,
-  EmbeddedRegex,
-  EmbeddedInstruction,
-} from './symbols.js';
+import { EmbeddedObject, Tag, Matcher, Regex, Instruction } from './symbols.js';
 
 export const getEmbeddedObject = (expr) => {
   if (!expr) return expr;
@@ -13,32 +6,26 @@ export const getEmbeddedObject = (expr) => {
   return expr.value;
 };
 
-export const getEmbeddedNode = (expr) => {
-  if (!expr) return expr;
-  if (expr.type !== EmbeddedNode) throw new Error();
-  return expr.value;
-};
-
 export const getEmbeddedMatcher = (expr) => {
   if (!expr) return expr;
-  if (expr.type !== EmbeddedMatcher) throw new Error();
+  if (expr.type !== Matcher) throw new Error();
   return expr.value;
 };
 
 export const getEmbeddedInstruction = (expr) => {
   if (!expr) return expr;
-  if (expr.type !== EmbeddedInstruction) throw new Error();
+  if (expr.type !== Instruction) throw new Error();
   return expr.value;
 };
 
 export const getEmbeddedRegex = (expr) => {
   if (!expr) return expr;
-  if (expr.type !== EmbeddedRegex) throw new Error();
+  if (expr.type !== Regex) throw new Error();
   return expr.value;
 };
 
 export const getEmbeddedTag = (expr) => {
-  if (expr.type !== EmbeddedTag) throw new Error();
+  if (expr.type !== Tag) throw new Error();
   const tag = expr.value;
   return tag;
 };

package/lib/index.js

@@ -2,39 +2,41 @@ import {
   sourceTextFor,
   getCooked,
   isNull,
-  nodeFlags,
   isNullNode,
-  buildStubNode,
-  isFragmentNode,
+  isCover,
   buildReferenceTag,
   getRoot,
-  buildChild,
+  get,
+  list,
 } from '@bablr/agast-helpers/tree';
-import * as btree from '@bablr/agast-helpers/btree';
-import * as sumtree from '@bablr/agast-helpers/children';
+import * as Tags from '@bablr/agast-helpers/tags';
 import {
   buildGapTag,
   buildNullTag,
   buildOpenNodeTag,
-  buildBindingTag,
-  buildInitializerTag,
   buildShiftTag,
   buildCloseNodeTag,
   buildLiteralTag,
   buildDoctypeTag,
+  buildAttributeDefinition,
+  nodeFlags,
   referenceFlags,
-  buildProperty,
+  buildBindingTag,
+  buildDocument,
+  buildPropertyTag,
+  tokenFlags,
+  buildFullOpenNodeTag,
 } from '@bablr/agast-helpers/builders';
 import { buildEmbeddedMatcher, buildEmbeddedRegex } from './builders.js';
 import {
   AttributeDefinition,
+  CloseNodeTag,
   GapTag,
-  InitializerTag,
   LiteralTag,
   NullTag,
-  Property,
+  OpenNodeTag,
 } from './symbols.js';
-import { isStubNode } from '@bablr/agast-helpers/path';
+import { buildNode, getFlags, getTags } from '@bablr/agast-helpers/path';
 
 const { freeze } = Object;
 
@@ -42,6 +44,7 @@ export const effectsFor = (verb) => {
   switch (verb) {
     case 'eat':
     case 'shift':
+    case 'eatHeld':
       return { success: 'eat', failure: 'fail' };
 
     case 'eatMatch':
@@ -59,108 +62,96 @@ export const effectsFor = (verb) => {
   }
 };
 
+export const reifyBablrOptions = (str) => {
+  if (str.length !== 4) throw new Error();
+  let shift = !str.includes('S');
+  let bind = str.includes('b');
+  let allowEmpty = str.includes('e');
+  let internal = str.includes('i');
+
+  return freeze({ shift, bind, allowEmpty, internal });
+};
+
 export const shouldBranch = (effects) => {
   return effects ? effects.success === 'none' || effects.failure === 'none' : false;
 };
 
+export const reifyMatcherReferenceName = (matcher) => {
+  if (matcher == null) return null;
+  return reifyExpression(get(['refMatcher', 'name'], matcher.value));
+};
+
 export const reifyNodeFlags = (flags) => {
-  let { tokenToken, hasGapToken, fragmentToken, coverFragmentToken } = flags.properties;
+  let { token, hasGap } = flags.value.attributes;
 
   return {
-    token: !!(tokenToken && reifyExpression(tokenToken.node)),
-    hasGap: !!(hasGapToken && reifyExpression(hasGapToken.node)),
-    fragment: !!(fragmentToken && reifyExpression(fragmentToken.node)),
-    cover: !!(coverFragmentToken && reifyExpression(coverFragmentToken.node)),
+    token,
+    hasGap,
   };
 };
 
 export const reifyReferenceFlags = (flags) => {
-  let { expressionToken, hasGapToken } = flags.properties;
-
-  return {
-    expression: !!(expressionToken && reifyExpression(expressionToken.node)),
-    hasGap: !!(hasGapToken && reifyExpression(hasGapToken.node)),
-  };
+  let arrayToken = get('arrayToken', flags);
+  let expressionToken = get('expressionToken', flags);
+  let intrinsicToken = get('intrinsicToken', flags);
+  let hasGapToken = get('hasGapToken', flags);
+
+  return freeze({
+    array: !!reifyExpression(arrayToken),
+    expression: !!reifyExpression(expressionToken),
+    intrinsic: !!reifyExpression(intrinsicToken),
+    hasGap: !!reifyExpression(hasGapToken),
+  });
 };
 
-export const reifyProperties = (properties = { node: [] }) => {
-  const built = {};
-  for (const property of btree.traverse(properties.node)) {
-    switch (property.node.type) {
-      case Symbol.for('Property'): {
-        let { reference, value: node } = property.node.properties;
-
-        reference = reference ? reifyExpression(reference.node) : buildReferenceTag('.');
-        node = reifyExpression(node.node);
-
-        let { name, isArray } = reference.value;
-        if (name) {
-          if (isArray) {
-            built[name] ||= [];
-            built[name].push({ reference, node });
-          } else {
-            built[name] = { reference, node };
-          }
-        }
-        break;
-      }
-    }
-  }
-  return built;
-};
+export const buildTags = (node) => {
+  let open = get('openTag', node);
 
-export const buildChildren = (node) => {
-  let { open, children = [], close } = node.properties;
+  let openTag = reifyExpression(open);
+  let children = buildChildren(list('children', node));
+  let closeTag = buildCloseNodeTag();
 
-  const selfClosing = !isNull(open.node.properties.selfClosingTagToken?.node);
-  const { intrinsicValue } = open.node.properties;
-  let built = [];
+  if (openTag.value.selfClosing) {
+    return Tags.fromValues([openTag]);
+  }
 
-  open = reifyExpression(open.node);
-  close = reifyExpression(close?.node);
+  return Tags.fromValues([openTag, children, closeTag]);
+};
+
+export const buildChildren = (children) => {
+  let built = Tags.fromValues([]);
 
-  if (selfClosing) {
-    built = sumtree.push(built, open);
-    if (!isNull(intrinsicValue?.node)) {
-      built = sumtree.push(built, buildLiteralTag(reifyExpression(intrinsicValue.node)));
+  for (const child of children) {
+    if ([AttributeDefinition, LiteralTag].includes(child.value.name)) {
+      built = Tags.push(built, reifyExpression(child));
+      continue;
     }
-    built = sumtree.push(built, buildCloseNodeTag());
-  } else {
-    built = sumtree.push(built, open);
-    for (const child of sumtree.traverse(children.node)) {
-      if ([AttributeDefinition, LiteralTag].includes(child.node.type)) {
-        built = sumtree.push(built, reifyExpression(child.node));
-        continue;
-      }
 
-      if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
+    if (child.value.name !== Symbol.for('Property')) throw new Error('umimplemented');
 
-      let { reference, binding, value } = child.node.properties;
+    let reference = get('referenceTag', child);
+    let boundNode = reifyExpression(get('value', child));
+    let { node, bindingTags } = boundNode;
 
-      let referenceTag = reference ? reifyExpression(reference.node) : buildReferenceTag('.');
-      let bindingTag = binding
-        ? reifyExpression(binding.node)
-        : buildBindingTag(isStubNode(value.node) ? null : []);
+    let bindings = bindingTags.map((tag) => tag.value);
 
-      value = reifyExpression(value.node);
+    let referenceTag =
+      reference && !isNullNode(reference) ? reifyExpression(reference) : buildReferenceTag();
 
-      if (value.type === NullTag || value.type === GapTag) {
-        value = buildStubNode(value);
+    if (node.value.type === Symbol.for('__')) {
+      for (let child of Tags.traverse(getTags(node))) {
+        if (![OpenNodeTag, CloseNodeTag].includes(child.value.type))
+          built = Tags.push(built, child);
       }
+      continue;
+    }
 
-      built = sumtree.push(built, referenceTag);
-      if (value.type === InitializerTag) {
-        built = sumtree.push(built, value);
-      } else {
-        built = sumtree.push(built, bindingTag);
-        built = sumtree.push(
-          built,
-          buildChild(Property, buildProperty(referenceTag.value, buildBindingTag().value, value)),
-        );
-      }
+    if (node.value.name === NullTag || node.value.name === GapTag) {
+      throw new Error('not implemented');
+      node = buildNode(node);
     }
 
-    built = sumtree.push(built, close);
+    built = Tags.push(built, buildPropertyTag([referenceTag, bindingTags, node]));
   }
 
   return built;
@@ -172,91 +163,135 @@ export const reifyExpression = (node) => {
   if (node == null) return node;
   if (isNullNode(node)) return null;
 
-  if (isFragmentNode(node)) {
+  if (isCover(node)) {
     node = getRoot(node);
   }
 
-  switch (node.type?.description || node.type) {
+  if (getFlags(node)?.token && !node.value.name) {
+    return getCooked(node);
+  }
+
+  switch (node.value.name?.description) {
     case 'Document': {
-      let { doctype, tree } = node.properties;
+      let tree = get(['tree', 'node'], node);
 
-      doctype = reifyExpression(doctype.node);
-      tree = reifyExpression(tree.node);
+      tree = reifyExpression(tree);
 
-      let { attributes } = doctype.value;
-      let { properties } = tree;
+      let doctypeTag = null;
 
-      return Object.freeze({
-        flags: nodeFlags,
-        type: null,
-        children: sumtree.addAt(
-          0,
-          buildChildren(node.properties.tree.node),
-          buildDoctypeTag(attributes),
-        ),
-        properties,
-        attributes,
-      });
+      return buildDocument(doctypeTag, tree);
     }
 
-    case 'Node': {
-      let { open, children } = node.properties;
+    case 'TreeNode': {
+      let open = get('openTag', node);
 
-      open = reifyExpression(open.node);
+      let openTag = reifyExpression(open);
 
-      let { flags, type, attributes } = open.value;
+      let { flags, name, attributes, literalValue } = openTag.value;
 
-      const properties = reifyProperties(children);
+      if (literalValue && !flags.token) {
+        let tokenFragment = buildNode(
+          Tags.fromValues([buildOpenNodeTag(tokenFlags, null, literalValue, {}, true)]),
+        );
 
-      return Object.freeze({
-        flags,
-        type,
-        children: buildChildren(node),
-        properties,
-        attributes,
-      });
+        return buildNode(
+          Tags.fromValues([
+            buildOpenNodeTag(flags, name, null, attributes),
+            Tags.fromValues([buildPropertyTag([buildReferenceTag('_'), [], tokenFragment])]),
+            buildCloseNodeTag(),
+          ]),
+        );
+      } else {
+        return buildNode(buildTags(node));
+      }
     }
 
     case 'DoctypeTag': {
-      let { version, attributes } = node.properties;
+      let version = get('version', node);
+      let attributes = get('attributes', node);
+
       return buildDoctypeTag(
-        attributes && reifyExpression(attributes.node),
-        parseInt(sourceTextFor(version.node), 10),
+        attributes && reifyExpression(attributes),
+        parseInt(sourceTextFor(version), 10),
       );
     }
 
     case 'ReferenceTag': {
-      let { type, name, arrayOperatorToken, flags } = node.properties;
+      let type = get('type', node);
+      let name = get('name', node);
+      let flags = get('flags', node);
 
-      name = name && reifyExpression(name.node);
-      type = type && reifyExpression(type.node);
-      flags = freeze({ expression: !!flags?.expressionToken, hasGap: !!flags?.hasGapToken });
+      name = name && (reifyExpression(name) || null);
+      type = type && reifyExpression(type);
+      flags = (flags && reifyReferenceFlags(flags)) || undefined;
 
-      return buildReferenceTag(type, name, !isNull(arrayOperatorToken?.node), flags);
+      return buildReferenceTag(type, name, flags);
     }
 
     case 'LiteralTag': {
-      let { value } = node.properties;
-
-      return buildLiteralTag(getCooked(value.node.properties.content.node));
+      return buildLiteralTag(getCooked(get(['value', 'content'], node)));
     }
 
     case 'Identifier': {
-      return getCooked(node.properties.content.node);
+      return getCooked(get('content', node));
     }
 
     case 'IdentifierPath': {
-      return node.properties.segments.node.map((segment) => reifyExpression(segment.node));
+      return freeze(
+        [...list('segments', node)].map((segment) =>
+          freeze({ type: null, name: reifyExpression(segment) }),
+        ),
+      );
+    }
+
+    case 'AttributeDefinition': {
+      let key = get('key', node);
+      let value = get('value', node);
+
+      key = key && reifyExpression(key).map((segment) => segment.name);
+      value = value && reifyExpression(value);
+
+      return buildAttributeDefinition(key, value);
+    }
+
+    case 'NodeFlags': {
+      return reifyNodeFlags(node);
+    }
+
+    case 'ReferenceFlags': {
+      return reifyReferenceFlags(node);
     }
 
     case 'OpenNodeTag': {
-      let { flags, type, attributes } = node.properties;
+      let flags = get('flags', node);
+      let type = get('type', node);
+      let name = get('name', node);
+      let attributes = get('attributes', node);
+      let literalValue = get('literalValue', node);
+      let openToken = get('openToken', node);
+      let selfClosing = get('selfClosingToken', node);
+
+      literalValue = literalValue && reifyExpression(literalValue);
 
-      flags = reifyNodeFlags(flags.node);
-      type = reifyExpression(type?.node);
-      attributes = reifyExpression(attributes?.node);
+      if (!openToken) {
+        if (!literalValue) throw new Error();
 
-      return buildOpenNodeTag(flags, type, attributes);
+        return buildOpenNodeTag(tokenFlags, null, literalValue, {});
+      }
+
+      let anonymousToken = !openToken;
+
+      flags = anonymousToken ? tokenFlags : (flags && reifyNodeFlags(flags)) || nodeFlags;
+      type = reifyExpression(type);
+      name = reifyExpression(name);
+      attributes = reifyExpression(attributes) || {};
+      selfClosing = !!reifyExpression(selfClosing);
+
+      // if (literalValue && !flags.token) {
+      //   return buildOpenNodeTag(tokenFlags, null, literalValue, {}, true);
+      // }
+
+      return buildFullOpenNodeTag(flags, type, name, literalValue, attributes, selfClosing);
     }
 
     case 'CloseNodeTag': {
@@ -264,153 +299,186 @@ export const reifyExpression = (node) => {
     }
 
     case 'Integer': {
-      let { digits } = node.properties;
-      return parseInt(digits.map((digit) => getCooked(digit.node)).join(''), 10);
+      return parseInt([...list('digits', node)].map((digit) => getCooked(digit)).join(''), 10);
     }
 
     case 'Infinity': {
-      return getCooked(node.properties.sign.node) === '-' ? -Infinity : Infinity;
-    }
-
-    case 'Punctuator': {
-      return getCooked(node);
+      return getCooked(get('sign', node)) === '-' ? -Infinity : Infinity;
     }
 
     case 'GapTag':
       return buildGapTag();
 
-    case 'InitializerTag':
-      return buildInitializerTag();
-
-    case 'BindingTag':
-      let { languagePath } = node.properties;
-
-      return buildBindingTag(reifyExpression(languagePath));
-
     case 'NullTag':
       return buildNullTag();
 
+    case 'NullNode':
+    case 'GapNode':
+      let tag = reifyExpression(get('sigilTag', node));
+      return buildNode(tag);
+
     case 'ShiftTag':
       return buildShiftTag();
 
     case 'String':
-      return node.properties.content.node ? getCooked(node.properties.content.node) : '';
+      return get('content', node) ? getCooked(get('content', node)) : '';
 
     case 'SpamexString': {
-      return buildEmbeddedMatcher(node.properties.content.node);
+      return buildEmbeddedMatcher(get('content', node));
     }
 
     case 'RegexString': {
-      return buildEmbeddedRegex(node.properties.content.node);
+      return buildEmbeddedRegex(get('content', node));
     }
 
-    case 'OpenNodeMatcher': {
-      let { flags, type, attributes, intrinsicValue } = node.properties;
+    case 'TreeNodeMatcherOpen': {
+      let flags = get('flags', node);
+      let name = get('name', node);
+      let type = get('type', node);
+      let attributes = get('attributes', node);
+      let literalValue = get('literalValue', node);
+
+      flags = (flags && reifyNodeFlags(flags)) || {};
+      name = name
+        ? name.value.name === Symbol.for('String')
+          ? getCooked(get('content', name))
+          : reifyExpression(name)
+        : null;
+      type = reifyExpression(type);
+      attributes = attributes ? reifyExpression(attributes) : {};
+      literalValue = literalValue && reifyExpression(literalValue);
+
+      return freeze({
+        flags,
+        type,
+        name,
+        literalValue,
+        attributes,
+      });
+    }
 
-      flags = (flags && reifyNodeFlags(flags.node)) || {};
-      type =
-        type.node.type === Symbol.for('String')
-          ? getCooked(type.node.properties.content.node)
-          : reifyExpression(type.node);
-      attributes = attributes ? reifyExpression(attributes.node) : {};
-      intrinsicValue = intrinsicValue && reifyExpression(intrinsicValue.node);
+    case 'TreeNodeMatcher': {
+      let open = reifyExpression(get('open', node));
 
-      return { flags, type, intrinsicValue, attributes };
+      if (!open) {
+        return [...list('children', node)].map(reifyExpression)[0];
+      }
+
+      return open;
     }
 
-    case 'FragmentMatcher': {
-      let { flags } = node.properties;
+    case 'PropertyMatcher': {
+      let refMatcher = get('refMatcher', node);
+      let boundMatcher = get('valueMatcher', node);
+
+      refMatcher = reifyExpression(refMatcher);
 
-      flags = (flags && reifyNodeFlags(flags.node)) || {};
+      if (!boundMatcher) throw new Error();
 
-      return {
-        flags,
-        type: Symbol.for('@bablr/fragment'),
-        intrinsicValue: null,
-        attributes: null,
-      };
+      if (boundMatcher.value.name !== Symbol.for('BoundNodeMatcher')) throw new Error();
+
+      let { nodeMatcher, bindingMatchers } = reifyExpression(boundMatcher);
+
+      return freeze({ refMatcher, bindingMatchers, nodeMatcher });
     }
 
-    case 'BasicNodeMatcher': {
-      let { open } = node.properties;
+    case 'ReferenceMatcher': {
+      let type = get('type', node);
+      let name = get('name', node);
+      let flags = get('flags', node);
+
+      type = type && reifyExpression(type);
+      name = name && reifyExpression(name);
+      flags = (flags && reifyReferenceFlags(flags)) || referenceFlags;
 
-      return reifyExpression(open.node);
+      return freeze({ type, name, flags });
     }
 
-    case 'PropertyMatcher': {
-      let { refMatcher, bindingMatcher, nodeMatcher } = node.properties;
+    case 'BoundNodeMatcher': {
+      let bindingMatchers, nodeMatcher;
+      // if (get(['nodeMatcher', 'open'], node)) {
+      bindingMatchers = [...list('bindingMatchers', node)].map(reifyExpression);
+      nodeMatcher = reifyExpression(get('nodeMatcher', node));
+      // } else {
+      //   ({ bindingMatchers, nodeMatcher } = reifyExpression(get('nodeMatcher', node)));
+      // }
+
+      return freeze({ bindingMatchers, nodeMatcher });
+    }
 
-      refMatcher = refMatcher ? reifyExpression(refMatcher.node) : null;
-      bindingMatcher = bindingMatcher ? reifyExpression(bindingMatcher.node) : null;
-      nodeMatcher = reifyExpression(nodeMatcher.node);
+    case 'BoundNode': {
+      let bindingTags = [],
+        node_;
+      if (get(['node', 'openTag'], node)) {
+        bindingTags = [...list('bindingTags', node)].map(reifyExpression);
+        node_ = reifyExpression(get('node', node));
+      } else {
+        ({ bindingTags, node: node_ } = reifyExpression(get('node', node)));
+      }
 
-      return { refMatcher, bindingMatcher, nodeMatcher };
+      return freeze({ bindingTags, node: node_ });
     }
 
-    case 'ReferenceMatcher': {
-      let { type, name, openIndexToken, flags } = node.properties;
+    case 'BindingTag': {
+      let segments = [...list('segments', node)].map((segment) => {
+        return reifyExpression(segment);
+      });
+      return buildBindingTag(segments);
+    }
 
-      type = type && reifyExpression(type.node);
-      name = name && reifyExpression(name.node);
-      let isArray = !isNull(openIndexToken?.node);
-      flags = (flags && reifyReferenceFlags(flags?.node)) || referenceFlags;
+    case 'BindingSegment': {
+      let path = get('path', node);
 
-      return { type, name, isArray, flags };
+      switch (path.value.name && path.value.name.description) {
+        case 'Identifier':
+          return freeze({ type: null, name: reifyExpression(path) });
+        case null:
+          return freeze({ type: reifyExpression(path), name: null });
+        default:
+          throw new Error();
+      }
     }
 
     case 'BindingMatcher': {
-      let { languagePath } = node.properties;
-
-      languagePath = languagePath && reifyExpression(languagePath.node);
+      let segments = [...list('segments', node)].map((segment) => reifyExpression(segment));
 
-      return { languagePath };
+      return freeze({ segments });
     }
 
     case 'GapNodeMatcher':
-      return buildStubNode(buildGapTag());
+      return buildNode(buildGapTag());
 
     case 'NullNodeMatcher':
-      return buildStubNode(buildNullTag());
-
-    case 'ArrayNodeMatcher':
-      return [];
+      return buildNode(buildNullTag());
 
     case 'Call': {
-      const { verb, arguments: args } = node.properties;
+      const verb = get('verb', node);
 
-      const args_ = [...btree.traverse(args.node)].map((el) => reifyExpression(el.node));
+      const args = [...list('arguments', node)].map((el) => reifyExpression(el));
 
-      return { verb: reifyExpression(verb.node), arguments: args_ };
+      return freeze({ verb: reifyExpression(verb), arguments: args });
     }
 
     case 'Object': {
-      const { properties } = node.properties;
-
       return Object.fromEntries(
-        [...btree.traverse(properties.node)].map((property) => {
-          const {
-            node: {
-              properties: { key, value },
-            },
-          } = property;
-          return [getCooked(key.node), reifyExpression(value.node)];
+        [...list('properties', node)].map((property) => {
+          const key = get('key', property);
+          const value = get('value', property);
+          return freeze([reifyExpression(key), reifyExpression(value)]);
         }),
       );
     }
 
     case 'Array': {
-      const { elements = [] } = node.properties;
-
-      return [...btree.traverse(elements.node)].map((el) => reifyExpression(el.node));
+      return freeze([...list('elements', node)].map((el) => reifyExpression(el)));
     }
 
-    case 'Punctuator':
     case 'Keyword':
       return getCooked(node);
 
     case 'Boolean': {
       // prettier-ignore
-      switch (getCooked(node.properties.sigilToken.node)) {
+      switch (getCooked(get('sigilToken', node))) {
         case 'true': return true;
         case 'false': return false;
         default: throw new Error();

package/lib/print.js

@@ -2,40 +2,52 @@ import {
   printSource,
   printTag,
   printExpression as printExpression_,
+  printCSTML,
 } from '@bablr/agast-helpers/tree';
 import {
-  EmbeddedNode,
-  EmbeddedTag,
+  Tag,
   EmbeddedObject,
-  EmbeddedMatcher,
-  EmbeddedRegex,
-  EmbeddedInstruction,
+  Matcher,
+  Regex,
+  Instruction,
+  TreeNode,
+  NullNode,
+  GapNode,
+  Node,
 } from './symbols.js';
 
 export const printEmbedded = (value) => {
   switch (value.type) {
-    case EmbeddedTag:
+    case Tag:
       return `t\`${printTag(value.value)}\``;
 
-    case EmbeddedMatcher:
+    case Node:
+      return `n\`${printCSTML(value.value)}\``;
+
+    case Matcher:
       return `m\`${printSource(value.value)}\``;
 
-    case EmbeddedRegex:
+    case Regex:
       return `re\`${printSource(value.value)}\``;
 
-    case EmbeddedInstruction:
+    case Instruction:
       return `i\`${printCall(value.value)}\``;
 
     case EmbeddedObject: {
       return printObject(value.value);
     }
 
-    case EmbeddedNode: {
-      return printSource(value.value);
-    }
+    case NullNode:
+    case GapNode:
+    case TreeNode:
+      throw new Error(
+        'Cannot print plain node. Did you mean to wrap this node in buildEmbeddedNode?',
+      );
 
     default:
-      throw new Error();
+      throw new Error(
+        'Cannot print plain object. Did you mean to wrap this object in buildEmbedded*?',
+      );
   }
 };
 

package/lib/stream.js

@@ -1,23 +1,21 @@
 import { Coroutine } from '@bablr/coroutine';
 import {
-  InitializerTag,
   CloseNodeTag,
   EmbeddedObject,
   GapTag,
   NullTag,
   OpenNodeTag,
   ReferenceTag,
-  TokenGroup,
 } from './symbols.js';
 import {
   getStreamIterator,
-  prettyGroupTags,
-  printSelfClosingNodeTag,
   printTag,
+  wait,
   StreamIterable,
+  prettyGroupTags,
+  hoistTrivia,
 } from '@bablr/agast-helpers/stream';
 import { buildWriteEffect } from './builders.js';
-import { getCooked } from '@bablr/agast-helpers/tree';
 
 const getEmbeddedObject = (obj) => {
   if (obj.type !== EmbeddedObject) throw new Error();
@@ -31,7 +29,7 @@ function* __generateStandardOutput(tags) {
     co.advance();
 
     if (co.current instanceof Promise) {
-      co.current = yield co.current;
+      co.current = yield wait(co.current);
     }
     if (co.done) break;
 
@@ -60,7 +58,7 @@ function* __generateAllOutput(tags) {
     co.advance();
 
     if (co.current instanceof Promise) {
-      co.current = yield co.current;
+      co.current = yield wait(co.current);
     }
     if (co.done) break;
 
@@ -101,7 +99,7 @@ function* __writeCSTMLStrategy(tags) {
     co.advance();
 
     if (co.current instanceof Promise) {
-      co.current = yield co.current;
+      co.current = yield wait(co.current);
     }
     if (co.done) break;
 
@@ -117,12 +115,7 @@ function* __writeCSTMLStrategy(tags) {
       continue;
     }
 
-    if (tag.type === TokenGroup) {
-      const intrinsicValue = getCooked(tag.value);
-      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
-    } else {
-      yield buildWriteEffect(printTag(tag));
-    }
+    yield buildWriteEffect(printTag(tag));
 
     prevTag = tag;
   }
@@ -141,7 +134,8 @@ function* __writePrettyCSTMLStrategy(tags, options) {
     return;
   }
 
-  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(hoistTrivia(tags))));
+  // const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
   let indentLevel = 0;
   let first = true;
   let inline = false;
@@ -150,11 +144,10 @@ function* __writePrettyCSTMLStrategy(tags, options) {
   for (;;) {
     co.advance();
 
-    if (co.done) break;
-
     if (co.current instanceof Promise) {
-      co.current = yield co.current;
+      co.current = yield wait(co.current);
     }
+    if (co.done) break;
 
     const tag = co.value;
 
@@ -181,8 +174,7 @@ function* __writePrettyCSTMLStrategy(tags, options) {
       ref &&
       (tag.type === NullTag ||
         tag.type === GapTag ||
-        tag.type === InitializerTag ||
-        tag.type === TokenGroup);
+        (tag.type === OpenNodeTag && tag.value.selfClosing));
 
     if (!first && !inline) {
       yield buildWriteEffect('\n');
@@ -203,20 +195,14 @@ function* __writePrettyCSTMLStrategy(tags, options) {
       yield buildWriteEffect(' ');
     }
 
-    if (tag.type === TokenGroup) {
-      ref = null;
-      const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
-      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
-    } else {
-      yield buildWriteEffect(printTag(tag));
-    }
+    yield buildWriteEffect(printTag(tag));
 
     if (tag.type === ReferenceTag) {
       inline = true;
       ref = tag;
     }
 
-    if (tag.type === OpenNodeTag) {
+    if (tag.type === OpenNodeTag && !tag.value.selfClosing) {
       indentLevel++;
     }
 

package/lib/symbols.js

@@ -1,11 +1,8 @@
 export * from '@bablr/agast-helpers/symbols';
 
-export const node = Symbol.for('@bablr/node');
-export const fragment = Symbol.for('@bablr/fragment');
-
-export const EmbeddedInstruction = Symbol.for('EmbeddedInstruction');
-export const EmbeddedMatcher = Symbol.for('EmbeddedMatcher');
-export const EmbeddedNode = Symbol.for('EmbeddedNode');
-export const EmbeddedRegex = Symbol.for('EmbeddedRegex');
-export const EmbeddedTag = Symbol.for('EmbeddedTag');
-export const EmbeddedObject = Symbol.for('EmbeddedObject');
+export const Instruction = Symbol.for('Instruction');
+export const Matcher = Symbol.for('Matcher');
+export const Regex = Symbol.for('Regex');
+export const Tag = Symbol.for('Tag');
+export const Object = Symbol.for('Object');
+export const EmbeddedObject = Object;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm-helpers",
   "description": "Helper functions for working with the BABLR VM",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -22,7 +22,7 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.8.0",
+    "@bablr/agast-helpers": "0.10.0",
     "@bablr/coroutine": "0.1.0"
   },
   "devDependencies": {