@bablr/agast-helpers 0.5.3 → 0.6.0

package/lib/tree.js

@@ -1,74 +1,121 @@
 import { Coroutine } from '@bablr/coroutine';
 import emptyStack from '@iter-tools/imm-stack';
-import { nodeFlags, buildEmbeddedNode } from './builders.js';
+import {
+  nodeFlags,
+  buildReferenceTag,
+  buildNullTag,
+  buildOpenNodeTag,
+  buildLiteralTag,
+  buildCloseNodeTag,
+  tokenFlags,
+} from './builders.js';
 import {
   printPrettyCSTML as printPrettyCSTMLFromStream,
   printCSTML as printCSTMLFromStream,
+  printSource as printSourceFromStream,
   getStreamIterator,
-  StreamIterable,
 } from './stream.js';
 import {
   DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
-  OpenFragmentTag,
-  CloseFragmentTag,
   ReferenceTag,
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   LiteralTag,
   EmbeddedNode,
 } from './symbols.js';
 import * as btree from './btree.js';
-import * as sym from './symbols.js';
 export * from './builders.js';
 export * from './print.js';
-
-const arrayLast = (arr) => arr[arr.length - 1];
+import {
+  add,
+  get,
+  TagPath,
+  Path,
+  isFragmentNode,
+  isNullNode,
+  isGapNode,
+  getOpenTag,
+  getCloseTag,
+} from './path.js';
+
+export { add, get, isFragmentNode, isNullNode, isGapNode, getOpenTag, getCloseTag };
+
+export const buildToken = (language, type, value, attributes = {}) => {
+  return treeFromStreamSync([
+    buildOpenNodeTag(tokenFlags, language, type, attributes),
+    buildLiteralTag(value),
+    buildCloseNodeTag(),
+  ]);
+};
 
 const isString = (str) => typeof str === 'string';
 
 const { isArray } = Array;
+const { freeze } = Object;
+
+export const parseReference = (str) => {
+  let {
+    1: name,
+    2: isArray,
+    3: index,
+    4: expressionToken,
+    5: hasGapToken,
+  } = /^\s*([.#@]|[a-zA-Z]+)\s*(\[\s*(\d+\s*)?\])?\s*(\+)?(\$)?\s*$/.exec(str);
+
+  let flags = {
+    expression: !!expressionToken,
+    hasGap: !!hasGapToken,
+  };
 
-const { hasOwn, freeze } = Object;
-
-export const get = (node, path) => {
-  const { properties } = node;
-  const { 1: name, 2: index } = /^([^\.]+|\.)(?:\.(\d+))?/.exec(path) || [];
-
-  if (!hasOwn(properties, name)) {
-    return null;
-  }
+  index = index ? parseInt(index, 10) : null;
+  isArray = !!isArray;
+  name = name || null;
 
-  if (index != null) {
-    return btree.getAt(parseInt(index, 10), properties[name]);
-  } else {
-    return properties[name];
-  }
+  return buildReferenceTag(name, isArray, flags, index);
 };
 
-export const add = (node, ref, value) => {
-  const { name, isArray } = ref.value;
-
-  if (isArray) {
-    if (!hasOwn(node.properties, name)) {
-      node.properties[name] = [];
-    }
+export const mergeReferences = (outer, inner) => {
+  let {
+    name,
+    isArray,
+    index,
+    flags: { expression, hasGap },
+  } = outer.value;
+
+  if (
+    name != null &&
+    name !== '.' &&
+    inner.value.name != null &&
+    inner.value.name !== '.' &&
+    name !== inner.value.name
+  )
+    throw new Error();
+
+  isArray = isArray || inner.value.isArray;
+  expression = !!(expression || inner.value.flags.expression);
+  hasGap = !!(hasGap || inner.value.flags.hasGap);
+  name = name === '.' ? inner.value.name : name;
+
+  return buildReferenceTag(name, isArray, { expression, hasGap }, index);
+};
 
-    node.properties[name] = btree.push(node.properties[name], value);
-  } else {
-    node.properties[name] = value;
-  }
+export const isEmptyReference = (ref) => {
+  let { name, isArray, flags } = ref.value;
+  return name === '.' && !isArray && !(flags.expression || flags.hasGap);
 };
 
-function* __treeFromStream(tokens) {
+function* __treeFromStream(tags, options) {
   let path = null;
   let rootPath = null;
   let held = null;
   let doctype = null;
-  const co = new Coroutine(getStreamIterator(tokens));
+  const co = new Coroutine(getStreamIterator(tags));
+  const expressionsCo = new Coroutine(getStreamIterator(options.expressions || []));
+  let reference = null;
 
   for (;;) {
     co.advance();
@@ -94,95 +141,179 @@ function* __treeFromStream(tokens) {
       throw new Error('cannot eat this type of tag while holding');
     }
 
+    let suppressTag = false;
+
     switch (tag.type) {
       case LiteralTag:
-      case ReferenceTag:
-      case CloseNodeTag:
-      case CloseFragmentTag: {
+      case CloseNodeTag: {
+        break;
+      }
+
+      case ReferenceTag: {
+        reference = tag;
+        suppressTag = true;
+        break;
+      }
+
+      case ArrayInitializerTag: {
+        add(path.node, reference, []);
+        suppressTag = true;
+        reference = null;
         break;
       }
 
       case NullTag:
       case GapTag: {
-        const parentNode = path.parent.node;
-        const ref = arrayLast(parentNode.children);
-        const isGap = tag.type === GapTag;
+        if (!path) {
+          return buildStubNode(tag);
+        }
 
-        if (ref.type !== ReferenceTag) throw new Error();
+        const isGap = tag.type === GapTag;
 
-        const node = (isGap && held) || createNode(nodeFlags, null, sym.null);
+        if (path.parent && reference.type !== ReferenceTag) throw new Error();
+
+        let node = createNode(tag);
+
+        if (isGap) {
+          if (held) {
+            node = held;
+            add(path.node, reference, node);
+            suppressTag = true;
+          } else if (!expressionsCo.done) {
+            expressionsCo.advance();
+
+            let outerReference = reference;
+
+            if (!expressionsCo.done) {
+              node =
+                node == null
+                  ? buildStubNode(buildNullTag())
+                  : expressionsCo.value == null
+                  ? buildStubNode(buildNullTag())
+                  : expressionsCo.value;
+              suppressTag = true;
+
+              if (isFragmentNode(node)) {
+                const parentNode = path.node;
+
+                let reference;
+
+                for (const tag of btree.traverse(node.children)) {
+                  switch (tag.type) {
+                    case DoctypeTag: {
+                      break;
+                    }
+                    case OpenNodeTag:
+                    case CloseNodeTag: {
+                      if (!tag.value.type) {
+                        break;
+                      } else {
+                        throw new Error();
+                      }
+                    }
+
+                    case ReferenceTag:
+                      // combine tags for .
+
+                      reference = tag;
+                      break;
+
+                    case ArrayInitializerTag: {
+                      add(parentNode, mergeReferences(outerReference, reference), []);
+                      break;
+                    }
+
+                    case EmbeddedNode: {
+                      add(parentNode, mergeReferences(outerReference, reference), tag.value);
+                      break;
+                    }
+
+                    case GapTag: {
+                      const resolvedNode = get(reference, node);
+                      add(parentNode, mergeReferences(outerReference, reference), resolvedNode);
+                      break;
+                    }
+
+                    case NullTag: {
+                      add(parentNode, mergeReferences(outerReference, reference), null);
+                      break;
+                    }
+
+                    default:
+                      throw new Error();
+                  }
+                }
+              } else {
+                if (path.node.flags.token) {
+                  throw new Error('not implemented');
+                }
+                add(path.node, reference, node);
+              }
+            } else {
+              if (!path.node.flags.token) {
+                add(path.node, reference, node);
+              }
+            }
+          }
+        }
 
+        reference = null;
         held = isGap ? null : held;
-        path = { parent: path, node, depth: (path.depth || -1) + 1 };
-
-        add(parentNode, ref, node);
-        break;
-      }
-
-      case ShiftTag: {
-        const { children, properties } = path.node;
-
-        const ref = arrayLast(children);
-        let node = properties[ref.value.name];
 
-        if (ref.value.isArray) {
-          node = arrayLast(node);
-          properties[ref.value.name].pop();
-        } else {
-          properties[ref.value.name] = null;
+        if (!path.node.flags.token) {
+          path = { parent: path, node, depth: (path.depth || -1) + 1, arrays: new Set() };
         }
 
-        held = node;
         break;
       }
 
-      case OpenNodeTag: {
-        const { flags, type, language, attributes } = tag.value;
+      // case ShiftTag: {
+      //   const { children, properties } = path.node;
 
-        const node = createNode(flags, language, type, [], {}, attributes);
+      //   let property = properties[ref.value.name];
+      //   let node;
 
-        const parentPath = path;
+      //   if (ref.value.isArray) {
+      //     ({ node } = btree.getAt(-1, property));
+      //     properties[ref.value.name].pop();
+      //   } else {
+      //     ({ node } = property);
+      //     properties[ref.value.name] = null;
+      //   }
 
-        path = { parent: path, node, depth: (path.depth || -1) + 1 };
+      //   held = node;
+      //   break;
+      // }
 
-        if (!parentPath) throw new Error();
+      case OpenNodeTag: {
+        if (path) {
+          const node = createNode(tag);
 
-        const { node: parentNode } = path;
-        if (!(flags.escape || flags.trivia)) {
-          if (!parentNode.children.length) {
-            throw new Error('Nodes must follow references');
+          if (path) {
+            add(path.node, reference, node);
+            reference = null;
           }
 
-          const ref = arrayLast(parentNode.children);
-
-          add(parentNode, ref, node);
+          path = { parent: path, node, depth: (path ? path.depth : -1) + 1, arrays: new Set() };
         } else {
-          parentNode.children.push(buildEmbeddedNode(node));
-        }
-
-        break;
-      }
-
-      case OpenFragmentTag: {
-        const { flags } = tag.value;
-
-        const { attributes } = doctype.value;
-        const language = attributes['bablr-language'];
+          const { language, type, flags, attributes } = tag.value;
 
-        const node = freeze({
-          flags,
-          language,
-          type: null,
-          children: [],
-          properties: {},
-          attributes,
-        });
+          const attributes_ = doctype?.value.attributes ?? attributes;
+          const language_ = attributes?.['bablrLanguage'] ?? language;
 
-        if (path) throw new Error();
+          const node = {
+            flags,
+            language: language_,
+            type,
+            children: [],
+            properties: {},
+            attributes: attributes_,
+          };
 
-        path = { parent: null, node, depth: 0 };
+          path = { parent: null, node, depth: 0, arrays: new Set() };
 
-        rootPath = path;
+          rootPath = path;
+        }
 
         break;
       }
@@ -192,7 +323,9 @@ function* __treeFromStream(tokens) {
       }
     }
 
-    path.node.children.push(tag);
+    if (!suppressTag) {
+      path.node.children = btree.push(path.node.children, tag);
+    }
 
     switch (tag.type) {
       case NullTag:
@@ -200,10 +333,14 @@ function* __treeFromStream(tokens) {
       case CloseNodeTag: {
         const completedNode = path.node;
 
-        finalizeNode(completedNode);
+        if (!(tag.type === GapTag && completedNode.flags.token)) {
+          finalizeNode(completedNode);
+        }
 
-        if (!completedNode.type && path.depth !== 1) {
-          throw new Error('imbalanced tag stack');
+        if (tag.type === GapTag) {
+          if (path && completedNode.type === null && completedNode.flags.token) {
+            break;
+          }
         }
 
         path = path.parent;
@@ -212,17 +349,25 @@ function* __treeFromStream(tokens) {
     }
   }
 
+  if (path && path.node.type) {
+    throw new Error('imbalanced tag stack');
+  }
+
   return rootPath.node;
 }
 
-export const treeFromStream = (tags) => __treeFromStream(tags);
+export const buildNullNode = () => {
+  return treeFromStreamSync([buildNullTag()]);
+};
+
+export const treeFromStream = (tags, options = {}) => __treeFromStream(tags, options);
 
-export const treeFromStreamSync = (tokens) => {
-  return evaluateReturnSync(treeFromStream(tokens));
+export const treeFromStreamSync = (tokens, options = {}) => {
+  return evaluateReturnSync(treeFromStream(tokens, options));
 };
 
-export const treeFromStreamAsync = async (tokens) => {
-  return evaluateReturnAsync(treeFromStream(tokens));
+export const treeFromStreamAsync = async (tokens, options = {}) => {
+  return evaluateReturnAsync(treeFromStream(tokens, options));
 };
 
 export const evaluateReturnSync = (generator) => {
@@ -243,20 +388,28 @@ export const evaluateReturnAsync = async (generator) => {
   return co.value;
 };
 
-export const streamFromTree = (rootNode) => __streamFromTree(rootNode);
+export const streamFromTree = (rootNode, options = {}) => __streamFromTree(rootNode, options);
 
 export const isEmpty = (node) => {
   const { properties } = node;
 
-  for (const child of btree.traverse(node.children)) {
-    switch (child.type) {
+  let ref = null;
+
+  for (const tag of btree.traverse(node.children)) {
+    switch (tag.type) {
       case ReferenceTag: {
-        const { name } = child.value;
+        const { name } = tag.value;
+
+        ref = tag;
 
         if (properties[name]) {
-          const value = properties[name];
+          const property = properties[name];
 
-          if (value != null || value.type !== sym.null || (isArray(value) && value.length)) {
+          if (
+            property != null ||
+            (isArray(property) && property.length) ||
+            !isNullNode(property.node)
+          ) {
             return false;
           }
         }
@@ -264,7 +417,7 @@ export const isEmpty = (node) => {
       }
 
       case EmbeddedNode: {
-        if (node.value.flags.escape) {
+        if (ref.value.name === '@') {
           return false;
         }
         break;
@@ -278,93 +431,37 @@ export const isEmpty = (node) => {
   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),
+    type: null,
     children: freeze([tag]),
     properties: freeze({}),
     attributes: freeze({}),
   });
 };
 
-function* __streamFromTree(rootNode) {
-  if (!rootNode || rootNode.type === GapTag) {
-    return rootNode;
-  }
-
-  let stack = emptyStack.push(rootNode);
-  const resolver = new Resolver();
-
-  stack: while (stack.size) {
-    const node = stack.value;
-    const { children } = node;
-
-    while (true) {
-      const tag = btree.getAt(resolver.idx, children);
-
-      if (isArray(tag)) {
-        throw new Error();
-      }
-
-      switch (tag.type) {
-        case EmbeddedNode: {
-          stack = stack.push(tag.value);
-
-          resolver.advance(tag);
-
-          continue stack;
-        }
+function* __streamFromTree(rootNode, options) {
+  const { unshift = false } = options;
+  if (!rootNode || !btree.getSum(rootNode.children)) return;
 
-        case ReferenceTag: {
-          const resolvedPath = resolver.resolve(tag);
-          const resolved = get(stack.value, resolvedPath);
-          const { isArray: refIsArray } = tag.value;
+  let tagPath = TagPath.from(Path.from(rootNode), 0);
 
-          if (!resolved) throw new Error();
+  let count = 0;
 
-          yield tag;
+  do {
+    if (tagPath.tag.type === OpenNodeTag) count++;
+    if (tagPath.tag.type === CloseNodeTag) count--;
 
-          resolver.advance(tag);
+    yield tagPath.tag;
+  } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
 
-          if (!refIsArray || !isArray(resolved)) {
-            if (isArray(resolved)) throw new Error();
-            stack = stack.push(resolved);
-          }
-          continue stack;
-        }
-
-        case GapTag:
-        case NullTag:
-        case CloseNodeTag:
-        case CloseFragmentTag: {
-          stack = stack.pop();
-          resolver.advance(tag);
-          yield tag;
-          continue stack;
-        }
-
-        default:
-          resolver.advance(tag);
-          yield tag;
-          break;
-      }
-    }
-  }
+  if (count !== 0) throw new Error();
 }
 
 export const getCooked = (cookable) => {
-  if (!cookable || cookable.type === GapTag) {
+  if (!cookable || isGapNode(cookable.type)) {
     return '';
   }
 
@@ -372,26 +469,31 @@ export const getCooked = (cookable) => {
 
   let cooked = '';
 
-  const openTag = getOpenTag(cookable);
-  const closeTag = getCloseTag(cookable);
+  // const openTag = getOpenTag(cookable);
+  // const closeTag = getCloseTag(cookable);
+
+  let reference = null;
 
   for (const tag of btree.traverse(children)) {
     switch (tag.type) {
       case ReferenceTag: {
-        throw new Error('cookable nodes must not contain other nodes');
-      }
-
-      case EmbeddedNode: {
-        const { flags, attributes } = tag.value;
+        const { name } = tag.value;
 
-        if (!(flags.trivia || (flags.escape && attributes.cooked))) {
+        if (!(name === '#' || name === '@')) {
           throw new Error('cookable nodes must not contain other nodes');
         }
 
-        if (flags.escape) {
+        reference = tag;
+        break;
+      }
+
+      case EmbeddedNode: {
+        const { attributes } = tag.value;
+
+        if (reference.value.name === '@') {
           const { cooked: cookedValue } = attributes;
 
-          if (!cookedValue && isString(cookedValue))
+          if (!isString(cookedValue))
             throw new Error('cannot cook string: it contains uncooked escapes');
 
           cooked += cookedValue;
@@ -430,74 +532,49 @@ export const printPrettyCSTML = (rootNode, options = {}) => {
   return printPrettyCSTMLFromStream(streamFromTree(rootNode), options);
 };
 
-const __printSource = (rootNode, resolver = new Resolver()) => {
-  let printed = '';
-
-  if (!rootNode) return '';
-
-  let node = rootNode;
-
-  if (node instanceof Promise) {
-    printed += '$Promise';
-  } else {
-    for (const child of btree.traverse(node.children)) {
-      if (child.type === LiteralTag) {
-        printed += child.value;
-        resolver.advance(child);
-      } else if (child.type === EmbeddedNode) {
-        resolver.advance(child);
-        printed += __printSource(child.value, resolver);
-      } else if (child.type === ReferenceTag) {
-        const resolvedPath = resolver.resolve(child);
-        const resolvedNode = get(node, resolvedPath);
-
-        resolver.advance(child);
-        if (resolvedNode) {
-          if (!isArray(resolvedNode)) {
-            printed += __printSource(resolvedNode, resolver);
-          }
-        }
-      } else {
-        resolver.advance(child);
-      }
-    }
-  }
-
-  return printed;
+export const printSource = (rootNode) => {
+  return printSourceFromStream(streamFromTree(rootNode, { unshift: true }));
 };
 
-export const printSource = (rootNode) => __printSource(rootNode);
-
 export const sourceTextFor = printSource;
 
-export const getOpenTag = (node) => {
-  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;
-};
-
-export const getCloseTag = (node) => {
-  const { children } = node;
-  const tag = btree.getAt(-1, children);
-  if (tag.type !== CloseNodeTag) return null;
-  return tag;
-};
-
 export const getRange = (node) => {
   const { children } = node;
-  return children.length ? [children[1], children[children.length - 1]] : null;
+  return btree.getSum(children) ? [btree.getAt(0, children), btree.getAt(-1, children)] : null;
 };
 
 export const createNode = (openTag) => {
-  const { flags, language, type, attributes } = openTag.value;
-  return { flags, language, type, children: [], properties: {}, attributes };
+  if (!openTag || openTag.type === GapTag || openTag.type === NullTag) {
+    return {
+      flags: nodeFlags,
+      language: openTag?.language,
+      type: openTag && ([NullTag, GapTag].includes(openTag.type) ? null : openTag.type),
+      children: [],
+      properties: {},
+      attributes: openTag?.attributes || {},
+    };
+  } else {
+    const { flags, language, type, attributes = {} } = openTag.value || {};
+    return { flags, language, type, children: [], properties: {}, attributes };
+  }
 };
 
 export const finalizeNode = (node) => {
-  for (const propertyValue of Object.values(node.properties)) {
-    if (isArray(propertyValue)) {
-      btree.freeze(propertyValue);
+  for (const property of Object.values(node.properties)) {
+    if (isArray(property)) {
+      btree.freeze(property);
+      for (const childProperty of btree.traverse(property)) {
+        freeze(childProperty);
+        if (childProperty.reference.value.flags.expression) {
+          btree.freeze(childProperty.node);
+        }
+      }
+    } else {
+      freeze(property);
+
+      if (property.reference.value.flags.expression) {
+        btree.freeze(property.node);
+      }
     }
   }
 
@@ -509,11 +586,11 @@ export const finalizeNode = (node) => {
 };
 
 export const notNull = (node) => {
-  return node && node.type !== sym.null;
+  return node != null && !isNullNode(node);
 };
 
 export const isNull = (node) => {
-  return !node || node.type === sym.null;
+  return node == null || isNullNode(node);
 };
 
 export const branchProperties = (properties) => {
@@ -521,7 +598,7 @@ export const branchProperties = (properties) => {
 
   for (const { 0: key, 1: value } of Object.entries(copy)) {
     if (isArray(value)) {
-      copy[key] = [...value];
+      copy[key] = btree.fromValues(value);
     }
   }
 
@@ -534,7 +611,8 @@ export const branchNode = (node) => {
     flags,
     language,
     type,
-    children: [...children],
+    // if we always use immutable trees we won't need to do this
+    children: btree.fromValues(btree.traverse(children)),
     properties: branchProperties(properties),
     attributes: { ...attributes },
   };
@@ -549,15 +627,21 @@ export const acceptNode = (node, accepted) => {
 };
 
 export const getRoot = (node) => {
-  return node.type == null ? node.properties['.'] : node;
+  return node == null ? node : isFragmentNode(node) ? node.properties['.'].node : node;
 };
 
 export function* traverseProperties(properties) {
   for (const value of Object.values(properties)) {
     if (isArray(value)) {
-      yield* btree.traverse(value);
+      for (let item of btree.traverse(value)) {
+        if (isArray(item.node)) {
+          yield btree.getAt(-1, item.node);
+        } else {
+          yield item.node;
+        }
+      }
     } else {
-      yield value;
+      yield value.node;
     }
   }
 }
@@ -591,6 +675,8 @@ export class Resolver {
 
     this.popped = false;
 
+    let hadReference = this.reference;
+
     switch (tag.type) {
       case ReferenceTag: {
         const { name, isArray } = tag.value;
@@ -600,62 +686,65 @@ export class Resolver {
 
         this.reference = tag;
 
-        let state = properties.get(name);
-
-        if (isArray) {
-          if (state && !state.isArray) throw new Error();
+        if (name && name !== '#' && name !== '@') {
+          let state = properties.get(name);
 
-          const { count = -1 } = state || {};
+          if (isArray) {
+            if (state && !state.isArray) throw new Error();
 
-          state = { count: count + 1, isArray };
-        } else if (state) {
-          throw new Error(`attempted to consume property {name: ${name}} twice`);
-        } else {
-          state = { count: 1, isArray: false };
-        }
+            const { count = -1 } = state || {};
 
-        properties.set(name, state);
+            state = { count: count + 1, isArray };
+          } else if (state) {
+            throw new Error(`attempted to consume property {name: ${name}} twice`);
+          } else {
+            state = { count: 1, isArray: false };
+          }
 
-        if (!isArray || state.count > 0) {
-          this.states = states.push({ properties: new Map(), idx: 0 });
+          properties.set(name, state);
         }
 
         break;
       }
 
       case EmbeddedNode: {
-        if (this.reference) throw new Error();
+        if (!this.reference || !['#', '@'].includes(this.reference.value.name)) throw new Error();
 
-        this.reference = tag;
-
-        this.states = states.push({ properties: new Map(), idx: 0 });
+        // this.states = states.push({ properties: new Map(), idx: 0 });
         break;
       }
 
-      case OpenNodeTag:
-      case OpenFragmentTag: {
+      case OpenNodeTag: {
+        const { reference } = this;
         const { flags } = tag.value;
         const isRootNode = states.size === 1;
 
-        if (tag.type === OpenFragmentTag && (!isRootNode || this.reference)) throw new Error();
+        if (tag.value.type) {
+          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();
-          }
+        if (!tag.value.type && (!isRootNode || this.reference)) throw new Error();
+
+        if (
+          tag.type === OpenNodeTag &&
+          ((!reference && !isRootNode) ||
+            (reference &&
+              reference.type !== ReferenceTag &&
+              reference.type !== ShiftTag &&
+              reference.type !== OpenNodeTag))
+        ) {
+          throw new Error('Invalid location for OpenNodeTag');
+        }
+
+        if (!isRootNode && !reference) {
+          throw new Error();
         }
 
         this.reference = null;
         break;
       }
 
-      case ArrayTag: {
+      case ArrayInitializerTag: {
         if (!this.reference) throw new Error();
 
         const { name } = this.reference.value;
@@ -679,14 +768,15 @@ export class Resolver {
       }
 
       case NullTag: {
-        this.states = states.pop();
+        if (!this.reference) throw new Error();
+
         this.popped = true;
         this.reference = null;
         break;
       }
 
       case GapTag: {
-        this.states = states.pop();
+        // if (!this.reference) throw new Error();
 
         if (this.held) {
           // this.states = this.states.push(this.held);
@@ -698,8 +788,9 @@ export class Resolver {
         break;
       }
 
-      case CloseNodeTag:
-      case CloseFragmentTag: {
+      case CloseNodeTag: {
+        if (this.reference) throw new Error();
+
         this.states = states.pop();
         this.popped = true;
         break;
@@ -708,6 +799,7 @@ export class Resolver {
       case DoctypeTag:
         this.doctype = tag;
         break;
+
       case LiteralTag:
         break;
 
@@ -715,23 +807,24 @@ export class Resolver {
         throw new Error();
     }
 
+    if (hadReference && this.reference) throw new Error();
+
     return this;
   }
 
   resolve(reference) {
-    let { name, isArray } = reference.value;
+    let { name, isArray, flags } = reference.value;
     const { states } = this;
     const state = states.value.properties.get(name);
-    let path = name;
+    let index = null;
 
-    if (isArray) {
-      if (state) {
-        const count = state?.count || 0;
-        path += '.' + count;
-      }
+    if (name === '@' || name === '#') return reference;
+
+    if (isArray && state) {
+      index = state?.count || 0;
     }
 
-    return path;
+    return buildReferenceTag(name, isArray, flags, index);
   }
 
   branch() {