@bablr/agast-helpers 0.10.9 → 0.11.0

package/lib/path.js

@@ -1,4 +1,4 @@
-import * as BTree from '@bablr/agast-helpers/btree';
+import * as BList from './b-list.js';
 import * as Tags from './tags.js';
 import {
   ReferenceTag,
@@ -14,28 +14,43 @@ import {
   TreeNode,
   NullNode,
   GapNode,
-  Document,
 } from './symbols.js';
 import {
   immSet,
-  isPlainObject,
   isString,
   has as objHas,
   get as objGet,
   isObject,
+  isArray,
   isSymbol,
+  recordValues,
+  freezeClass,
 } from './object.js';
 import {
-  buildReferenceTag,
   buildChild,
   buildProperty,
-  buildGapTag,
   buildNullTag,
   buildOpenNodeTag,
   buildShift,
   buildPropertyTag,
   buildPathFrame,
+  buildBounds,
+  parseOpenNodeTag,
+  parseTag,
+  parseTagType,
+  buildTag,
+  buildFullOpenNodeTag,
+  tokenFlags,
+  parseObject,
 } from './builders.js';
+import { printObject, printTag } from './print.js';
+import { arrayValues, map } from './iterable.js';
+import { freezeRecord } from '@bablr/record';
+
+let { hasOwn, freeze } = Object;
+let { getTags } = Tags;
+
+let arrayLast = (arr) => arr[arr.length - 1];
 
 export const incrementShift = (shift) => {
   if (!shift) return buildShift(1, 3);
@@ -43,74 +58,82 @@ export const incrementShift = (shift) => {
   return buildShift(shift.index + 1, shift.height + 1);
 };
 
-export const finalizeNode = (node) => {
-  freeze(node);
-  freeze(node.value);
-
-  return node;
+export const stringName = (name) => {
+  switch (typeof name) {
+    case 'symbol':
+      return name.description;
+    case 'string':
+      return name;
+    case 'null':
+    case 'undefined':
+      return null;
+    default:
+      throw new Error();
+  }
 };
 
 export const buildNode = (tags) => {
   if (isArray(tags) && !Number.isFinite(tags[0])) throw new Error();
-  if (!isArray(tags) && !isSymbol(tags.type)) throw new Error();
-  let tags_ = isArray(tags) ? tags : Tags.fromValues([tags]);
+  if (!isArray(tags) && !isString(tags) && !isSymbol(tags.type)) throw new Error();
+  let tags_ = isArray(tags) ? tags : Tags.fromValues([printTag(tags)]);
 
   if (!Number.isFinite(tags_[0])) throw new Error();
   if (!isArray(tags_[1]) || !tags_[1].length) throw new Error();
 
   let openTag = tags_[1][0];
-  if (![GapTag, NullTag, OpenNodeTag].includes(openTag.type)) throw new Error();
-  // let tags = openTag ? Tags.fromValues([openTag]) : Tags.fromValues([]);
-
-  if (openTag.type === GapTag) {
-    return finalizeNode({
-      type: GapNode,
-      value: {
-        tags: Tags.fromValues([openTag]),
-      },
-    });
-  } else if (openTag.type === NullTag) {
-    return finalizeNode({
-      type: NullNode,
-      value: { tags: Tags.fromValues([openTag]) },
-    });
-  } else if (openTag.type === OpenNodeTag) {
-    return finalizeNode({
-      type: TreeNode,
-      value: {
-        flags: openTag.value.flags,
-        type: openTag.value.type,
-        name: openTag.value.name,
-        attributes: openTag.value.attributes,
-        tags: tags_,
-        children: tags_[1][1] || Tags.fromValues([]),
-        bounds: buildBoundsFromTags(tags_),
-      },
-    });
-  } else {
-    throw new Error();
+
+  switch (parseTagType(openTag)) {
+    case GapTag:
+      return buildTag(GapNode, { tags: Tags.fromValues([openTag]) });
+    case NullTag:
+      return buildTag(NullNode, { tags: Tags.fromValues([openTag]) });
+    case OpenNodeTag: {
+      let { flags, type, name, attributes } = parseOpenNodeTag(openTag).value;
+
+      let children = tags_[1][1] || Tags.fromValues([]);
+
+      if (!Tags.isNode(children)) throw new Error();
+
+      return freezeRecord({
+        type: TreeNode,
+        value: freezeRecord({
+          flags,
+          type,
+          name,
+          attributes: parseObject(attributes),
+          tags: tags_,
+          children,
+          bounds: buildBoundsFromTags(tags_),
+        }),
+      });
+    }
+    default:
+      throw new Error();
   }
 };
 
-export const buildBoundsFromTags = (tags) => {
-  let gapFrame = buildPathFrame(
-    buildPropertyTag([buildReferenceTag(), [], buildNode(buildGapTag())]),
-    null,
-    true,
-  );
+let gapFrame = buildPathFrame(
+  buildPropertyTag(
+    BList.fromValues([Tags.fromValues([]), Tags.fromValues([]), buildNode('<//>')], 1),
+  ),
+  null,
+  true,
+);
 
-  let bounds = [BTree.fromValues([gapFrame]), BTree.fromValues([gapFrame])];
+export const buildBoundsFromTags = (tags) => {
+  let leading = BList.fromValues([gapFrame]);
+  let trailing = leading;
   let firstProperty, lastProperty;
   let firstPropertyIndex, lastPropertyIndex;
 
-  if (Tags.getAt(-1, tags)?.type !== CloseNodeTag) {
-    return freeze(bounds);
+  if (parseTagType(Tags.getAt(-1, tags)) !== CloseNodeTag) {
+    return buildBounds(leading, trailing);
   }
 
   for (let i = 1; i < Tags.getSize(tags); i++) {
     let tag = Tags.getAt(i, tags);
 
-    if (tag.type === Property && !isNullNode(tag.value.node)) {
+    if (parseTagType(tag) === Property && !isNullNode(tag.value.node)) {
       firstProperty = tag;
       firstPropertyIndex = i;
       break;
@@ -120,107 +143,90 @@ export const buildBoundsFromTags = (tags) => {
   for (let i = Tags.getSize(tags) - 2; i >= 0; i--) {
     let tag = Tags.getAt(i, tags);
 
-    if (tag.type === Property && !isNullNode(tag.value.node)) {
+    if (parseTagType(tag) === Property && !isNullNode(tag.value.node)) {
       lastProperty = tag;
       lastPropertyIndex = i;
       break;
     }
   }
 
-  let { 0: openStack, 1: closeStack } = bounds;
-
   if (firstProperty && firstProperty.value.node.type === TreeNode) {
-    openStack = firstProperty.value.node.value.bounds[0];
+    leading = firstProperty.value.node.value.bounds.leading;
 
-    let rootFrame = BTree.getAt(1, openStack);
+    let rootFrame = BList.getAt(1, leading);
 
-    openStack = BTree.replaceAt(0, openStack, buildPathFrame(firstProperty));
+    leading = BList.replaceAt(0, buildPathFrame(firstProperty), leading);
     if (rootFrame) {
-      openStack = BTree.replaceAt(
-        1,
-        openStack,
-        buildPathFrame(rootFrame.property, firstPropertyIndex),
-      );
+      leading = BList.replaceAt(1, buildPathFrame(rootFrame.property, firstPropertyIndex), leading);
     }
-    openStack = BTree.unshift(gapFrame, openStack);
+    leading = BList.unshift(gapFrame, leading);
   }
 
-  if (lastProperty && lastProperty.value.type === TreeNode) {
+  if (lastProperty && lastProperty.value.node.type === TreeNode) {
     if (!lastProperty.value.node) throw new Error();
 
-    closeStack = lastProperty.value.node.value.bounds[1];
+    trailing = lastProperty.value.node.value.bounds.trailing;
 
-    let rootFrame = BTree.getAt(1, openStack);
+    let rootFrame = BList.getAt(1, trailing);
 
-    closeStack = BTree.replaceAt(0, closeStack, buildPathFrame(lastProperty));
+    trailing = BList.replaceAt(0, buildPathFrame(lastProperty), trailing);
     if (rootFrame) {
-      closeStack = BTree.replaceAt(
+      trailing = BList.replaceAt(
         1,
-        closeStack,
         buildPathFrame(rootFrame.property, lastPropertyIndex),
+        trailing,
       );
     }
-    closeStack = BTree.unshift(gapFrame, closeStack);
+    trailing = BList.unshift(gapFrame, trailing);
   }
 
-  bounds[0] = openStack;
-  bounds[1] = closeStack;
-
-  return freeze(bounds);
+  return buildBounds(leading, trailing);
 };
 
 export const isNode = (value) => {
-  return [TreeNode, NullNode, GapNode].includes(value?.type);
+  return isObject(value) && [TreeNode, NullNode, GapNode].includes(value?.type);
 };
 
 export const endsNode = (tag) => {
-  return (
-    [CloseNodeTag, NullTag, GapTag].includes(tag.type) ||
-    (tag.type === OpenNodeTag && tag.value.selfClosing)
-  );
+  let tagType = parseTagType(tag);
+  if ([CloseNodeTag, NullTag, GapTag].includes(tagType)) return true;
+
+  return tagType === OpenNodeTag ? parseTag(tag).value.selfClosing : false;
 };
 
 export const propertyIsFull = (tag) => {
-  if (tag.type !== Property) return true;
+  if (isString(tag) || tag.type !== Property) return true;
 
   let { tags } = tag.value;
 
-  return tags.length === 3;
+  return tags[1].length === 3;
 };
 
 export const nodeIsComplete = (node) => {
-  let sigilTag = getOpenTag(node);
-  return sigilTag.type !== OpenNodeTag || sigilTag.value.selfClosing ? true : !!getCloseTag(node);
-};
-
-export const getTags = (node) => {
-  switch (node.type) {
-    case TreeNode:
-      return node.value.tags;
-    case NullNode:
-      return node.value.tags;
-    case GapNode:
-      return node.value.tags;
-    case Document:
-      return getTags(node.value.tree);
-    default:
-      throw new Error();
-  }
+  let sigilTag = parseTag(getOpenTag(node));
+  return sigilTag.type !== OpenNodeTag || sigilTag.value.selfClosing
+    ? true
+    : !!getCloseNodeTag(node);
 };
 
 export const offsetForTag = (tag) => {
-  switch (tag.type) {
+  switch (parseTagType(tag)) {
     case ReferenceTag:
     case ShiftTag:
       return [0];
     case BindingTag:
       return [1, -1];
+    case TreeNode:
+    case NullNode:
+    case GapNode:
+      return [2];
     default:
       return [];
   }
 };
 
 export const isNodeTag = (tag) => {
+  if (isString(tag)) return false;
   switch (tag.type) {
     case TreeNode:
     case NullNode:
@@ -259,13 +265,13 @@ export const getRootProperty = (node) => {
   if (node == null || !isCover(node)) {
     return null;
   }
-  let idx = getPropertyTagsIndex(node, '_', null);
+  let idx = Tags.getIndex(buildFullPathSegment('_', null), node.value.tags);
 
   if (idx == null) return null;
 
   let tag = Tags.getAt(idx, getTags(node));
 
-  if (tag.type !== Property) throw new Error();
+  if (isString(tag) || tag.type !== Property) throw new Error();
   return tag;
 };
 
@@ -288,15 +294,15 @@ export const getSigilTag = (node) => {
 
 export const getOpenTag = (node) => {
   let tag = Tags.getValues(getTags(node))[0];
-  return tag.type === OpenNodeTag ? tag : null;
+  return parseTagType(tag) === OpenNodeTag ? tag : null;
 };
 
-export const getCloseTag = (node) => {
+export const getCloseNodeTag = (node) => {
   return Tags.getValues(getTags(node))[2];
 };
 
 export const isNullNode = (node) => {
-  return node && Tags.getAt(0, getTags(node)).type === NullTag;
+  return node && parseTagType(Tags.getAt(0, getTags(node))) === NullTag;
 };
 
 export const isCover = (node) => {
@@ -316,197 +322,17 @@ export const isMultiFragment = (node) => {
 };
 
 export const isGapNode = (node) => {
-  return node && Tags.getAt(0, getTags(node)).type === GapTag;
+  return node && parseTagType(Tags.getAt(0, getTags(node))) === GapTag;
 };
 
 export const isStubNode = (node) => {
-  return node && [GapTag, NullTag].includes(Tags.getAt(0, getTags(node)).type);
+  return node && [GapTag, NullTag].includes(parseTagType(Tags.getAt(0, getTags(node))));
 };
 
 export const isStubTag = (tag) => {
-  return [GapTag, NullTag].includes(tag.type);
-};
-
-export const getChildPropertyIndex = (agAstNode, tagsIndex) => {
-  let child = Tags.getAt(tagsIndex, agAstNode.value.tags);
-
-  if (child.type !== Property) return null;
-
-  let tag = child.value.tags[0];
-
-  let refIndex = tag.type === ShiftTag ? tagsIndex - tag.value.index : tagsIndex;
-
-  let stack = Tags.findPath(refIndex, agAstNode.value.tags);
-  let { node, index: leafIdx } = stack.value;
-  let leaf = Tags.getAt(leafIdx, node);
-
-  if (leaf.type !== Property) {
-    return null;
-  }
-
-  let leafRefTag = leaf.value.tags[0];
-
-  if (leafRefTag.type !== ReferenceTag) return null;
-
-  let { name, flags } = leafRefTag.value;
-  let count = -1;
-
-  if (!name) throw new Error();
-
-  if (!flags.array) return null;
-
-  for (let i = leafIdx; i >= 0; i--) {
-    let value = Tags.getAt(i, node);
-    if (value.type === Property) {
-      let firstTag = value.value.tags[0];
-
-      if (firstTag.type === ReferenceTag && firstTag.value.name === name) {
-        count++;
-      }
-    }
-  }
-  stack = stack.pop();
-
-  if (!stack.size) return count - 1;
-
-  ({ node, index: leafIdx } = stack.value);
-
-  do {
-    for (let i = leafIdx - 1; i >= 0; i--) {
-      let value = Tags.getValues(node)[i];
-
-      if (Array.isArray(value)) {
-        let childNode = value;
-        let { names } = Tags.getSums(childNode);
-
-        let res;
-        if ((res = Tags.getAtName(name, names))) {
-          count += res;
-        }
-      }
-    }
-    stack = stack.pop();
-    if (stack.size) {
-      ({ node, index: leafIdx } = stack.value);
-    }
-  } while (stack.size);
-
-  // the initializer doesn't matter to us
-  // also we're going from fenceposts to gaps
-  return count - 1;
+  return [GapTag, NullTag].includes(parseTagType(tag));
 };
 
-export const getPropertyTagsIndex = (agAstNode, type, name, index, shiftIndex) => {
-  let firstPropsIndex = __getPropertyTagsIndex(agAstNode, type, name, 0);
-  let prop = firstPropsIndex == null ? null : Tags.getAt(firstPropsIndex, getTags(agAstNode));
-  let ref = prop?.value.reference;
-  let sums = Tags.getSums(agAstNode.value.tags);
-  let counts = name ? sums.names : sums.types;
-
-  if (ref?.flags.array) {
-    if (index < 0) {
-      index = Tags.getAtName(type, counts) + index;
-    } else if (index == null) {
-      index = Tags.getAtName(name, counts) - 1;
-
-      if (index < 0) return null;
-    }
-  }
-
-  let parentIndex = __getPropertyTagsIndex(agAstNode, type, name, index ?? 0);
-
-  if (parentIndex != null && ref?.flags.expression) {
-    let shiftIndex_ = shiftIndex == null ? -1 : shiftIndex;
-    if (shiftIndex_ < 0) {
-      let shifts = 0;
-      // TODO speed this up for deeply nested shifts
-      // algorithm: make big jump forward, then look at shift index to see if we overshot completely
-      // works because we know the size of the thing and a bigger thing doesn't fit in a smaller one
-      while (Tags.getAt(parentIndex + shifts, agAstNode.value.children)?.value.shift) {
-        shifts++;
-      }
-
-      if (-shiftIndex_ > shifts + 1) return null;
-
-      return parentIndex + shifts + shiftIndex_ + 1;
-    } else {
-      if (parentIndex + shiftIndex_ >= Tags.getSize(agAstNode.value.tags)) {
-        return null;
-      }
-
-      return parentIndex + shiftIndex_;
-    }
-  }
-
-  return parentIndex;
-};
-
-const __getPropertyTagsIndex = (agAstNode, type, name, index) => {
-  let nameCount = 0;
-  let node = Tags.getValues(agAstNode.value.tags)[1];
-  let idx = -1;
-
-  // drill into subtrees, passing over subtrees with too few references of the desired name
-  outer: while (node) {
-    let sums = Tags.getSums(node);
-
-    if (!sums) return null;
-
-    let valueNameCount =
-      name != null ? Tags.getAtName(name, sums.names) : Tags.getAtName(type, sums.types);
-
-    if (nameCount + valueNameCount < index) {
-      return null;
-    }
-
-    for (const value of Tags.getValues(node)) {
-      if (!isArray(value)) {
-        idx++;
-        let tag = value;
-        if (tag.type === Property) {
-          let { tags, reference } = tag.value;
-          if (tags[0].type === ReferenceTag) {
-            if (
-              (name != null && reference.name === name) ||
-              (type != null && reference.type === type)
-            ) {
-              nameCount += 1;
-              if (nameCount > index) {
-                return idx + 1;
-              }
-            }
-          }
-        }
-      } else {
-        let valueSums = Tags.getSums(value);
-        if (
-          nameCount +
-            (name != null
-              ? Tags.getAtName(name, valueSums.names)
-              : Tags.getAtName(type, valueSums.types)) >
-          index
-        ) {
-          node = value;
-          continue outer;
-        } else {
-          nameCount +=
-            (name != null
-              ? Tags.getAtName(name, valueSums.names)
-              : Tags.getAtName(type, valueSums.types)) ?? 0;
-          idx += Tags.getSize(value);
-        }
-      }
-    }
-
-    return null;
-  }
-
-  return null;
-};
-
-const { hasOwn, freeze } = Object;
-const { isArray } = Array;
-
 export const getOriginalFirstNode = (node) => {
   if (node.type !== TreeNode) return;
 
@@ -529,7 +355,10 @@ export const getFirstNodeProperty = (node) => {
       if (!ref.flags.expression) {
         return child;
       } else {
-        let tagsIndex = getPropertyTagsIndex(node, ref.type, ref.name, 0, -1);
+        let tagsIndex = Tags.getIndex(
+          buildFullPathSegment(ref.type, ref.name, 0, -1),
+          node.value.tags,
+        );
         return Tags.getAt(tagsIndex, getTags(node), 2)?.value;
       }
       // is it shifted?
@@ -538,22 +367,6 @@ export const getFirstNodeProperty = (node) => {
   return null;
 };
 
-export const referenceIsSingular = (ref) => {
-  return (ref.name && !['#', '@'].includes(ref.type)) || ref.type === '_';
-};
-
-export const referencesAreEqual = (a, b) => {
-  return (
-    a === b ||
-    (a.type === b.type &&
-      a.name === b.name &&
-      a.flags.array === b.flags.array &&
-      a.flags.intrinsic === b.flags.intrinsic &&
-      a.flags.hasGap === b.flags.hasGap &&
-      a.flags.expression === b.flags.expression)
-  );
-};
-
 export const isDefined = (obj, key) => hasOwn(obj, key) && obj[key] !== undefined;
 export const isUndefined = (obj, key) => !hasOwn(obj, key) || obj[key] === undefined;
 
@@ -570,10 +383,8 @@ export const getProperty = (pathSegment, node) => {
 
   if (pathSegment == null) throw new Error('Bad path segment');
 
-  let { name, type, index, shiftIndex } =
-    typeof pathSegment === 'string' ? buildPathSegment(pathSegment) : pathSegment;
-
-  let propIndex = getPropertyTagsIndex(node, type, name, index, shiftIndex);
+  let segment = typeof pathSegment === 'string' ? buildPathSegment(pathSegment) : pathSegment;
+  let propIndex = Tags.getIndex(segment, node.value.tags);
 
   if (propIndex == null) return null;
 
@@ -638,7 +449,12 @@ export const getOr = (defaultValue, path, node) => {
   return isNullNode(result) ? null : result;
 };
 
+export const set = (path, value, node) => {
+  return Path.from(node).replaceAt(path, value).node;
+};
+
 export function* list(name, node) {
+  if (isArray(name)) throw new Error('not supported');
   let count = countList(name, node);
 
   for (let i = 0; i < count; i++) {
@@ -651,10 +467,10 @@ export const countList = (name, node) => {
 
   if (name == null) throw new Error('Bad path');
 
-  return Tags.getAtName(name, Tags.getSums(getTags(node)).names);
+  return Tags.findStats(name, Tags.getSums(getTags(node)).names);
 };
 
-export function* allTagPathsFor(range, options = {}) {
+export function* allTagPathsFor(range, options = freeze({})) {
   if (range == null) return;
 
   if (range[0] && !(range[0] instanceof TagPath)) throw new Error();
@@ -666,7 +482,7 @@ export function* allTagPathsFor(range, options = {}) {
   let path = startPath;
 
   while (path) {
-    if (path.inner && path.previousSibling.tag.type === ReferenceTag) {
+    if (path.inner && path.previousSibling.type === ReferenceTag) {
       path = TagPath.from(path.inner, 0);
     }
 
@@ -684,7 +500,7 @@ export function* allTagPathsFor(range, options = {}) {
 
     if (
       endPath &&
-      path.tag.type === CloseNodeTag &&
+      path.type === CloseNodeTag &&
       gapPath &&
       gapPath.tagsIndex === endPath.tagsIndex &&
       gapPath.path.node === endPath.path.node
@@ -695,7 +511,7 @@ export function* allTagPathsFor(range, options = {}) {
   }
 }
 
-export function* allTagsFor(range, options = {}) {
+export function* allTagsFor(range, options = freeze({})) {
   for (let path of allTagPathsFor(range, options)) {
     yield path.tag;
   }
@@ -786,51 +602,27 @@ export const getAttributes = (node) => {
 };
 
 export const isSelfClosingTag = (tag) => {
-  return tag.type === OpenNodeTag
-    ? tag.value.selfClosing
-    : [NullTag, GapTag].includes(tag.type)
-    ? true
-    : false;
-};
-
-export let pathForTagPath = (tagPath) => {
-  let refTagPath = tagPath;
-  let isShift = tagPath.tag.type === ShiftTag;
-
-  if (isShift) {
-    refTagPath = tagPath.siblingAt(tagPath.tagsIndex - tagPath.tag.value.index);
-  }
-
-  let { type, name } = refTagPath.tag.value;
-
-  if (refTagPath.tag.type !== ReferenceTag) throw new Error();
-
-  let index = getChildPropertyIndex(tagPath.node, refTagPath.tagsIndex);
-  let shiftIndex = isShift ? (tagPath.tag.value.index ?? 0) + 1 : null;
-
-  return [{ type, name, index, shiftIndex }];
-};
-
-let getSigilTag_ = (tag) => {
-  switch (tag.type) {
-    case Property:
-      return getTags(tag.value.property.node)[1][0];
-    case TreeNode:
-    case NullNode:
-    case GapNode:
-      return getTags(tag)[1][0];
-    case OpenNodeTag:
-    case GapTag:
-    case NullTag:
-      return tag;
-  }
+  if (!tag) return false;
+  let tagType = parseTagType(tag);
+  if ([NullTag, GapTag].includes(tagType)) return true;
+  if (tagType !== OpenNodeTag) return false;
+  let tag_ = isString(tag) ? parseOpenNodeTag(tag) : tag;
+  return tag_.value.selfClosing;
 };
 
 const parents = new WeakMap();
 
 export const Path = class AgastPath {
   static from(node) {
-    return node && new Path(null, buildPathFrame(buildPropertyTag([null, [], node])));
+    return (
+      node &&
+      new Path(
+        null,
+        buildPathFrame(
+          buildPropertyTag(BList.fromValues([Tags.fromValues([]), Tags.fromValues([]), node], 1)),
+        ),
+      )
+    );
   }
 
   static wrap(frames) {
@@ -841,17 +633,17 @@ export const Path = class AgastPath {
     return Path.from(buildNode(openTag));
   }
 
-  static set(node, path, value) {
+  static set(path, value, node) {
     return Path.from(node).replaceAt(path, value).node;
   }
 
-  static get(node, path) {
+  static get(path, node) {
     return Path.from(node).get(path).node;
   }
 
   constructor(parent, frame) {
     if (!frame) throw new Error();
-    let frame_ = isArray(frame) ? BTree.getAt(-1, frame) : frame;
+    let frame_ = isArray(frame) ? BList.getAt(-1, frame) : frame;
     let { property, parentIndex, isGap } = frame_;
     let { node } = property.value;
 
@@ -868,13 +660,13 @@ export const Path = class AgastPath {
       parents.set(this, parent);
     }
 
-    this.depth = parent ? parent.depth + 1 : isArray(frame) ? BTree.getSize(frame) - 1 : 0;
+    this.depth = parent ? parent.depth + 1 : isArray(frame) ? BList.getSize(frame) - 1 : 0;
     this.frame = frame_;
     this.frames = !parent
       ? isArray(frame)
         ? frame
-        : BTree.fromValues([frame])
-      : BTree.push(parent.frames, frame);
+        : BList.fromValues([frame])
+      : BList.push(frame, parent.frames);
 
     buildSkips(this);
 
@@ -888,18 +680,10 @@ export const Path = class AgastPath {
       throw new Error();
     }
 
-    if (
-      parentIndex != null &&
-      !parent?.node.value.flags.token &&
-      (!this.referenceTag || ![ReferenceTag, ShiftTag].includes(this.referenceTag.type))
-    ) {
-      throw new Error();
-    }
-
     if (
       parent_ &&
       (isGap
-        ? BTree.getAt(0, parent_.node.value.bounds[0]).property
+        ? BList.getAt(0, parent_.node.value.bounds.leading).property
         : parent_.tagPathAt(parentIndex).tag) !== property
     ) {
       throw new Error('Path not reachable');
@@ -914,12 +698,12 @@ export const Path = class AgastPath {
 
   push(tagsIndex, isGap) {
     let tag = isGap
-      ? BTree.getAt(0, this.node.value.bounds[0]).property
+      ? BList.getAt(0, this.node.value.bounds.leading).property
       : tagsIndex != null
       ? Tags.getAt(tagsIndex, this.tags)
       : null;
 
-    if (!tag || tag.type !== Property) {
+    if (!tag || parseTagType(tag) !== Property) {
       return null;
     }
 
@@ -940,7 +724,7 @@ export const Path = class AgastPath {
       return parent;
     }
 
-    parent = new Path(null, BTree.pop(frames));
+    parent = new Path(null, BList.pop(frames));
 
     parents.set(this, parent);
 
@@ -959,6 +743,10 @@ export const Path = class AgastPath {
     return this.frame.property.value.node;
   }
 
+  get value() {
+    return this.node.value;
+  }
+
   get name() {
     let { node } = this;
     return node.type === TreeNode ? node.value.name : null;
@@ -986,6 +774,7 @@ export const Path = class AgastPath {
   getChild(childrenIndex) {
     let { node } = this;
     if (isStubNode(node)) return null;
+
     return Tags.getAt(childrenIndex, getChildren(node)) || null;
   }
 
@@ -999,7 +788,7 @@ export const Path = class AgastPath {
 
   getPropertyTagPath(childrenIndex) {
     let tagPath = this.tagPathAt(childrenIndex + 1);
-    return tagPath && tagPath.tag.type === Property ? tagPath : null;
+    return tagPath && tagPath.type === Property ? tagPath : null;
   }
 
   getReferenceTagPath(childrenIndex) {
@@ -1025,12 +814,12 @@ export const Path = class AgastPath {
 
   get openTagPath() {
     let tagPath = TagPath.from(this, 0);
-    return tagPath.tag.type === OpenNodeTag ? tagPath : null;
+    return tagPath.type === OpenNodeTag ? tagPath : null;
   }
 
   get closeTagPath() {
     let tagPath = TagPath.from(this, -1);
-    return tagPath.tag.type === CloseNodeTag ? tagPath : null;
+    return tagPath.type === CloseNodeTag ? tagPath : null;
   }
 
   get openTag() {
@@ -1038,7 +827,7 @@ export const Path = class AgastPath {
   }
 
   get open() {
-    return this.openTag.value;
+    return parseOpenNodeTag(this.openTag).value;
   }
 
   get closeTag() {
@@ -1050,11 +839,12 @@ export const Path = class AgastPath {
   }
 
   get bindingTags() {
-    return this.parentPropertyPath?.tag.value.tags[1];
+    return this.parentPropertyPath?.tag.value.tags[1][1];
   }
 
   get reference() {
-    return this.referenceTag?.value ?? null;
+    let { referenceTag } = this;
+    return referenceTag && parseTag(referenceTag)?.value;
   }
 
   get referenceTag() {
@@ -1080,8 +870,8 @@ export const Path = class AgastPath {
       return null;
     }
     let path = TagPath.from(this.parent, this.parentIndex);
-    if (path.tag.type === ShiftTag) {
-      path = TagPath.from(this.parent, this.parentIndex - path.tag.value.index);
+    if (path.next?.type === ShiftTag) {
+      path = TagPath.from(this.parent, this.parentIndex - path.value.shift.index);
     }
     return path;
   }
@@ -1096,7 +886,7 @@ export const Path = class AgastPath {
 
   get firstPropertyTagPath() {
     let tagPath = this.tagPathAt(0);
-    while (tagPath && (!tagPath.propertyPath || isNullNode(tagPath.propertyPath.tag.value.node))) {
+    while (tagPath && (!tagPath.propertyPath || isNullNode(tagPath.propertyPath.value.node))) {
       tagPath = tagPath.nextSibling;
       if (tagPath?.propertyPath) {
         tagPath = tagPath.propertyPath;
@@ -1107,7 +897,7 @@ export const Path = class AgastPath {
 
   get lastPropertyTagPath() {
     let tagPath = this.tagPathAt(-1);
-    while (tagPath && (!tagPath.propertyPath || isNullNode(tagPath.propertyPath.tag.value.node))) {
+    while (tagPath && (!tagPath.propertyPath || isNullNode(tagPath.propertyPath.value.node))) {
       tagPath = tagPath.previousSibling;
       if (tagPath?.propertyPath) {
         tagPath = tagPath.propertyPath;
@@ -1140,7 +930,9 @@ export const Path = class AgastPath {
       while (!pathInst.node.value.name && pathInst.node.value.type === Symbol.for('_')) {
         if (pathInst.depth) throw new Error();
         skippedRootFragment = true;
-        pathInst = pathInst.push(getPropertyTagsIndex(pathInst.node, '_', null, 0));
+        pathInst = pathInst.push(
+          Tags.getIndex(buildFullPathSegment('_', null, 0), pathInst.node.value.tags),
+        );
       }
     }
 
@@ -1160,12 +952,9 @@ export const Path = class AgastPath {
 
       if (i === 0 && seg.type === '_' && skippedRootFragment) continue;
 
-      let tagsIndex = getPropertyTagsIndex(
-        pathInst.node,
-        seg.type,
-        seg.name,
-        seg.index,
-        seg.shiftIndex,
+      let tagsIndex = Tags.getIndex(
+        buildFullPathSegment(seg.type, seg.name, seg.index, seg.shiftIndex),
+        pathInst.node.value.tags,
       );
 
       if (tagsIndex == null) return null;
@@ -1177,9 +966,9 @@ export const Path = class AgastPath {
   }
 
   replaceWith(node, bindingTags) {
-    let bindings = bindingTags?.map((tag) => tag.value); // TODO improve here
+    let bindings = bindingTags?.map((tag) => parseTag(tag).value); // TODO improve here
     if (bindings != null && !isArray(bindings)) throw new Error();
-    if (!isPlainObject(node)) throw new Error();
+    if (!isNode(node)) throw new Error();
 
     if (!node) throw new Error();
 
@@ -1191,7 +980,7 @@ export const Path = class AgastPath {
     let path = this.parent;
     let replacementPath = [];
 
-    let targetShift_ = this.parent?.parentProperty?.value.tags[0];
+    let targetShift_ = this.parent?.parentProperty?.value.tags[1][0];
     let targetShift = targetShift_ && (targetShift_.type === ReferenceTag ? null : targetShift_);
     let targetReference = this.reference;
     let targetBindings = bindings == null ? this.bindings : bindings;
@@ -1206,24 +995,29 @@ export const Path = class AgastPath {
 
       let { tags, shift } = Tags.getAt(targetParentIndex, getTags(path.node)).value;
 
-      let firstTag = tags[0];
+      let firstTag = tags[1][0];
       let newFirstTag = firstTag;
       if (shift) {
         newFirstTag = buildChild(ReferenceTag, targetReference);
       }
 
-      let tags_ = [
-        firstTag,
-        targetBindings.map((binding) => buildChild(BindingTag, binding)),
-        value,
-      ];
+      let tags_ = BList.fromValues(
+        [
+          firstTag,
+          Tags.fromValues(
+            map((binding) => buildChild(BindingTag, binding), arrayValues(targetBindings)),
+          ),
+          value,
+        ],
+        1,
+      );
 
       if (!held && !shift) {
         built = buildNode(
           Tags.replaceAt(
             targetParentIndex,
-            built.value.tags,
             buildChild(Property, buildProperty(tags_)),
+            built.value.tags,
           ),
         );
         replacementPath.push(targetParentIndex);
@@ -1234,16 +1028,18 @@ export const Path = class AgastPath {
         let nextShift = nextProperty?.type === Property && nextProperty.value.shift;
 
         if (nextShift) {
-          let { reference, bindings } = BTree.getAt(-1, nextProperty.value.node.value.bounds[0])
-            .property.value;
+          let { reference, bindings } = BList.getAt(
+            -1,
+            nextProperty.value.node.value.bounds.leading,
+          ).property.value;
 
           path = path.push(i);
 
           built = buildNode(
             Tags.replaceAt(
               targetParentIndex - shift.index,
-              built.value.tags,
               buildChild(Property, buildProperty(tags_)),
+              built.value.tags,
             ),
           );
 
@@ -1252,17 +1048,14 @@ export const Path = class AgastPath {
             built = buildNode(Tags.removeAt(targetParentIndex + 1, built.value.tags));
           }
 
-          tags_ = [newFirstTag, tags_[1], tags_[2]];
+          tags_ = BList.fromValues([newFirstTag, tags_[1][1], tags_[1][2]], 1);
 
           targetShift = null;
           targetReference = reference;
           targetBindings = bindings;
-          targetParentIndex = getPropertyTagsIndex(
-            nextProperty.value.node,
-            reference.type,
-            reference.name,
-            0,
-            0,
+          targetParentIndex = Tags.getIndex(
+            buildFullPathSegment(reference.type, reference.name, 0, 0),
+            nextProperty.value.node.value.tags,
           );
           held = null;
 
@@ -1272,8 +1065,8 @@ export const Path = class AgastPath {
           built = buildNode(
             Tags.replaceAt(
               targetParentIndex,
-              getTags(built),
               buildChild(Property, buildProperty(tags_, shift)),
+              getTags(built),
             ),
           );
           replacementPath.push(targetParentIndex);
@@ -1283,7 +1076,7 @@ export const Path = class AgastPath {
       held = targetShift ? value : null;
       heldCount = held ? heldCount + 1 : 0;
 
-      targetShift_ = path?.parentProperty?.value.tags[0];
+      targetShift_ = path?.parentProperty?.value.tags[1][0];
       targetShift = targetShift_ && (targetShift_.type === ReferenceTag ? null : targetShift_);
       targetReference = path.reference;
       targetBindings = path.bindings;
@@ -1295,7 +1088,131 @@ export const Path = class AgastPath {
   }
 
   replaceAt(path, node, bindings) {
-    return this.get(path).replaceWith(node, bindings).atDepth(0);
+    return this.get(path).replaceWith(node, bindings).atDepth(this.depth);
+  }
+
+  removeAt(path) {
+    if (!this.depth && !path.length) {
+      return null;
+    }
+
+    let built = null;
+    let lastPath = this.get(path);
+    let path_ = lastPath.parent;
+    let replacementPath = [];
+
+    let targetShift_ = lastPath.parent?.parentProperty?.value.tags[1][0];
+    let targetShift = targetShift_ && (targetShift_.type === ReferenceTag ? null : targetShift_);
+    let targetReference = lastPath.reference;
+    let targetBindings = lastPath.bindings;
+    let targetParentIndex = lastPath.parentIndex;
+    let held = null;
+    let heldCount = 0;
+    let value;
+
+    while (path_) {
+      value = built;
+      built = buildNode(getTags(path_.node));
+
+      let { tags, shift } = Tags.getAt(targetParentIndex, getTags(path_.node)).value;
+
+      let firstTag = tags[1][0];
+      let newFirstTag = firstTag;
+      if (shift) {
+        newFirstTag = buildChild(ReferenceTag, targetReference);
+      }
+
+      let tags_ =
+        value &&
+        BList.fromValues(
+          [
+            firstTag,
+            Tags.fromValues(
+              map((binding) => buildChild(BindingTag, binding), arrayValues(targetBindings)),
+            ),
+            value,
+          ],
+          1,
+        );
+
+      if (!held && !shift) {
+        if (tags_) {
+          built = buildNode(
+            Tags.replaceAt(
+              targetParentIndex,
+              buildChild(Property, buildProperty(tags_)),
+              built.value.tags,
+            ),
+          );
+        } else {
+          built = buildNode(Tags.removeAt(targetParentIndex, built.value.tags));
+        }
+        replacementPath.push(targetParentIndex);
+      } else {
+        let i = targetParentIndex + 1;
+        let nextProperty = Tags.getAt(i, built.value.tags);
+
+        let nextShift = nextProperty?.type === Property && nextProperty.value.shift;
+
+        if (nextShift) {
+          let { reference, bindings } = BList.getAt(
+            -1,
+            nextProperty.value.node.value.bounds.leading,
+          ).property.value;
+
+          path_ = path_.push(i);
+
+          built = buildNode(
+            Tags.replaceAt(
+              targetParentIndex - shift.index,
+              buildChild(Property, buildProperty(tags_)),
+              built.value.tags,
+            ),
+          );
+
+          targetParentIndex -= shift.index;
+          for (let i = shift.index - 1; i >= 0; i--) {
+            built = buildNode(Tags.removeAt(targetParentIndex + 1, built.value.tags));
+          }
+
+          tags_ = BList.fromValues([newFirstTag, tags_[1][1], tags_[1][2]], 1);
+
+          targetShift = null;
+          targetReference = reference;
+          targetBindings = bindings;
+          targetParentIndex = Tags.getIndex(
+            buildFullPathSegment(reference.type, reference.name, 0, 0),
+            nextProperty.value.node.value.tags,
+          );
+          held = null;
+
+          replacementPath.push(targetParentIndex);
+          continue;
+        } else {
+          built = buildNode(
+            Tags.replaceAt(
+              targetParentIndex,
+              buildChild(Property, buildProperty(tags_, shift)),
+              getTags(built),
+            ),
+          );
+          replacementPath.push(targetParentIndex);
+        }
+      }
+
+      held = targetShift ? value : null;
+      heldCount = held ? heldCount + 1 : 0;
+
+      targetShift_ = path_?.parentProperty?.value.tags[1][0];
+      targetShift = targetShift_ && (targetShift_.type === ReferenceTag ? null : targetShift_);
+      targetReference = path_.reference;
+      targetBindings = path_.bindings;
+      targetParentIndex = path_.parentIndex;
+      lastPath = path_;
+      path_ = path_.parent;
+    }
+
+    return Path.from(built);
   }
 
   mapOnto(rootNode) {
@@ -1321,19 +1238,19 @@ export const Path = class AgastPath {
     let { parent, node } = this;
     let sigilTag = getSigilTag(node);
 
-    return !parent && sigilTag && !!(isSelfClosingTag(sigilTag) || getCloseTag(node));
+    return !parent && sigilTag && !!(isSelfClosingTag(sigilTag) || getCloseNodeTag(node));
   }
 
   get held() {
     let tagPath = this.tagPathAt(-1);
 
     // TODO is this safe
-    if (tagPath.tag.type !== Property) return null;
+    if (tagPath.type !== Property) return null;
 
-    let { tags } = tagPath.tag.value;
+    let { tags } = tagPath.value;
 
-    if (tags[0]?.type === ShiftTag && !tags[2]) {
-      return TagPath.from(tagPath.path, tagPath.tagsIndex - 1).tag.value;
+    if (tags[1][0]?.type === ShiftTag && !tags[1][2]) {
+      return TagPath.from(tagPath.path, tagPath.tagsIndex - 1).value;
     }
 
     // if we're not at the left side, we aren't held
@@ -1350,8 +1267,8 @@ export const Path = class AgastPath {
     for (;;) {
       let refPath = coverParent.propertyKeyTagPath;
 
-      if (refPath?.tag.type === ShiftTag) {
-        return TagPath.from(refPath.path, refPath.tagsIndex - 1).tag.value;
+      if (refPath?.type === ShiftTag) {
+        return TagPath.from(refPath.path, refPath.tagsIndex - 1).value;
       }
 
       coverParent = coverParent.parent;
@@ -1364,57 +1281,24 @@ export const Path = class AgastPath {
   advance(tag) {
     if (!tag) throw new Error();
 
-    let tagPath = this.tagPathAt(-1, 2);
+    let tagPath = this.tagPathAt(-1, -1);
 
-    if (tagPath?.tag.type === Property ? tagPath?.nextSibling : tagPath?.next) throw new Error();
+    if (tagPath?.type === Property ? tagPath?.nextSibling : tagPath?.next) throw new Error();
 
     if (this.done) throw new Error();
 
     let resultPath = this;
 
-    switch (tag.type) {
-      case BindingTag: {
-        if (!this.lastPropertyTagPath) {
-          resultPath = this.advanceUnwrapped(buildReferenceTag()).path;
-        }
-        break;
-      }
-
-      case TreeNode:
-      case NullNode:
-      case GapNode:
-      case NullTag:
-      case GapTag:
-      case OpenNodeTag: {
-        let sigilTag = getSigilTag_(tag);
-
-        if (sigilTag.type === OpenNodeTag && sigilTag.value.type === Symbol.for('__')) {
-          break;
-        }
-
-        let lastTagPath = this.lastPropertyTagPath;
-        let newProperty = !lastTagPath || propertyIsFull(lastTagPath.tag);
-        let reference = lastTagPath?.referenceTagPath.tag.value;
+    let tag_ = isNode(tag) ? tag : parseTag(tag);
 
-        // TODO revisit this condition
-        if (!getFlags(this.node)?.token || reference?.type === '@' || tag.type === GapTag) {
-          if (newProperty || !lastTagPath.tag.value.tags.length) {
-            resultPath = this.advanceUnwrapped(buildReferenceTag()).path;
-          }
-        }
-
-        break;
-      }
-    }
-
-    if (tag.type === Property) {
-      resultPath = Path.from(buildNode(Tags.push(getTags(resultPath.node), tag)));
+    if (tag_.type === Property) {
+      resultPath = Path.from(buildNode(Tags.push(tag, getTags(resultPath.node))));
     } else {
-      resultPath = resultPath.advanceUnwrapped(tag).path;
+      resultPath = resultPath.advanceUnwrapped(printTag(tag)).path;
     }
 
     if (
-      (tag.type === CloseNodeTag || (tag.type === OpenNodeTag && tag.value.selfClosing)) &&
+      (tag_.type === CloseNodeTag || (tag_.type === OpenNodeTag && tag_.value.selfClosing)) &&
       resultPath.depth
     ) {
       return resultPath.parent;
@@ -1424,14 +1308,13 @@ export const Path = class AgastPath {
   }
 
   advanceUnwrapped(tag) {
-    if (!tag) throw new Error();
+    if (!isString(tag) && !isNode(tag)) throw new Error();
+    let tag_ = isString(tag) ? parseTag(tag) : tag;
 
     let tagPath = this.tagPathAt(-1, [-1, -1]);
 
     if (
-      [TreeNode, NullNode, GapNode].includes(tagPath?.tag.type)
-        ? tagPath?.nextSibling
-        : tagPath?.next
+      [TreeNode, NullNode, GapNode].includes(tagPath?.type) ? tagPath?.nextSibling : tagPath?.next
     )
       throw new Error();
 
@@ -1439,11 +1322,11 @@ export const Path = class AgastPath {
 
     let targetPath = tagPath && endsNode(tagPath.tag) ? this.parent : this;
 
-    switch (tag.type) {
+    switch (tag_.type) {
       case ReferenceTag: {
-        let { type, name, flags } = tag.value;
+        let { type, name, flags } = tag_.value;
 
-        if ([ReferenceTag, ShiftTag, BindingTag].includes(targetPath.tagPathAt(-1, -1)?.tag.type))
+        if ([ReferenceTag, ShiftTag, BindingTag].includes(targetPath.tagPathAt(-1, -1)?.type))
           throw new Error('invalid location for reference');
         if (!name && !type) throw new Error();
 
@@ -1456,22 +1339,25 @@ export const Path = class AgastPath {
         if (targetPath.open.type === Symbol.for('_') && !['_', '#'].includes(type))
           throw new Error();
 
-        if (tag.value.name) {
-          let property = getProperty(tag.value.name, targetPath.node);
+        if (tag_.value.name) {
+          let property = getProperty(tag_.value.name, targetPath.node);
           if (
-            getOr(null, tag.value.name, targetPath.node) &&
+            getOr(null, tag_.value.name, targetPath.node) &&
             !property.value.shift &&
-            !referencesAreEqual(tag.value, property.value.reference)
+            !Tags.referencesAreEqual(tag_.value, property.value.reference)
           ) {
             throw new Error('mismatched references');
           }
-        } else if (tag.value.type === '_') {
-          let rootIdx = getPropertyTagsIndex(targetPath.node, '_', null, 0);
+        } else if (tag_.value.type === '_') {
+          let rootIdx = Tags.getIndex(
+            buildFullPathSegment('_', null, 0),
+            targetPath.node.value.tags,
+          );
 
           if (
             rootIdx != null &&
-            !referencesAreEqual(
-              tag.value,
+            !Tags.referencesAreEqual(
+              tag_.value,
               Tags.getAt(rootIdx, getTags(targetPath.node)).value.reference,
             )
           ) {
@@ -1479,43 +1365,42 @@ export const Path = class AgastPath {
           }
         }
 
-        let property = buildChild(Property, buildProperty([tag]));
+        let property = buildChild(Property, buildProperty(BList.fromValues([printTag(tag)])));
 
         targetPath = targetPath.replaceWith(
-          buildNode(Tags.push(getTags(targetPath.node), property)),
+          buildNode(Tags.push(property, getTags(targetPath.node))),
         );
         break;
       }
 
       case BindingTag: {
-        if (![ReferenceTag, ShiftTag].includes(this.tagPathAt(-1, -1).tag.type)) {
+        if (![ReferenceTag, ShiftTag].includes(parseTagType(this.tagPathAt(-1, -1)))) {
           throw new Error('Invalid location for BindingTag');
         }
-        if (!tag.value.segments) throw new Error();
 
         let refPath = this.tagPathAt(-1, 0);
         let propPath = TagPath.from(refPath.path, refPath.tagsIndex);
 
-        let { shift } = propPath.tag.value;
+        let { shift } = propPath.value;
 
-        if (![ReferenceTag, ShiftTag].includes(refPath.tag.type)) throw new Error();
+        if (![ReferenceTag, ShiftTag].includes(refPath.type)) throw new Error();
 
-        if (refPath.tag.type === ShiftTag) {
+        if (refPath.type === ShiftTag) {
           refPath = TagPath.from(refPath.path, refPath.tagsIndex - shift.index, 0);
         }
 
-        let { 0: firstTag, 1: bindingTags = [] } = propPath.tag.value.tags;
-        let tags = [firstTag, [...bindingTags, tag]];
+        let { 0: firstTag, 1: bindingTags = [] } = propPath.value.tags[1];
+        let tags = BList.fromValues([firstTag, Tags.from(...bindingTags, tag_)], 1);
         let property = buildChild(Property, buildProperty(tags, shift));
 
         targetPath = this.replaceWith(
-          buildNode(Tags.replaceAt(propPath.tagsIndex, getTags(this.node), property)),
+          buildNode(Tags.replaceAt(propPath.tagsIndex, property, getTags(this.node))),
         );
         break;
       }
 
       case OpenNodeTag: {
-        let { literalValue, flags, type } = tag.value;
+        let { literalValue, flags, type, name, attributes } = tag_.value;
 
         if (this.held && flags.token) throw new Error();
 
@@ -1524,22 +1409,36 @@ export const Path = class AgastPath {
         }
 
         let parentProp = this.node && Tags.getAt(-1, getChildren(this.node));
-        let ref = parentProp.value.shift
+
+        if (parentProp && propertyIsFull(parentProp)) {
+          parentProp = null;
+        }
+
+        let ref = parentProp?.value.shift
           ? this.node &&
-            Tags.getAt(-1 - parentProp.value.shift.index, getChildren(this.node)).value.tags[0]
-              .value
-          : parentProp.value.reference;
+            parseTag(
+              Tags.getAt(-1 - parentProp.value.shift.index, getChildren(this.node)).value
+                .tags[1][0],
+            ).value
+          : parentProp?.value.reference;
 
-        if (this.node.value.flags.token && ref.type !== '@') throw new Error();
+        let parentFlags = parentProp?.value.shift ? flags : this.node.value.flags;
 
-        let node = buildNode(tag);
+        if (parentFlags.token && ref?.type !== '@') throw new Error();
 
+        let node;
         if (literalValue && !flags.token) {
-          throw new Error();
+          let newOpenTag = buildFullOpenNodeTag(flags, type, name, null, attributes);
+          let literalNode = Path.fromTag(
+            buildFullOpenNodeTag(tokenFlags, null, null, literalValue),
+          ).node;
+
+          node = Path.fromTag(newOpenTag).advance(literalNode).advance('</>').node;
+        } else {
+          node = buildNode(tag_);
         }
 
         targetPath = this.advanceUnwrapped(node).path;
-
         targetPath = targetPath.tagPathAt(-1).inner;
 
         break;
@@ -1548,11 +1447,11 @@ export const Path = class AgastPath {
       case GapTag:
       case NullTag: {
         // if (getSigilTag(this.node)) throw new Error();
-        if (this.tagPathAt(-1, 0).tag.type !== ReferenceTag) {
+        if (parseTagType(this.tagPathAt(-1, 0)) !== ReferenceTag) {
           throw new Error('Invalid location for NullTag');
         }
 
-        let node = buildNode(tag);
+        let node = buildNode(tag_);
 
         targetPath = this.advanceUnwrapped(node).path;
         // targetPath = targetPath.tagPathAt(-1).inner; // ?
@@ -1565,21 +1464,22 @@ export const Path = class AgastPath {
 
         let lastChild = targetPath.getChild(-1);
 
-        if (lastChild?.type === Property && !propertyIsFull(lastChild)) throw new Error();
+        if (isObject(lastChild) && lastChild?.type === Property && !propertyIsFull(lastChild))
+          throw new Error();
 
         let openTag = getOpenTag(node);
 
         if (!openTag) throw new Error();
-        if (openTag.value.selfClosing) throw new Error();
+        if (parseTag(openTag).value.selfClosing) throw new Error();
 
-        targetPath = targetPath.replaceWith(buildNode(Tags.push(getTags(node), tag)));
+        targetPath = targetPath.replaceWith(buildNode(Tags.push(tag_, getTags(node))));
         break;
       }
 
       case NullNode:
       case GapNode:
       case TreeNode: {
-        let node = tag;
+        let node = tag_;
         let parentPath = targetPath;
         let { node: parentNode } = parentPath;
 
@@ -1588,12 +1488,12 @@ export const Path = class AgastPath {
         if (isMultiFragment(node)) {
           let existingProperty = tagPath;
 
-          while (existingProperty?.tag.type === AttributeDefinition) {
-            existingProperty = existingProperty.previousSibling.propertyPath;
+          while (existingProperty?.type === AttributeDefinition) {
+            existingProperty = tagPath.siblingAt(existingProperty.tagsIndex - 1);
           }
 
           if (
-            existingProperty.tag.type !== OpenNodeTag &&
+            existingProperty.type !== OpenNodeTag &&
             existingProperty.tag &&
             !propertyIsFull(existingProperty.tag)
           ) {
@@ -1603,7 +1503,7 @@ export const Path = class AgastPath {
           let newPath = Path.from(buildNode(this.node.value.tags));
 
           for (let tag of Tags.traverse(node.value.children)) {
-            if (tag.type === Property) {
+            if (parseTagType(tag) === Property) {
               newPath = newPath.advance(tag);
             } else {
               newPath = newPath.advanceUnwrapped(tag).path.atDepth(0);
@@ -1614,11 +1514,11 @@ export const Path = class AgastPath {
           break;
         }
 
-        let shift = tagPath.tag.type === Property ? tagPath.tag.value.shift : undefined;
+        let shift = tagPath.type === Property ? tagPath.value.shift : undefined;
         let { held } = this;
 
         if (held) {
-          // let heldProperty = this.tagPathAt(-2, 2).tag.value;
+          // let heldProperty = this.tagPathAt(-2, 2).value;
           let matchesHeld = isGapNode(node);
           if (getRoot(node) && nodeIsComplete(node)) {
             matchesHeld =
@@ -1626,8 +1526,10 @@ export const Path = class AgastPath {
               isGapNode(node) ||
               held.node === node ||
               held.node ===
-                BTree.getAt(-BTree.getSize(held.node.value.bounds[0]), node.value.bounds[0])
-                  .property.value.node;
+                BList.getAt(
+                  -BList.getSize(held.node.value.bounds.leading),
+                  node.value.bounds.leading,
+                ).property.value.node;
             if (!matchesHeld) {
               // TODO We're passing by the node that shifted if it's a cover!
               throw new Error();
@@ -1636,17 +1538,17 @@ export const Path = class AgastPath {
         }
 
         if (propertyIsFull(tagPath.tag)) {
-          let tags = [null, [], node];
+          let tags = BList.fromValues([Tags.fromValues([]), Tags.fromValues([]), node], 1);
           let property = buildChild(Property, buildProperty(tags, shift));
 
-          targetPath = this.replaceWith(buildNode(Tags.push(parentNode.value.tags, property)));
+          targetPath = this.replaceWith(buildNode(Tags.push(property, parentNode.value.tags)));
         } else {
-          let { 0: firstTag, 1: bindingTags = [] } = tagPath.tag.value.tags;
-          let tags = [firstTag, bindingTags, node];
+          let { 0: firstTag, 1: bindingTags = Tags.fromValues([]) } = tagPath.value.tags[1];
+          let tags = BList.fromValues([firstTag, bindingTags, node], 1);
           let property = buildChild(Property, buildProperty(tags, shift));
 
           targetPath = this.replaceWith(
-            buildNode(Tags.replaceAt(tagPath.tagsIndex, parentNode.value.tags, property)),
+            buildNode(Tags.replaceAt(tagPath.tagsIndex, property, parentNode.value.tags)),
           );
         }
 
@@ -1662,10 +1564,10 @@ export const Path = class AgastPath {
 
         // add undefined attributes from value
         let { node } = this;
-        if (tag.type !== AttributeDefinition) throw new Error();
+        if (tag_.type !== AttributeDefinition) throw new Error();
 
-        let { path, value } = tag.value;
-        let openTag = getOpenTag(node);
+        let { path, value } = tag_.value;
+        let openTag = parseTag(getOpenTag(node));
         let { attributes } = node.value;
 
         if (!objHas(attributes, path) && objGet(attributes, path) !== undefined)
@@ -1675,10 +1577,10 @@ export const Path = class AgastPath {
 
         let { flags, name } = openTag.value;
         attributes = immSet(attributes, path, value);
-        let newOpenTag = buildOpenNodeTag(flags, name, null, attributes);
+        let newOpenTag = buildOpenNodeTag(flags, name, null, printObject(attributes));
 
         targetPath = this.replaceWith(
-          buildNode(Tags.push(Tags.replaceAt(0, getTags(node), newOpenTag), tag)),
+          buildNode(Tags.push(tag_, Tags.replaceAt(0, newOpenTag, getTags(node)))),
         );
         break;
       }
@@ -1691,7 +1593,7 @@ export const Path = class AgastPath {
         let { reference, shift: heldShift } = lastPropertyTag.value;
 
         if (!reference) {
-          ({ reference } = this.tagPathAt(-1 - (heldShift?.index ?? 0)).tag.value);
+          ({ reference } = this.tagPathAt(-1 - (heldShift?.index ?? 0)).value);
         }
 
         if (!reference.flags.expression && reference.type !== '_') throw new Error();
@@ -1700,55 +1602,114 @@ export const Path = class AgastPath {
           ? buildShift(heldShift.index + 1, heldShift.height + 1)
           : buildShift(1, 3);
 
-        let property = buildChild(Property, buildProperty([tag], shift));
+        let property = buildChild(Property, buildProperty(BList.fromValues([tag]), shift));
 
-        targetPath = this.replaceWith(buildNode(Tags.push(this.node.value.tags, property)));
+        targetPath = this.replaceWith(buildNode(Tags.push(property, this.node.value.tags)));
         break;
       }
 
       case LiteralTag:
-        if (typeof tag.value !== 'string') throw new Error();
+        if (typeof tag_.value !== 'string') throw new Error();
 
-        targetPath = this.replaceWith(buildNode(Tags.push(this.node.value.tags, tag)));
+        targetPath = this.replaceWith(buildNode(Tags.push(tag_, this.node.value.tags)));
         break;
 
       default:
         throw new Error();
     }
 
-    return targetPath && TagPath.from(targetPath, -1, isNodeTag(tag) ? -1 : offsetForTag(tag));
+    return targetPath && TagPath.from(targetPath, -1, offsetForTag(tag_));
   }
 };
 
-Object.freeze(Path.prototype);
+freezeClass(Path);
 
 export const tagPathsAreEqual = (a, b) => {
   if (a == null || b == null) return b == a;
   return a.path.node === b.path.node && a.tagsIndex === b.tagsIndex;
 };
 
+let resolveIdx = (idx, tree) => {
+  let path = [];
+  let node = tree;
+
+  if (isArray(idx)) {
+    for (let seg of arrayValues(idx)) {
+      let index = typeof seg !== 'object' ? seg : seg.index;
+      if (typeof index === 'string') throw new Error();
+      if (!Tags.isNode(node)) return null;
+      let index_ = index < 0 ? Tags.getSize(node) + index : index;
+      path.push(index_);
+      node = Tags.getValues(node)[index_];
+      if (node && !Tags.isNode(node)) {
+        return path;
+      }
+      if (!node) return null;
+    }
+
+    return path;
+  }
+};
+
 export class TagPath {
   static from(path, tagsIndex, propertyIndex) {
     let tags = getTags(path.node);
     let size = Tags.getSize(tags);
     let index = Number.isFinite(tagsIndex) && tagsIndex < 0 ? size + tagsIndex : tagsIndex;
-
-    let propertyIndex_ = typeof propertyIndex === 'number' ? [propertyIndex] : propertyIndex;
-
-    let propTag = Tags.getAt(index, tags);
+    let propertyIndex_ = propertyIndex;
+    let propTag_ = Tags.getAt(index, tags);
+    let propTag = propTag_ && parseTag(propTag_);
 
     if (
       [OpenNodeTag, CloseNodeTag, LiteralTag, AttributeDefinition, GapTag, NullTag].includes(
         propTag?.type,
       )
     ) {
-      propertyIndex_ = [];
+      propertyIndex_ = null;
     }
 
-    let resolvedPropertyIndex =
-      propTag && (propertyIndex_?.length ? Tags.findPath(propertyIndex_, propTag.value.tags) : []);
+    let idx = null;
+    if (propTag?.type === Property) {
+      if (isArray(propertyIndex_)) {
+        if (propertyIndex_.length) {
+          idx = resolveIdx(propertyIndex_, propTag.value.tags);
+        }
+      } else if (propertyIndex_ != null) {
+        let { tags } = propTag.value;
+        let bindingsSize = Tags.getSize(tags[1][1]);
+        let valuesSize = Tags.getValues(tags).length;
+        let tagsSize = valuesSize - (tags[1][1] ? 1 : 0) + bindingsSize;
+        let absoluteIndex = propertyIndex_ < 0 ? propertyIndex_ + tagsSize : propertyIndex_;
+
+        let bindingsStop = 1 + bindingsSize;
+
+        if (absoluteIndex === 0) {
+          idx = [0];
+        } else if (absoluteIndex > bindingsStop) {
+          idx = [2];
+        } else if (tags[1][1]) {
+          let result = Tags.findPath(absoluteIndex - 1, tags[1][1]).map(({ index }) => index);
+          if (Number.isFinite(arrayLast(result))) {
+            idx = [1].concat(result);
+          }
+        }
+      }
+    }
+
+    idx ||= [];
+
+    if (idx?.length) {
+      let tag = Tags.getAt(idx, propTag.value.tags);
+      if (isArray(tag)) {
+        idx = [];
+      }
+    }
+
+    freezeRecord(idx);
 
-    return resolvedPropertyIndex && new TagPath(path, index, resolvedPropertyIndex);
+    let pathExists = isArray(propertyIndex_) && propertyIndex_?.length ? idx.length : propTag;
+
+    return pathExists ? new TagPath(path, index, idx) : null;
   }
 
   static fromNode(node, tagsIndex, propertyIndex) {
@@ -1773,28 +1734,26 @@ export class TagPath {
     if (!Number.isFinite(tagsIndex) || tagsIndex < 0) throw new Error();
     if (!isArray(propertyIndex)) throw new Error();
 
-    let propertyIndex_ = Object.freeze([...propertyIndex]);
+    for (let index of recordValues(propertyIndex)) {
+      if (!(index >= 0) || !Number.isFinite(index)) throw new Error();
+    }
 
     let tag = Tags.getAt(tagsIndex, getTags(path.node));
 
-    if (propertyIndex_.length) {
-      tag = Tags.getAt(propertyIndex_, tag.value.tags);
+    if (propertyIndex.length) {
+      tag = Tags.getAt(propertyIndex, tag.value.tags);
     }
 
     if (tag == null || isArray(tag)) throw new Error();
 
-    for (let segment of propertyIndex_) {
-      if (!isPlainObject(segment) || !(segment.index === 0 || segment.index > 0)) throw new Error();
-    }
-
     this.path = path;
     this.tagsIndex = tagsIndex;
-    this.propertyIndex = propertyIndex_;
+    this.propertyIndex = propertyIndex;
 
     this.node = path.node;
     this.tag = tag;
 
-    if (tag.type === Property && propertyIndex_.length) throw new Error();
+    if (isObject(tag) && tag.type === Property && propertyIndex.length) throw new Error();
 
     freeze(this);
   }
@@ -1802,13 +1761,21 @@ export class TagPath {
   asPrimitive() {
     let { path, tagsIndex, propertyIndex } = this;
 
-    return Object.freeze({ path: path.asPrimitive(), tagsIndex, propertyIndex });
+    return freeze({ path: path.asPrimitive(), tagsIndex, propertyIndex });
   }
 
   get child() {
     return this.tag;
   }
 
+  get type() {
+    return parseTagType(this.tag);
+  }
+
+  get value() {
+    return parseTag(this.tag).value;
+  }
+
   get parentNode() {
     return this.path.parentNode;
   }
@@ -1830,12 +1797,12 @@ export class TagPath {
   get referenceTagPath() {
     let path = TagPath.from(this.path, this.tagsIndex, 0);
     if (path && path.propertyPath) {
-      let { shift } = path.propertyPath.tag.value;
+      let { shift } = path.propertyPath.value;
       if (shift) {
         path = TagPath.from(this.path, this.tagsIndex - shift.index, 0);
       }
     }
-    return path?.tag.type === ReferenceTag ? path : null;
+    return path?.type === ReferenceTag ? path : null;
   }
 
   get nextProperty() {
@@ -1843,33 +1810,33 @@ export class TagPath {
 
     let nextChild = TagPath.from(path, tagsIndex + 1);
 
-    return nextChild?.tag.type === Property ? nextChild : null;
+    return nextChild?.type === Property ? nextChild : null;
   }
 
   get nextSibling() {
     let { path, tagsIndex, propertyIndex } = this;
 
-    let propertyIndex0 = propertyIndex[0]?.index;
+    let propertyIndex0 = propertyIndex[0];
 
-    let nextChildIndex = tagsIndex === 0 ? 0 : tagsIndex - 1 + 1;
+    let nextChildIndex = tagsIndex;
     let nextChild = path.getChild(nextChildIndex);
 
     if (propertyIndex0 == null && !nextChild) {
-      return this.tag.type === CloseNodeTag ? null : path.closeTagPath;
+      return this.type === CloseNodeTag ? null : path.closeTagPath;
     }
 
     switch (propertyIndex0) {
       case 0:
       case 1: {
         let childIndex = tagsIndex - 1;
-        let bindingIndex = propertyIndex[1]?.index ?? -1;
+        let bindingIndex = propertyIndex[1] ?? -1;
         let binding = path.getBindingTagPath(childIndex, bindingIndex + 1);
         if (binding) return binding;
         return path.getNodeTagPath(childIndex);
       }
       case 2:
       default: {
-        if (!nextChild || nextChild.type !== Property) {
+        if (!nextChild || nextChild.type !== Property || !propertyIndex.length) {
           return path.tagPathAt(tagsIndex + 1);
         } else {
           let ref = path.getReferenceTagPath(nextChildIndex);
@@ -1916,38 +1883,34 @@ export class TagPath {
   get next() {
     let { path, tagsIndex, propertyIndex } = this;
 
-    propertyIndex = [...propertyIndex];
+    propertyIndex = [...recordValues(propertyIndex)];
 
     let leaving = false;
 
     for (;;) {
-      let tag = Tags.getAt(tagsIndex, getTags(path.node));
+      let tag = parseTag(Tags.getAt(tagsIndex, getTags(path.node)));
       let propTag = tag;
       let lastRef = null;
+      let wasLeaving = leaving;
       leaving = false;
 
       if (!tag) return null;
 
-      if (tag.type === Property) {
-        if (propertyIndex.length === 0 && !leaving) {
-          propertyIndex.push({ index: 0, node: tag.value.tags });
-        }
+      if (isObject(tag) && tag.type === Property && !wasLeaving) {
+        if (propertyIndex.length === 0) {
+          let { 0: open, 1: bindings } = tag.value.tags[1];
 
-        if (propertyIndex != null) {
-          propTag = Tags.getAt(propertyIndex, tag.value.tags);
-          lastRef = Tags.getAt(0, tag.value.tags);
+          let index = !isArray(open) ? 0 : !isArray(bindings) ? 1 : 2;
+
+          propertyIndex.push({ index, node: tag.value.tags });
         }
-      }
 
-      if (isArray(propTag)) {
-        if (propTag.length) {
-          // enter bindings array
-          propertyIndex.push({ index: 0, node: propTag });
-          propTag = propTag[propertyIndex[1].index];
-        } else {
-          propertyIndex = [{ index: propertyIndex[0].index + 1, node: tag }];
+        if (propertyIndex != null) {
+          let tag_ = Tags.getAt(propertyIndex, tag.value.tags);
+          propTag = isNode(tag_) ? tag_ : parseTag(tag_);
+          let lastRef_ = Tags.getAt([0], tag.value.tags);
+          lastRef = isArray(lastRef_) ? null : parseTag(lastRef_);
         }
-        continue;
       }
 
       let isInitialTag =
@@ -1956,21 +1919,21 @@ export class TagPath {
         arraysEqual(propertyIndex, this.propertyIndex);
 
       // done
-      if (!isInitialTag && !isNodeTag(propTag)) {
+      if (!isInitialTag && !isNodeTag(propTag) && propTag.type !== Property) {
         return TagPath.from(path, tagsIndex, propertyIndex);
       }
 
       // shift
-      if (propTag.type === BindingTag && lastRef.type === ShiftTag) {
+      if (propTag.type === BindingTag && lastRef?.type === ShiftTag) {
         let lastProp = Tags.getAt(tagsIndex, path.tags);
         let { shift } = lastProp.value;
         let refIndex = tagsIndex - shift.index;
         if (refIndex < 0) throw new Error();
-        let refTag = Tags.getAt(refIndex, path.tags, 0);
+        let refTag = parseTag(Tags.getAt(refIndex, path.tags, 0));
 
         if (refTag.type !== ReferenceTag) throw new Error();
 
-        let { node } = tag.value;
+        let { node } = parseTag(tag).value;
         if (!node) return null;
 
         path = new Path(path, tagsIndex);
@@ -1982,66 +1945,47 @@ export class TagPath {
         continue;
       }
 
-      let { nextSibling } = this;
+      // in
+      if (isNodeTag(propTag)) {
+        let shiftPath = path;
+
+        while (
+          shiftPath.parent &&
+          !Tags.getAt(shiftPath.parentIndex - 1, shiftPath.parent.node.value.children).value.shift
+        ) {
+          shiftPath = shiftPath.parent;
+        }
+
+        let isGap =
+          path.parent &&
+          tagsIndex === 1 &&
+          shiftPath.parent &&
+          Tags.getAt(shiftPath.parentIndex - 1, shiftPath.parent.node.value.children).value.shift &&
+          tag.value.node ===
+            Tags.getAt(shiftPath.parentIndex - 2, shiftPath.parent.node.value.children).value.node;
+
+        path = path.push(tagsIndex, isGap);
+        tagsIndex = 0;
+        propertyIndex = [];
+        continue;
+      }
 
       // over
+      let { nextSibling } = TagPath.from(path, tagsIndex, freeze([...arrayValues(propertyIndex)]));
+
       if (nextSibling) {
         ({ tagsIndex, propertyIndex } = nextSibling);
-        // in
-        if (isNodeTag(nextSibling.tag)) {
-          let shiftPath = path;
-
-          while (
-            shiftPath.parent &&
-            !Tags.getAt(shiftPath.parentIndex - 1, shiftPath.parent.node.value.children).value.shift
-          ) {
-            shiftPath = shiftPath.parent;
-          }
-
-          let isGap =
-            path.parent &&
-            tagsIndex === 1 &&
-            shiftPath.parent &&
-            Tags.getAt(shiftPath.parentIndex - 1, shiftPath.parent.node.value.children).value
-              .shift &&
-            tag.value.node ===
-              Tags.getAt(shiftPath.parentIndex - 2, shiftPath.parent.node.value.children).value
-                .node;
-
-          path = path.push(tagsIndex, isGap);
-          tagsIndex = 0;
-          propertyIndex = [];
-          continue;
-        } else {
-          return nextSibling;
-        }
+        propertyIndex = [...arrayValues(propertyIndex)];
+        continue;
       }
 
       // out
       if (path.parentIndex != null && path.parent) {
-        do {
-          if (
-            path.coverBoundary.parent &&
-            Tags.getAt(
-              [path.coverBoundary.parentIndex, 0],
-              path.coverBoundary.parent.node.value.tags,
-            )?.type === ShiftTag
-          ) {
-            // while
-            tagsIndex =
-              Tags.getSize(path.parent.node.value.tags) > path.parentIndex + 1
-                ? path.parentIndex + 1
-                : null;
-          } else {
-            tagsIndex = path.parentIndex + 1;
-          }
-
-          propertyIndex = [];
-          path = path.parent;
-          leaving = true;
+        tagsIndex = path.parentIndex;
+        propertyIndex = [];
+        path = path.parent;
 
-          if (!path) return null;
-        } while (tagsIndex == null);
+        if (!path) return null;
 
         leaving = true;
         continue;
@@ -2054,21 +1998,23 @@ export class TagPath {
   get nextUnshifted() {
     let { path, tagsIndex, propertyIndex } = this;
 
-    propertyIndex = [...propertyIndex];
+    propertyIndex = [...arrayValues(propertyIndex)];
 
     let leaving = false;
 
     for (;;) {
-      let tag = Tags.getAt(tagsIndex, getTags(path.node));
+      let tag = parseTag(Tags.getAt(tagsIndex, getTags(path.node)));
       let propTag = tag;
       let wasLeaving = leaving;
       leaving = false;
 
       if (!tag) return null;
 
-      if (tag.type === Property) {
+      if (isObject(tag) && tag.type === Property) {
         if (propertyIndex.length === 0 && !leaving) {
-          propertyIndex.push({ index: 0, node: tag.value.tags });
+          let { 0: open, 1: bindings } = tag.value.tags[1];
+          let index = !isArray(open) ? 0 : !isArray(bindings) ? 1 : 2;
+          propertyIndex.push({ index, node: tag.value.tags });
         }
 
         if (propertyIndex != null) {
@@ -2077,7 +2023,7 @@ export class TagPath {
       }
 
       if (isArray(propTag)) {
-        if (propTag.length) {
+        if (Tags.getSize(propTag)) {
           // enter bindings array
           propertyIndex.push({ index: 0, node: propTag });
           propTag = propTag[propertyIndex[1].index];
@@ -2097,7 +2043,7 @@ export class TagPath {
         tagsIndex === this.tagsIndex &&
         arraysEqual(propertyIndex, this.propertyIndex);
 
-      if (!wasLeaving && propTag.type === ReferenceTag && propTag.value.flags.expression) {
+      if (!wasLeaving && parseTagType(propTag) === ReferenceTag) {
         // move past shifts
 
         let shifts = 0;
@@ -2125,6 +2071,7 @@ export class TagPath {
       // over
       if (nextSibling) {
         ({ tagsIndex, propertyIndex } = nextSibling);
+        propertyIndex = [...arrayValues(propertyIndex)];
         continue;
       }
 
@@ -2159,7 +2106,7 @@ export class TagPath {
 
     let tag = Tags.getAt(tagsIndex, getTags(path.node));
 
-    return tag.type === Property ? path.tagPathAt(tagsIndex) : null;
+    return isObject(tag) && tag.type === Property ? path.tagPathAt(tagsIndex) : null;
   }
 
   get innerNode() {
@@ -2167,20 +2114,22 @@ export class TagPath {
   }
 
   get inner() {
-    let { tagsIndex, tag } = this;
+    let { tagsIndex, type } = this;
 
     let node;
-    switch (tag.type) {
+    switch (type) {
       case Property: {
-        ({ node } = tag.value);
+        ({ node } = this.tag.value);
         break;
       }
+      case GapNode:
+      case NullNode:
       case TreeNode: {
-        node = tag;
+        node = this.tag;
         break;
       }
       default:
-        throw new Error();
+        node = null;
     }
     return node && this.path.push(tagsIndex);
   }
@@ -2194,4 +2143,4 @@ export class TagPath {
   }
 }
 
-Object.freeze(TagPath.prototype);
+freezeClass(TagPath);