@bablr/agast-helpers 0.4.0 → 0.5.1

package/lib/builders.js

@@ -4,6 +4,8 @@ import {
   DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
+  OpenFragmentTag,
+  CloseFragmentTag,
   ReferenceTag,
   ShiftTag,
   GapTag,
@@ -17,9 +19,26 @@ import {
 } from './symbols.js';
 
 const { freeze } = Object;
+const { isArray } = Array;
 
 const isObject = (val) => val !== null && typeof value !== 'object';
 
+function* relatedNodes(properties) {
+  for (const value of Object.values(properties)) {
+    if (isArray(value)) {
+      yield* btree.traverse(value);
+    } else {
+      yield value;
+    }
+  }
+}
+
+const find = (predicate, iterable) => {
+  for (const value of iterable) {
+    if (predicate(value)) return value;
+  }
+};
+
 export const buildEmbeddedExpression = (expr) => {
   if (!isObject(expr)) return expr;
   return freeze({ type: EmbeddedExpression, value: expr });
@@ -35,32 +54,28 @@ export const buildEffect = (value) => {
 
 export const buildWriteEffect = (text, options = {}) => {
   return buildEffect(
-    buildEmbeddedExpression(
-      freeze({
-        verb: 'write',
-        value: buildEmbeddedExpression(
-          freeze({ text, options: buildEmbeddedExpression(freeze(options)) }),
-        ),
-      }),
-    ),
+    freeze({
+      verb: 'write',
+      value: buildEmbeddedExpression(
+        freeze({ text, options: buildEmbeddedExpression(freeze(options)) }),
+      ),
+    }),
   );
 };
 
 export const buildAnsiPushEffect = (spans = '') => {
   return buildEffect(
-    buildEmbeddedExpression(
-      freeze({
-        verb: 'ansi-push',
-        value: buildEmbeddedExpression(
-          freeze({ spans: spans === '' ? freeze([]) : freeze(spans.split(' ')) }),
-        ),
-      }),
-    ),
+    freeze({
+      verb: 'ansi-push',
+      value: buildEmbeddedExpression(
+        freeze({ spans: spans === '' ? freeze([]) : freeze(spans.split(' ')) }),
+      ),
+    }),
   );
 };
 
 export const buildAnsiPopEffect = () => {
-  return buildEffect(buildEmbeddedExpression(freeze({ verb: 'ansi-pop', value: undefined })));
+  return buildEffect(freeze({ verb: 'ansi-pop', value: undefined }));
 };
 
 export const buildTokenGroup = (tokens) => {
@@ -75,8 +90,8 @@ export const buildBeginningOfStreamToken = () => {
   return freeze({ type: Symbol.for('@bablr/beginning-of-stream'), value: undefined });
 };
 
-export const buildReferenceTag = (name, isArray = false) => {
-  return freeze({ type: ReferenceTag, value: freeze({ name, isArray }) });
+export const buildReferenceTag = (name, isArray = false, hasGap = false) => {
+  return freeze({ type: ReferenceTag, value: freeze({ name, isArray, hasGap }) });
 };
 
 export const buildNullTag = () => {
@@ -99,7 +114,7 @@ export const buildEmbeddedNode = (node) => {
   return freeze({ type: EmbeddedNode, value: node });
 };
 
-export const buildDoctypeTag = (attributes) => {
+export const buildDoctypeTag = (attributes = {}) => {
   return freeze({
     type: DoctypeTag,
     value: { doctype: 'cstml', version: 0, attributes: freeze(attributes) },
@@ -107,18 +122,10 @@ export const buildDoctypeTag = (attributes) => {
 };
 
 export const buildNodeOpenTag = (flags = {}, language = null, type = null, attributes = {}) => {
-  let { token, trivia, escape, expression, intrinsic } = flags;
-
-  token = !!token;
-  trivia = !!trivia;
-  escape = !!escape;
-  expression = !!expression;
-  intrinsic = !!intrinsic;
-
   return freeze({
     type: OpenNodeTag,
     value: freeze({
-      flags: freeze({ token, trivia, escape, intrinsic, expression }),
+      flags: freeze(flags),
       language,
       type,
       attributes,
@@ -130,6 +137,23 @@ export const buildNodeCloseTag = (type = null, language = null) => {
   return freeze({ type: CloseNodeTag, value: freeze({ language, type }) });
 };
 
+export const buildFragmentOpenTag = (flags = {}) => {
+  return freeze({
+    type: OpenFragmentTag,
+    value: freeze({
+      flags: freeze(flags),
+    }),
+  });
+};
+
+export const buildFragmentCloseTag = (type = null, language = null) => {
+  return freeze({ type: CloseFragmentTag, value: freeze({ language, type }) });
+};
+
+export const wrapFragment = (node) => {
+  return buildFragment([buildReferenceTag('.')], { '.': node });
+};
+
 const isString = (val) => typeof val === 'string';
 
 export const buildLiteralTag = (value) => {
@@ -145,7 +169,7 @@ export const buildNodeWithFlags = (
   properties = {},
   attributes = {},
 ) => {
-  const openTag = buildNodeOpenTag(nodeFlags, language, type, attributes);
+  const openTag = buildNodeOpenTag(flags, language, type, attributes);
   const closeTag = buildNodeCloseTag(type);
 
   return freeze({
@@ -158,61 +182,84 @@ export const buildNodeWithFlags = (
   });
 };
 
+const flagsWithGap = new WeakMap();
+
+export const getFlagsWithGap = (flags) => flagsWithGap.get(flags);
+
 export const nodeFlags = freeze({
   token: false,
   escape: false,
   trivia: false,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
+const hasGap = (flags, children, properties) => {
+  return find((node) => node.flags.hasGap, relatedNodes(properties));
+};
+
+const getGapFlags = (flags) => {
+  let gapFlags = flagsWithGap.get(flags);
+  if (!gapFlags) {
+    gapFlags = { ...flags, hasGap: true };
+    flagsWithGap.set(flags, gapFlags);
+  }
+  return gapFlags;
+};
+
+const getFlags = (flags, children, properties) => {
+  if (!hasGap(flags, children, properties)) {
+    return flags;
+  } else {
+    return getGapFlags(flags);
+  }
+};
+
 export const buildNode = (language, type, children = [], properties = {}, attributes = {}) => {
-  return buildNodeWithFlags(nodeFlags, language, type, children, properties, attributes);
+  const flags = getFlags(nodeFlags, children, properties);
+  return buildNodeWithFlags(flags, language, type, children, properties, attributes);
 };
 
-export const syntacticFlags = freeze({
-  token: true,
-  escape: false,
-  trivia: false,
-  intrinsic: false,
-  expression: false,
-});
+export const buildFragmentWithFlags = (flags, children = [], properties = {}, attributes = {}) => {
+  const doctypeTag = buildDoctypeTag(attributes);
+  const openTag = buildFragmentOpenTag(flags);
+  const closeTag = buildFragmentCloseTag();
 
-export const buildSyntacticNode = (language, type, value, attributes = {}) => {
-  return buildNodeWithFlags(
-    syntacticFlags,
-    language,
-    type,
-    [buildLiteralTag(value)],
-    {},
-    attributes,
-  );
+  return freeze({
+    flags,
+    children: btree.addAt(
+      0,
+      btree.addAt(0, btree.addAt(btree.getSum(children), children, closeTag), openTag),
+      doctypeTag,
+    ),
+    properties: freeze(properties),
+    attributes: freeze(attributes),
+  });
+};
+
+export const buildFragment = (children = [], properties = {}, attributes = {}) => {
+  const flags = getFlags(nodeFlags, children, properties);
+  return buildFragmentWithFlags(flags, children, properties, attributes);
 };
 
-export const syntacticIntrinsicFlags = freeze({
+export const syntacticFlags = freeze({
   token: true,
   escape: false,
   trivia: false,
-  intrinsic: true,
   expression: false,
+  hasGap: false,
 });
-export const buildSyntacticIntrinsicNode = (language, type, value, attributes = {}) => {
-  return buildNodeWithFlags(
-    syntacticIntrinsicFlags,
-    language,
-    type,
-    [buildLiteralTag(value)],
-    {},
-    attributes,
-  );
+
+export const buildSyntacticNode = (language, type, value) => {
+  return buildNodeWithFlags(syntacticFlags, language, type, [buildLiteralTag(value)]);
 };
 
 export const escapeFlags = freeze({
   token: false,
   escape: true,
   trivia: false,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
 export const buildEscapeNode = (
@@ -222,15 +269,16 @@ export const buildEscapeNode = (
   properties = {},
   attributes = {},
 ) => {
-  return buildNodeWithFlags(escapeFlags, language, type, children, properties, attributes);
+  const flags = getFlags(escapeFlags, children, properties);
+  return buildNodeWithFlags(flags, language, type, children, properties, attributes);
 };
 
 export const syntacticEscapeFlags = freeze({
   token: true,
   escape: true,
   trivia: false,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
 export const buildSyntacticEscapeNode = (
@@ -247,8 +295,8 @@ export const syntacticTriviaFlags = freeze({
   token: true,
   escape: false,
   trivia: true,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
 export const buildSyntacticTriviaNode = (
@@ -265,8 +313,8 @@ export const triviaFlags = freeze({
   token: false,
   escape: false,
   trivia: true,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
 export const buildTriviaNode = (
@@ -276,7 +324,8 @@ export const buildTriviaNode = (
   properties = {},
   attributes = {},
 ) => {
-  return buildNodeWithFlags(triviaFlags, language, type, children, properties, attributes);
+  const flags = getFlags(triviaFlags, children, properties);
+  return buildNodeWithFlags(flags, language, type, children, properties, attributes);
 };
 
 export const buildNullNode = (nullToken = buildNullTag()) => {
@@ -292,7 +341,7 @@ export const buildNullNode = (nullToken = buildNullTag()) => {
 
 export const buildGapNode = (gapToken = buildGapTag()) => {
   return freeze({
-    flags: nodeFlags,
+    flags: getGapFlags(nodeFlags),
     language: null,
     type: sym.gap,
     children: btree.freeze([gapToken]),

package/lib/path.js

@@ -1,16 +1,26 @@
 export const parsePath = (str) => {
-  const isArray = str.endsWith('[]');
-  const name = isArray ? str.slice(0, -2) : str;
+  let name = str;
+  const hasGap = name.endsWith('$');
 
-  if (!/^[a-zA-Z]+$/.test(name)) throw new Error();
+  if (hasGap) name = name.slice(0, -1);
 
-  return { name, isArray };
+  const isArray = name.endsWith('[]');
+
+  if (isArray) name = name.slice(0, -2);
+
+  if (!/^(\.|[a-zA-Z]+)$/.test(name)) throw new Error();
+
+  const isRoot = name === '.';
+
+  return { name, hasGap, isArray, isRoot };
 };
 
 export const printPath = (path) => {
   if (!path) return null;
 
-  const { isArray, name } = path;
+  const { isArray, isRoot, hasGap, name } = path;
+
+  if (isRoot && name !== '.') throw new Error();
 
-  return `${name}${isArray ? '[]' : ''}`;
+  return `${name}${isArray ? '[]' : ''}${hasGap ? '$' : ''}`;
 };

package/lib/print.js

@@ -2,6 +2,8 @@ import {
   DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
+  OpenFragmentTag,
+  CloseFragmentTag,
   ReferenceTag,
   ShiftTag,
   GapTag,
@@ -151,10 +153,11 @@ export const printShiftTag = (tag) => {
 export const printReferenceTag = (tag) => {
   if (tag?.type !== ReferenceTag) throw new Error();
 
-  const { name, isArray } = tag.value;
+  const { name, isArray, hasGap } = tag.value;
   const pathBraces = isArray ? '[]' : '';
+  const gapDollar = hasGap ? '$' : '';
 
-  return `${name}${pathBraces}:`;
+  return `${name}${pathBraces}${gapDollar}:`;
 };
 
 export const printNullTag = (tag) => {
@@ -192,14 +195,14 @@ export const printLiteralTag = (tag) => {
 
 export const printFlags = (flags) => {
   const hash = flags.trivia ? '#' : '';
-  const tilde = flags.intrinsic ? '~' : '';
   const star = flags.token ? '*' : '';
   const at = flags.escape ? '@' : '';
   const plus = flags.expression ? '+' : '';
+  const dollar = flags.hasGap ? '$' : '';
 
   if (flags.escape && flags.trivia) throw new Error('Node cannot be escape and trivia');
 
-  return `${hash}${tilde}${star}${at}${plus}`;
+  return `${hash}${star}${at}${plus}${dollar}`;
 };
 
 export const printOpenNodeTag = (tag) => {
@@ -213,6 +216,14 @@ export const printOpenNodeTag = (tag) => {
   return `<${printFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
 };
 
+export const printOpenFragmentTag = (tag) => {
+  if (tag?.type !== OpenFragmentTag) throw new Error();
+
+  const { flags } = tag.value;
+
+  return `<${printFlags(flags)}>`;
+};
+
 export const printSelfClosingNodeTag = (tag, intrinsicValue) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
@@ -234,6 +245,12 @@ export const printCloseNodeTag = (tag) => {
   return `</>`;
 };
 
+export const printCloseFragmentTag = (tag) => {
+  if (tag?.type !== CloseFragmentTag) throw new Error();
+
+  return `</>`;
+};
+
 export const printTag = (tag) => {
   if (!isObject(tag)) throw new Error();
 
@@ -265,6 +282,12 @@ export const printTag = (tag) => {
     case CloseNodeTag:
       return printCloseNodeTag(tag);
 
+    case OpenFragmentTag:
+      return printOpenFragmentTag(tag);
+
+    case CloseFragmentTag:
+      return printCloseFragmentTag(tag);
+
     default:
       throw new Error();
   }

package/lib/shorthand.js

@@ -8,14 +8,15 @@ import {
   buildNullNode,
   buildArrayTag,
   buildNode,
+  buildFragment,
   buildGapNode,
   buildSyntacticNode,
-  buildSyntacticIntrinsicNode,
   buildEscapeNode,
   buildSyntacticEscapeNode,
   buildSyntacticTriviaNode,
   buildTriviaNode,
 } from './builders.js';
+import { parsePath } from './path.js';
 
 export * from './builders.js';
 
@@ -33,14 +34,9 @@ const stripArray = (val) => {
 };
 
 export const ref = (path) => {
-  if (isArray(path)) {
-    const pathIsArray = path[0].endsWith('[]');
-    const name = pathIsArray ? path[0].slice(0, -2) : path[0];
-    return buildReferenceTag(name, pathIsArray);
-  } else {
-    const { name, isArray: pathIsArray } = path;
-    return buildReferenceTag(name, pathIsArray);
-  }
+  const { name, isArray: pathIsArray } = parsePath(isArray(path) ? path[0] : path);
+
+  return buildReferenceTag(name, pathIsArray);
 };
 
 export const lit = (str) => buildLiteralTag(stripArray(str));
@@ -51,9 +47,9 @@ export const embedded = buildEmbeddedNode;
 export const nodeOpen = buildNodeOpenTag;
 export const nodeClose = buildNodeCloseTag;
 export const node = buildNode;
+export const frag = buildFragment;
 export const g_node = buildGapNode;
 export const s_node = buildSyntacticNode;
-export const s_i_node = buildSyntacticIntrinsicNode;
 export const e_node = buildEscapeNode;
 export const s_e_node = buildSyntacticEscapeNode;
 export const s_t_node = buildSyntacticTriviaNode;

package/lib/stream.js

@@ -14,6 +14,8 @@ import {
   LiteralTag,
   EmbeddedExpression,
   TokenGroup,
+  OpenFragmentTag,
+  CloseFragmentTag,
 } from './symbols.js';
 
 export * from './print.js';
@@ -103,10 +105,6 @@ export class AsyncGenerator {
   }
 }
 
-export const isIntrinsicToken = (tag) => {
-  return tag.type === OpenNodeTag && tag.value.flags.intrinsic && tag.value.flags.token;
-};
-
 export class StreamGenerator {
   constructor(embeddedGenerator) {
     this.generator = embeddedGenerator;
@@ -161,6 +159,51 @@ export const maybeWait = (maybePromise, callback) => {
   }
 };
 
+function* __isEmpty(tags) {
+  const co = new Coroutine(getStreamIterator(tags));
+
+  for (;;) {
+    co.advance();
+
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+    if (co.done) break;
+
+    let depth = 0;
+
+    const tag = co.value;
+
+    switch (tag.type) {
+      case OpenFragmentTag:
+      case OpenNodeTag:
+        if (tag.value.flags.trivia) {
+          ++depth;
+        }
+
+        if (depth === 0 && tag.value.flags.escape) {
+          return false;
+        }
+
+        break;
+
+      case CloseFragmentTag:
+      case CloseNodeTag:
+        --depth;
+        break;
+
+      case LiteralTag:
+      case GapTag:
+        return false;
+    }
+  }
+
+  return true;
+}
+
+export const isEmpty = (tags) =>
+  new StreamIterable(__isEmpty(tags))[Symbol.iterator]().next().value;
+
 function* __generateStandardOutput(tags) {
   const co = new Coroutine(getStreamIterator(tags));
 
@@ -175,7 +218,7 @@ function* __generateStandardOutput(tags) {
     const tag = co.value;
 
     if (tag.type === 'Effect') {
-      const effect = getEmbeddedExpression(tag.value);
+      const effect = tag.value;
       if (effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         if (writeEffect.stream == null || writeEffect.stream === 1) {
@@ -204,7 +247,7 @@ function* __generateAllOutput(tags) {
     const tag = co.value;
 
     if (tag.type === 'Effect') {
-      const effect = getEmbeddedExpression(tag.value);
+      const effect = tag.value;
       if (effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         const prevStream = currentStream;
@@ -316,6 +359,10 @@ function* __generateCSTMLStrategy(tags, options) {
 export const generateCSTMLStrategy = (tags, options = {}) =>
   new StreamIterable(__generateCSTMLStrategy(tags, options));
 
+const isToken = (tag) => {
+  return tag.value.flags.token;
+};
+
 export const prettyGroupTokens = (tags) => new StreamIterable(__prettyGroupTokens(tags));
 
 function* __prettyGroupTokens(tags) {
@@ -334,15 +381,18 @@ function* __prettyGroupTokens(tags) {
     }
 
     const tag = co.value;
-    const isOpenClose = tag.type === CloseNodeTag || (tag.type === OpenNodeTag && tag.value.type);
+    const isOpenClose =
+      tag.type === CloseNodeTag ||
+      tag.type === OpenNodeTag ||
+      tag.type === CloseFragmentTag ||
+      tag.type === OpenFragmentTag;
 
     if (
       (tag.type === 'Effect' && tag.value.verb === 'write') ||
-      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayTag, ShiftTag].includes(tag.type) ||
-      (tag.type === OpenNodeTag && !tag.value.type) ||
-      (state.open &&
-        !isIntrinsicToken(state.open) &&
-        (tag.type === LiteralTag || (tag.type === OpenNodeTag && tag.value.flags.escape)))
+      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayTag, ShiftTag, OpenFragmentTag].includes(
+        tag.type,
+      ) ||
+      (tag.type === OpenNodeTag && tag.value.flags.escape)
     ) {
       state.broken = true;
 
@@ -350,20 +400,16 @@ function* __prettyGroupTokens(tags) {
         yield* state.holding;
         state.holding = [];
       }
-
-      if (!isOpenClose && tag.type !== 'Effect') {
-        yield tag;
-      }
-    } else if (!isOpenClose && tag.type !== 'Effect') {
+    } else if (tag.type === LiteralTag) {
       state.holding.push(tag);
     }
 
-    if (tag.type === 'Effect') {
+    if (!state.holding.length && !isOpenClose) {
       yield tag;
     }
 
-    if (tag.type === CloseNodeTag) {
-      if (!state.broken && (isIntrinsicToken(state.open) || state.holding.length === 1)) {
+    if (tag.type === CloseNodeTag || tag.type === CloseFragmentTag) {
+      if (!state.broken && (isToken(state.open) || state.holding.length === 1)) {
         state.holding.push(tag);
         yield buildTokenGroup(state.holding);
       } else {
@@ -377,8 +423,14 @@ function* __prettyGroupTokens(tags) {
       state = states.value;
     }
 
-    if (tag.type === OpenNodeTag && tag.value.type) {
-      states = states.push({ holding: [tag], broken: false, open: tag });
+    if (tag.type === OpenNodeTag || tag.type === OpenFragmentTag) {
+      if (tag.type === OpenFragmentTag) {
+        states = states.push({ holding: [], broken: false, open: tag });
+        yield tag;
+      } else {
+        states = states.push({ holding: [tag], broken: false, open: tag });
+      }
+
       state = states.value;
     }
   }
@@ -396,6 +448,7 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
   let indentLevel = 0;
   let first = true;
   let inline = false;
+  let ref = null;
 
   for (;;) {
     co.advance();
@@ -409,7 +462,7 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
     const tag = co.value;
 
     if (tag.type === 'Effect') {
-      const effect = getEmbeddedExpression(tag.value);
+      const effect = tag.value;
       if (emitEffects && effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         yield buildWriteEffect(
@@ -426,6 +479,7 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
     inline =
       inlineOption &&
       inline &&
+      ref &&
       (tag.type === NullTag ||
         tag.type === GapTag ||
         tag.type === ArrayTag ||
@@ -435,7 +489,8 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
       yield buildWriteEffect('\n');
     }
 
-    if (tag.type === CloseNodeTag) {
+    if (tag.type === CloseNodeTag || tag.type === CloseFragmentTag) {
+      ref = null;
       if (indentLevel === 0) {
         throw new Error('imbalanced tag stack');
       }
@@ -450,6 +505,7 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
     }
 
     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 {
@@ -458,9 +514,10 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
 
     if (tag.type === ReferenceTag) {
       inline = true;
+      ref = tag;
     }
 
-    if (tag.type === OpenNodeTag) {
+    if (tag.type === OpenNodeTag || tag.type === OpenFragmentTag) {
       indentLevel++;
     }
 
@@ -496,6 +553,7 @@ export const getCooked = (tags) => {
         break;
       }
 
+      case OpenFragmentTag:
       case OpenNodeTag: {
         const { flags, attributes } = tag.value;
 
@@ -524,6 +582,7 @@ export const getCooked = (tags) => {
         break;
       }
 
+      case CloseFragmentTag:
       case CloseNodeTag: {
         if (depth === 1) {
           foundLast = true;

package/lib/symbols.js

@@ -9,6 +9,8 @@ export const null_ = Symbol.for('@bablr/null');
 export const DoctypeTag = Symbol.for('DoctypeTag');
 export const OpenNodeTag = Symbol.for('OpenNodeTag');
 export const CloseNodeTag = Symbol.for('CloseNodeTag');
+export const OpenFragmentTag = Symbol.for('OpenFragmentTag');
+export const CloseFragmentTag = Symbol.for('CloseFragmentTag');
 export const ReferenceTag = Symbol.for('ReferenceTag');
 export const ShiftTag = Symbol.for('ShiftTag');
 export const GapTag = Symbol.for('GapTag');

package/lib/template.js

@@ -1,12 +1,24 @@
 import * as t from './builders.js';
-import { LiteralTag, EmbeddedNode } from './symbols.js';
+import {
+  LiteralTag,
+  EmbeddedNode,
+  ReferenceTag,
+  ArrayTag,
+  OpenFragmentTag,
+  OpenNodeTag,
+  DoctypeTag,
+  CloseFragmentTag,
+} from './symbols.js';
 import * as btree from './btree.js';
+import { getOpenTag, getRoot } from './tree.js';
 
 const { isArray } = Array;
 const { freeze } = Object;
 const { isFinite } = Number;
 
-export const interpolateArray = (value) => {
+export const interpolateArray = (fragment) => {
+  const value = getRoot(fragment);
+
   if (isArray(value)) {
     if (isFinite(value[0])) {
       return [...btree.traverse(value)];
@@ -18,21 +30,41 @@ export const interpolateArray = (value) => {
   }
 };
 
-export const interpolateArrayChildren = (value, ref, sep) => {
-  if (isArray(value)) {
-    const values = value;
-    const children = [];
-    let first = true;
-    for (const _ of values) {
-      if (!first) children.push(freeze({ ...sep }));
-      children.push(freeze({ ...ref }));
-      first = false;
+export function* interpolateFragmentChildren(value, ref) {
+  const open = getOpenTag(value);
+
+  if (open.type === OpenFragmentTag) {
+    let currentRef = null;
+    for (let child of btree.traverse(value.children)) {
+      if (
+        child.type === DoctypeTag ||
+        child.type === OpenFragmentTag ||
+        child.type === CloseFragmentTag
+      ) {
+        continue;
+      }
+
+      if (child.type === ArrayTag) {
+        // if (notAlreadyInitialized) {
+        yield child;
+        // }
+      } else if (child.type === ReferenceTag) {
+        currentRef = child;
+        if (child.value.name === '.') {
+          yield freeze({ ...ref });
+        } else {
+          yield child;
+        }
+      } else {
+        yield child;
+      }
     }
-    return children;
+  } else if (open.type === OpenNodeTag) {
+    yield freeze({ ...ref });
   } else {
-    return [freeze({ ...ref })];
+    throw new Error();
   }
-};
+}
 
 const validateTag = (tag) => {
   if (!tag || (tag.type !== LiteralTag && tag.type !== EmbeddedNode)) {

package/lib/tree.js

@@ -1,6 +1,6 @@
 import { Coroutine } from '@bablr/coroutine';
 import emptyStack from '@iter-tools/imm-stack';
-import { nodeFlags, buildDoctypeTag, buildEmbeddedNode } from './builders.js';
+import { nodeFlags, buildEmbeddedNode } from './builders.js';
 import {
   printPrettyCSTML as printPrettyCSTMLFromStream,
   printCSTML as printCSTMLFromStream,
@@ -11,6 +11,8 @@ import {
   DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
+  OpenFragmentTag,
+  CloseFragmentTag,
   ReferenceTag,
   ShiftTag,
   GapTag,
@@ -33,11 +35,11 @@ const { isArray } = Array;
 const { hasOwn, freeze } = Object;
 
 export const get = (node, path) => {
-  const { type, properties } = node;
-  const { 1: name, 2: index } = /^([^\.]+)(?:\.(\d+))?/.exec(path) || [];
+  const { properties } = node;
+  const { 1: name, 2: index } = /^([^\.]+|\.)(?:\.(\d+))?/.exec(path) || [];
 
   if (!hasOwn(properties, name)) {
-    throw new Error(`Cannot find {name: ${name}} on node of {type: ${type}}`);
+    return null;
   }
 
   if (index != null) {
@@ -88,14 +90,15 @@ function* __treeFromStream(tokens) {
       continue;
     }
 
-    if (held && tag.type !== 'StartNodeTag' && tag.type !== GapTag) {
+    if (held && tag.type !== OpenNodeTag && tag.type !== GapTag) {
       throw new Error('cannot eat this type of tag while holding');
     }
 
     switch (tag.type) {
       case LiteralTag:
       case ReferenceTag:
-      case CloseNodeTag: {
+      case CloseNodeTag:
+      case CloseFragmentTag: {
         break;
       }
 
@@ -134,10 +137,7 @@ function* __treeFromStream(tokens) {
       }
 
       case OpenNodeTag: {
-        const { flags, type } = tag.value;
-
-        const language = type ? tag.value.language : doctype.value.attributes['bablr-language'];
-        const attributes = type ? tag.value.attributes : doctype.value.attributes;
+        const { flags, type, language, attributes } = tag.value;
 
         const node = createNode(flags, language, type, [], {}, attributes);
 
@@ -145,26 +145,48 @@ function* __treeFromStream(tokens) {
 
         path = { parent: path, node, depth: (path.depth || -1) + 1 };
 
-        if (parentPath) {
-          const { node: parentNode } = path;
-          if (!(flags.escape || flags.trivia)) {
-            if (!parentNode.children.length) {
-              throw new Error('Nodes must follow references');
-            }
+        if (!parentPath) throw new Error();
 
-            const ref = arrayLast(parentNode.children);
-
-            add(parentNode, ref, node);
-          } else {
-            parentNode.children.push(buildEmbeddedNode(node));
+        const { node: parentNode } = path;
+        if (!(flags.escape || flags.trivia)) {
+          if (!parentNode.children.length) {
+            throw new Error('Nodes must follow references');
           }
+
+          const ref = arrayLast(parentNode.children);
+
+          add(parentNode, ref, node);
         } else {
-          rootPath = path;
+          parentNode.children.push(buildEmbeddedNode(node));
         }
 
         break;
       }
 
+      case OpenFragmentTag: {
+        const { flags } = tag.value;
+
+        const language = doctype.value.attributes['bablr-language'];
+        const attributes = doctype.value.attributes;
+
+        const node = freeze({
+          flags,
+          language,
+          type: null,
+          children: [],
+          properties: {},
+          attributes,
+        });
+
+        if (path) throw new Error();
+
+        path = { parent: null, node, depth: 0 };
+
+        rootPath = path;
+
+        break;
+      }
+
       default: {
         throw new Error();
       }
@@ -193,7 +215,7 @@ function* __treeFromStream(tokens) {
   return rootPath.node;
 }
 
-export const treeFromStream = (tags) => new StreamIterable(__treeFromStream(tags));
+export const treeFromStream = (tags) => __treeFromStream(tags);
 
 export const treeFromStreamSync = (tokens) => {
   return evaluateReturnSync(treeFromStream(tokens));
@@ -223,13 +245,64 @@ export const evaluateReturnAsync = async (generator) => {
 
 export const streamFromTree = (rootNode) => __streamFromTree(rootNode);
 
+export const isEmpty = (node) => {
+  const { properties } = node;
+
+  for (const child of btree.traverse(node.children)) {
+    switch (child.type) {
+      case ReferenceTag: {
+        const { name } = child.value;
+
+        if (properties[name]) {
+          const value = properties[name];
+
+          if (value != null || value.type !== sym.null || (isArray(value) && value.length)) {
+            return false;
+          }
+        }
+        break;
+      }
+
+      case EmbeddedNode: {
+        if (node.value.flags.escape) {
+          return false;
+        }
+        break;
+      }
+
+      case LiteralTag:
+      case GapTag:
+        return false;
+    }
+  }
+  return true;
+};
+
+const symbolTypeFor = (type) => {
+  // prettier-ignore
+  switch (type) {
+    case NullTag: return sym.null;
+    case GapTag: return sym.gap;
+    default: throw new Error();
+  }
+};
+
+export const buildStubNode = (tag) => {
+  return freeze({
+    flags: nodeFlags,
+    language: null,
+    type: symbolTypeFor(tag.type),
+    children: freeze([tag]),
+    properties: freeze({}),
+    attributes: freeze({}),
+  });
+};
+
 function* __streamFromTree(rootNode) {
   if (!rootNode || rootNode.type === GapTag) {
     return rootNode;
   }
 
-  yield buildDoctypeTag(rootNode.attributes);
-
   let stack = emptyStack.push(rootNode);
   const resolver = new Resolver();
 
@@ -273,7 +346,8 @@ function* __streamFromTree(rootNode) {
 
         case GapTag:
         case NullTag:
-        case CloseNodeTag: {
+        case CloseNodeTag:
+        case CloseFragmentTag: {
           stack = stack.pop();
           resolver.advance(tag);
           yield tag;
@@ -397,8 +471,9 @@ export const printSource = (rootNode) => __printSource(rootNode);
 export const sourceTextFor = printSource;
 
 export const getOpenTag = (node) => {
-  const tag = btree.getAt(0, node.children);
-  if (tag && tag.type !== OpenNodeTag) throw new Error();
+  const tag = btree.getAt(node.type ? 0 : 1, node.children);
+  if (tag.type === NullTag) return null;
+  if (tag && tag.type !== OpenNodeTag && tag.type !== OpenFragmentTag) throw new Error();
   return tag;
 };
 
@@ -473,15 +548,19 @@ export const acceptNode = (node, accepted) => {
   return node;
 };
 
-export const getRoot = (fragmentNode) => {
-  if (!fragmentNode) return null;
+export const getRoot = (node) => {
+  return node.type == null ? node.properties['.'] : node;
+};
 
-  for (const tag of btree.traverse(fragmentNode.children)) {
-    if (tag.type === ReferenceTag) {
-      return fragmentNode.properties[tag.value.name];
+export function* traverseProperties(properties) {
+  for (const value of Object.values(properties)) {
+    if (isArray(value)) {
+      yield* btree.traverse(value);
+    } else {
+      yield value;
     }
   }
-};
+}
 
 export class Resolver {
   constructor(
@@ -494,6 +573,7 @@ export class Resolver {
     this.reference = reference;
     this.popped = popped;
     this.held = held;
+    this.doctype = null;
   }
 
   get idx() {
@@ -552,16 +632,23 @@ export class Resolver {
         break;
       }
 
-      case OpenNodeTag: {
+      case OpenNodeTag:
+      case OpenFragmentTag: {
         const { flags } = tag.value;
         const isRootNode = states.size === 1;
 
-        if (!isRootNode && !this.reference && !(flags.trivia || flags.escape)) {
-          throw new Error();
-        }
+        if (tag.type === OpenFragmentTag && (!isRootNode || this.reference)) throw new Error();
 
-        if (this.reference?.type !== EmbeddedNode && (flags.trivia || flags.escape)) {
-          this.states = states.push({ properties: new Map(), idx: 0 });
+        if (flags.trivia || flags.escape) {
+          if (this.reference?.type === ReferenceTag)
+            throw new Error('embedded nodes cannot follow references');
+          if (this.reference?.type !== EmbeddedNode) {
+            this.states = states.push({ properties: new Map(), idx: 0 });
+          }
+        } else {
+          if (!isRootNode && !this.reference) {
+            throw new Error();
+          }
         }
 
         this.reference = null;
@@ -611,10 +698,21 @@ export class Resolver {
         break;
       }
 
-      case CloseNodeTag: {
+      case CloseNodeTag:
+      case CloseFragmentTag: {
         this.states = states.pop();
         this.popped = true;
+        break;
       }
+
+      case DoctypeTag:
+        this.doctype = tag;
+        break;
+      case LiteralTag:
+        break;
+
+      default:
+        throw new Error();
     }
 
     return this;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-helpers",
   "description": "Helper functions for working with agAST trees",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -20,7 +20,7 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/btree": "0.1.0",
+    "@bablr/btree": "^0.1.0",
     "@bablr/coroutine": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0"
   },