@bablr/agast-helpers 0.11.3 → 0.11.4

package/lib/builders.js

@@ -1,7 +1,6 @@
 import * as BList from './b-list.js';
 import { hasOwn, isObject, isArray, isSymbol, isString, isFrozen, freezeRecord } from './object.js';
 import { buildParser, match } from './parse.js';
-import { printExpression, printTag } from './print.js';
 
 import {
   DoctypeTag,
@@ -19,7 +18,7 @@ import {
   NullNode,
   GapNode,
   TreeNode,
-  StreamTag,
+  MuxerTag,
 } from './symbols.js';
 
 export const symbolName = (name) => {
@@ -144,17 +143,15 @@ export const buildBindingTag = (type, name) => {
   return buildTag(BindingTag, buildBinding(type, name));
 };
 
-export const buildStreamTag = (processPath, stream) => {
+export const buildMuxerTag = (processPath, stream) => {
   if (stream && !(stream >= 1 && stream <= 4)) throw new Error();
 
-  return buildTag(StreamTag, { processPath, stream });
+  return buildTag(MuxerTag, { processPath, stream });
 };
 
 export const buildChild = (type, value) => {
   if (!isSymbol(type)) throw new Error();
-  let child = buildTag(type, value);
-  if (!parseTag(child)) throw new Error();
-  return child;
+  return buildTag(type, value);
 };
 
 export const buildGapTag = () => {
@@ -325,10 +322,10 @@ export const canContinueIdentifier = (chr) => {
 };
 
 export const parseTagType = (input) => {
+  if (isObject(input) && input.type) return input.type;
   let p = buildTagParser(input);
   let { str, idx } = p;
   if (str == null) return null;
-  if (isObject(str)) return str.type;
   if (!isString(str)) throw new Error();
   if (!str.length) throw new Error();
 
@@ -348,7 +345,7 @@ export const parseTagType = (input) => {
           ? GapTag
           : CloseNodeTag
         : str[idx + 1] === '-'
-        ? StreamTag
+        ? MuxerTag
         : OpenNodeTag;
     case '^':
       return ShiftTag;
@@ -373,6 +370,30 @@ export const parseTagType = (input) => {
   }
 };
 
+export const parseStreamTagType = (input) => {
+  if (isObject(input) && input.type) return input.type;
+  let p = buildTagParser(input);
+  let { str, idx } = p;
+  if (str == null) return null;
+  if (!isString(str)) throw new Error();
+  if (!str.length) throw new Error();
+
+  if (str[idx] === '<') {
+    if (str[idx + 1] === '-') {
+      if (str[idx + 2] === '-') {
+        return parseTagType(input);
+      } else {
+        return MuxerTag;
+      }
+      throw new Error('reserved syntax');
+    } else {
+      return parseTagType(input);
+    }
+  } else {
+    return parseTagType(input);
+  }
+};
+
 export const parseObject = (input) => {
   let p = buildParser(input);
   let { str } = p;
@@ -567,7 +588,7 @@ export const parseNumber = (input) => {
 
   let endIdx = p.idx;
 
-  return parseFloat(str.slice(startIdx, endIdx));
+  return parseFloat([...str.slice(startIdx, endIdx)].join(''));
 };
 
 export const parseEscape = (input) => {
@@ -760,8 +781,7 @@ let buildTagParser = (tag) => {
       return { idx: 0, str: tag };
     case 'object':
       if (tag.type) {
-        // TODO str is sometimes not a string!
-        return { idx: 0, str: typeof tag === 'string' ? tag : printTag(tag) };
+        throw new Error();
       } else {
         return tag;
       }
@@ -818,11 +838,15 @@ export const parseOpenNodeTag = (tag) => {
     while (chr === ' ') chr = str[++p.idx];
   }
 
-  let attributes = freezeRecord({});
+  let attributes = '{}';
 
   if (chr === '{') {
-    attributes = parseObject(p);
+    let startIdx = p.idx;
+    parseObject(p);
+    let endIdx = p.idx;
     chr = str[p.idx];
+    // prevent attributes causing a memory leak on the original string
+    attributes = [...str.slice(startIdx, endIdx)].join('');
 
     while (chr === ' ') chr = str[++p.idx];
   }
@@ -847,7 +871,7 @@ export const parseOpenNodeTag = (tag) => {
     name: symbolName(name),
     type: symbolName(type),
     literalValue,
-    attributes: printExpression(attributes),
+    attributes,
     selfClosing,
   });
 };
@@ -898,6 +922,14 @@ export const parseReferenceTag = (tag) => {
     chr = str[++p.idx];
   }
 
+  if (type === '.' && chr === '.') {
+    type = '..';
+    chr = str[++p.idx];
+  } else if (type === '_' && chr === '_') {
+    type = '__';
+    chr = str[++p.idx];
+  }
+
   let quotedIdent = chr === '`';
   if (!type || (type === '#' && canStartIdentifier(chr))) {
     name = parseIdentifier(p);
@@ -1061,10 +1093,14 @@ export const parseDoctypeTag = (tag) => {
     chr = str[++p.idx];
   }
 
-  let attributes = {};
+  let attributes = '{}';
+
   if (chr === '{') {
-    attributes = parseObject(p);
+    let startIdx = p.idx;
+    parseObject(p);
+    let endIdx = p.idx;
     chr = str[p.idx];
+    attributes = [...str.slice(startIdx, endIdx)].join('');
 
     while (chr === ' ') chr = str[++p.idx];
   }
@@ -1074,10 +1110,10 @@ export const parseDoctypeTag = (tag) => {
 
   if (isString(tag) && p.idx !== p.str.length) throw new Error();
 
-  return buildDoctypeTag(version, printExpression(attributes));
+  return buildDoctypeTag(version, attributes);
 };
 
-export const parseStreamTag = (tag) => {
+export const parseMuxerTag = (tag) => {
   let p = buildTagParser(tag);
   let { str } = p;
   let chr = str[p.idx];
@@ -1110,10 +1146,12 @@ export const parseStreamTag = (tag) => {
   if (chr !== '>') throw new Error();
   chr = str[++p.idx];
 
-  return buildStreamTag(processPath, stream);
+  return buildMuxerTag(processPath, stream);
 };
 
 export const parseTag = (tag) => {
+  if (isObject(tag) && tag.type === Property) return tag;
+
   let p = buildTagParser(tag);
   if (tag == null) return null;
 
@@ -1134,8 +1172,6 @@ export const parseTag = (tag) => {
       return parseLiteralTag(tag);
     case CloseNodeTag:
       return parseCloseNodeTag(tag);
-    case StreamTag:
-      return parseStreamTag(tag);
     case GapTag:
       return parseGapTag(tag);
     case NullTag:
@@ -1152,6 +1188,16 @@ export const parseTag = (tag) => {
   }
 };
 
+export const parseStreamTag = (tag) => {
+  if (isObject(tag) && tag.type === Property) return tag;
+  let p = buildTagParser(tag);
+  if (tag == null) return null;
+
+  let tagType = parseStreamTagType(p);
+
+  return tagType === MuxerTag ? parseMuxerTag(tag) : parseTag(tag);
+};
+
 export const isValidTag = (tag) => {
   if (isString(tag)) return !!parseTag(tag);
   if (!isFrozen(tag)) return false;

package/lib/path.js

@@ -210,7 +210,7 @@ export const nodeIsComplete = (node) => {
 };
 
 export const offsetForTag = (tag) => {
-  switch (parseTagType(tag)) {
+  switch (isString(tag) ? parseTagType(tag) : tag) {
     case ReferenceTag:
     case ShiftTag:
       return [0];
@@ -396,7 +396,7 @@ export const has = (path, node) => {
     path = [path];
   }
 
-  let pathArr = [...path];
+  let pathArr = [...arrayValues(path)];
   let node_ = get(pathArr.slice(0, -1), node);
   let seg = pathArr[pathArr.length - 1];
 
@@ -1005,7 +1005,10 @@ export const Path = class AgastPath {
         [
           firstTag,
           Tags.fromValues(
-            map((binding) => buildChild(BindingTag, binding), arrayValues(targetBindings)),
+            map(
+              (binding) => printTag(buildChild(BindingTag, binding)),
+              arrayValues(targetBindings),
+            ),
           ),
           value,
         ],
@@ -1128,7 +1131,10 @@ export const Path = class AgastPath {
           [
             firstTag,
             Tags.fromValues(
-              map((binding) => buildChild(BindingTag, binding), arrayValues(targetBindings)),
+              map(
+                (binding) => printTag(buildChild(BindingTag, binding)),
+                arrayValues(targetBindings),
+              ),
             ),
             value,
           ],
@@ -1249,7 +1255,7 @@ export const Path = class AgastPath {
 
     let { tags } = tagPath.value;
 
-    if (tags[1][0]?.type === ShiftTag && !tags[1][2]) {
+    if (parseTagType(tags[1][0]) === ShiftTag && !tags[1][2]) {
       return TagPath.from(tagPath.path, tagPath.tagsIndex - 1).value;
     }
 
@@ -1389,8 +1395,8 @@ export const Path = class AgastPath {
           refPath = TagPath.from(refPath.path, refPath.tagsIndex - shift.index, 0);
         }
 
-        let { 0: firstTag, 1: bindingTags = [] } = propPath.value.tags[1];
-        let tags = BList.fromValues([firstTag, Tags.from(...bindingTags, tag_)], 1);
+        let { 0: firstTag, 1: bindingTags = BList.fromValues([]) } = propPath.value.tags[1];
+        let tags = BList.fromValues([firstTag, Tags.push(tag, bindingTags)], 1);
         let property = buildChild(Property, buildProperty(tags, shift));
 
         targetPath = this.replaceWith(
@@ -1472,7 +1478,7 @@ export const Path = class AgastPath {
         if (!openTag) throw new Error();
         if (parseTag(openTag).value.selfClosing) throw new Error();
 
-        targetPath = targetPath.replaceWith(buildNode(Tags.push(tag_, getTags(node))));
+        targetPath = targetPath.replaceWith(buildNode(Tags.push(tag, getTags(node))));
         break;
       }
 
@@ -1580,7 +1586,7 @@ export const Path = class AgastPath {
         let newOpenTag = buildOpenNodeTag(flags, name, null, printObject(attributes));
 
         targetPath = this.replaceWith(
-          buildNode(Tags.push(tag_, Tags.replaceAt(0, newOpenTag, getTags(node)))),
+          buildNode(Tags.push(tag, Tags.replaceAt(0, printTag(newOpenTag), getTags(node)))),
         );
         break;
       }
@@ -1611,7 +1617,7 @@ export const Path = class AgastPath {
       case LiteralTag:
         if (typeof tag_.value !== 'string') throw new Error();
 
-        targetPath = this.replaceWith(buildNode(Tags.push(tag_, this.node.value.tags)));
+        targetPath = this.replaceWith(buildNode(Tags.push(tag, this.node.value.tags)));
         break;
 
       default:
@@ -1784,6 +1790,10 @@ export class TagPath {
     return this.path.depth;
   }
 
+  atDepth(depth) {
+    return this.path.atDepth(depth);
+  }
+
   siblingAt(index) {
     return TagPath.from(this.path, index);
   }

package/lib/print.js

@@ -10,7 +10,7 @@ import {
   LiteralTag,
   AttributeDefinition,
   BindingTag,
-  StreamTag,
+  MuxerTag,
 } from './symbols.js';
 import { parseObject } from './builders.js';
 import { arrayValues } from './iterable.js';
@@ -131,7 +131,7 @@ export const printReference = (ref) => {
   let { type, name, flags } = ref;
 
   if (type && type !== '#' && name) throw new Error();
-  if (type && !['_', '.', '#', '@'].includes(type)) throw new Error();
+  if (type && !['_', '__', '.', '..', '#', '@'].includes(type)) throw new Error();
 
   return `${type || ''}${printIdentifier(name) || ''}${printReferenceFlags(flags)}:`;
 };
@@ -253,8 +253,8 @@ export const printSelfClosingNodeTag = (tag, literalValue) => {
   return `<${printNodeFlags(flags)}${typeFrag}${nameFrag}${literalFrag}${attributesFrag} />`;
 };
 
-export const printStreamTag = (tag) => {
-  if (tag?.type !== StreamTag) throw new Error();
+export const printMuxerTag = (tag) => {
+  if (tag?.type !== MuxerTag) throw new Error();
 
   let { processPath, stream } = tag.value;
 
@@ -287,7 +287,7 @@ const printers = {
   [ReferenceTag]: printReferenceTag,
   [OpenNodeTag]: printOpenNodeTag,
   [CloseNodeTag]: printCloseNodeTag,
-  [StreamTag]: printStreamTag,
+  [MuxerTag]: printMuxerTag,
   [AttributeDefinition]: printAttributeDefinition,
 };
 
@@ -304,8 +304,8 @@ export const printIOTag = (tag) => {
   if (tag == null || isString(tag)) return tag;
   if (!isObject(tag)) throw new Error();
 
-  if (tag.type === StreamTag) {
-    return printStreamTag(tag);
+  if (tag.type === MuxerTag) {
+    return printMuxerTag(tag);
   }
   return printTag(tag);
 };

package/lib/stream.js

@@ -5,7 +5,6 @@ import {
   StreamIterable,
   StreamGenerator,
   wait,
-  createDeferred,
   continue_,
 } from '@bablr/stream-iterator';
 import * as Tags from './tags.js';
@@ -19,6 +18,7 @@ import {
   buildProperty,
   buildReference,
   parseTag,
+  parseStreamTag,
   parseTagType,
 } from './builders.js';
 import {
@@ -32,11 +32,10 @@ import {
   DoctypeTag,
   ShiftTag,
   AttributeDefinition,
-  StreamTag,
+  MuxerTag,
 } from './symbols.js';
-import { buildNode, getRoot, isGapNode, isNode, Path } from './path.js';
-import { streamFromTree } from './tree.js';
-import { freeze, isObject } from './object.js';
+import { buildNode, getRoot, isGapNode, isNode, Path, TagPath } from './path.js';
+import { freeze, isPlainObject } from './object.js';
 import { maybeWait } from './iterable.js';
 import { arrayValues } from '@bablr/record';
 import { buildParser } from './parse.js';
@@ -139,8 +138,7 @@ function* __treeFromStream(tags, options) {
 }
 
 export const treeFromStream = (tags, options = freeze({})) => {
-  let iter = new StreamGenerator(__treeFromStream(tags, options));
-  return maybeWait(iter.next(), (step) => step.value);
+  return evaluateReturn(__treeFromStream(tags, options));
 };
 
 function* __isEmpty(tags) {
@@ -280,7 +278,7 @@ export const generateCSTML = (tags, options = freeze({})) =>
   new StreamIterable(__generateCSTML(tags, options));
 
 const isToken = (tag) => {
-  return parseTag(tag).value.flags.token;
+  return tag.value.flags.token;
 };
 
 export const prettyGroupTags = (tags) => new StreamIterable(__prettyGroupTags(tags));
@@ -300,8 +298,9 @@ function* __prettyGroupTags(tags) {
     }
     if (step.done) break;
 
-    const tag = parseTag(step.value);
-    const isOpenClose = tag.type === CloseNodeTag || tag.type === OpenNodeTag;
+    let tag_ = step.value;
+    let tag = parseTag(tag_);
+    let isOpenClose = tag.type === CloseNodeTag || tag.type === OpenNodeTag;
 
     if (
       (tag.type === 'Effect' && tag.value.verb === 'write') ||
@@ -323,28 +322,28 @@ function* __prettyGroupTags(tags) {
         state.holding = [];
       }
     } else if (tag.type === LiteralTag) {
-      state.holding.push(tag);
+      state.holding.push(tag_);
     }
 
     if (!state.holding.length && !isOpenClose) {
-      yield tag;
+      yield step.value;
     }
 
     if (tag.type === CloseNodeTag) {
       if (!state.broken && (isToken(state.open) || state.holding.length === 1)) {
-        let { flags, name, attributes } = state.holding[0].value;
+        let { flags, name, attributes } = parseTag(state.holding[0]).value;
 
         let literal = state.holding
           .slice(1)
-          .map((lit) => lit.value)
+          .map((lit) => parseTag(lit).value)
           .join('');
 
-        yield buildOpenNodeTag(flags, name, literal, attributes, true);
+        yield printTag(buildOpenNodeTag(flags, name, literal, attributes, true));
       } else {
         if (state.holding.length) {
           yield* state.holding;
         }
-        yield tag;
+        yield step.value;
       }
 
       states = states.pop();
@@ -353,9 +352,9 @@ function* __prettyGroupTags(tags) {
 
     if (tag.type === OpenNodeTag) {
       if (tag.value.selfClosing) {
-        yield tag;
+        yield step.value;
       } else {
-        states = states.push({ holding: [tag], broken: false, open: tag });
+        states = states.push({ holding: [tag_], broken: false, open: tag });
 
         state = states.value;
       }
@@ -379,9 +378,9 @@ function* __transformStream(tags, stream, strategy) {
       }
       if (step.done) break;
 
-      let tag = parseTag(step.value);
+      let tag = parseStreamTag(step.value);
 
-      if (tag.type === StreamTag) {
+      if (tag.type === MuxerTag) {
         if (tag.value.stream !== stream) {
           transforming = false;
           yield continue_();
@@ -410,7 +409,7 @@ function* __transformStream(tags, stream, strategy) {
     }
     if (step.done) break;
 
-    let tag = parseTag(step.value);
+    let tag = parseStreamTag(step.value);
 
     if (transforming) {
       strategyStep = strategyIter.next();
@@ -425,8 +424,8 @@ function* __transformStream(tags, stream, strategy) {
         }
       }
       if (step.done) break;
-      tag = parseTag(step.value);
-      if (tag.type === StreamTag) {
+      tag = parseStreamTag(step.value);
+      if (tag.type === MuxerTag) {
         stream_ = tag.value.stream;
       } else {
         throw new Error();
@@ -434,7 +433,7 @@ function* __transformStream(tags, stream, strategy) {
       yield step.value;
       transforming = stream_ === stream;
     } else {
-      if (tag.type === StreamTag) {
+      if (tag.type === MuxerTag) {
         stream_ = tag.value.stream;
 
         yield step.value;
@@ -456,6 +455,85 @@ export const transformStream = (tags, stream, strategy) => {
   return new StreamIterable(__transformStream(tags, stream, strategy));
 };
 
+function* __transformStreams(tags, strategy) {
+  let iter = getStreamIterator(tags);
+  let step;
+  let str = '';
+  let streamTag = '<-1>';
+  let alreadyAdvanced = false;
+  let strategyStep;
+  let streams = new Map();
+
+  function* __streamTags(streamTag) {
+    for (;;) {
+      while (step === null || step instanceof Promise) {
+        if (step === null) yield continue_(), (step = iter.next());
+        if (step instanceof Promise) step = yield wait(step);
+      }
+      if (step.done) break;
+
+      let tag = parseStreamTag(step.value);
+
+      if (tag.type === MuxerTag) {
+        if (printTag(streamTag) !== printTag(tag)) {
+          yield continue_();
+        }
+
+        streamTag = step.value;
+      } else {
+        yield step.value;
+      }
+
+      step = iter.next();
+    }
+  }
+
+  for (;;) {
+    if (!alreadyAdvanced) {
+      step = iter.next();
+    }
+    alreadyAdvanced = false;
+    while (step === null || step instanceof Promise) {
+      if (step === null) yield continue_(), (step = iter.next());
+      if (step instanceof Promise) step = yield wait(step);
+    }
+    if (step.done) break;
+
+    let tag = parseStreamTag(step.value);
+
+    streams[streamTag] ||= getStreamIterator(
+      strategy(new StreamGenerator(__streamTags(parseStreamTag(streamTag)))),
+    );
+
+    strategyStep = streams[streamTag].next();
+
+    while (strategyStep !== null) {
+      if (strategyStep instanceof Promise) strategyStep = yield wait(strategyStep);
+      if (strategyStep) {
+        if (strategyStep.done) break;
+        yield strategyStep.value;
+
+        strategyStep = streams[streamTag].next();
+      }
+    }
+    if (step.done) break;
+    tag = parseStreamTag(step.value);
+    if (tag.type === MuxerTag) {
+      streamTag = step.value;
+
+      yield step.value;
+
+      alreadyAdvanced = true;
+    } else {
+      throw new Error();
+    }
+  }
+}
+
+export const transformStreams = (tags, strategy) => {
+  return new StreamIterable(__transformStreams(tags, strategy));
+};
+
 let pushFrame = (parent = null) => {
   let heldProperties = parent ? [...parent.heldProperties] : [];
   if (parent) {
@@ -487,16 +565,61 @@ let popFrame = (frame) => {
   return frame.parent;
 };
 
+export const streamFromTree = (tree, options = freeze({})) => {
+  if (tree && !isPlainObject(tree)) throw new Error();
+
+  return __streamFromTree(null, tree, options);
+};
+
+function* __streamFromTree(doctypeTag, rootNode, options) {
+  const { unshift = false, getGapNode, checkBalance = true } = options;
+  if (!rootNode || !Tags.getSize(Tags.getTags(rootNode))) return;
+
+  let tagPath = TagPath.fromNode(rootNode, 0);
+  let count = 0;
+  let stack = [{ tagPath, count }];
+
+  if (doctypeTag) {
+    yield doctypeTag;
+  }
+
+  do {
+    ({ tagPath, count } = stack.pop());
+    do {
+      if (tagPath.type === OpenNodeTag && !tagPath.value.selfClosing) count++;
+      if (tagPath.type === CloseNodeTag) count--;
+
+      let gapNode;
+      if (
+        getGapNode &&
+        tagPath.type === GapTag &&
+        (gapNode = getGapNode(tagPath.path.node)) &&
+        gapNode !== tagPath.path.node
+      ) {
+        stack.push({ tagPath: unshift ? tagPath.nextUnshifted : tagPath.next, count });
+        tagPath = TagPath.fromNode(gapNode, 0);
+        count = 0;
+      }
+
+      if (!(tagPath.type === AttributeDefinition)) {
+        yield tagPath.tag;
+      }
+    } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
+  } while (stack.length);
+
+  if (checkBalance && count !== 0) throw new Error();
+}
+
 function* emitHeld(frame, nextTag) {
   if (frame.ref?.flags.expression && nextTag?.type === ShiftTag) return;
 
   for (let property of frame.heldProperties) {
     let { reference, bindings, node } = property;
-    yield buildChild(ReferenceTag, reference);
+    yield printTag(buildChild(ReferenceTag, reference));
     let isAnonymous = node.value.flags.token && !node.value.name;
     if (!isAnonymous) {
       for (let binding of arrayValues(bindings)) {
-        yield buildChild(BindingTag, binding);
+        yield printTag(buildChild(BindingTag, binding));
       }
     }
     yield* streamFromTree(node);
@@ -625,11 +748,11 @@ function* __hoistTrivia(co, firstTag) {
         }
       } else if (frame && !isCover) {
         if (!frame.shifting && ((frame.ref && frame.ref.type !== '_') || frame.expanded)) {
-          yield buildChild(ReferenceTag, frame.ref);
+          yield printTag(buildChild(ReferenceTag, frame.ref));
           let isAnonymous = tag.value.flags.token && !tag.value.name;
           if (!isAnonymous) {
             for (let binding of frame.bindings) {
-              yield buildChild(BindingTag, binding);
+              yield printTag(buildChild(BindingTag, binding));
             }
           }
         }
@@ -665,15 +788,15 @@ function* __hoistTrivia(co, firstTag) {
           frame = popFrame(frame);
 
           if (!frame) {
-            yield tag;
+            yield printTag(tag);
 
             break;
           } else {
-            yield tag;
+            yield printTag(tag);
           }
         } else {
           if (!isCover || !parentFrame) {
-            yield tag;
+            yield printTag(tag);
           }
         }
       }
@@ -697,7 +820,7 @@ function* __hoistTrivia(co, firstTag) {
       frame.expanded = frame.depth === 1 && frame.coverDepth === 1;
 
       if (tag.value.type === '_' && parentFrame.expanded && parentFrame.depth) {
-        yield tag;
+        yield printTag(tag);
       }
     } else if (tag.type === ShiftTag) {
       let doneFrame = frame;
@@ -710,7 +833,7 @@ function* __hoistTrivia(co, firstTag) {
       frame.shifting = true;
       // frame.heldProperties = [...doneFrame.heldProperties];
 
-      yield tag;
+      yield printTag(tag);
     } else if (tag.type === BindingTag) {
       let { heldProperties } = frame;
       if (heldProperties.length) {
@@ -721,7 +844,7 @@ function* __hoistTrivia(co, firstTag) {
             BList.fromValues(
               [
                 tags[1][0] || Tags.fromValues([]),
-                Tags.push(tag, tags[1][1] || Tags.fromValues([])),
+                Tags.push(printTag(tag), tags[1][1] || Tags.fromValues([])),
               ],
               1,
             ),
@@ -749,33 +872,33 @@ function* __hoistTrivia(co, firstTag) {
       if (frame) {
         frame.heldProperties = [...lastFrame.heldProperties];
         if (!lastFrame?.coverDepth) {
-          yield tag;
+          yield printTag(tag);
         }
       } else {
         if (lastFrame.expanded || lastFrame.open.value.type !== Symbol.for('_')) {
-          yield tag;
+          yield printTag(tag);
         }
         break;
       }
     } else if (tag.type === GapTag || tag.type === NullTag) {
       if (frame.ref) {
-        yield buildChild(ReferenceTag, frame.ref);
+        yield printTag(buildChild(ReferenceTag, frame.ref));
       }
       lastFrame = frame;
 
       frame = popFrame(frame);
 
       if (tag.type === GapTag && frame.heldProperties.length) {
-        yield tag;
+        yield printTag(tag);
 
         frame.shifting = false;
 
         yield* emitHeld(frame, nextTag);
       } else {
-        yield tag;
+        yield printTag(tag);
       }
     } else {
-      yield tag;
+      yield printTag(tag);
     }
 
     tag = nextTag;

package/lib/symbols.js

@@ -5,7 +5,7 @@ export const ReferenceTag = Symbol.for('ReferenceTag');
 export const ShiftTag = Symbol.for('ShiftTag');
 export const GapTag = Symbol.for('GapTag');
 export const BindingTag = Symbol.for('BindingTag');
-export const StreamTag = Symbol.for('StreamTag');
+export const MuxerTag = Symbol.for('MuxerTag');
 export const NullTag = Symbol.for('NullTag');
 export const AttributeDefinition = Symbol.for('AttributeDefinition');
 export const LiteralTag = Symbol.for('LiteralTag');

package/lib/tags.js

@@ -273,6 +273,7 @@ export const sumValues = (values, depth) => {
     types: freezeRecord(
       [...mapStats.types.values()].sort((a, b) => compareNames(a[0], b[0])).flatMap((_) => _),
     ),
+    hashes: null,
   });
   return stats;
 };

package/lib/tree.js

@@ -1,10 +1,7 @@
 import {
   buildOpenNodeTag,
-  buildCloseNodeTag,
   tokenFlags,
   buildChild,
-  buildGapTag,
-  buildOpenFragmentTag,
   buildReference,
   parseTagType,
   parseTag,
@@ -17,6 +14,7 @@ import {
   evaluateReturn,
   printOpenNodeTag,
   streamFromString,
+  streamFromTree,
 } from './stream.js';
 import {
   OpenNodeTag,
@@ -24,13 +22,8 @@ import {
   ReferenceTag,
   GapTag,
   LiteralTag,
-  AttributeDefinition,
   BindingTag,
-  ShiftTag,
   Property,
-  NullNode,
-  TreeNode,
-  GapNode,
 } from './symbols.js';
 import * as Tags from './tags.js';
 export * from './builders.js';
@@ -40,7 +33,6 @@ import {
   getOr,
   has,
   list,
-  TagPath,
   isCover,
   isNullNode,
   isGapNode,
@@ -48,7 +40,7 @@ import {
   getCloseNodeTag,
   getRoot,
 } from './path.js';
-import { freeze, freezeRecord, isPlainObject } from './object.js';
+import { freeze, freezeRecord } from './object.js';
 
 export {
   get,
@@ -136,149 +128,6 @@ export const isEmpty = (node) => {
   return true;
 };
 
-export const streamFromTree = (tree, options = freeze({})) => {
-  if (tree && !isPlainObject(tree)) throw new Error();
-
-  return __streamFromTree(null, tree, options);
-};
-
-function* __streamFromTree(doctypeTag, rootNode, options) {
-  const { unshift = false, getGapNode, checkBalance = true } = options;
-  if (!rootNode || !Tags.getSize(getTags(rootNode))) return;
-
-  let tagPath = TagPath.fromNode(rootNode, 0);
-  let count = 0;
-  let stack = [{ tagPath, count }];
-
-  if (doctypeTag) {
-    yield doctypeTag;
-  }
-
-  do {
-    ({ tagPath, count } = stack.pop());
-    do {
-      if (tagPath.type === OpenNodeTag && !tagPath.value.selfClosing) count++;
-      if (tagPath.type === CloseNodeTag) count--;
-
-      let gapNode;
-      if (
-        getGapNode &&
-        tagPath.type === GapTag &&
-        (gapNode = getGapNode(tagPath.path.node)) &&
-        gapNode !== tagPath.path.node
-      ) {
-        stack.push({ tagPath: unshift ? tagPath.nextUnshifted : tagPath.next, count });
-        tagPath = TagPath.fromNode(gapNode, 0);
-        count = 0;
-      }
-
-      if (!(tagPath.type === AttributeDefinition)) {
-        yield tagPath.tag;
-      }
-    } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
-  } while (stack.length);
-
-  if (checkBalance && count !== 0) throw new Error();
-}
-
-export const vcsStreamFromTree = (rootNode) => {
-  return __vcsStreamFromTree(rootNode);
-};
-
-function* __vcsStreamFromTree(rootNode) {
-  let stack = null;
-  let agastNode = rootNode;
-  let depth = 0;
-  let nodeShifted = false;
-  let i = 0;
-  let seenFirstProperty = false;
-  let node = Tags.getValues(rootNode.value.tags);
-
-  outer: while (node) {
-    while (i >= node.length) {
-      if (stack) {
-        let oldAgastNode = agastNode;
-        let hadSeenFirst = seenFirstProperty;
-        ({ stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty } = stack);
-        if (oldAgastNode === agastNode) {
-          seenFirstProperty = hadSeenFirst;
-          yield buildCloseNodeTag();
-        }
-
-        i++;
-      } else {
-        return;
-      }
-    }
-
-    let child = node[i];
-
-    if (isArray(child)) {
-      stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty };
-
-      yield buildOpenFragmentTag();
-
-      node = Tags.getValues(child);
-      depth++;
-      i = 0;
-    } else {
-      let wrappedTag = child;
-
-      let wrappedType = parseTagType(wrappedTag);
-
-      if (wrappedType === Property) {
-        for (let tag of wrappedTag.value.tags) {
-          let tagType = parseTagType(tag);
-          switch (tagType) {
-            case TreeNode:
-            case NullNode:
-            case GapNode: {
-              let replaceWithGap = nodeShifted && !seenFirstProperty;
-
-              if (replaceWithGap) {
-                yield buildGapTag();
-
-                seenFirstProperty = true;
-
-                break;
-              } else {
-                stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty: true };
-                node = Tags.getValues(tag.value.tags);
-
-                depth++;
-                i = 0;
-                agastNode = tag;
-                nodeShifted = wrappedTag.value.tags[0].type === ShiftTag;
-                seenFirstProperty = false;
-                continue outer;
-              }
-            }
-
-            default: {
-              yield tag;
-
-              if (tagType === OpenNodeTag && parseTag(tag).value.literalValue) {
-                ({ stack, agastNode, node, depth, i, nodeShifted } = stack);
-                seenFirstProperty = true;
-              }
-
-              break;
-            }
-          }
-        }
-      } else {
-        yield wrappedTag;
-
-        if (wrappedType === OpenNodeTag && wrappedTag.value.literalValue) {
-          ({ stack, agastNode, node, depth, i, nodeShifted } = stack);
-          seenFirstProperty = true;
-        }
-      }
-      i++;
-    }
-  }
-}
-
 export const getCooked = (cookable) => {
   if (!cookable || isGapNode(cookable)) {
     return '';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-helpers",
   "description": "Helper functions for working with agAST trees",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [