@bablr/agast-vm-helpers 0.8.0 → 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';
 
@@ -22,27 +15,27 @@ export const buildEmbeddedObject = (obj) => {
 
 export const buildEmbeddedNode = (node) => {
   if (!isObject(node)) throw new Error();
-  return freeze({ type: EmbeddedNode, value: freeze(node) });
+  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/index.js

@@ -2,16 +2,17 @@ import {
   sourceTextFor,
   getCooked,
   isNull,
-  nodeFlags,
   isNullNode,
   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/children';
+import * as Tags from '@bablr/agast-helpers/tags';
 import {
   buildGapTag,
   buildNullTag,
@@ -24,15 +25,22 @@ import {
   buildDoctypeTag,
   referenceFlags,
   buildProperty,
+  fragmentFlags,
+  buildBinding,
+  buildAttributeDefinition,
+  buildPropertyWrapper,
 } from '@bablr/agast-helpers/builders';
 import { buildEmbeddedMatcher, buildEmbeddedRegex } from './builders.js';
 import {
   AttributeDefinition,
+  CloseNodeTag,
   GapTag,
   InitializerTag,
   LiteralTag,
   NullTag,
+  OpenNodeTag,
   Property,
+  PropertyWrapper,
 } from './symbols.js';
 import { isStubNode } from '@bablr/agast-helpers/path';
 
@@ -64,103 +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 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('open', node);
 
-export const buildChildren = (node) => {
-  let { open, children = [], close } = node.properties;
+  let children = buildChildren(list('children', node));
+  let openTag = reifyExpression(open);
+  let closeTag = buildCloseNodeTag();
 
-  const selfClosing = !isNull(open.node.properties.selfClosingTagToken?.node);
-  const { intrinsicValue } = open.node.properties;
-  let built = [];
+  let literalValue = reifyExpression(get('literalValue', open));
 
-  open = reifyExpression(open.node);
-  close = reifyExpression(close?.node);
+  if (literalValue) {
+    children = Tags.fromValues([buildLiteralTag(literalValue)]);
+  }
+
+  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.type)) {
+      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.type !== Symbol.for('Property')) throw new Error('umimplemented');
 
-      let { reference, binding, value } = child.node.properties;
+    let reference = get('reference', child);
+    let binding = get('binding', child);
+    let value = get('value', child);
 
-      let referenceTag = reference ? reifyExpression(reference.node) : buildReferenceTag('.');
-      let bindingTag = binding
-        ? reifyExpression(binding.node)
-        : buildBindingTag(isStubNode(value.node) ? null : []);
+    let referenceTag = reference ? reifyExpression(reference) : buildReferenceTag('.');
+    let bindingTag = binding
+      ? reifyExpression(binding)
+      : buildBindingTag(isStubNode(value) ? null : []);
 
-      value = reifyExpression(value.node);
+    value = reifyExpression(value);
 
-      if (value.type === NullTag || value.type === GapTag) {
-        value = buildStubNode(value);
+    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, 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 (value.type === NullTag || value.type === GapTag) {
+      value = buildStubNode(value);
     }
 
-    built = sumtree.push(built, close);
+    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;
@@ -178,83 +177,95 @@ export const reifyExpression = (node) => {
 
   switch (node.type?.description || node.type) {
     case 'Document': {
-      let { doctype, tree } = node.properties;
+      let doctype = get('doctype', node);
+      let tree = get('tree', node);
 
-      doctype = reifyExpression(doctype.node);
-      tree = reifyExpression(tree.node);
+      doctype = reifyExpression(doctype);
+      tree = reifyExpression(tree);
 
       let { attributes } = doctype.value;
-      let { properties } = tree;
 
       return Object.freeze({
-        flags: nodeFlags,
+        flags: fragmentFlags,
         type: null,
-        children: sumtree.addAt(
-          0,
-          buildChildren(node.properties.tree.node),
-          buildDoctypeTag(attributes),
-        ),
-        properties,
+        bounds: tree.bounds,
+        tags: tree.tags,
         attributes,
       });
     }
 
     case 'Node': {
-      let { open, children } = node.properties;
-
-      open = reifyExpression(open.node);
+      let open = get('open', node);
 
-      let { flags, type, attributes } = open.value;
+      let openTag = reifyExpression(open);
 
-      const properties = reifyProperties(children);
+      let { flags, type, attributes } = openTag.value;
 
       return Object.freeze({
         flags,
         type,
-        children: buildChildren(node),
-        properties,
+        bounds: buildBounds(),
+        tags: buildTags(node),
         attributes,
       });
     }
 
     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;
-
-      name = name && reifyExpression(name.node);
-      type = type && reifyExpression(type.node);
-      flags = freeze({ expression: !!flags?.expressionToken, hasGap: !!flags?.hasGapToken });
+      let type = get('type', node);
+      let name = get('name', node);
+      let arrayOperatorToken = get('arrayOperatorToken', node);
+      let flags = get('flags', node);
+
+      name = name && reifyExpression(name);
+      type = type && reifyExpression(type);
+      flags = freeze({
+        expression: !!(flags && get('expressionToken', flags)),
+        hasGap: !!(flags && get('hasGapToken', flags)),
+      });
 
-      return buildReferenceTag(type, name, !isNull(arrayOperatorToken?.node), flags);
+      return buildReferenceTag(type, name, !isNull(arrayOperatorToken), 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 [...list('segments', node)].map((segment) => reifyExpression(segment));
+    }
+
+    case 'AttributeDefinition': {
+      let path = get('path', node);
+      let value = get('value', node);
+
+      path = path && reifyExpression(path);
+      value = value && reifyExpression(value);
+
+      return buildAttributeDefinition(path, value);
     }
 
     case 'OpenNodeTag': {
-      let { flags, type, attributes } = node.properties;
+      let flags = get('flags', node);
+      let type = get('type', node);
+      let attributes = get('attributes', node);
 
-      flags = reifyNodeFlags(flags.node);
-      type = reifyExpression(type?.node);
-      attributes = reifyExpression(attributes?.node);
+      flags = reifyNodeFlags(flags);
+      type = reifyExpression(type);
+      attributes = reifyExpression(attributes);
 
       return buildOpenNodeTag(flags, type, attributes);
     }
@@ -264,12 +275,11 @@ 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;
+      return getCooked(get('sign', node)) === '-' ? -Infinity : Infinity;
     }
 
     case 'Punctuator': {
@@ -283,7 +293,7 @@ export const reifyExpression = (node) => {
       return buildInitializerTag();
 
     case 'BindingTag':
-      let { languagePath } = node.properties;
+      let languagePath = get('languagePath', node);
 
       return buildBindingTag(reifyExpression(languagePath));
 
@@ -294,74 +304,79 @@ export const reifyExpression = (node) => {
       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;
+      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)) || {};
+      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, 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,
         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, bindingMatcher, nodeMatcher } = node.properties;
+      let refMatcher = get('refMatcher', node);
+      let bindingMatcher = get('bindingMatcher', node);
+      let nodeMatcher = get('nodeMatcher', node);
 
-      refMatcher = refMatcher ? reifyExpression(refMatcher.node) : null;
-      bindingMatcher = bindingMatcher ? reifyExpression(bindingMatcher.node) : null;
-      nodeMatcher = reifyExpression(nodeMatcher.node);
+      refMatcher = refMatcher ? reifyExpression(refMatcher) : null;
+      bindingMatcher = bindingMatcher ? reifyExpression(bindingMatcher) : null;
+      nodeMatcher = reifyExpression(nodeMatcher);
 
       return { refMatcher, bindingMatcher, nodeMatcher };
     }
 
     case 'ReferenceMatcher': {
-      let { type, 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.node);
-      name = name && reifyExpression(name.node);
-      let isArray = !isNull(openIndexToken?.node);
-      flags = (flags && reifyReferenceFlags(flags?.node)) || referenceFlags;
+      type = type && reifyExpression(type);
+      name = name && reifyExpression(name);
+      flags = (flags && reifyReferenceFlags(flags)) || referenceFlags;
 
       return { type, name, isArray, flags };
     }
 
     case 'BindingMatcher': {
-      let { languagePath } = node.properties;
+      let languagePath = get('languagePath', node);
 
-      languagePath = languagePath && reifyExpression(languagePath.node);
+      languagePath = languagePath && reifyExpression(languagePath);
 
       return { languagePath };
     }
@@ -376,32 +391,25 @@ export const reifyExpression = (node) => {
       return [];
 
     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 { 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 [reifyExpression(key), reifyExpression(value)];
         }),
       );
     }
 
     case 'Array': {
-      const { elements = [] } = node.properties;
-
-      return [...btree.traverse(elements.node)].map((el) => reifyExpression(el.node));
+      return [...list('elements', node)].map((el) => reifyExpression(el));
     }
 
     case 'Punctuator':
@@ -410,7 +418,7 @@ export const reifyExpression = (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

@@ -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,9 +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 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.9.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.9.0",
     "@bablr/coroutine": "0.1.0"
   },
   "devDependencies": {