@bablr/agast-helpers 0.7.0 → 0.8.0

package/lib/path.js

@@ -1,31 +1,67 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
 import * as btree from '@bablr/agast-helpers/btree';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
+import * as Children from './children.js';
 import {
   ReferenceTag,
   InitializerTag,
-  EmbeddedNode,
   DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
   GapTag,
   NullTag,
   ShiftTag,
+  BindingTag,
+  Property,
 } from './symbols.js';
-import {
-  buildInitializerTag,
-  buildEmbeddedNode,
-  buildGapTag,
-  buildReferenceTag,
-  buildShiftTag,
-} from './builders.js';
+import { isString } from './object.js';
+
+export const buildPathSegment = (name, index = null, shiftIndex = null) => {
+  if (!name) throw new Error();
+  return { type: null, name, index, shiftIndex };
+};
+
+export const buildTypePathSegment = (type, index = null, shiftIndex = null) => {
+  if (!type) throw new Error();
+  return { type, name: null, index, shiftIndex };
+};
+
+export const buildFullPathSegment = (type, name, index = null, shiftIndex = null) => {
+  return { type, name, index, shiftIndex };
+};
+
+export const getRoot = (node, index = 0) => {
+  if (node == null || !isFragmentNode(node)) {
+    return node;
+  }
+  let idx = getPropertyChildrenIndex(node, '.', null, index);
+
+  if (idx == null) return null;
+
+  let tag = Children.getAt(idx + 2, node.children);
+
+  if (tag.type !== Property) throw new Error();
+  return tag.value.node;
+};
+
+export const getRootArray = (node) => {
+  let arr = [];
+  for (let i = 0; ; i++) {
+    let root = getRoot(node, i);
+    if (root) {
+      arr.push(root);
+    } else {
+      break;
+    }
+  }
+  return arr;
+};
 
 export const getOpenTag = (node) => {
   if (!node.children.length) return null;
-  let tag = sumtree.getAt(0, node.children);
+  let tag = Children.getAt(0, node.children);
   if (tag.type === NullTag || tag.type === GapTag) return null;
   if (tag.type === DoctypeTag) {
-    tag = sumtree.getAt(1, node.children);
+    tag = Children.getAt(1, node.children);
   }
   if (tag && tag.type !== OpenNodeTag) throw new Error();
   return tag;
@@ -33,13 +69,13 @@ export const getOpenTag = (node) => {
 
 export const getCloseTag = (node) => {
   const { children } = node;
-  const tag = sumtree.getAt(-1, children);
+  const tag = Children.getAt(-1, children);
   if (tag.type !== CloseNodeTag) return null;
   return tag;
 };
 
 export const isNullNode = (node) => {
-  return node && node.type === null && sumtree.getAt(0, node.children).type === NullTag;
+  return node && node.type === null && Children.getAt(0, node.children).type === NullTag;
 };
 
 export const isFragmentNode = (node) => {
@@ -47,13 +83,23 @@ export const isFragmentNode = (node) => {
 };
 
 export const isGapNode = (node) => {
-  return node && node.type === null && sumtree.getAt(0, node.children).type === GapTag;
+  return node && node.type === null && Children.getAt(0, node.children).type === GapTag;
+};
+
+export const isStubNode = (node) => {
+  return (
+    node && node.type === null && [GapTag, NullTag].includes(Children.getAt(0, node.children).type)
+  );
 };
 
 export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
-  let stack = sumtree.findPath(childrenIndex, agAstNode.children);
+  let child = Children.getAt(childrenIndex, agAstNode.children);
+
+  let refIndex = child.type === ShiftTag ? childrenIndex - child.value.index * 3 : childrenIndex;
+
+  let stack = Children.findPath(refIndex, agAstNode.children);
   let { node, index: leafIdx } = stack.value;
-  let leaf = sumtree.getAt(leafIdx, node);
+  let leaf = Children.getAt(leafIdx, node);
 
   if (leaf.type !== ReferenceTag) return null;
 
@@ -63,7 +109,7 @@ export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
   if (!isArray) return null;
 
   for (let i = leafIdx; i >= 0; i--) {
-    let value = sumtree.getAt(i, node);
+    let value = Children.getAt(i, node);
 
     if (value.type === ReferenceTag && value.value.name === name) {
       count++;
@@ -77,8 +123,8 @@ export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
 
   do {
     for (let i = leafIdx - 1; i >= 0; i--) {
-      let childNode = sumtree.getValues(node)[i];
-      let { references } = sumtree.getSums(childNode);
+      let childNode = Children.getValues(node)[i];
+      let { references } = Children.getSums(childNode);
 
       if (hasOwn(references, name)) {
         count += references[name];
@@ -95,61 +141,69 @@ export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
   return count - 1;
 };
 
-export const getPropertyChildrenIndex = (agAstNode, reference) => {
-  let { index, name } = reference.value;
+export const getPropertyChildrenIndex = (agAstNode, type, name, index) => {
+  let firstRefIndex = __getPropertyChildrenIndex(agAstNode, type, name, 0);
+  let nextTag = Children.getAt(firstRefIndex + 1, agAstNode.children);
+  let initializerOffset = nextTag.type === InitializerTag ? 1 : 0;
+
   if (isArray) {
     if (index == null) {
-      index = btree.getSize(agAstNode.properties[name]) - 1;
+      if (type) {
+        index = btree.getSums(agAstNode.children).specialTypes[type] - 1 - initializerOffset;
+      } else {
+        index = btree.getSums(agAstNode.children).references[name] - 1 - initializerOffset;
+      }
     }
   }
 
-  let firstRefIndex = __getPropertyChildrenIndex(agAstNode, name, 0);
-  let nextTag = sumtree.getAt(firstRefIndex + 1, agAstNode.children);
-
-  return __getPropertyChildrenIndex(
-    agAstNode,
-    name,
-    index + (nextTag.type === InitializerTag ? 1 : 0),
-  );
+  return __getPropertyChildrenIndex(agAstNode, type, name, index + initializerOffset);
 };
 
 export const getInitializerChildrenIndex = (agAstNode, reference) => {
-  return __getPropertyChildrenIndex(agAstNode, reference.value.name, 0);
+  let { type, name } = reference.value;
+  return __getPropertyChildrenIndex(agAstNode, type, name, 0);
 };
 
-const __getPropertyChildrenIndex = (agAstNode, name, index) => {
+const __getPropertyChildrenIndex = (agAstNode, type, 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];
+    let isLeaf = Children.isLeafNode(node);
+    let sums = Children.getSums(node);
+    let valueNameCount = type == null ? sums.references[name] : sums.specialTypes[type];
 
     if (nameCount + valueNameCount < index) {
       return null;
     }
 
-    for (const value of sumtree.getValues(node)) {
+    for (const value of Children.getValues(node)) {
       if (isLeaf) {
         idx++;
         let tag = value;
-        if (tag.type === ReferenceTag && tag.value.name === name) {
+        if (
+          tag.type === ReferenceTag &&
+          ((name != null && tag.value.name === name) || (type != null && tag.value.type === type))
+        ) {
           nameCount += 1;
           if (nameCount > index) {
             return idx;
           }
         }
       } else {
-        let valueSums = sumtree.getSums(value);
-        if (nameCount + valueSums.references[name] > index) {
+        let valueSums = Children.getSums(value);
+        if (
+          nameCount + (type == null ? valueSums.references[name] : valueSums.specialTypes[type]) >
+          index
+        ) {
           node = value;
           continue outer;
         } else {
-          nameCount += valueSums.references[name] ?? 0;
-          idx += sumtree.getSize(value);
+          nameCount +=
+            (type == null ? valueSums.references[name] : valueSums.specialTypes[type]) ?? 0;
+          idx += Children.getSize(value);
         }
       }
     }
@@ -160,9 +214,49 @@ const __getPropertyChildrenIndex = (agAstNode, name, index) => {
   return null;
 };
 
-const { hasOwn } = Object;
+const { hasOwn, freeze } = Object;
 const { isArray } = Array;
 
+export const getOriginalFirstNode = (node, height = 1) => {
+  for (let child of Children.traverse(node.children)) {
+    if (child.type === Property) {
+      return getProperties(buildPathSegment(child.value.reference.name, 0, height), node.properties)
+        .node;
+    }
+  }
+  return null;
+};
+
+export const getFirstNode = (node) => {
+  return getFirstNodeProperty(node)?.node;
+};
+
+export const getFirstNodeProperty = (node) => {
+  for (let child of Children.traverse(node.children)) {
+    if (child.type === Property) {
+      return child.value;
+    }
+  }
+  return null;
+};
+
+export const getFirstNodeShiftStack = (node) => {
+  for (let child of Children.traverse(node.children)) {
+    if (child.type === Property) {
+      let { reference } = child.value;
+
+      if (!reference.flags.expression) return null;
+
+      let property = node.properties[reference.name];
+      if (reference.isArray) {
+        property = btree.getAt(-1, property.node);
+      }
+      return property.node;
+    }
+  }
+  return null;
+};
+
 export const referencesAreEqual = (a, b) => {
   return (
     a === b ||
@@ -173,163 +267,85 @@ export const referencesAreEqual = (a, b) => {
   );
 };
 
-export const getProperties = (ref, properties) => {
-  const { name, index, isArray } = ref.value;
+export const getProperties = (pathSegment, properties) => {
+  let pathSegment_ = typeof pathSegment === 'string' ? buildPathSegment(pathSegment) : pathSegment;
+  if (!hasOwn(pathSegment_, 'shiftIndex')) throw new Error();
+  let { name, index, shiftIndex } = pathSegment_;
 
-  if (name === '.') {
-    if (!hasOwn(properties, name)) {
-      return null;
-    }
-  }
+  if (hasOwn(properties, name)) {
+    let prop = properties[name];
 
-  if (isArray || Array.isArray(properties[name])) {
-    return btree.getAt(index ?? -1, properties[name]);
-  } else {
-    return properties[name];
-  }
-};
+    if (prop.reference.isArray) {
+      prop = btree.getAt(index ?? -1, prop.node);
+    }
 
-export const getPropertiesSimple = (ref, properties) => {
-  const { name, index, isArray } = ref.value;
+    if (!prop) return null;
 
-  if (!hasOwn(properties, name)) {
-    return null;
-  }
+    if (prop.reference.flags.expression) {
+      prop = btree.getAt(shiftIndex ?? -1, prop.node);
+    }
 
-  if (isArray) {
-    return properties[name][index == null ? properties[name].length - 1 : index];
-  } else {
-    return properties[name];
+    return prop;
   }
+  return null;
 };
 
 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 result = getProperties(ref, node.properties);
-  const { flags } = result.reference.value;
-
-  return flags.expression ? btree.getAt(-1, result.node) : result?.node;
-};
-
-export const getShifted = (shiftIndex, ref, node) => {
-  const { flags } = ref.value;
+export const get = (path, node) => {
+  if (!node) throw new Error();
 
-  const result = getProperties(ref, node.properties);
-  return flags.expression ? btree.getAt(shiftIndex ?? -1, result.node) : result?.node;
-};
+  if (path == null) throw new Error('Bad path');
 
-export const add = (node, reference, value, shift = null) => {
-  if (node == null || reference == null) throw new Error('invalid arguments to add');
-  if (value === node) {
-    throw new Error('cannot add a node to itself');
+  if (!isArray(path)) {
+    path = [path];
   }
 
-  const { properties } = node;
-  const { name, isArray, flags } = reference.value;
+  let node_ = node;
+  for (let i = 0; i < path.length; i++) {
+    let nameOrSeg = path[i];
+    let isName = typeof nameOrSeg === 'string';
+    let property;
 
-  if (node.type && name === '.') {
-    throw new Error('Only fragments can have . properties');
-  }
+    if (!isName && (!nameOrSeg || !hasOwn(nameOrSeg, 'shiftIndex'))) throw new Error('Bad path');
 
-  if (Array.isArray(value) && !isArray) throw new Error();
-  if (Array.isArray(value) && value.length) throw new Error();
+    let name = isName ? nameOrSeg : nameOrSeg.name;
 
-  if (name == null) throw new Error();
-
-  const lastChild = sumtree.getAt(-1, node.children);
-
-  if (lastChild.type === ReferenceTag) {
-    if (!referencesAreEqual(lastChild, reference)) throw new Error();
-  } else if (lastChild.type !== ShiftTag) {
-    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) {
+      let { index } = nameOrSeg;
 
-  if (name === '#' || name === '@') {
-    node.children = sumtree.push(node.children, buildEmbeddedNode(value));
-  } else {
-    if (isArray) {
-      let isInitializer = Array.isArray(value);
-      let exists = !isInitializer && isDefined(properties, name);
-
-      let existed = exists;
-      if (!existed) {
-        if (isInitializer && value.length)
-          throw new Error('Array value only allowed for initialization');
+      property = getProperties(
+        isName ? buildPathSegment(name, index) : nameOrSeg,
+        node_.properties,
+      );
 
-        properties[name] = [];
-        node.children = sumtree.push(node.children, buildInitializerTag(true));
-        exists = !isInitializer;
-      }
+      ({ node: node_ } = property || {});
+    } else if (!isName) {
+      let { type } = nameOrSeg;
+      if (type !== '.') throw new Error('not implemented');
 
-      if (exists) {
-        if (!existed) {
-          if (sumtree.getAt(-1, node.children).type === ReferenceTag) throw new Error();
-          node.children = sumtree.push(node.children, reference);
-        }
+      let refIndex = getPropertyChildrenIndex(node_, '.');
 
-        let newBinding;
-        if (flags.expression) {
-          let shiftedNodes = shift > 0 ? btree.getAt(-1, properties[name])?.node : [];
+      if (refIndex == null) return null;
 
-          newBinding = {
-            reference,
-            node: btree.push(shiftedNodes, value),
-          };
-        } else {
-          newBinding = { reference, node: value };
-        }
-
-        properties[name] =
-          shift > 0
-            ? btree.replaceAt(-1, properties[name], newBinding)
-            : btree.push(properties[name], newBinding);
-
-        node.children = sumtree.push(node.children, buildGapTag(value));
-      }
+      node_ = Children.getAt(refIndex + 2, node_.children).value.node;
     } else {
-      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 {
-        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));
-      }
+      throw new Error();
     }
+
+    if (!node_) return null;
   }
+
+  return node_;
 };
 
 export function* allTagPathsFor(range, options = {}) {
   if (range == null) return;
 
+  if (range[0] && !(range[0] instanceof TagPath)) throw new Error();
+  if (range[1] && !(range[1] instanceof TagPath)) throw new Error();
+
   const { unshift = false } = options;
   let startPath = range[0];
   let endPath = range[1];
@@ -337,7 +353,7 @@ export function* allTagPathsFor(range, options = {}) {
 
   while (path) {
     if (path.inner && path.previousSibling.tag.type === ReferenceTag) {
-      path = new TagPath(path.innerPath, 0);
+      path = new TagPath(path.inner, 0);
     }
 
     if (path.path.depth < startPath.path.depth) {
@@ -370,25 +386,25 @@ export function* allTagPathsFor(range, options = {}) {
 }
 
 export function* allTagsFor(range, options = {}) {
-  for (const path of allTagPathsFor(range, options)) {
+  for (let path of allTagPathsFor(range, options)) {
     yield path.tag;
   }
 }
 
 export const buildFullRange = (node) => {
-  const sum = sumtree.getSize(node.children);
+  let sum = Children.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 startPath = range[0];
+  let endPath = range[1];
 
-  if (startPath.outer !== endPath.outer) throw new Error();
+  if (startPath.parent.node !== endPath.parent.node) throw new Error();
 
-  const { children } = startPath.outer;
+  let { children } = startPath.parent.node;
 
   for (let i = startPath.childrenIndex; i < endPath.childrenIndex; i++) {
     yield children[i];
@@ -397,7 +413,7 @@ export function* ownTagPathsFor(range) {
 
 const findRight = (arr, predicate) => {
   for (let i = arr.length - 1; i >= 0; i--) {
-    const value = arr[i];
+    let value = arr[i];
     if (predicate(value)) return value;
   }
   return null;
@@ -420,7 +436,7 @@ const buildSkips = (frame) => {
       skipsByFrame.set(frame, skips);
     }
 
-    skips[skipIdx] = frame.at(frame.depth - skipAmount);
+    skips[skipIdx] = frame.atDepth(frame.depth - skipAmount);
 
     skipIdx++;
     skipAmount = skipAmounts[skipIdx];
@@ -441,15 +457,33 @@ const skipToDepth = (depth, frame) => {
   return parent;
 };
 
+export let pathForTagPath = (tagPath) => {
+  let refTagPath = tagPath;
+  let isShift = tagPath.tag.type === ShiftTag;
+
+  if (isShift) {
+    refTagPath = tagPath.siblingAt(tagPath.childrenIndex - tagPath.tag.value.index * 3);
+  }
+
+  let { type, name } = refTagPath.tag.value;
+
+  if (refTagPath.tag.type !== ReferenceTag) throw new Error();
+
+  let index = getChildPropertyIndex(tagPath.node, refTagPath.childrenIndex);
+  let shiftIndex = isShift ? (tagPath.tag.value.index ?? 0) + 1 : null;
+
+  return [{ type, name, index, shiftIndex }];
+};
+
 export const Path = class AgastPath extends WeakStackFrame {
   static from(node) {
-    return this.create(node);
+    return node && this.create(node);
   }
 
   constructor(parent, node, referenceIndex = null) {
     super(parent);
 
-    if (!(hasOwn(node, 'type') && hasOwn(node, 'language'))) throw new Error();
+    if (!(hasOwn(node, 'type') && hasOwn(node, 'properties'))) throw new Error();
 
     if (parent && referenceIndex == null) throw new Error();
     if (!node) throw new Error();
@@ -458,10 +492,10 @@ export const Path = class AgastPath extends WeakStackFrame {
     this.node = node;
     this.referenceIndex = referenceIndex; // in the parent
 
-    if (
-      referenceIndex != null &&
-      ![ReferenceTag, ShiftTag].includes(sumtree.getAt(referenceIndex, parent.node.children).type)
-    ) {
+    let referenceTag =
+      referenceIndex != null && Children.getAt(referenceIndex, parent.node.children);
+
+    if (referenceTag && ![ReferenceTag, ShiftTag].includes(referenceTag.type)) {
       throw new Error();
     }
 
@@ -469,13 +503,28 @@ export const Path = class AgastPath extends WeakStackFrame {
       throw new Error();
     }
 
+    // if (
+    //   parent &&
+    //   (['#', '@'].includes(this.reference.value.type)
+    //     ? parent.tagPathAt(referenceIndex + 1).tag.value
+    //     : get(pathForTagPath(parent.tagPathAt(referenceIndex)), parent.node)) !== node
+    // ) {
+    //   throw new Error('Path not reachable');
+    // }
+
     if (!Number.isFinite(this.depth)) throw new Error();
 
     buildSkips(this);
+
+    freeze(this);
   }
 
   get openTagPath() {
-    return TagPath.from(this, 0);
+    let tagPath = TagPath.from(this, 0);
+    if (tagPath.tag.type === DoctypeTag) {
+      tagPath = tagPath.nextSibling;
+    }
+    return tagPath;
   }
 
   get openTag() {
@@ -483,42 +532,71 @@ export const Path = class AgastPath extends WeakStackFrame {
   }
 
   get closeTagPath() {
-    return TagPath.from(this, -1);
+    let tagPath = TagPath.from(this, -1);
+    if (tagPath.tag.type !== CloseNodeTag) return null;
+    return tagPath;
   }
 
   get closeTag() {
     return this.closeTagPath.tag;
   }
 
-  get reference() {
-    return this.outer && sumtree.getAt(this.referenceIndex, this.outer.children);
+  tagPathAt(idx) {
+    return TagPath.from(this, idx);
   }
 
-  get referencePath() {
-    return this.outer && new TagPath(this.parent, this.referenceIndex);
+  get reference() {
+    return (
+      (this.parent?.node ?? null) && Children.getAt(this.referenceIndex, this.parent.node.children)
+    );
   }
 
-  get gap() {
-    return this.outer && sumtree.getAt(this.referenceIndex + 1, this.outer.children);
+  get referenceTagPath() {
+    return (this.parent?.node ?? null) && new TagPath(this.parent, this.referenceIndex);
   }
 
-  get gapPath() {
-    return this.outer && new TagPath(this.parent, this.referenceIndex + 1);
-  }
+  get(path) {
+    let path_ = path;
+    if (typeof path_ === 'string') {
+      path_ = [path_];
+    }
+    if (!isArray(path_)) throw new Error();
 
-  get outer() {
-    return this.parent?.node;
-  }
+    let pathInst = this;
+    for (let i = 0; i < path_.length; i++) {
+      let nameOrSeg = path_[i];
 
-  get(reference, shiftIndex) {
-    let node = getShifted(shiftIndex, reference, this.node);
+      if (isString(nameOrSeg)) {
+        nameOrSeg = { type: null, name: nameOrSeg, index: null, shiftIndex: null };
+      }
+
+      let property = getProperties(nameOrSeg, pathInst.node.properties);
+
+      if (!property) return null;
+
+      let { node, reference: ref } = property;
+
+      let shiftIndex_ = nameOrSeg.shiftIndex;
+
+      if (shiftIndex_ && shiftIndex_ < 0) {
+        shiftIndex_ = btree.getSize(node) + shiftIndex_;
+      } else if (shiftIndex_ == null && ref.flags.expression) {
+        shiftIndex_ = 0;
+      }
 
-    let shiftOffset = (shiftIndex ?? 0) * 2;
+      let shiftOffset = shiftIndex_ ? (shiftIndex_ - 1) * 3 : 0;
 
-    return node && this.push(node, getPropertyChildrenIndex(this.node, reference) + shiftOffset);
+      pathInst = pathInst.push(
+        node,
+        getPropertyChildrenIndex(pathInst.node, nameOrSeg.type, nameOrSeg.name, nameOrSeg.index) +
+          shiftOffset,
+      );
+    }
+
+    return pathInst;
   }
 
-  at(depth) {
+  atDepth(depth) {
     return skipToDepth(depth, this);
   }
 };
@@ -532,14 +610,20 @@ export class TagPath {
   constructor(path, childrenIndex) {
     if (path == null || childrenIndex == null) throw new Error();
 
+    let tag = Children.getAt(childrenIndex, path.node.children);
+
+    if (tag == null) throw new Error();
+
     this.path = path;
+    this.node = path.node;
+    this.tag = tag;
     this.childrenIndex = childrenIndex;
 
-    if (this.tag == null) throw new Error();
+    freeze(this);
   }
 
   static from(path, childrenIndex) {
-    let size = sumtree.getSize(path.node.children);
+    let size = Children.getSize(path.node.children);
     let index = childrenIndex < 0 ? size + childrenIndex : childrenIndex;
 
     return index >= 0 && index < size ? new TagPath(path, index) : null;
@@ -549,33 +633,21 @@ export class TagPath {
     return TagPath.from(Path.from(node), childrenIndex);
   }
 
-  get tag() {
-    return this.child;
-  }
-
-  get node() {
-    return this.path.node;
-  }
-
   get child() {
-    return sumtree.getAt(this.childrenIndex, this.path.node.children);
-  }
-
-  siblingPathAt(index) {
-    return TagPath.from(this.path, index);
+    return this.tag;
   }
 
   siblingAt(index) {
-    return this.siblingPathAt(index)?.tag;
+    return TagPath.from(this.path, index);
   }
 
   get nextSibling() {
     const { path, childrenIndex } = this;
 
     const child =
-      childrenIndex + 1 >= sumtree.getSize(path.node.children)
+      childrenIndex + 1 >= Children.getSize(path.node.children)
         ? null
-        : sumtree.getAt(childrenIndex + 1, path.node.children);
+        : Children.getAt(childrenIndex + 1, path.node.children);
 
     return child && new TagPath(path, childrenIndex + 1);
   }
@@ -586,8 +658,8 @@ export class TagPath {
     let leaving = false;
 
     for (;;) {
-      let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
-      let tag = sumtree.getAt(childrenIndex, path.node.children);
+      let prevTag = Children.getAt(childrenIndex - 1, path.node.children);
+      let tag = Children.getAt(childrenIndex, path.node.children);
       let isInitialTag = path.node === this.path.node && childrenIndex === this.childrenIndex;
       let wasLeaving = leaving;
       leaving = false;
@@ -595,130 +667,58 @@ export class TagPath {
       if (!tag) return null;
 
       // done
-      if (
-        !isInitialTag &&
-        tag.type !== EmbeddedNode &&
-        (tag.type !== GapTag || isGapNode(path.node) || prevTag.type === ShiftTag)
-      ) {
+      if (!isInitialTag && tag.type !== Property) {
         return new TagPath(path, childrenIndex);
       }
 
       // in
-      if (tag.type === EmbeddedNode && !wasLeaving) {
-        path = path.push(tag.value, childrenIndex - 1);
-        childrenIndex = 0;
-        continue;
-      }
-
-      // in
-      if (tag.type === GapTag && !wasLeaving && !isGapNode(path.node)) {
-        let refIndex = childrenIndex - 1;
-        let refTag;
-        let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
-        let nextTag = sumtree.getAt(childrenIndex + 1, path.node.children);
-
+      if (tag.type === Property && !wasLeaving) {
+        // jump to gap tag?
         if (
           path.parent &&
-          sumtree.getAt(path.referenceIndex, path.outer.children)?.type === ShiftTag
+          tag.value.reference.flags.expression &&
+          (childrenIndex === 3 ||
+            (childrenIndex === 5 &&
+              Children.getAt(2, path.node.children).type === InitializerTag)) &&
+          Children.getAt(path.referenceIndex, path.parent.node.children)?.type === ShiftTag
         ) {
-          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) {
-          refTag = prevTag;
-
-          if (nextTag && nextTag.type === ShiftTag) {
-            const shifts = getProperties(refTag, path.node.properties).node;
+          let { reference: ref } = tag.value;
+          let shiftStack = path.node.properties[ref.name].node;
 
-            if (!Array.isArray(shifts)) throw new Error();
-
-            const { name, isArray, flags } = refTag.value;
-            let resolvedReference = refTag;
-            if (isArray) {
-              let index = getChildPropertyIndex(path.node, refIndex);
-              resolvedReference =
-                index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
-            }
-
-            path = path.get(resolvedReference, 0);
-            childrenIndex = 0;
-
-            if (!path) {
-              return null;
-            }
-            continue;
-          } else {
-            if (
-              !['#', '@'].includes(refTag.value.name) &&
-              (!refTag.value.isArray || getChildPropertyIndex(path.node, refIndex) != null)
-            ) {
-              const { name, isArray, flags } = refTag.value;
-              let resolvedReference = refTag;
-              if (isArray) {
-                let index = getChildPropertyIndex(path.node, refIndex);
-                resolvedReference =
-                  index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
-              }
-
-              if (resolvedReference) {
-                path = path.get(resolvedReference);
-                childrenIndex = 0;
-
-                if (!path) {
-                  return null;
-                }
-                continue;
-              }
-            }
-          }
-        } else if (prevTag.type === ShiftTag) {
-          let refIndex = childrenIndex - prevTag.value.index * 2 - 1;
-          let refTag = sumtree.getAt(refIndex, path.node.children);
-
-          const { name, isArray, flags } = refTag.value;
-          let resolvedReference = refTag;
-          if (isArray) {
-            let index = getChildPropertyIndex(path.node, refIndex);
-            resolvedReference =
-              index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
+          if (ref.isArray) {
+            shiftStack = btree.getAt(-1, shiftStack).node;
           }
+          let gapNode = btree.getAt(0, shiftStack).node;
 
-          if (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 = sumtree.getAt(2, path.node.children).type === InitializerTag ? 5 : 3;
-            continue;
-          }
-        } else {
-          throw new Error();
+          path = new Path(path, gapNode, childrenIndex - 2);
+          childrenIndex = 0;
+          continue;
         }
+
+        path = path.push(tag.value.node, childrenIndex - 2);
+        childrenIndex = 0;
+        continue;
       }
 
       // shift
-      if (tag.type === ShiftTag) {
-        let refIndex = childrenIndex - tag.value.index * 2;
-        let refTag = sumtree.getAt(refIndex, path.node.children);
-
-        const { name, isArray, flags } = refTag.value;
-        let resolvedReference = null;
+      if (tag.type === BindingTag && prevTag.type === ShiftTag) {
+        let refIndex = childrenIndex - 1 - prevTag.value.index * 3;
+        if (refIndex < 0) throw new Error();
+        let refTag = Children.getAt(refIndex, path.node.children);
+
+        const { name, isArray } = refTag.value;
+        let pathDesc = buildPathSegment(name);
+        let index;
         if (isArray) {
-          let index = getChildPropertyIndex(path.node, refIndex);
-          resolvedReference =
-            index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
-        } else {
-          resolvedReference = refTag;
+          index = getChildPropertyIndex(path.node, refIndex);
+          pathDesc = buildPathSegment(name, index);
         }
 
-        if (resolvedReference) {
-          path = path.get(resolvedReference, tag.value.index);
+        // HMM
+        pathDesc.shiftIndex = prevTag.value.height;
+
+        if (index !== -1) {
+          path = path.get([pathDesc]);
 
           if (!path) return null;
 
@@ -728,25 +728,30 @@ export class TagPath {
       }
 
       // over
-      if (path.node && childrenIndex + 1 < sumtree.getSize(path.node.children)) {
+      if (path.node && childrenIndex + 1 < Children.getSize(path.node.children)) {
         childrenIndex++;
         continue;
       }
 
       // out
-      if (path.referenceIndex != null) {
+      if (path.referenceIndex != null && path.parent) {
         do {
-          if (sumtree.getAt(path.referenceIndex + 2, path.outer.children)?.type === ShiftTag) {
+          if (
+            path.parent &&
+            Children.getAt(path.referenceIndex, path.parent.node.children)?.type === ShiftTag
+          ) {
             childrenIndex =
-              sumtree.getSize(path.outer.children) > path.referenceIndex + 2
+              Children.getSize(path.parent.node.children) > path.referenceIndex + 2
                 ? path.referenceIndex + 2
                 : null;
           } else {
-            childrenIndex = path.referenceIndex + 1;
+            childrenIndex = path.referenceIndex + 2;
           }
 
           path = path.parent;
           leaving = true;
+
+          if (!path) return null;
         } while (childrenIndex == null);
 
         leaving = true;
@@ -763,70 +768,47 @@ export class TagPath {
     let leaving = false;
 
     for (;;) {
-      let tag = sumtree.getAt(childrenIndex, path.node.children);
+      let tag = Children.getAt(childrenIndex, path.node.children);
       let isInitialTag = path.node === this.path.node && childrenIndex === this.childrenIndex;
       let wasLeaving = leaving;
       leaving = false;
 
       if (!tag) return null;
 
+      if (tag.type === ReferenceTag && tag.value.flags.expression) {
+        // look forward for another reference
+        let offset = 1;
+        let tag_ = tag;
+        do {
+          tag_ = Children.getAt(childrenIndex + offset, path.node.children);
+          offset++;
+
+          if (tag_?.type === InitializerTag) break;
+        } while (tag_ && [BindingTag, ShiftTag].includes(tag_.type));
+        if (!tag_) {
+          return null;
+        }
+      }
+
       // done
-      if (
-        !isInitialTag &&
-        tag.type !== EmbeddedNode &&
-        tag.type !== ShiftTag &&
-        (tag.type !== GapTag || isGapNode(path.node))
-      ) {
+      if (!isInitialTag && tag.type !== Property) {
         return new TagPath(path, childrenIndex);
       }
 
       // in
-      if (tag.type === EmbeddedNode && !wasLeaving) {
-        path = path.push(tag.value, childrenIndex - 1);
+      if (
+        tag.type === Property &&
+        !wasLeaving &&
+        !(Children.getAt(childrenIndex + 1, path.node.children)?.type === ShiftTag)
+      ) {
+        // TODO use properties to skip over a lot of tag walking
+        path = path.push(tag.value.node, childrenIndex - 2);
         childrenIndex = 0;
         continue;
       }
 
-      // in
-      if (tag.type === GapTag && !wasLeaving && !isGapNode(path.node)) {
-        let refIndex = childrenIndex - 1;
-        let refTag;
-        let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
-
-        if (prevTag.type === ShiftTag) {
-          // continue
-        } else if (prevTag.type === ReferenceTag) {
-          refTag = prevTag;
-
-          if (
-            !['#', '@'].includes(refTag.value.name) &&
-            (!refTag.value.isArray || getChildPropertyIndex(path.node, refIndex) != null)
-          ) {
-            const { name, isArray, flags } = refTag.value;
-            let resolvedReference = refTag;
-            if (isArray) {
-              let index = getChildPropertyIndex(path.node, refIndex);
-              resolvedReference =
-                index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
-            }
-
-            if (resolvedReference) {
-              path = path.get(resolvedReference);
-              childrenIndex = 0;
-
-              if (!path) {
-                return null;
-              }
-              continue;
-            }
-          }
-        } else {
-          throw new Error();
-        }
-      }
-
       // over
-      if (path.node && childrenIndex + 1 < sumtree.getSize(path.node.children)) {
+      if (path.node && childrenIndex + 1 < Children.getSize(path.node.children)) {
         childrenIndex++;
         continue;
       }
@@ -834,7 +816,7 @@ export class TagPath {
       // out
       if (path.referenceIndex != null) {
         do {
-          childrenIndex = path.referenceIndex + 1;
+          childrenIndex = path.referenceIndex + 2;
 
           path = path.parent;
           leaving = true;
@@ -866,7 +848,7 @@ export class TagPath {
     let leaving = false;
 
     for (;;) {
-      let tag = sumtree.getAt(childrenIndex, path.node.children);
+      let tag = Children.getAt(childrenIndex, path.node.children);
       let isInitialTag = path.node === this.path.node && childrenIndex === this.childrenIndex;
       let wasLeaving = leaving;
       leaving = false;
@@ -874,62 +856,19 @@ export class TagPath {
       if (!tag) return null;
 
       // done
-      if (
-        !isInitialTag &&
-        tag.type !== EmbeddedNode &&
-        tag.type !== ShiftTag &&
-        (tag.type !== GapTag || isGapNode(path.node))
-      ) {
+      if (!isInitialTag && tag.type !== ShiftTag && tag.type !== Property) {
         return new TagPath(path, childrenIndex);
       }
 
       // in
-      if (tag.type === EmbeddedNode && !wasLeaving) {
-        path = path.push(tag.value, childrenIndex - 1);
-        childrenIndex = sumtree.getSize(tag.value.children) - 1;
+      if (tag.type === Property && !wasLeaving) {
+        path = path.push(tag.value.node, childrenIndex - 1);
+        childrenIndex = Children.getSize(tag.value.children) - 1;
         continue;
       }
 
-      // in
-      if (tag.type === GapTag && !wasLeaving && !isGapNode(path.node)) {
-        let refIndex = childrenIndex - 1;
-        let refTag;
-        let prevTag = sumtree.getAt(childrenIndex - 1, path.node.children);
-
-        if (prevTag.type === ShiftTag) {
-          // continue
-        } else if (prevTag.type === ReferenceTag) {
-          refTag = prevTag;
-
-          if (
-            !['#', '@'].includes(refTag.value.name) &&
-            (!refTag.value.isArray || getChildPropertyIndex(path.node, refIndex) != null)
-          ) {
-            const { name, isArray, flags } = refTag.value;
-            let resolvedReference = refTag;
-            if (isArray) {
-              let index = getChildPropertyIndex(path.node, refIndex);
-              resolvedReference =
-                index === -1 ? null : buildReferenceTag(name, index != null, flags, index);
-            }
-
-            if (resolvedReference) {
-              path = path.get(resolvedReference);
-              childrenIndex = 0;
-
-              if (!path) {
-                return null;
-              }
-              continue;
-            }
-          }
-        } else {
-          throw new Error();
-        }
-      }
-
       // over
-      if (path.node && childrenIndex + 1 < sumtree.getSize(path.node.children)) {
+      if (path.node && childrenIndex + 1 < Children.getSize(path.node.children)) {
         childrenIndex--;
         continue;
       }
@@ -951,38 +890,37 @@ export class TagPath {
     }
   }
 
-  get inner() {
-    return this.innerPath?.node;
+  get innerNode() {
+    return this.inner?.node;
   }
 
-  get innerPath() {
-    let { tag, previousSibling: refPath } = this;
+  get inner() {
+    let { tag, previousSibling } = this;
+
+    let refPath = previousSibling?.previousSibling;
 
-    if (tag.type !== GapTag || isGapNode(this.node)) {
+    if (tag.type !== Property) {
       return null;
     }
 
     let shiftPath = null;
     if (refPath.tag.type === ShiftTag) {
       shiftPath = refPath;
-      refPath = TagPath.from(this.path, this.childrenIndex - refPath.tag.value.index * 2 - 1);
+      refPath = TagPath.from(this.path, this.childrenIndex - refPath.tag.value.index * 3 - 2);
     }
 
     if (refPath.tag.type !== ReferenceTag) throw new Error();
 
-    let resolvedRef = refPath.tag;
+    const { type, name } = refPath.tag.value;
 
-    if (refPath.tag.value.isArray) {
-      const { name, flags, isArray } = refPath.tag.value;
-      resolvedRef = buildReferenceTag(
+    return this.path.get([
+      buildFullPathSegment(
+        type,
         name,
-        isArray,
-        flags,
         getChildPropertyIndex(refPath.path.node, refPath.childrenIndex),
-      );
-    }
-
-    return this.path.get(resolvedRef, shiftPath?.tag.value.index);
+        shiftPath?.tag.value.index,
+      ),
+    ]);
   }
 
   equalTo(tagPath) {