@bablr/agast-vm-helpers 0.9.0 → 0.10.1

package/lib/builders.js

@@ -1,9 +1,21 @@
-import { Node, Matcher, Regex, Tag, EmbeddedObject, Instruction } 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) });
 };
@@ -13,11 +25,6 @@ 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: Matcher, value: matcher });
@@ -38,6 +45,11 @@ export const buildEmbeddedTag = (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) => {
   return freeze({ type: 'Effect', value });
 };

package/lib/deembed.js

@@ -1,4 +1,4 @@
-import { Node, EmbeddedObject, Tag, Matcher, Regex, Instruction } from './symbols.js';
+import { EmbeddedObject, Tag, Matcher, Regex, Instruction } from './symbols.js';
 
 export const getEmbeddedObject = (expr) => {
   if (!expr) return expr;
@@ -6,12 +6,6 @@ export const getEmbeddedObject = (expr) => {
   return expr.value;
 };
 
-export const getEmbeddedNode = (expr) => {
-  if (!expr) return expr;
-  if (expr.type !== Node) throw new Error();
-  return expr.value;
-};
-
 export const getEmbeddedMatcher = (expr) => {
   if (!expr) return expr;
   if (expr.type !== Matcher) throw new Error();

package/lib/index.js

@@ -3,46 +3,40 @@ import {
   getCooked,
   isNull,
   isNullNode,
-  buildStubNode,
-  isFragmentNode,
+  isCover,
   buildReferenceTag,
   getRoot,
-  buildChild,
   get,
   list,
-  buildBounds,
 } from '@bablr/agast-helpers/tree';
 import * as Tags from '@bablr/agast-helpers/tags';
 import {
   buildGapTag,
   buildNullTag,
   buildOpenNodeTag,
-  buildBindingTag,
-  buildInitializerTag,
   buildShiftTag,
   buildCloseNodeTag,
   buildLiteralTag,
   buildDoctypeTag,
-  referenceFlags,
-  buildProperty,
-  fragmentFlags,
-  buildBinding,
   buildAttributeDefinition,
-  buildPropertyWrapper,
+  nodeFlags,
+  referenceFlags,
+  buildBindingTag,
+  buildDocument,
+  buildPropertyTag,
+  tokenFlags,
+  buildFullOpenNodeTag,
 } 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';
+import { buildNode, getFlags, getTags } from '@bablr/agast-helpers/path';
 
 const { freeze } = Object;
 
@@ -50,6 +44,7 @@ export const effectsFor = (verb) => {
   switch (verb) {
     case 'eat':
     case 'shift':
+    case 'eatHeld':
       return { success: 'eat', failure: 'fail' };
 
     case 'eatMatch':
@@ -67,45 +62,57 @@ 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 reifyNodeFlags = (flags) => {
-  let tokenToken = get('tokenToken', flags);
-  let hasGapToken = get('hasGapToken', flags);
-  let fragmentToken = get('fragmentToken', flags);
-  let multiFragmentToken = get('multiFragmentToken', flags);
+export const reifyMatcherReferenceName = (matcher) => {
+  if (matcher == null) return null;
+  return reifyExpression(get(['refMatcher', 'name'], matcher.value));
+};
 
-  let token = !!(tokenToken && reifyExpression(tokenToken));
-  let hasGap = !!(hasGapToken && reifyExpression(hasGapToken));
-  let fragment = !!(fragmentToken && reifyExpression(fragmentToken));
-  let cover = !!(fragment && !(multiFragmentToken && reifyExpression(multiFragmentToken)));
+export const reifyNodeFlags = (flags) => {
+  let { token, hasGap } = flags.value.attributes;
 
-  return { token, hasGap, fragment, cover };
+  return {
+    token,
+    hasGap,
+  };
 };
 
 export const reifyReferenceFlags = (flags) => {
+  let arrayToken = get('arrayToken', flags);
   let expressionToken = get('expressionToken', flags);
+  let intrinsicToken = get('intrinsicToken', flags);
   let hasGapToken = get('hasGapToken', flags);
 
-  return {
-    expression: !!(expressionToken && reifyExpression(expressionToken)),
-    hasGap: !!(hasGapToken && reifyExpression(hasGapToken)),
-  };
+  return freeze({
+    array: !!reifyExpression(arrayToken),
+    expression: !!reifyExpression(expressionToken),
+    intrinsic: !!reifyExpression(intrinsicToken),
+    hasGap: !!reifyExpression(hasGapToken),
+  });
 };
 
 export const buildTags = (node) => {
-  let open = get('open', node);
+  let open = get('openTag', node);
 
-  let children = buildChildren(list('children', node));
   let openTag = reifyExpression(open);
+  let children = buildChildren(list('children', node));
   let closeTag = buildCloseNodeTag();
 
-  let literalValue = reifyExpression(get('literalValue', open));
-
-  if (literalValue) {
-    children = Tags.fromValues([buildLiteralTag(literalValue)]);
+  if (openTag.value.selfClosing) {
+    return Tags.fromValues([openTag]);
   }
 
   return Tags.fromValues([openTag, children, closeTag]);
@@ -115,51 +122,36 @@ export const buildChildren = (children) => {
   let built = Tags.fromValues([]);
 
   for (const child of children) {
-    if ([AttributeDefinition, LiteralTag].includes(child.type)) {
+    if ([AttributeDefinition, LiteralTag].includes(child.value.name)) {
       built = Tags.push(built, reifyExpression(child));
       continue;
     }
 
-    if (child.type !== Symbol.for('Property')) throw new Error('umimplemented');
+    if (child.value.name !== Symbol.for('Property')) throw new Error('umimplemented');
 
-    let reference = get('reference', child);
-    let binding = get('binding', child);
-    let value = get('value', child);
+    let reference = get('referenceTag', child);
+    let boundNode = reifyExpression(get('value', child));
+    let { node, bindingTags } = boundNode;
 
-    let referenceTag = reference ? reifyExpression(reference) : buildReferenceTag('.');
-    let bindingTag = binding
-      ? reifyExpression(binding)
-      : buildBindingTag(isStubNode(value) ? null : []);
+    let bindings = bindingTags.map((tag) => tag.value);
 
-    value = reifyExpression(value);
+    let referenceTag =
+      reference && !isNullNode(reference) ? reifyExpression(reference) : buildReferenceTag();
 
-    if (referenceTag.value.type === '_') {
-      for (let child of Tags.traverse(value.tags)) {
-        if (![OpenNodeTag, CloseNodeTag].includes(child.type)) built = Tags.push(built, child);
+    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;
     }
 
-    if (value.type === NullTag || value.type === GapTag) {
-      value = buildStubNode(value);
+    if (node.value.name === NullTag || node.value.name === GapTag) {
+      throw new Error('not implemented');
+      node = buildNode(node);
     }
 
-    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,
-          ),
-        ),
-      );
-    }
+    built = Tags.push(built, buildPropertyTag([referenceTag, bindingTags, node]));
   }
 
   return built;
@@ -171,43 +163,47 @@ 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 = get('doctype', node);
-      let tree = get('tree', node);
+      let tree = get(['tree', 'node'], node);
 
-      doctype = reifyExpression(doctype);
       tree = reifyExpression(tree);
 
-      let { attributes } = doctype.value;
+      let doctypeTag = null;
 
-      return Object.freeze({
-        flags: fragmentFlags,
-        type: null,
-        bounds: tree.bounds,
-        tags: tree.tags,
-        attributes,
-      });
+      return buildDocument(doctypeTag, tree);
     }
 
-    case 'Node': {
-      let open = get('open', node);
+    case 'TreeNode': {
+      let open = get('openTag', node);
 
       let openTag = reifyExpression(open);
 
-      let { flags, type, attributes } = openTag.value;
-
-      return Object.freeze({
-        flags,
-        type,
-        bounds: buildBounds(),
-        tags: buildTags(node),
-        attributes,
-      });
+      let { flags, name, attributes, literalValue } = openTag.value;
+
+      if (literalValue && !flags.token) {
+        let tokenFragment = buildNode(
+          Tags.fromValues([buildOpenNodeTag(tokenFlags, null, literalValue, {}, true)]),
+        );
+
+        return buildNode(
+          Tags.fromValues([
+            buildOpenNodeTag(flags, name, null, attributes),
+            Tags.fromValues([buildPropertyTag([buildReferenceTag('_'), [], tokenFragment])]),
+            buildCloseNodeTag(),
+          ]),
+        );
+      } else {
+        return buildNode(buildTags(node));
+      }
     }
 
     case 'DoctypeTag': {
@@ -223,17 +219,13 @@ export const reifyExpression = (node) => {
     case 'ReferenceTag': {
       let type = get('type', node);
       let name = get('name', node);
-      let arrayOperatorToken = get('arrayOperatorToken', node);
       let flags = get('flags', node);
 
-      name = name && reifyExpression(name);
+      name = name && (reifyExpression(name) || null);
       type = type && reifyExpression(type);
-      flags = freeze({
-        expression: !!(flags && get('expressionToken', flags)),
-        hasGap: !!(flags && get('hasGapToken', flags)),
-      });
+      flags = (flags && reifyReferenceFlags(flags)) || undefined;
 
-      return buildReferenceTag(type, name, !isNull(arrayOperatorToken), flags);
+      return buildReferenceTag(type, name, flags);
     }
 
     case 'LiteralTag': {
@@ -245,29 +237,61 @@ export const reifyExpression = (node) => {
     }
 
     case 'IdentifierPath': {
-      return [...list('segments', node)].map((segment) => reifyExpression(segment));
+      return freeze(
+        [...list('segments', node)].map((segment) =>
+          freeze({ type: null, name: reifyExpression(segment) }),
+        ),
+      );
     }
 
     case 'AttributeDefinition': {
-      let path = get('path', node);
+      let key = get('key', node);
       let value = get('value', node);
 
-      path = path && reifyExpression(path);
+      key = key && reifyExpression(key).map((segment) => segment.name);
       value = value && reifyExpression(value);
 
-      return buildAttributeDefinition(path, value);
+      return buildAttributeDefinition(key, value);
+    }
+
+    case 'NodeFlags': {
+      return reifyNodeFlags(node);
+    }
+
+    case 'ReferenceFlags': {
+      return reifyReferenceFlags(node);
     }
 
     case 'OpenNodeTag': {
       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);
+      if (!openToken) {
+        if (!literalValue) throw new Error();
+
+        return buildOpenNodeTag(tokenFlags, null, literalValue, {});
+      }
+
+      let anonymousToken = !openToken;
+
+      flags = anonymousToken ? tokenFlags : (flags && reifyNodeFlags(flags)) || nodeFlags;
       type = reifyExpression(type);
-      attributes = reifyExpression(attributes);
+      name = reifyExpression(name);
+      attributes = reifyExpression(attributes) || {};
+      selfClosing = !!reifyExpression(selfClosing);
+
+      // if (literalValue && !flags.token) {
+      //   return buildOpenNodeTag(tokenFlags, null, literalValue, {}, true);
+      // }
 
-      return buildOpenNodeTag(flags, type, attributes);
+      return buildFullOpenNodeTag(flags, type, name, literalValue, attributes, selfClosing);
     }
 
     case 'CloseNodeTag': {
@@ -282,24 +306,17 @@ export const reifyExpression = (node) => {
       return getCooked(get('sign', node)) === '-' ? -Infinity : Infinity;
     }
 
-    case 'Punctuator': {
-      return getCooked(node);
-    }
-
     case 'GapTag':
       return buildGapTag();
 
-    case 'InitializerTag':
-      return buildInitializerTag();
-
-    case 'BindingTag':
-      let languagePath = get('languagePath', node);
-
-      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();
 
@@ -314,88 +331,132 @@ export const reifyExpression = (node) => {
       return buildEmbeddedRegex(get('content', node));
     }
 
-    case 'OpenNodeMatcher': {
+    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)) || {};
-      type =
-        type.type === Symbol.for('String')
-          ? getCooked(get('content', type))
-          : reifyExpression(type);
+      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 { flags, type, literalValue, attributes };
+      return freeze({
+        flags,
+        type,
+        name,
+        literalValue,
+        attributes,
+      });
     }
 
-    case 'FragmentMatcher': {
-      let flags = get('flags', node);
+    case 'TreeNodeMatcher': {
+      let open = reifyExpression(get('open', node));
 
-      flags = (flags && reifyNodeFlags(flags)) || {};
-
-      return {
-        flags,
-        type: Symbol.for('@bablr/fragment'),
-        literalValue: null,
-        attributes: null,
-      };
-    }
+      if (!open) {
+        return [...list('children', node)].map(reifyExpression)[0];
+      }
 
-    case 'BasicNodeMatcher': {
-      return reifyExpression(get('open', node));
+      return open;
     }
 
     case 'PropertyMatcher': {
       let refMatcher = get('refMatcher', node);
-      let bindingMatcher = get('bindingMatcher', node);
-      let nodeMatcher = get('nodeMatcher', node);
+      let boundMatcher = get('valueMatcher', node);
+
+      refMatcher = reifyExpression(refMatcher);
 
-      refMatcher = refMatcher ? reifyExpression(refMatcher) : null;
-      bindingMatcher = bindingMatcher ? reifyExpression(bindingMatcher) : null;
-      nodeMatcher = reifyExpression(nodeMatcher);
+      if (!boundMatcher) throw new Error();
 
-      return { refMatcher, bindingMatcher, nodeMatcher };
+      if (boundMatcher.value.name !== Symbol.for('BoundNodeMatcher')) throw new Error();
+
+      let { nodeMatcher, bindingMatchers } = reifyExpression(boundMatcher);
+
+      return freeze({ refMatcher, bindingMatchers, nodeMatcher });
     }
 
     case 'ReferenceMatcher': {
       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 };
+      return freeze({ type, name, flags });
     }
 
-    case 'BindingMatcher': {
-      let languagePath = get('languagePath', node);
+    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 });
+    }
+
+    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 freeze({ bindingTags, node: node_ });
+    }
+
+    case 'BindingTag': {
+      let segments = [...list('segments', node)].map((segment) => {
+        return reifyExpression(segment);
+      });
+      return buildBindingTag(segments);
+    }
 
-      languagePath = languagePath && reifyExpression(languagePath);
+    case 'BindingSegment': {
+      let path = get('path', node);
 
-      return { languagePath };
+      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 segments = [...list('segments', node)].map((segment) => reifyExpression(segment));
+
+      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 = get('verb', node);
 
       const args = [...list('arguments', node)].map((el) => reifyExpression(el));
 
-      return { verb: reifyExpression(verb), arguments: args };
+      return freeze({ verb: reifyExpression(verb), arguments: args });
     }
 
     case 'Object': {
@@ -403,16 +464,15 @@ export const reifyExpression = (node) => {
         [...list('properties', node)].map((property) => {
           const key = get('key', property);
           const value = get('value', property);
-          return [reifyExpression(key), reifyExpression(value)];
+          return freeze([reifyExpression(key), reifyExpression(value)]);
         }),
       );
     }
 
     case 'Array': {
-      return [...list('elements', node)].map((el) => reifyExpression(el));
+      return freeze([...list('elements', node)].map((el) => reifyExpression(el)));
     }
 
-    case 'Punctuator':
     case 'Keyword':
       return getCooked(node);
 

package/lib/print.js

@@ -2,14 +2,28 @@ import {
   printSource,
   printTag,
   printExpression as printExpression_,
+  printCSTML,
 } from '@bablr/agast-helpers/tree';
-import { Node, Tag, EmbeddedObject, Matcher, Regex, Instruction } from './symbols.js';
+import {
+  Tag,
+  EmbeddedObject,
+  Matcher,
+  Regex,
+  Instruction,
+  TreeNode,
+  NullNode,
+  GapNode,
+  Node,
+} from './symbols.js';
 
 export const printEmbedded = (value) => {
   switch (value.type) {
     case Tag:
       return `t\`${printTag(value.value)}\``;
 
+    case Node:
+      return `n\`${printCSTML(value.value)}\``;
+
     case Matcher:
       return `m\`${printSource(value.value)}\``;
 
@@ -23,12 +37,17 @@ export const printEmbedded = (value) => {
       return printObject(value.value);
     }
 
-    case Node: {
-      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,6 +1,5 @@
 import { Coroutine } from '@bablr/coroutine';
 import {
-  InitializerTag,
   CloseNodeTag,
   EmbeddedObject,
   GapTag,
@@ -11,11 +10,12 @@ import {
 import {
   getStreamIterator,
   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();
@@ -29,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;
 
@@ -58,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;
 
@@ -99,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;
 
@@ -134,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;
@@ -143,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;
 
@@ -174,7 +174,6 @@ function* __writePrettyCSTMLStrategy(tags, options) {
       ref &&
       (tag.type === NullTag ||
         tag.type === GapTag ||
-        tag.type === InitializerTag ||
         (tag.type === OpenNodeTag && tag.value.selfClosing));
 
     if (!first && !inline) {
@@ -203,7 +202,7 @@ function* __writePrettyCSTMLStrategy(tags, options) {
       ref = tag;
     }
 
-    if (tag.type === OpenNodeTag && !tag.value.literalValue) {
+    if (tag.type === OpenNodeTag && !tag.value.selfClosing) {
       indentLevel++;
     }
 

package/lib/symbols.js

@@ -1,8 +1,5 @@
 export * from '@bablr/agast-helpers/symbols';
 
-export const node = Symbol.for('@bablr/node');
-export const fragment = Symbol.for('@bablr/fragment');
-
 export const Instruction = Symbol.for('Instruction');
 export const Matcher = Symbol.for('Matcher');
 export const Regex = Symbol.for('Regex');

package/package.json

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