@bablr/agast-helpers 0.6.1 → 0.7.1

package/lib/path.js

@@ -1,8 +1,9 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
 import * as btree from '@bablr/agast-helpers/btree';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
 import {
   ReferenceTag,
-  ArrayInitializerTag,
+  InitializerTag,
   EmbeddedNode,
   DoctypeTag,
   OpenNodeTag,
@@ -12,7 +13,7 @@ import {
   ShiftTag,
 } from './symbols.js';
 import {
-  buildArrayInitializerTag,
+  buildInitializerTag,
   buildEmbeddedNode,
   buildGapTag,
   buildReferenceTag,
@@ -20,10 +21,11 @@ import {
 } from './builders.js';
 
 export const getOpenTag = (node) => {
-  let tag = btree.getAt(0, node.children);
+  if (!node.children.length) return null;
+  let tag = sumtree.getAt(0, node.children);
   if (tag.type === NullTag || tag.type === GapTag) return null;
   if (tag.type === DoctypeTag) {
-    tag = btree.getAt(1, node.children);
+    tag = sumtree.getAt(1, node.children);
   }
   if (tag && tag.type !== OpenNodeTag) throw new Error();
   return tag;
@@ -31,13 +33,13 @@ export const getOpenTag = (node) => {
 
 export const getCloseTag = (node) => {
   const { children } = node;
-  const tag = btree.getAt(-1, children);
+  const tag = sumtree.getAt(-1, children);
   if (tag.type !== CloseNodeTag) return null;
   return tag;
 };
 
 export const isNullNode = (node) => {
-  return node && node.type === null && btree.getAt(0, node.children).type === NullTag;
+  return node && node.type === null && sumtree.getAt(0, node.children).type === NullTag;
 };
 
 export const isFragmentNode = (node) => {
@@ -45,7 +47,117 @@ export const isFragmentNode = (node) => {
 };
 
 export const isGapNode = (node) => {
-  return node && node.type === null && btree.getAt(0, node.children).type === GapTag;
+  return node && node.type === null && sumtree.getAt(0, node.children).type === GapTag;
+};
+
+export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
+  let stack = sumtree.findPath(childrenIndex, agAstNode.children);
+  let { node, index: leafIdx } = stack.value;
+  let leaf = sumtree.getAt(leafIdx, node);
+
+  if (leaf.type !== ReferenceTag) return null;
+
+  let { name, isArray } = leaf.value;
+  let count = -1;
+
+  if (!isArray) return null;
+
+  for (let i = leafIdx; i >= 0; i--) {
+    let value = sumtree.getAt(i, node);
+
+    if (value.type === ReferenceTag && value.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 childNode = sumtree.getValues(node)[i];
+      let { references } = sumtree.getSums(childNode);
+
+      if (hasOwn(references, name)) {
+        count += references[name];
+      }
+    }
+    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;
+};
+
+export const getPropertyChildrenIndex = (agAstNode, reference) => {
+  let { index, name } = reference.value;
+  if (isArray) {
+    if (index == null) {
+      index = btree.getSize(agAstNode.properties[name]) - 1;
+    }
+  }
+
+  let firstRefIndex = __getPropertyChildrenIndex(agAstNode, name, 0);
+  let nextTag = sumtree.getAt(firstRefIndex + 1, agAstNode.children);
+
+  return __getPropertyChildrenIndex(
+    agAstNode,
+    name,
+    index + (nextTag.type === InitializerTag ? 1 : 0),
+  );
+};
+
+export const getInitializerChildrenIndex = (agAstNode, reference) => {
+  return __getPropertyChildrenIndex(agAstNode, reference.value.name, 0);
+};
+
+const __getPropertyChildrenIndex = (agAstNode, name, index) => {
+  let nameCount = 0;
+  let node = agAstNode.children;
+  let idx = -1;
+
+  // drill into subtrees, passing over subtrees with too few references of the desired name
+  outer: while (node) {
+    let isLeaf = sumtree.isLeafNode(node);
+    let sums = sumtree.getSums(node);
+    let valueNameCount = sums.references[name];
+
+    if (nameCount + valueNameCount < index) {
+      return null;
+    }
+
+    for (const value of sumtree.getValues(node)) {
+      if (isLeaf) {
+        idx++;
+        let tag = value;
+        if (tag.type === ReferenceTag && tag.value.name === name) {
+          nameCount += 1;
+          if (nameCount > index) {
+            return idx;
+          }
+        }
+      } else {
+        let valueSums = sumtree.getSums(value);
+        if (nameCount + valueSums.references[name] > index) {
+          node = value;
+          continue outer;
+        } else {
+          nameCount += valueSums.references[name] ?? 0;
+          idx += sumtree.getSize(value);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  return null;
 };
 
 const { hasOwn } = Object;
@@ -70,7 +182,7 @@ export const getProperties = (ref, properties) => {
     }
   }
 
-  if (isArray) {
+  if (isArray || Array.isArray(properties[name])) {
     return btree.getAt(index ?? -1, properties[name]);
   } else {
     return properties[name];
@@ -91,9 +203,12 @@ export const getPropertiesSimple = (ref, properties) => {
   }
 };
 
+export const isDefined = (obj, key) => hasOwn(obj, key) && obj[key] !== undefined;
+export const isUndefined = (obj, key) => !hasOwn(obj, key) || obj[key] === undefined;
+
 export const get = (ref, node) => {
-  const { flags } = ref.value;
   const result = getProperties(ref, node.properties);
+  const { flags } = result.reference.value;
 
   return flags.expression ? btree.getAt(-1, result.node) : result?.node;
 };
@@ -106,7 +221,10 @@ export const getShifted = (shiftIndex, ref, node) => {
 };
 
 export const add = (node, reference, value, shift = null) => {
-  if (node == null || reference == null || value == null) throw new Error();
+  if (node == null || reference == null) throw new Error('invalid arguments to add');
+  if (value === node) {
+    throw new Error('cannot add a node to itself');
+  }
 
   const { properties } = node;
   const { name, isArray, flags } = reference.value;
@@ -115,22 +233,26 @@ export const add = (node, reference, value, shift = null) => {
     throw new Error('Only fragments can have . properties');
   }
 
+  if (Array.isArray(value) && !isArray) throw new Error();
+  if (Array.isArray(value) && value.length) throw new Error();
+
   if (name == null) throw new Error();
 
-  const lastChild = btree.getAt(-1, node.children);
+  const lastChild = sumtree.getAt(-1, node.children);
 
   if (lastChild.type === ReferenceTag) {
     if (!referencesAreEqual(lastChild, reference)) throw new Error();
   } else if (lastChild.type !== ShiftTag) {
-    node.children = btree.push(node.children, shift == null ? reference : buildShiftTag(shift));
+    if ([ShiftTag, ReferenceTag].includes(sumtree.getAt(-1, node.children).type)) throw new Error();
+    node.children = sumtree.push(node.children, shift > 0 ? buildShiftTag(shift) : reference);
   }
 
   if (name === '#' || name === '@') {
-    node.children = btree.push(node.children, buildEmbeddedNode(value));
+    node.children = sumtree.push(node.children, buildEmbeddedNode(value));
   } else {
     if (isArray) {
       let isInitializer = Array.isArray(value);
-      let exists = !isInitializer && hasOwn(properties, name);
+      let exists = !isInitializer && isDefined(properties, name);
 
       let existed = exists;
       if (!existed) {
@@ -138,19 +260,19 @@ export const add = (node, reference, value, shift = null) => {
           throw new Error('Array value only allowed for initialization');
 
         properties[name] = [];
-        node.children = btree.push(node.children, buildArrayInitializerTag(value));
+        node.children = sumtree.push(node.children, buildInitializerTag(true));
         exists = !isInitializer;
       }
 
       if (exists) {
         if (!existed) {
-          if (btree.getAt(-1, node.children).type === ReferenceTag) throw new Error();
-          node.children = btree.push(node.children, reference);
+          if (sumtree.getAt(-1, node.children).type === ReferenceTag) throw new Error();
+          node.children = sumtree.push(node.children, reference);
         }
 
         let newBinding;
         if (flags.expression) {
-          let shiftedNodes = shift != null ? btree.getAt(-1, properties[name])?.node : [];
+          let shiftedNodes = shift > 0 ? btree.getAt(-1, properties[name])?.node : [];
 
           newBinding = {
             reference,
@@ -161,40 +283,67 @@ export const add = (node, reference, value, shift = null) => {
         }
 
         properties[name] =
-          shift != null
+          shift > 0
             ? btree.replaceAt(-1, properties[name], newBinding)
             : btree.push(properties[name], newBinding);
 
-        node.children = btree.push(node.children, buildGapTag(value));
+        node.children = sumtree.push(node.children, buildGapTag(value));
       }
     } else {
-      if (hasOwn(properties, name)) {
-        throw new Error();
-      }
-
-      if (flags.expression) {
-        let shiftedNodes = shift ? properties[name]?.node : [];
-        properties[name] = { reference, node: btree.push(shiftedNodes, value) };
+      if (value === undefined) {
+        if (isUndefined(properties, name)) {
+          let newBinding;
+          if (flags.expression) {
+            let shiftedNodes = shift > 0 ? btree.getAt(-1, properties[name])?.node : [];
+
+            newBinding = {
+              reference,
+              node: btree.push(shiftedNodes, undefined),
+            };
+          } else {
+            newBinding = { reference, node: undefined };
+          }
+          properties[name] = newBinding;
+          node.children = sumtree.push(node.children, buildInitializerTag());
+        }
       } else {
-        properties[name] = { reference, node: value };
+        if (flags.expression) {
+          if (shift == null) {
+            throw new Error();
+          }
+
+          let shiftedNodes = shift ? properties[name]?.node : [];
+          properties[name] = { reference, node: btree.push(shiftedNodes, value) };
+        } else {
+          if (shift != null) throw new Error();
+          if (hasOwn(properties, name) && properties[name].node !== undefined) {
+            throw new Error();
+          }
+          properties[name] = { reference, node: value };
+        }
+        node.children = sumtree.push(node.children, buildGapTag(value));
       }
-      node.children = btree.push(node.children, buildGapTag(value));
     }
   }
 };
 
-export function* allTagPathsFor(range) {
+export function* allTagPathsFor(range, options = {}) {
   if (range == null) return;
 
+  const { unshift = false } = options;
   let startPath = range[0];
   let endPath = range[1];
   let path = startPath;
 
   while (path) {
-    if (path.inner) {
+    if (path.inner && path.previousSibling.tag.type === ReferenceTag) {
       path = new TagPath(path.innerPath, 0);
     }
 
+    if (path.path.depth < startPath.path.depth) {
+      return;
+    }
+
     yield path;
 
     if (
@@ -205,24 +354,38 @@ export function* allTagPathsFor(range) {
       return;
     }
 
-    path = path.next;
+    let gapPath = path.path.parent && TagPath.from(path.path.parent, path.path.referenceIndex + 1);
+
+    if (
+      endPath &&
+      path.tag.type === CloseNodeTag &&
+      gapPath &&
+      gapPath.childrenIndex === endPath.childrenIndex &&
+      gapPath.path.node === endPath.path.node
+    ) {
+      return;
+    }
+    path = unshift ? path.nextUnshifted : path.next;
   }
 }
 
-export function* allTagsFor(range) {
-  for (const path of allTagPathsFor(range)) {
+export function* allTagsFor(range, options = {}) {
+  for (const path of allTagPathsFor(range, options)) {
     yield path.tag;
   }
 }
 
+export const buildFullRange = (node) => {
+  const sum = sumtree.getSize(node.children);
+  return sum ? [0, sum - 1] : null;
+};
+
 export function* ownTagPathsFor(range) {
   if (!isArray(range)) throw new Error();
 
   const startPath = range[0];
   const endPath = range[1];
 
-  let path = startPath;
-
   if (startPath.outer !== endPath.outer) throw new Error();
 
   const { children } = startPath.outer;
@@ -232,46 +395,6 @@ export function* ownTagPathsFor(range) {
   }
 }
 
-export class PathResolver {
-  constructor() {
-    this.childrenIndex = -1;
-    this.counters = {};
-    this.reference = null;
-  }
-
-  advance(tag) {
-    this.childrenIndex++;
-
-    const { counters } = this;
-    if (tag.type === ReferenceTag) {
-      const { isArray, name, flags } = tag.value;
-
-      let resolvedReference = tag;
-
-      this.reference = tag;
-
-      if (isArray) {
-        if (hasOwn(counters, name)) {
-          const counter = ++counters[name];
-
-          resolvedReference = buildReferenceTag(name, isArray, flags, counter);
-        }
-      } else if (name !== '@' && name !== '#') {
-        if (hasOwn(counters, name)) throw new Error();
-
-        counters[name] = true;
-      }
-
-      return resolvedReference;
-    } else if (tag.type === ArrayInitializerTag) {
-      counters[this.reference.value.name] = -1;
-      return this.reference.value.name;
-    }
-  }
-}
-
-Object.freeze(PathResolver.prototype);
-
 const findRight = (arr, predicate) => {
   for (let i = arr.length - 1; i >= 0; i--) {
     const value = arr[i];
@@ -318,94 +441,6 @@ const skipToDepth = (depth, frame) => {
   return parent;
 };
 
-const buildBindings = (node) => {
-  const { children, properties } = node;
-  const referenceIndexes = new Array(children.length);
-  const childrenIndexes = Object.fromEntries(Object.keys(properties).map((key) => [key, null]));
-
-  const resolver = new PathResolver();
-
-  for (const tag of btree.traverse(children)) {
-    resolver.advance(tag);
-    const i = resolver.childrenIndex;
-
-    if (tag.type === ReferenceTag) {
-      const { name, isArray, index } = tag.value;
-
-      if (!name) throw new Error();
-      // if (name === '.') throw new Error();
-
-      const counter = isArray
-        ? hasOwn(resolver.counters, name)
-          ? resolver.counters[name]
-          : null
-        : null;
-
-      if (index != null && index !== counter) throw new Error();
-
-      referenceIndexes[i] = counter;
-
-      if (isArray) {
-        if (childrenIndexes[name] === null || !hasOwn(childrenIndexes, name)) {
-          childrenIndexes[name] = [];
-        } else if (counter >= 0) {
-          childrenIndexes[name][counter] = i;
-        } else {
-          throw new Error();
-        }
-      } else {
-        if (name !== '#' && name !== '@') {
-          childrenIndexes[name] = i;
-        }
-      }
-    } else {
-      referenceIndexes[i] = null;
-    }
-  }
-
-  return { referenceIndexes, childrenIndexes };
-};
-
-const nodeStates = new WeakMap();
-
-// TODO remove this; it is a very bad API to have to support!!
-export const updatePath = (path, tag) => {
-  const { node, childrenIndexes, referenceIndexes } = path;
-  const i = btree.getSum(node.children) - 1;
-
-  if (tag.type === ReferenceTag) {
-    const { name, isArray, index: literalArrayIndex } = tag.value;
-
-    const arrayIndex = isArray
-      ? hasOwn(node.properties, name)
-        ? btree.getSum(node.properties[name])
-        : -1
-      : null;
-
-    if (literalArrayIndex != null && literalArrayIndex !== arrayIndex) throw new Error();
-
-    referenceIndexes[i] = arrayIndex;
-
-    if (isArray) {
-      if (!hasOwn(childrenIndexes, name) || childrenIndexes[name] === null) {
-        childrenIndexes[name] = [];
-      } else {
-        if (arrayIndex >= 0) {
-          childrenIndexes[name][arrayIndex] = i;
-        }
-      }
-    } else {
-      if (name !== '#' && name !== '@') {
-        childrenIndexes[name] = i;
-      }
-    }
-  } else if (tag.type === ArrayInitializerTag) {
-    referenceIndexes[i] = -1;
-  } else {
-    referenceIndexes[i] = null;
-  }
-};
-
 export const Path = class AgastPath extends WeakStackFrame {
   static from(node) {
     return this.create(node);
@@ -425,11 +460,10 @@ export const Path = class AgastPath extends WeakStackFrame {
 
     if (
       referenceIndex != null &&
-      ![ReferenceTag, ShiftTag].includes(btree.getAt(referenceIndex, parent.node.children).type)
-    )
+      ![ReferenceTag, ShiftTag].includes(sumtree.getAt(referenceIndex, parent.node.children).type)
+    ) {
       throw new Error();
-
-    nodeStates.set(node, buildBindings(node));
+    }
 
     if (parent && (!this.reference || ![ReferenceTag, ShiftTag].includes(this.reference.type))) {
       throw new Error();
@@ -440,16 +474,24 @@ export const Path = class AgastPath extends WeakStackFrame {
     buildSkips(this);
   }
 
-  get referenceIndexes() {
-    return nodeStates.get(this.node).referenceIndexes;
+  get openTagPath() {
+    return TagPath.from(this, 0);
+  }
+
+  get openTag() {
+    return this.openTagPath.tag;
+  }
+
+  get closeTagPath() {
+    return TagPath.from(this, -1);
   }
 
-  get childrenIndexes() {
-    return nodeStates.get(this.node).childrenIndexes;
+  get closeTag() {
+    return this.closeTagPath.tag;
   }
 
   get reference() {
-    return this.outer && btree.getAt(this.referenceIndex, this.outer.children);
+    return this.outer && sumtree.getAt(this.referenceIndex, this.outer.children);
   }
 
   get referencePath() {
@@ -457,7 +499,7 @@ export const Path = class AgastPath extends WeakStackFrame {
   }
 
   get gap() {
-    return this.outer && btree.getAt(this.referenceIndex + 1, this.outer.children);
+    return this.outer && sumtree.getAt(this.referenceIndex + 1, this.outer.children);
   }
 
   get gapPath() {
@@ -473,9 +515,7 @@ export const Path = class AgastPath extends WeakStackFrame {
 
     let shiftOffset = (shiftIndex ?? 0) * 2;
 
-    return (
-      node && this.push(node, getPropertiesSimple(reference, this.childrenIndexes) + shiftOffset)
-    );
+    return node && this.push(node, getPropertyChildrenIndex(this.node, reference) + shiftOffset);
   }
 
   at(depth) {
@@ -499,12 +539,16 @@ export class TagPath {
   }
 
   static from(path, childrenIndex) {
-    let size = btree.getSum(path.node.children);
+    let size = sumtree.getSize(path.node.children);
     let index = childrenIndex < 0 ? size + childrenIndex : childrenIndex;
 
     return index >= 0 && index < size ? new TagPath(path, index) : null;
   }
 
+  static fromNode(node, childrenIndex) {
+    return TagPath.from(Path.from(node), childrenIndex);
+  }
+
   get tag() {
     return this.child;
   }
@@ -514,16 +558,24 @@ export class TagPath {
   }
 
   get child() {
-    return btree.getAt(this.childrenIndex, this.path.node.children);
+    return sumtree.getAt(this.childrenIndex, this.path.node.children);
+  }
+
+  siblingPathAt(index) {
+    return TagPath.from(this.path, index);
+  }
+
+  siblingAt(index) {
+    return this.siblingPathAt(index)?.tag;
   }
 
   get nextSibling() {
     const { path, childrenIndex } = this;
 
     const child =
-      childrenIndex + 1 >= btree.getSum(path.node.children)
+      childrenIndex + 1 >= sumtree.getSize(path.node.children)
         ? null
-        : btree.getAt(childrenIndex + 1, path.node.children);
+        : sumtree.getAt(childrenIndex + 1, path.node.children);
 
     return child && new TagPath(path, childrenIndex + 1);
   }
@@ -534,8 +586,8 @@ export class TagPath {
     let leaving = false;
 
     for (;;) {
-      let prevTag = btree.getAt(childrenIndex - 1, path.node.children);
-      let tag = btree.getAt(childrenIndex, path.node.children);
+      let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
+      let tag = sumtree.getAt(childrenIndex, path.node.children);
       let isInitialTag = path.node === this.path.node && childrenIndex === this.childrenIndex;
       let wasLeaving = leaving;
       leaving = false;
@@ -562,18 +614,20 @@ export class TagPath {
       if (tag.type === GapTag && !wasLeaving && !isGapNode(path.node)) {
         let refIndex = childrenIndex - 1;
         let refTag;
-        let prevTag = btree.getAt(childrenIndex - 1, path.node.children);
-        let nextTag = btree.getAt(childrenIndex + 1, path.node.children);
+        let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
+        let nextTag = sumtree.getAt(childrenIndex + 1, path.node.children);
 
         if (
           path.parent &&
-          btree.getAt(path.referenceIndex, path.outer.children)?.type === ShiftTag &&
-          childrenIndex === 2
+          sumtree.getAt(path.referenceIndex, path.outer.children)?.type === ShiftTag
         ) {
-          childrenIndex = path.referenceIndex + 1;
-          path = path.parent;
-          leaving = true;
-          continue;
+          let third = sumtree.getAt(2, path.node.children);
+          if (childrenIndex === 2 || (childrenIndex === 4 && third.type === InitializerTag)) {
+            childrenIndex = path.referenceIndex + 1;
+            path = path.parent;
+            leaving = true;
+            continue;
+          }
         }
 
         if (prevTag.type === ReferenceTag) {
@@ -587,7 +641,7 @@ export class TagPath {
             const { name, isArray, flags } = refTag.value;
             let resolvedReference = refTag;
             if (isArray) {
-              let index = path.referenceIndexes[refIndex];
+              let index = getChildPropertyIndex(path.node, refIndex);
               resolvedReference =
                 index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
             }
@@ -602,12 +656,12 @@ export class TagPath {
           } else {
             if (
               !['#', '@'].includes(refTag.value.name) &&
-              (!refTag.value.isArray || path.referenceIndexes[refIndex] != null)
+              (!refTag.value.isArray || getChildPropertyIndex(path.node, refIndex) != null)
             ) {
               const { name, isArray, flags } = refTag.value;
               let resolvedReference = refTag;
               if (isArray) {
-                let index = path.referenceIndexes[refIndex];
+                let index = getChildPropertyIndex(path.node, refIndex);
                 resolvedReference =
                   index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
               }
@@ -625,22 +679,22 @@ export class TagPath {
           }
         } else if (prevTag.type === ShiftTag) {
           let refIndex = childrenIndex - prevTag.value.index * 2 - 1;
-          let refTag = btree.getAt(refIndex, path.node.children);
+          let refTag = sumtree.getAt(refIndex, path.node.children);
 
           const { name, isArray, flags } = refTag.value;
           let resolvedReference = refTag;
           if (isArray) {
-            let index = path.referenceIndexes[refIndex];
+            let index = getChildPropertyIndex(path.node, refIndex);
             resolvedReference =
               index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
           }
 
           if (resolvedReference) {
-            path = path.get(resolvedReference);
+            path = path.get(resolvedReference, prevTag.value.index);
             // this was introducing errors
             // caused us to return to a point before we left
             path.referenceIndex = childrenIndex;
-            childrenIndex = 3;
+            childrenIndex = sumtree.getAt(2, path.node.children).type === InitializerTag ? 5 : 3;
             continue;
           }
         } else {
@@ -651,12 +705,12 @@ export class TagPath {
       // shift
       if (tag.type === ShiftTag) {
         let refIndex = childrenIndex - tag.value.index * 2;
-        let refTag = btree.getAt(refIndex, path.node.children);
+        let refTag = sumtree.getAt(refIndex, path.node.children);
 
         const { name, isArray, flags } = refTag.value;
         let resolvedReference = null;
         if (isArray) {
-          let index = path.referenceIndexes[refIndex];
+          let index = getChildPropertyIndex(path.node, refIndex);
           resolvedReference =
             index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
         } else {
@@ -665,18 +719,16 @@ export class TagPath {
 
         if (resolvedReference) {
           path = path.get(resolvedReference, tag.value.index);
+
+          if (!path) return null;
+
           childrenIndex = 0;
           continue;
         }
-
-        // go backwards through any other shifts until we're done
-        // path = path.parent;
-        // childrenIndex = 0;
-        // continue;
       }
 
       // over
-      if (path.node && childrenIndex + 1 < btree.getSum(path.node.children)) {
+      if (path.node && childrenIndex + 1 < sumtree.getSize(path.node.children)) {
         childrenIndex++;
         continue;
       }
@@ -684,9 +736,9 @@ export class TagPath {
       // out
       if (path.referenceIndex != null) {
         do {
-          if (btree.getAt(path.referenceIndex + 2, path.outer.children)?.type === ShiftTag) {
+          if (sumtree.getAt(path.referenceIndex + 2, path.outer.children)?.type === ShiftTag) {
             childrenIndex =
-              btree.getSum(path.outer.children) > path.referenceIndex + 2
+              sumtree.getSize(path.outer.children) > path.referenceIndex + 2
                 ? path.referenceIndex + 2
                 : null;
           } else {
@@ -711,7 +763,7 @@ export class TagPath {
     let leaving = false;
 
     for (;;) {
-      let tag = btree.getAt(childrenIndex, path.node.children);
+      let tag = sumtree.getAt(childrenIndex, path.node.children);
       let isInitialTag = path.node === this.path.node && childrenIndex === this.childrenIndex;
       let wasLeaving = leaving;
       leaving = false;
@@ -739,7 +791,7 @@ export class TagPath {
       if (tag.type === GapTag && !wasLeaving && !isGapNode(path.node)) {
         let refIndex = childrenIndex - 1;
         let refTag;
-        let prevTag = btree.getAt(childrenIndex - 1, path.node.children);
+        let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
 
         if (prevTag.type === ShiftTag) {
           // continue
@@ -748,12 +800,12 @@ export class TagPath {
 
           if (
             !['#', '@'].includes(refTag.value.name) &&
-            (!refTag.value.isArray || path.referenceIndexes[refIndex] != null)
+            (!refTag.value.isArray || getChildPropertyIndex(path.node, refIndex) != null)
           ) {
             const { name, isArray, flags } = refTag.value;
             let resolvedReference = refTag;
             if (isArray) {
-              let index = path.referenceIndexes[refIndex];
+              let index = getChildPropertyIndex(path.node, refIndex);
               resolvedReference =
                 index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
             }
@@ -774,7 +826,7 @@ export class TagPath {
       }
 
       // over
-      if (path.node && childrenIndex + 1 < btree.getSum(path.node.children)) {
+      if (path.node && childrenIndex + 1 < sumtree.getSize(path.node.children)) {
         childrenIndex++;
         continue;
       }
@@ -814,7 +866,7 @@ export class TagPath {
     let leaving = false;
 
     for (;;) {
-      let tag = btree.getAt(childrenIndex, path.node.children);
+      let tag = sumtree.getAt(childrenIndex, path.node.children);
       let isInitialTag = path.node === this.path.node && childrenIndex === this.childrenIndex;
       let wasLeaving = leaving;
       leaving = false;
@@ -834,7 +886,7 @@ export class TagPath {
       // in
       if (tag.type === EmbeddedNode && !wasLeaving) {
         path = path.push(tag.value, childrenIndex - 1);
-        childrenIndex = btree.getSum(tag.value.children) - 1;
+        childrenIndex = sumtree.getSize(tag.value.children) - 1;
         continue;
       }
 
@@ -842,7 +894,7 @@ export class TagPath {
       if (tag.type === GapTag && !wasLeaving && !isGapNode(path.node)) {
         let refIndex = childrenIndex - 1;
         let refTag;
-        let prevTag = btree.getAt(childrenIndex - 1, path.node.children);
+        let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
 
         if (prevTag.type === ShiftTag) {
           // continue
@@ -851,12 +903,12 @@ export class TagPath {
 
           if (
             !['#', '@'].includes(refTag.value.name) &&
-            (!refTag.value.isArray || path.referenceIndexes[refIndex] != null)
+            (!refTag.value.isArray || getChildPropertyIndex(path.node, refIndex) != null)
           ) {
             const { name, isArray, flags } = refTag.value;
             let resolvedReference = refTag;
             if (isArray) {
-              let index = path.referenceIndexes[refIndex];
+              let index = getChildPropertyIndex(path.node, refIndex);
               resolvedReference =
                 index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
             }
@@ -877,7 +929,7 @@ export class TagPath {
       }
 
       // over
-      if (path.node && childrenIndex + 1 < btree.getSum(path.node.children)) {
+      if (path.node && childrenIndex + 1 < sumtree.getSize(path.node.children)) {
         childrenIndex--;
         continue;
       }
@@ -904,27 +956,33 @@ export class TagPath {
   }
 
   get innerPath() {
-    let { tag, previousSibling: ref } = this;
+    let { tag, previousSibling: refPath } = this;
 
-    if (tag.type !== GapTag || isGapNode(this.node) || ref.tag.type === ShiftTag) {
+    if (tag.type !== GapTag || isGapNode(this.node)) {
       return null;
     }
 
-    if (ref.tag.type !== ReferenceTag) throw new Error();
+    let shiftPath = null;
+    if (refPath.tag.type === ShiftTag) {
+      shiftPath = refPath;
+      refPath = TagPath.from(this.path, this.childrenIndex - refPath.tag.value.index * 2 - 1);
+    }
+
+    if (refPath.tag.type !== ReferenceTag) throw new Error();
 
-    let resolvedRef = ref.tag;
+    let resolvedRef = refPath.tag;
 
-    if (ref.tag.value.isArray) {
-      const { name, flags, isArray } = ref.tag.value;
+    if (refPath.tag.value.isArray) {
+      const { name, flags, isArray } = refPath.tag.value;
       resolvedRef = buildReferenceTag(
         name,
         isArray,
         flags,
-        ref.path.referenceIndexes[ref.childrenIndex],
+        getChildPropertyIndex(refPath.path.node, refPath.childrenIndex),
       );
     }
 
-    return this.path.get(resolvedRef);
+    return this.path.get(resolvedRef, shiftPath?.tag.value.index);
   }
 
   equalTo(tagPath) {