@bablr/agast-vm-helpers 0.7.1 → 0.9.0

package/lib/builders.js

@@ -1,11 +1,4 @@
-import {
-  EmbeddedNode,
-  EmbeddedMatcher,
-  EmbeddedRegex,
-  EmbeddedTag,
-  EmbeddedObject,
-  EmbeddedInstruction,
-} from './symbols.js';
+import { Node, Matcher, Regex, Tag, EmbeddedObject, Instruction } from './symbols.js';
 
 const isObject = (val) => val !== null && typeof val === 'object';
 
@@ -20,24 +13,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: Node, 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 buildEffect = (value) => {

package/lib/deembed.js

@@ -1,11 +1,4 @@
-import {
-  EmbeddedNode,
-  EmbeddedObject,
-  EmbeddedTag,
-  EmbeddedMatcher,
-  EmbeddedRegex,
-  EmbeddedInstruction,
-} from './symbols.js';
+import { Node, EmbeddedObject, Tag, Matcher, Regex, Instruction } from './symbols.js';
 
 export const getEmbeddedObject = (expr) => {
   if (!expr) return expr;
@@ -15,30 +8,30 @@ export const getEmbeddedObject = (expr) => {
 
 export const getEmbeddedNode = (expr) => {
   if (!expr) return expr;
-  if (expr.type !== EmbeddedNode) throw new Error();
+  if (expr.type !== Node) 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/embed.js

@@ -1,4 +1,4 @@
-import { buildEmbeddedObject } from './internal-builders.js';
+import { buildEmbeddedObject } from './builders';
 
 const { isArray } = Array;
 const isString = (val) => typeof val === 'string';

package/lib/index.js

@@ -2,45 +2,58 @@ import {
   sourceTextFor,
   getCooked,
   isNull,
-  nodeFlags,
-  printType,
-  buildGapTag,
   isNullNode,
-  buildNullTag,
   buildStubNode,
   isFragmentNode,
   buildReferenceTag,
+  getRoot,
+  buildChild,
+  get,
+  list,
+  buildBounds,
 } from '@bablr/agast-helpers/tree';
-import * as btree from '@bablr/agast-helpers/btree';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
+import * as Tags from '@bablr/agast-helpers/tags';
 import {
+  buildGapTag,
+  buildNullTag,
+  buildOpenNodeTag,
+  buildBindingTag,
+  buildInitializerTag,
+  buildShiftTag,
   buildCloseNodeTag,
   buildLiteralTag,
   buildDoctypeTag,
   referenceFlags,
+  buildProperty,
+  fragmentFlags,
+  buildBinding,
+  buildAttributeDefinition,
+  buildPropertyWrapper,
 } from '@bablr/agast-helpers/builders';
+import { buildEmbeddedMatcher, buildEmbeddedRegex } from './builders.js';
 import {
-  DoctypeTag,
-  OpenNodeTag,
+  AttributeDefinition,
   CloseNodeTag,
-  ShiftTag,
   GapTag,
-  NullTag,
   InitializerTag,
   LiteralTag,
-} from '@bablr/agast-helpers/symbols';
-import { buildEmbeddedMatcher, buildEmbeddedRegex } from './builders.js';
+  NullTag,
+  OpenNodeTag,
+  Property,
+  PropertyWrapper,
+} from './symbols.js';
+import { isStubNode } from '@bablr/agast-helpers/path';
 
 const { freeze } = Object;
 
 export const effectsFor = (verb) => {
   switch (verb) {
     case 'eat':
-    case 'holdFor':
+    case 'shift':
       return { success: 'eat', failure: 'fail' };
 
     case 'eatMatch':
-    case 'holdForMatch':
+    case 'shiftMatch':
       return { success: 'eat', failure: 'none' };
 
     case 'match':
@@ -59,112 +72,94 @@ export const shouldBranch = (effects) => {
 };
 
 export const reifyNodeFlags = (flags) => {
-  let { tokenToken, hasGapToken, fragmentToken, coverFragmentToken } = flags.properties;
+  let tokenToken = get('tokenToken', flags);
+  let hasGapToken = get('hasGapToken', flags);
+  let fragmentToken = get('fragmentToken', flags);
+  let multiFragmentToken = get('multiFragmentToken', flags);
 
-  return {
-    token: !!(tokenToken && reifyExpression(tokenToken.node)),
-    hasGap: !!(hasGapToken && reifyExpression(hasGapToken.node)),
-    fragment: !!(fragmentToken && reifyExpression(fragmentToken.node)),
-    cover: !!(coverFragmentToken && reifyExpression(coverFragmentToken.node)),
-  };
+  let token = !!(tokenToken && reifyExpression(tokenToken));
+  let hasGap = !!(hasGapToken && reifyExpression(hasGapToken));
+  let fragment = !!(fragmentToken && reifyExpression(fragmentToken));
+  let cover = !!(fragment && !(multiFragmentToken && reifyExpression(multiFragmentToken)));
+
+  return { token, hasGap, fragment, cover };
 };
 
 export const reifyReferenceFlags = (flags) => {
-  let { expressionToken, hasGapToken } = flags.properties;
+  let expressionToken = get('expressionToken', flags);
+  let hasGapToken = get('hasGapToken', flags);
 
   return {
-    expression: !!(expressionToken && reifyExpression(expressionToken.node)),
-    hasGap: !!(hasGapToken && reifyExpression(hasGapToken.node)),
+    expression: !!(expressionToken && reifyExpression(expressionToken)),
+    hasGap: !!(hasGapToken && reifyExpression(hasGapToken)),
   };
 };
 
-export const reifyLanguage = (language) => {
-  const value = reifyExpression(language);
+export const buildTags = (node) => {
+  let open = get('open', node);
 
-  return typeof value === 'string' && !value.startsWith('https://') ? [value] : value;
-};
+  let children = buildChildren(list('children', node));
+  let openTag = reifyExpression(open);
+  let closeTag = buildCloseNodeTag();
 
-export const reifyProperties = (properties = []) => {
-  const built = {};
-  for (const property of btree.traverse(properties)) {
-    switch (property.node.type) {
-      case Symbol.for('Property'): {
-        let { reference, value: node } = property.node.properties;
-
-        reference = reifyExpression(reference.node);
-        node = reifyExpression(node.node);
-
-        if (reference.value.isArray) {
-          built[reference.value.name] ||= [];
-          built[reference.value.name].push({ reference, node });
-        } else {
-          built[reference.value.name] = { reference, node };
-        }
-        break;
-      }
-      default:
-        throw new Error();
-    }
-  }
-  return built;
-};
-
-export const buildFragmentChildren = (node) => {
-  let { open, children = [], close } = node.properties;
-
-  let built = [];
+  let literalValue = reifyExpression(get('literalValue', open));
 
-  open = reifyExpression(open.node);
-  close = reifyExpression(close.node);
-
-  built = sumtree.push(built, open);
-
-  for (const child of sumtree.traverse(children)) {
-    if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
-
-    let { reference } = child.node.properties;
-
-    reference = reifyExpression(reference.node);
-
-    built = sumtree.push(built, reference);
-    built = sumtree.push(built, buildGapTag());
+  if (literalValue) {
+    children = Tags.fromValues([buildLiteralTag(literalValue)]);
   }
 
-  built = sumtree.push(built, close);
-
-  return built;
+  return Tags.fromValues([openTag, children, closeTag]);
 };
 
-export const buildChildren = (node) => {
-  let { open, children = [], close } = node.properties;
+export const buildChildren = (children) => {
+  let built = Tags.fromValues([]);
 
-  const selfClosing = !isNull(open.node.properties.selfClosingTagToken?.node);
-  const { intrinsicValue } = open.node.properties;
-  let built = [];
+  for (const child of children) {
+    if ([AttributeDefinition, LiteralTag].includes(child.type)) {
+      built = Tags.push(built, reifyExpression(child));
+      continue;
+    }
 
-  open = reifyExpression(open.node);
-  close = reifyExpression(close?.node);
+    if (child.type !== Symbol.for('Property')) throw new Error('umimplemented');
 
-  if (selfClosing) {
-    built = sumtree.push(built, open);
-    if (!isNull(intrinsicValue?.node)) {
-      built = sumtree.push(built, buildLiteralTag(intrinsicValue.node));
-    }
-    built = sumtree.push(built, buildCloseNodeTag());
-  } else {
-    built = sumtree.push(built, open);
-    for (const child of sumtree.traverse(children)) {
-      if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
+    let reference = get('reference', child);
+    let binding = get('binding', child);
+    let value = get('value', child);
 
-      let { reference } = child.node.properties;
+    let referenceTag = reference ? reifyExpression(reference) : buildReferenceTag('.');
+    let bindingTag = binding
+      ? reifyExpression(binding)
+      : buildBindingTag(isStubNode(value) ? null : []);
 
-      reference = reifyExpression(reference.node);
+    value = reifyExpression(value);
 
-      built = sumtree.push(built, reference);
-      built = sumtree.push(built, buildGapTag());
+    if (referenceTag.value.type === '_') {
+      for (let child of Tags.traverse(value.tags)) {
+        if (![OpenNodeTag, CloseNodeTag].includes(child.type)) built = Tags.push(built, child);
+      }
+      continue;
     }
 
-    built = sumtree.push(built, close);
+    if (value.type === NullTag || value.type === GapTag) {
+      value = buildStubNode(value);
+    }
+
+    built = Tags.push(built, referenceTag);
+    if (value.type === InitializerTag) {
+      built = Tags.push(built, value);
+    } else {
+      let property = buildProperty(referenceTag.value, bindingTag.value, value);
+      built = Tags.push(
+        built,
+        buildChild(
+          PropertyWrapper,
+          buildPropertyWrapper(
+            [referenceTag, bindingTag, buildChild(Property, property)],
+            property,
+          ),
+        ),
+      );
+    }
   }
 
   return built;
@@ -177,230 +172,213 @@ export const reifyExpression = (node) => {
   if (isNullNode(node)) return null;
 
   if (isFragmentNode(node)) {
-    node = node.properties['.'].node;
+    node = getRoot(node);
   }
 
-  if (node.language === 'https://bablr.org/languages/core/en/cstml') {
-    switch (node.type?.description || node.type) {
-      case 'Document': {
-        let { doctype, tree } = node.properties;
-
-        doctype = reifyExpression(doctype.node);
-        tree = reifyExpression(tree.node);
-
-        let { attributes } = doctype.value;
-        let { properties } = tree;
-
-        return {
-          flags: nodeFlags,
-          language: attributes.bablrLanguage,
-          type: null,
-          children: sumtree.addAt(
-            0,
-            buildFragmentChildren(node.properties.tree.node),
-            buildDoctypeTag(attributes),
-          ),
-          properties,
-          attributes,
-        };
-      }
+  switch (node.type?.description || node.type) {
+    case 'Document': {
+      let doctype = get('doctype', node);
+      let tree = get('tree', node);
 
-      case 'Node': {
-        let { open, children } = node.properties;
+      doctype = reifyExpression(doctype);
+      tree = reifyExpression(tree);
 
-        open = reifyExpression(open.node);
+      let { attributes } = doctype.value;
 
-        let { flags, language, type, attributes } = open.value;
+      return Object.freeze({
+        flags: fragmentFlags,
+        type: null,
+        bounds: tree.bounds,
+        tags: tree.tags,
+        attributes,
+      });
+    }
 
-        const properties = reifyProperties(children);
+    case 'Node': {
+      let open = get('open', node);
 
-        return {
-          flags,
-          language,
-          type,
-          children: buildChildren(node),
-          properties,
-          attributes,
-        };
-      }
+      let openTag = reifyExpression(open);
 
-      case 'Fragment': {
-        let { open, children } = node.properties;
+      let { flags, type, attributes } = openTag.value;
 
-        open = reifyExpression(open.node);
+      return Object.freeze({
+        flags,
+        type,
+        bounds: buildBounds(),
+        tags: buildTags(node),
+        attributes,
+      });
+    }
 
-        let { flags } = open.value;
+    case 'DoctypeTag': {
+      let version = get('version', node);
+      let attributes = get('attributes', node);
 
-        const properties = reifyProperties(children);
+      return buildDoctypeTag(
+        attributes && reifyExpression(attributes),
+        parseInt(sourceTextFor(version), 10),
+      );
+    }
 
-        return {
-          flags,
-          language: null,
-          type: null,
-          children: buildChildren(node),
-          properties,
-          attributes: {},
-        };
-      }
+    case 'ReferenceTag': {
+      let type = get('type', node);
+      let name = get('name', node);
+      let arrayOperatorToken = get('arrayOperatorToken', node);
+      let flags = get('flags', node);
 
-      case 'DoctypeTag': {
-        let { doctypeToken, version, attributes } = node.properties;
-        return {
-          type: DoctypeTag,
-          value: {
-            doctypeToken: getCooked(doctypeToken?.node),
-            version: parseInt(sourceTextFor(version.node), 10),
-            attributes: reifyExpression(attributes.node),
-          },
-        };
-      }
+      name = name && reifyExpression(name);
+      type = type && reifyExpression(type);
+      flags = freeze({
+        expression: !!(flags && get('expressionToken', flags)),
+        hasGap: !!(flags && get('hasGapToken', flags)),
+      });
 
-      case 'ReferenceTag': {
-        let { name, arrayOperatorToken, flags } = node.properties;
+      return buildReferenceTag(type, name, !isNull(arrayOperatorToken), flags);
+    }
 
-        name = reifyExpression(name.node);
-        flags = freeze({ expression: !!flags?.expressionToken, hasGap: !!flags?.hasGapToken });
+    case 'LiteralTag': {
+      return buildLiteralTag(getCooked(get(['value', 'content'], node)));
+    }
 
-        return buildReferenceTag(name, !isNull(arrayOperatorToken?.node), flags);
-      }
+    case 'Identifier': {
+      return getCooked(get('content', node));
+    }
 
-      case 'LiteralTag': {
-        let { value } = node.properties;
+    case 'IdentifierPath': {
+      return [...list('segments', node)].map((segment) => reifyExpression(segment));
+    }
 
-        return { type: LiteralTag, value: getCooked(value.properties.content) };
-      }
+    case 'AttributeDefinition': {
+      let path = get('path', node);
+      let value = get('value', node);
 
-      case 'Identifier': {
-        return getCooked(node.properties.content.node);
-      }
+      path = path && reifyExpression(path);
+      value = value && reifyExpression(value);
 
-      case 'IdentifierPath': {
-        return node.properties.segments.map((segment) => reifyExpression(segment.node));
-      }
+      return buildAttributeDefinition(path, value);
+    }
 
-      case 'OpenNodeTag': {
-        let { flags, language, type, attributes } = node.properties;
+    case 'OpenNodeTag': {
+      let flags = get('flags', node);
+      let type = get('type', node);
+      let attributes = get('attributes', node);
 
-        flags = reifyNodeFlags(flags.node);
-        language = reifyLanguage(language?.node);
-        type = reifyExpression(type?.node);
-        attributes = reifyExpression(attributes?.node);
+      flags = reifyNodeFlags(flags);
+      type = reifyExpression(type);
+      attributes = reifyExpression(attributes);
 
-        return {
-          type: OpenNodeTag,
-          value: { flags, language, type, attributes },
-        };
-      }
+      return buildOpenNodeTag(flags, type, attributes);
+    }
 
-      case 'CloseNodeTag': {
-        return { type: CloseNodeTag, value: undefined };
-      }
+    case 'CloseNodeTag': {
+      return buildCloseNodeTag();
+    }
 
-      case 'Integer': {
-        let { digits } = node.properties;
-        return parseInt(digits.map((digit) => getCooked(digit.node)).join(''), 10);
-      }
+    case 'Integer': {
+      return parseInt([...list('digits', node)].map((digit) => getCooked(digit)).join(''), 10);
+    }
 
-      case 'Infinity': {
-        return getCooked(node.properties.sign.node) === '-' ? -Infinity : Infinity;
-      }
+    case 'Infinity': {
+      return getCooked(get('sign', node)) === '-' ? -Infinity : Infinity;
+    }
 
-      case 'Punctuator': {
-        return getCooked(node);
-      }
+    case 'Punctuator': {
+      return getCooked(node);
+    }
 
-      case 'GapTag':
-        return { type: GapTag, value: undefined };
+    case 'GapTag':
+      return buildGapTag();
 
-      case 'InitializerTag':
-        return { type: InitializerTag, value: undefined };
+    case 'InitializerTag':
+      return buildInitializerTag();
 
-      case 'NullTag':
-        return { type: NullTag, value: undefined };
+    case 'BindingTag':
+      let languagePath = get('languagePath', node);
 
-      case 'ShiftTag':
-        return { type: ShiftTag, value: undefined };
+      return buildBindingTag(reifyExpression(languagePath));
 
-      default:
-        throw new Error();
-    }
-  }
+    case 'NullTag':
+      return buildNullTag();
 
-  if (
-    ![
-      'https://bablr.org/languages/core/en/bablr-vm-instruction',
-      'https://bablr.org/languages/core/en/cstml-json',
-      'https://bablr.org/languages/core/en/cstml',
-      'https://bablr.org/languages/core/en/spamex',
-    ].includes(node.language)
-  ) {
-    return node;
-  }
+    case 'ShiftTag':
+      return buildShiftTag();
 
-  switch (printType(node.type)) {
     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, language, type, attributes, intrinsicValue } = node.properties;
+      let flags = get('flags', node);
+      let type = get('type', node);
+      let attributes = get('attributes', node);
+      let literalValue = get('literalValue', node);
 
-      flags = (flags && reifyNodeFlags(flags.node)) || {};
-      language = language && reifyLanguage(language.node);
+      flags = (flags && reifyNodeFlags(flags)) || {};
       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);
+        type.type === Symbol.for('String')
+          ? getCooked(get('content', type))
+          : reifyExpression(type);
+      attributes = attributes ? reifyExpression(attributes) : {};
+      literalValue = literalValue && reifyExpression(literalValue);
 
-      return { flags, language, type, intrinsicValue, attributes };
+      return { flags, type, literalValue, attributes };
     }
 
     case 'FragmentMatcher': {
-      let { flags } = node.properties;
+      let flags = get('flags', node);
 
-      flags = (flags && reifyNodeFlags(flags.node)) || {};
+      flags = (flags && reifyNodeFlags(flags)) || {};
 
       return {
         flags,
-        language: null,
         type: Symbol.for('@bablr/fragment'),
-        intrinsicValue: null,
+        literalValue: null,
         attributes: null,
       };
     }
 
     case 'BasicNodeMatcher': {
-      let { open } = node.properties;
-
-      return reifyExpression(open.node);
+      return reifyExpression(get('open', node));
     }
 
     case 'PropertyMatcher': {
-      let { refMatcher, nodeMatcher } = node.properties;
+      let refMatcher = get('refMatcher', node);
+      let bindingMatcher = get('bindingMatcher', node);
+      let nodeMatcher = get('nodeMatcher', node);
 
-      refMatcher = refMatcher ? reifyExpression(refMatcher.node) : null;
-      nodeMatcher = reifyExpression(nodeMatcher.node);
+      refMatcher = refMatcher ? reifyExpression(refMatcher) : null;
+      bindingMatcher = bindingMatcher ? reifyExpression(bindingMatcher) : null;
+      nodeMatcher = reifyExpression(nodeMatcher);
 
-      return { refMatcher, nodeMatcher };
+      return { refMatcher, bindingMatcher, nodeMatcher };
     }
 
     case 'ReferenceMatcher': {
-      let { name, openIndexToken, flags } = node.properties;
+      let type = get('type', node);
+      let name = get('name', node);
+      let isArray = !isNull(get('openIndexToken', node));
+      let flags = get('flags', node);
+
+      type = type && reifyExpression(type);
+      name = name && reifyExpression(name);
+      flags = (flags && reifyReferenceFlags(flags)) || referenceFlags;
+
+      return { type, name, isArray, flags };
+    }
+
+    case 'BindingMatcher': {
+      let languagePath = get('languagePath', node);
 
-      name = name && reifyExpression(name.node);
-      let isArray = !isNull(openIndexToken?.node);
-      flags = (flags && reifyReferenceFlags(flags?.node)) || referenceFlags;
+      languagePath = languagePath && reifyExpression(languagePath);
 
-      return { name, isArray, flags };
+      return { languagePath };
     }
 
     case 'GapNodeMatcher':
@@ -413,44 +391,34 @@ export const reifyExpression = (node) => {
       return [];
 
     case 'Call': {
-      const { verb, arguments: args } = node.properties;
+      const verb = get('verb', node);
 
-      const args_ = [...btree.traverse(args)].map((el) => reifyExpression(el.node));
+      const args = [...list('arguments', node)].map((el) => reifyExpression(el));
 
-      return { verb: reifyExpression(verb.node), arguments: args_ };
+      return { verb: reifyExpression(verb), arguments: args };
     }
 
     case 'Object': {
-      const { properties } = node.properties;
-
       return Object.fromEntries(
-        [...btree.traverse(properties)].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 [reifyExpression(key), reifyExpression(value)];
         }),
       );
     }
 
     case 'Array': {
-      const { elements = [] } = node.properties;
-
-      return [...btree.traverse(elements)].map((el) => reifyExpression(el.node));
+      return [...list('elements', node)].map((el) => reifyExpression(el));
     }
 
     case 'Punctuator':
     case 'Keyword':
       return getCooked(node);
 
-    case 'Identifier':
-      return getCooked(node.properties.content.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();
@@ -467,61 +435,6 @@ export const reifyExpression = (node) => {
       return undefined;
 
     default:
-      throw new Error('bad expression');
-  }
-};
-
-export const reifyExpressionShallow = (node) => {
-  if (!node || isNullNode(node)) return null;
-
-  if (
-    ![
-      'https://bablr.org/languages/core/en/bablr-vm-instruction',
-      'https://bablr.org/languages/core/en/cstml',
-      'https://bablr.org/languages/core/en/cstml-json',
-      'https://bablr.org/languages/core/en/spamex',
-    ].includes(node.language)
-  ) {
-    return node;
-  }
-
-  switch (printType(node.type)) {
-    case 'String':
-    case 'SpamexString':
-    case 'RegexString': {
-      return reifyExpression(node);
-    }
-
-    case 'Object': {
-      const { properties } = node.properties;
-
-      return Object.fromEntries(
-        [...btree.traverse(properties)].map(
-          ({
-            node: {
-              properties: { key, value },
-            },
-          }) => [getCooked(key.node), value.node],
-        ),
-      );
-    }
-
-    case 'Array':
-      return [...btree.traverse(node.properties.elements)].map((prop) => prop.node);
-
-    case 'Boolean': {
-      // prettier-ignore
-      switch (getCooked(node.properties.sigilToken.node)) {
-        case 'true': return true;
-        case 'false': return false;
-        default: throw new Error();
-      }
-    }
-
-    case 'Null':
-      return null;
-
-    default:
-      return reifyExpression(node);
+      return node;
   }
 };

package/lib/print.js

@@ -3,34 +3,27 @@ import {
   printTag,
   printExpression as printExpression_,
 } from '@bablr/agast-helpers/tree';
-import {
-  EmbeddedNode,
-  EmbeddedTag,
-  EmbeddedObject,
-  EmbeddedMatcher,
-  EmbeddedRegex,
-  EmbeddedInstruction,
-} from './symbols.js';
+import { Node, Tag, EmbeddedObject, Matcher, Regex, Instruction } from './symbols.js';
 
 export const printEmbedded = (value) => {
   switch (value.type) {
-    case EmbeddedTag:
+    case Tag:
       return `t\`${printTag(value.value)}\``;
 
-    case EmbeddedMatcher:
+    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: {
+    case Node: {
       return printSource(value.value);
     }
 

package/lib/stream.js

@@ -7,14 +7,12 @@ import {
   NullTag,
   OpenNodeTag,
   ReferenceTag,
-  TokenGroup,
 } from './symbols.js';
 import {
   getStreamIterator,
-  prettyGroupTags,
-  printSelfClosingNodeTag,
   printTag,
   StreamIterable,
+  prettyGroupTags,
 } from '@bablr/agast-helpers/stream';
 import { buildWriteEffect } from './builders.js';
 import { getCooked } from '@bablr/agast-helpers/tree';
@@ -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;
   }
@@ -182,7 +175,7 @@ function* __writePrettyCSTMLStrategy(tags, options) {
       (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 +196,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.literalValue) {
       indentLevel++;
     }
 

package/lib/symbols.js

@@ -3,8 +3,9 @@ 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 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.7.1",
+  "version": "0.9.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -22,11 +22,11 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.7.1",
+    "@bablr/agast-helpers": "0.9.0",
     "@bablr/coroutine": "0.1.0"
   },
   "devDependencies": {
-    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#c97bfa4b3663f8378e9b3e42bb5a41e685406cf9",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",