@bablr/agast-helpers 0.8.0 → 0.9.0

package/lib/path.js

@@ -1,19 +1,42 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
-import * as btree from '@bablr/agast-helpers/btree';
-import * as Children from './children.js';
+import * as BTree from '@bablr/agast-helpers/btree';
+import * as Tags from './tags.js';
 import {
   ReferenceTag,
   InitializerTag,
   DoctypeTag,
-  OpenNodeTag,
   CloseNodeTag,
   GapTag,
   NullTag,
   ShiftTag,
   BindingTag,
+  PropertyWrapper,
   Property,
 } from './symbols.js';
-import { isString } from './object.js';
+import { isPlainObject, isString } from './object.js';
+import { buildBinding, buildChild, buildProperty, buildPropertyWrapper } from './builders.js';
+import { buildReferenceTag, finalizeNode } from './tree.js';
+
+export const wrapperIsFull = (wrapper) => {
+  let { tags } = wrapper.value;
+
+  if (tags[1]?.type === InitializerTag) {
+    return true;
+  } else {
+    return tags.length === 3;
+  }
+};
+
+export const offsetForTag = (tag) => {
+  switch (tag.type) {
+    case ReferenceTag:
+    case ShiftTag:
+      return 0;
+    case BindingTag:
+    case InitializerTag:
+      return 1;
+  }
+};
 
 export const buildPathSegment = (name, index = null, shiftIndex = null) => {
   if (!name) throw new Error();
@@ -29,18 +52,26 @@ export const buildFullPathSegment = (type, name, index = null, shiftIndex = null
   return { type, name, index, shiftIndex };
 };
 
-export const getRoot = (node, index = 0) => {
+export const getRootProperty = (node, index = 0) => {
   if (node == null || !isFragmentNode(node)) {
-    return node;
+    return null;
   }
-  let idx = getPropertyChildrenIndex(node, '.', null, index);
+  let idx = getPropertyTagsIndex(node, '.', null, index);
 
   if (idx == null) return null;
 
-  let tag = Children.getAt(idx + 2, node.children);
+  let tag = Tags.getAt(idx, node.tags);
+
+  if (tag.type !== PropertyWrapper) throw new Error();
+  return tag.value.property;
+};
+
+export const getRoot = (node, index = 0) => {
+  if (!isFragmentNode(node)) {
+    return node;
+  }
 
-  if (tag.type !== Property) throw new Error();
-  return tag.value.node;
+  return getRootProperty(node, index)?.node;
 };
 
 export const getRootArray = (node) => {
@@ -57,62 +88,67 @@ export const getRootArray = (node) => {
 };
 
 export const getOpenTag = (node) => {
-  if (!node.children.length) return null;
-  let tag = Children.getAt(0, node.children);
-  if (tag.type === NullTag || tag.type === GapTag) return null;
-  if (tag.type === DoctypeTag) {
-    tag = Children.getAt(1, node.children);
-  }
-  if (tag && tag.type !== OpenNodeTag) throw new Error();
-  return tag;
+  return Tags.getValues(node.tags)[0];
 };
 
 export const getCloseTag = (node) => {
-  const { children } = node;
-  const tag = Children.getAt(-1, children);
-  if (tag.type !== CloseNodeTag) return null;
-  return tag;
+  return Tags.getValues(node.tags)[2];
 };
 
 export const isNullNode = (node) => {
-  return node && node.type === null && Children.getAt(0, node.children).type === NullTag;
+  return node && node.type === null && Tags.getAt(0, node.tags).type === NullTag;
 };
 
 export const isFragmentNode = (node) => {
-  return node && node.type === null && getOpenTag(node)?.value.type === null;
+  return node && node.type === null && getOpenTag(node)?.value?.type === null;
 };
 
 export const isGapNode = (node) => {
-  return node && node.type === null && Children.getAt(0, node.children).type === GapTag;
+  return node && node.type === null && Tags.getAt(0, node.tags).type === GapTag;
 };
 
 export const isStubNode = (node) => {
-  return (
-    node && node.type === null && [GapTag, NullTag].includes(Children.getAt(0, node.children).type)
-  );
+  return node && node.type === null && [GapTag, NullTag].includes(Tags.getAt(0, node.tags).type);
+};
+
+export const isStubTag = (tag) => {
+  return [GapTag, NullTag].includes(tag.type);
 };
 
-export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
-  let child = Children.getAt(childrenIndex, agAstNode.children);
+export const getChildPropertyIndex = (agAstNode, tagsIndex) => {
+  let child = Tags.getAt(tagsIndex, agAstNode.tags);
+
+  if (child.type !== PropertyWrapper) return null;
 
-  let refIndex = child.type === ShiftTag ? childrenIndex - child.value.index * 3 : childrenIndex;
+  let tag = child.value.tags[0];
 
-  let stack = Children.findPath(refIndex, agAstNode.children);
+  let refIndex = tag.type === ShiftTag ? tagsIndex - tag.value.index : tagsIndex;
+
+  let stack = Tags.findPath(refIndex, agAstNode.tags);
   let { node, index: leafIdx } = stack.value;
-  let leaf = Children.getAt(leafIdx, node);
+  let leaf = Tags.getAt(leafIdx, node);
+
+  if (leaf.type !== PropertyWrapper) {
+    return null;
+  }
 
-  if (leaf.type !== ReferenceTag) return null;
+  let leafRefTag = leaf.value.tags[0];
 
-  let { name, isArray } = leaf.value;
+  if (leafRefTag.type !== ReferenceTag) return null;
+
+  let { name, isArray } = leafRefTag.value;
   let count = -1;
 
   if (!isArray) return null;
 
   for (let i = leafIdx; i >= 0; i--) {
-    let value = Children.getAt(i, node);
+    let value = Tags.getAt(i, node);
+    if (value.type === PropertyWrapper) {
+      let firstTag = value.value.tags[0];
 
-    if (value.type === ReferenceTag && value.value.name === name) {
-      count++;
+      if (firstTag.type === ReferenceTag && firstTag.value.name === name) {
+        count++;
+      }
     }
   }
   stack = stack.pop();
@@ -123,11 +159,17 @@ export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
 
   do {
     for (let i = leafIdx - 1; i >= 0; i--) {
-      let childNode = Children.getValues(node)[i];
-      let { references } = Children.getSums(childNode);
+      let value = Tags.getValues(node)[i];
 
-      if (hasOwn(references, name)) {
-        count += references[name];
+      if (Array.isArray(value)) {
+        let childNode = value;
+        let { references } = Tags.getSums(childNode);
+
+        let res;
+        if ((res = Tags.getAtName(name, references))) {
+          count += res;
+        }
+      } else {
       }
     }
     stack = stack.pop();
@@ -141,69 +183,129 @@ export const getChildPropertyIndex = (agAstNode, childrenIndex) => {
   return count - 1;
 };
 
-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) {
-      if (type) {
-        index = btree.getSums(agAstNode.children).specialTypes[type] - 1 - initializerOffset;
+export const getPropertyTagsIndex = (agAstNode, type, name, index, shiftIndex) => {
+  let firstPropsIndex = __getPropertyTagsIndex(agAstNode, type, name, 0);
+  let prop = firstPropsIndex == null ? null : Tags.getAt(firstPropsIndex, agAstNode.tags);
+  let initializerOffset = prop?.value.tags[1]?.type === InitializerTag ? 1 : 0;
+  let ref = prop?.value.property.reference;
+  let sums = Tags.getSums(agAstNode.tags);
+
+  if (ref?.isArray) {
+    if (index < 0) {
+      if (name) {
+        index = Tags.getAtName(name, sums.references) - initializerOffset + index;
       } else {
-        index = btree.getSums(agAstNode.children).references[name] - 1 - initializerOffset;
+        index = Tags.getAtName(type, sums.specialTypes) - initializerOffset + index;
       }
+    } else if (index == null) {
+      if (name) {
+        index = Tags.getAtName(name, sums.references) - 1 - initializerOffset;
+      } else {
+        index = Tags.getAtName(type, sums.specialTypes) - 1 - initializerOffset;
+      }
+
+      if (index < 0) return null;
+    }
+  }
+
+  let parentIndex = __getPropertyTagsIndex(agAstNode, type, name, (index ?? 0) + initializerOffset);
+
+  if (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 + 1, agAstNode.tags, 0)?.type === ShiftTag) {
+        shifts++;
+      }
+
+      if (-shiftIndex_ > shifts + 1) return null;
+
+      return parentIndex + shifts + shiftIndex_ + 1;
+    } else {
+      if (parentIndex + shiftIndex_ >= Tags.getSize(agAstNode.tags)) {
+        return null;
+      }
+
+      return parentIndex + shiftIndex_;
     }
   }
 
-  return __getPropertyChildrenIndex(agAstNode, type, name, index + initializerOffset);
+  return parentIndex;
 };
 
-export const getInitializerChildrenIndex = (agAstNode, reference) => {
-  let { type, name } = reference.value;
-  return __getPropertyChildrenIndex(agAstNode, type, name, 0);
+export const getInitializerTagsIndex = (agAstNode, referenceTag) => {
+  let { type, name } = referenceTag.value;
+
+  if (type === '#') return null;
+
+  let index = __getPropertyTagsIndex(agAstNode, type, name, 0);
+
+  if (index == null) return null;
+
+  let nextTag = Tags.getAt(index, agAstNode.tags, 1);
+
+  return nextTag?.type === InitializerTag ? index : null;
 };
 
-const __getPropertyChildrenIndex = (agAstNode, type, name, index) => {
+const __getPropertyTagsIndex = (agAstNode, type, name, index) => {
   let nameCount = 0;
-  let node = agAstNode.children;
+  let node = Tags.getValues(agAstNode.tags)[1];
   let idx = -1;
 
   // drill into subtrees, passing over subtrees with too few references of the desired name
   outer: while (node) {
-    let isLeaf = Children.isLeafNode(node);
-    let sums = Children.getSums(node);
-    let valueNameCount = type == null ? sums.references[name] : sums.specialTypes[type];
+    let sums = Tags.getSums(node);
+
+    if (!sums) return null;
+
+    let valueNameCount =
+      name != null
+        ? Tags.getAtName(name, sums.references)
+        : Tags.getAtName(type, sums.specialTypes);
 
     if (nameCount + valueNameCount < index) {
       return null;
     }
 
-    for (const value of Children.getValues(node)) {
-      if (isLeaf) {
+    for (const value of Tags.getValues(node)) {
+      if (!isArray(value)) {
         idx++;
         let tag = value;
-        if (
-          tag.type === ReferenceTag &&
-          ((name != null && tag.value.name === name) || (type != null && tag.value.type === type))
-        ) {
-          nameCount += 1;
-          if (nameCount > index) {
-            return idx;
+        if (tag.type === PropertyWrapper) {
+          let { tags, property } = tag.value;
+          let { reference } = property;
+          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 = Children.getSums(value);
+        let valueSums = Tags.getSums(value);
         if (
-          nameCount + (type == null ? valueSums.references[name] : valueSums.specialTypes[type]) >
+          nameCount +
+            (name != null
+              ? Tags.getAtName(name, valueSums.references)
+              : Tags.getAtName(type, valueSums.specialTypes)) >
           index
         ) {
           node = value;
           continue outer;
         } else {
           nameCount +=
-            (type == null ? valueSums.references[name] : valueSums.specialTypes[type]) ?? 0;
-          idx += Children.getSize(value);
+            (name != null
+              ? Tags.getAtName(name, valueSums.references)
+              : Tags.getAtName(type, valueSums.specialTypes)) ?? 0;
+          idx += Tags.getSize(value);
         }
       }
     }
@@ -218,10 +320,9 @@ 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;
+  for (let child of Tags.traverse(node.tags)) {
+    if (child.type === PropertyWrapper) {
+      return child.value.property.node;
     }
   }
   return null;
@@ -232,26 +333,16 @@ export const getFirstNode = (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);
+  for (let child of Tags.traverse(node.tags)) {
+    if (child.type === PropertyWrapper) {
+      let ref = child.value.reference;
+      if (!ref.flags.expression) {
+        return child.value;
+      } else {
+        let tagsIndex = getPropertyTagsIndex(node, ref.type, ref.name, 0, -1);
+        return Tags.getAt(tagsIndex, node.tags + 2)?.value.node;
       }
-      return property.node;
+      // is it shifted?
     }
   }
   return null;
@@ -260,40 +351,59 @@ export const getFirstNodeShiftStack = (node) => {
 export const referencesAreEqual = (a, b) => {
   return (
     a === b ||
-    (a.value.name === b.value.name &&
-      a.value.isArray === b.value.isArray &&
-      a.value.flags.hasGap === b.value.flags.hasGap &&
-      a.value.flags.expression === b.value.flags.expression)
+    (a.type === b.type &&
+      a.name === b.name &&
+      a.isArray === b.isArray &&
+      a.flags.hasGap === b.flags.hasGap &&
+      a.flags.expression === b.flags.expression)
   );
 };
 
-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 (hasOwn(properties, name)) {
-    let prop = properties[name];
+export const isDefined = (obj, key) => hasOwn(obj, key) && obj[key] !== undefined;
+export const isUndefined = (obj, key) => !hasOwn(obj, key) || obj[key] === undefined;
 
-    if (prop.reference.isArray) {
-      prop = btree.getAt(index ?? -1, prop.node);
+export function* relatedNodes(node) {
+  for (const child of Tags.traverse(node.tags)) {
+    if (child.type === PropertyWrapper) {
+      yield child.node;
     }
+  }
+}
 
-    if (!prop) return null;
+export const getProperty = (pathSegment, node) => {
+  if (!node) throw new Error();
 
-    if (prop.reference.flags.expression) {
-      prop = btree.getAt(shiftIndex ?? -1, prop.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);
+
+  if (propIndex == null) return null;
+
+  return Tags.getAt(propIndex, node.tags)?.value.property;
+};
 
-    return prop;
+export const has = (path, node) => {
+  if (!isArray(path)) {
+    path = [path];
   }
-  return null;
+
+  let pathArr = [...path];
+  let node_ = get(pathArr.slice(0, -1), node);
+  let seg = pathArr[pathArr.length - 1];
+  let name = typeof seg === 'string' ? seg : seg.name;
+
+  return (
+    !!getProperty(seg, node_) ||
+    getInitializerTagsIndex(node_, buildReferenceTag(null, name)) != 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 = (path, node) => getOr(null, path, node);
 
-export const get = (path, node) => {
+export const getOr = (defaultValue, path, node) => {
   if (!node) throw new Error();
 
   if (path == null) throw new Error('Bad path');
@@ -302,42 +412,57 @@ export const get = (path, node) => {
     path = [path];
   }
 
-  let node_ = node;
-  for (let i = 0; i < path.length; i++) {
+  let root = getRoot(node);
+  let result = root || node;
+
+  let start = 0;
+  if (path[0]?.type === '.') {
+    if (!root) return null;
+    start = 1;
+  }
+
+  for (let i = start; i < path.length; i++) {
     let nameOrSeg = path[i];
     let isName = typeof nameOrSeg === 'string';
     let property;
+    let index = path[i + 1];
 
-    if (!isName && (!nameOrSeg || !hasOwn(nameOrSeg, 'shiftIndex'))) throw new Error('Bad path');
+    if (typeof index === 'number') {
+      i++;
+    } else {
+      index = undefined;
+    }
 
-    let name = isName ? nameOrSeg : nameOrSeg.name;
+    if (!isName && (!nameOrSeg || !hasOwn(nameOrSeg, 'shiftIndex'))) throw new Error('Bad path');
 
-    if (name) {
-      let { index } = nameOrSeg;
+    let seg = isName ? buildPathSegment(nameOrSeg, index) : nameOrSeg;
 
-      property = getProperties(
-        isName ? buildPathSegment(name, index) : nameOrSeg,
-        node_.properties,
-      );
+    property = getProperty(seg, result);
 
-      ({ node: node_ } = property || {});
-    } else if (!isName) {
-      let { type } = nameOrSeg;
-      if (type !== '.') throw new Error('not implemented');
+    if (!property) return defaultValue;
 
-      let refIndex = getPropertyChildrenIndex(node_, '.');
+    result = property.node;
+  }
 
-      if (refIndex == null) return null;
+  return result;
+};
 
-      node_ = Children.getAt(refIndex + 2, node_.children).value.node;
-    } else {
-      throw new Error();
-    }
+export function* list(name, node) {
+  let count = countList(name, node);
 
-    if (!node_) return null;
+  for (let i = 0; i < count; i++) {
+    yield get(buildPathSegment(name, i, -1), node);
   }
+}
 
-  return node_;
+export const countList = (name, node) => {
+  if (!node) throw new Error();
+
+  if (name == null) throw new Error('Bad path');
+
+  let hasInitializer = getInitializerTagsIndex(node, buildReferenceTag(null, name)) != null;
+
+  return Tags.getAtName(name, Tags.getSums(node.tags).references) - (hasInitializer ? 1 : 0);
 };
 
 export function* allTagPathsFor(range, options = {}) {
@@ -362,21 +487,17 @@ export function* allTagPathsFor(range, options = {}) {
 
     yield path;
 
-    if (
-      endPath &&
-      path.childrenIndex === endPath.childrenIndex &&
-      path.path.node === endPath.path.node
-    ) {
+    if (endPath && path.tagsIndex === endPath.tagsIndex && path.path.node === endPath.path.node) {
       return;
     }
 
-    let gapPath = path.path.parent && TagPath.from(path.path.parent, path.path.referenceIndex + 1);
+    let gapPath = path.path.parent && TagPath.from(path.path.parent, path.path.parentIndex, 1);
 
     if (
       endPath &&
       path.tag.type === CloseNodeTag &&
       gapPath &&
-      gapPath.childrenIndex === endPath.childrenIndex &&
+      gapPath.tagsIndex === endPath.tagsIndex &&
       gapPath.path.node === endPath.path.node
     ) {
       return;
@@ -392,7 +513,7 @@ export function* allTagsFor(range, options = {}) {
 }
 
 export const buildFullRange = (node) => {
-  let sum = Children.getSize(node.children);
+  let sum = Tags.getSize(node.tags);
   return sum ? [0, sum - 1] : null;
 };
 
@@ -404,10 +525,10 @@ export function* ownTagPathsFor(range) {
 
   if (startPath.parent.node !== endPath.parent.node) throw new Error();
 
-  let { children } = startPath.parent.node;
+  let { tags } = startPath.parent.node;
 
-  for (let i = startPath.childrenIndex; i < endPath.childrenIndex; i++) {
-    yield children[i];
+  for (let i = startPath.tagsIndex; i < endPath.tagsIndex; i++) {
+    yield tags[i];
   }
 }
 
@@ -462,14 +583,14 @@ export let pathForTagPath = (tagPath) => {
   let isShift = tagPath.tag.type === ShiftTag;
 
   if (isShift) {
-    refTagPath = tagPath.siblingAt(tagPath.childrenIndex - tagPath.tag.value.index * 3);
+    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.childrenIndex);
+  let index = getChildPropertyIndex(tagPath.node, refTagPath.tagsIndex);
   let shiftIndex = isShift ? (tagPath.tag.value.index ?? 0) + 1 : null;
 
   return [{ type, name, index, shiftIndex }];
@@ -477,37 +598,42 @@ export let pathForTagPath = (tagPath) => {
 
 export const Path = class AgastPath extends WeakStackFrame {
   static from(node) {
-    return node && this.create(node);
+    let node_ = isPlainObject(node) ? node : node.node;
+    return node_ && this.create(node_);
   }
 
-  constructor(parent, node, referenceIndex = null) {
+  constructor(parent, node, parentIndex = null) {
     super(parent);
 
-    if (!(hasOwn(node, 'type') && hasOwn(node, 'properties'))) throw new Error();
+    if (!node || !(hasOwn(node, 'type') && hasOwn(node, 'tags'))) throw new Error();
 
-    if (parent && referenceIndex == null) throw new Error();
+    if (parent && parentIndex == null) throw new Error();
     if (!node) throw new Error();
     if (isArray(node)) throw new Error();
 
     this.node = node;
-    this.referenceIndex = referenceIndex; // in the parent
+    this.parentIndex = parentIndex; // in the parent
 
-    let referenceTag =
-      referenceIndex != null && Children.getAt(referenceIndex, parent.node.children);
+    let parentTag = parent && Tags.getAt(parentIndex, parent.node.tags);
 
-    if (referenceTag && ![ReferenceTag, ShiftTag].includes(referenceTag.type)) {
+    if (parentTag && parentTag.type !== PropertyWrapper) {
       throw new Error();
     }
 
-    if (parent && (!this.reference || ![ReferenceTag, ShiftTag].includes(this.reference.type))) {
+    parentIndex != null && parentTag?.value.tags[0];
+
+    if (
+      parent &&
+      (!this.referenceTag || ![ReferenceTag, ShiftTag].includes(this.referenceTag.type))
+    ) {
       throw new Error();
     }
 
     // if (
     //   parent &&
-    //   (['#', '@'].includes(this.reference.value.type)
-    //     ? parent.tagPathAt(referenceIndex + 1).tag.value
-    //     : get(pathForTagPath(parent.tagPathAt(referenceIndex)), parent.node)) !== node
+    //   (['#', '@'].includes(this.referenceTag.value.type)
+    //     ? parent.tagPathAt(parentIndex, 1).tag.value
+    //     : get(pathForTagPath(parent.tagPathAt(parentIndex)), parent.node)) !== node
     // ) {
     //   throw new Error('Path not reachable');
     // }
@@ -541,18 +667,54 @@ export const Path = class AgastPath extends WeakStackFrame {
     return this.closeTagPath.tag;
   }
 
-  tagPathAt(idx) {
-    return TagPath.from(this, idx);
+  tagPathAt(idx, offset) {
+    return TagPath.from(this, idx, offset);
+  }
+
+  get binding() {
+    return this.bindingTag?.value ?? null;
+  }
+
+  get bindingTag() {
+    return this.bindingTagPath?.tag ?? null;
+  }
+
+  get bindingTagPath() {
+    return (this.parent?.node ?? null) && new TagPath(this.parent, this.parentIndex, 1);
   }
 
   get reference() {
-    return (
-      (this.parent?.node ?? null) && Children.getAt(this.referenceIndex, this.parent.node.children)
-    );
+    return this.referenceTag?.value ?? null;
+  }
+
+  get referenceTag() {
+    return this.referenceTagPath?.tag ?? null;
   }
 
   get referenceTagPath() {
-    return (this.parent?.node ?? null) && new TagPath(this.parent, this.referenceIndex);
+    if (!this.parent?.node) {
+      return null;
+    }
+    let path = new TagPath(this.parent, this.parentIndex, 0);
+    if (path.tag.type === ShiftTag) {
+      path = new TagPath(this.parent, this.parentIndex - path.tag.value.index, 0);
+    }
+    return path;
+  }
+
+  get parentPropertyPath() {
+    if (!this.parent?.node) {
+      return null;
+    }
+    let path = new TagPath(this.parent, this.parentIndex);
+    if (path.tag.type === ShiftTag) {
+      path = new TagPath(this.parent, this.parentIndex - path.tag.value.index);
+    }
+    return path;
+  }
+
+  get parentProperty() {
+    return this.parentPropertyPath?.tag ?? null;
   }
 
   get(path) {
@@ -563,37 +725,167 @@ export const Path = class AgastPath extends WeakStackFrame {
     if (!isArray(path_)) throw new Error();
 
     let pathInst = this;
+
+    if (!pathInst.node.type && pathInst.node.flags.cover) {
+      if (pathInst.depth) throw new Error();
+      pathInst = pathInst.push(
+        getRoot(pathInst.node),
+        getPropertyTagsIndex(pathInst.node, '.', null, 0),
+      );
+    }
+
     for (let i = 0; i < path_.length; i++) {
       let nameOrSeg = path_[i];
 
+      let seg = nameOrSeg;
       if (isString(nameOrSeg)) {
-        nameOrSeg = { type: null, name: nameOrSeg, index: null, shiftIndex: null };
+        let index = path_[i + 1];
+        if (typeof index === 'number') {
+          i++;
+        } else {
+          index = undefined;
+        }
+        seg = buildPathSegment(nameOrSeg, index);
       }
 
-      let property = getProperties(nameOrSeg, pathInst.node.properties);
+      let tagsIndex = getPropertyTagsIndex(
+        pathInst.node,
+        seg.type,
+        seg.name,
+        seg.index,
+        seg.shiftIndex,
+      );
+
+      let { property } = Tags.getAt(tagsIndex, pathInst.node.tags).value;
 
       if (!property) return null;
 
-      let { node, reference: ref } = property;
+      let { node } = property;
 
-      let shiftIndex_ = nameOrSeg.shiftIndex;
+      pathInst = pathInst.push(node, tagsIndex);
+    }
 
-      if (shiftIndex_ && shiftIndex_ < 0) {
-        shiftIndex_ = btree.getSize(node) + shiftIndex_;
-      } else if (shiftIndex_ == null && ref.flags.expression) {
-        shiftIndex_ = 0;
-      }
+    return pathInst;
+  }
+
+  replaceWith(node, binding = buildBinding()) {
+    return this.replaceAt([], node, binding);
+  }
+
+  replaceAt(path, node, binding = buildBinding()) {
+    throw new Error('not working yet');
+
+    let built;
+    let path_ = path;
+    if (typeof path_ === 'string') {
+      path_ = [path_];
+    }
+    if (!isArray(path_)) throw new Error();
 
-      let shiftOffset = shiftIndex_ ? (shiftIndex_ - 1) * 3 : 0;
+    let pathInst = this;
 
+    if (!pathInst.node.type && pathInst.node.flags.cover) {
+      if (pathInst.depth) throw new Error();
       pathInst = pathInst.push(
-        node,
-        getPropertyChildrenIndex(pathInst.node, nameOrSeg.type, nameOrSeg.name, nameOrSeg.index) +
-          shiftOffset,
+        getRoot(pathInst.node),
+        getPropertyTagsIndex(pathInst.node, '.', null, 0),
       );
     }
 
-    return pathInst;
+    for (let i = 0; i < path_.length; i++) {
+      let nameOrSeg = path_[i];
+
+      built = { ...pathInst.node };
+
+      let seg = nameOrSeg;
+      if (isString(nameOrSeg)) {
+        let index = path_[i + 1];
+        if (typeof index === 'number') {
+          i++;
+        } else {
+          index = undefined;
+        }
+        seg = buildPathSegment(nameOrSeg, index);
+      }
+
+      let tagsIndex = getPropertyTagsIndex(
+        pathInst.node,
+        seg.type,
+        seg.name,
+        seg.index,
+        seg.shiftIndex,
+      );
+
+      let tagPath = TagPath.from(pathInst, tagsIndex);
+
+      let {
+        property,
+        tags: { 0: refTag },
+      } = tagPath.tag.value;
+
+      if (refTag.type === ShiftTag) {
+        let { index } = refTag.value;
+
+        for (let i = 0; i < index - 1; i++) {
+          // update bounds!
+        }
+        tagsIndex -= index;
+        pathInst = pathInst.replace(built, tagsIndex);
+      }
+
+      if (!property) return null;
+
+      let { node } = property;
+
+      pathInst = pathInst.push(node, tagsIndex);
+    }
+
+    let node_ = isPlainObject(node) ? node : node.node;
+
+    if (!node_) throw new Error();
+
+    path = pathInst.parent;
+    let replacementPath = [];
+
+    let targetReference = pathInst.reference;
+    let targetBinding = binding;
+    let targetParentIndex = pathInst.parentIndex;
+
+    while (path) {
+      let value = built;
+      built = { ...path.node };
+
+      let { tags } = Tags.getAt(targetParentIndex, path.node.tags).value;
+      let property = buildProperty(targetReference, targetBinding, value);
+
+      let tags_ = [tags[0], buildChild(BindingTag, targetBinding), buildChild(Property, property)];
+
+      built.tags = Tags.replaceAt(
+        targetParentIndex,
+        built.tags,
+        buildChild(PropertyWrapper, buildPropertyWrapper(tags_, property)),
+      );
+
+      finalizeNode(built);
+
+      if (targetReference.name) {
+        replacementPath.push(
+          buildPathSegment(
+            targetReference.name,
+            getChildPropertyIndex(path.node, targetParentIndex),
+          ),
+        );
+      }
+
+      targetReference = path.reference;
+      targetBinding = path.binding;
+      targetParentIndex = path.parentIndex;
+      path = path.parent;
+    }
+
+    replacementPath.reverse();
+
+    return Path.from(built).get(replacementPath).atDepth(this.depth);
   }
 
   atDepth(depth) {
@@ -603,34 +895,50 @@ export const Path = class AgastPath extends WeakStackFrame {
 
 export const tagPathsAreEqual = (a, b) => {
   if (a == null || b == null) return b == a;
-  return a.path.node === b.path.node && a.childrenIndex === b.childrenIndex;
+  return a.path.node === b.path.node && a.tagsIndex === b.tagsIndex;
 };
 
 export class TagPath {
-  constructor(path, childrenIndex) {
-    if (path == null || childrenIndex == null) throw new Error();
+  constructor(path, tagsIndex, wrapperIndex) {
+    if (path == null || tagsIndex == null) throw new Error();
 
-    let tag = Children.getAt(childrenIndex, path.node.children);
+    let tag = Tags.getAt(tagsIndex, path.node.tags);
 
     if (tag == null) throw new Error();
 
+    if (tag.type === PropertyWrapper && wrapperIndex != null) {
+      tag = tag.value.tags[wrapperIndex];
+    }
+
     this.path = path;
     this.node = path.node;
     this.tag = tag;
-    this.childrenIndex = childrenIndex;
+    this.tagsIndex = tagsIndex;
+    this.wrapperIndex = wrapperIndex;
 
     freeze(this);
   }
 
-  static from(path, childrenIndex) {
-    let size = Children.getSize(path.node.children);
-    let index = childrenIndex < 0 ? size + childrenIndex : childrenIndex;
+  static from(path, tagsIndex, wrapperIndex) {
+    let size = Tags.getSize(path.node.tags);
+    let index = tagsIndex < 0 ? size + tagsIndex : tagsIndex;
+
+    let tag = Tags.getAt(index, path.node.tags);
 
-    return index >= 0 && index < size ? new TagPath(path, index) : null;
+    if (!tag) return null;
+
+    let offset =
+      wrapperIndex == null || tag.type !== PropertyWrapper
+        ? null
+        : wrapperIndex < 0
+        ? tag.value.tags.length + wrapperIndex
+        : wrapperIndex;
+
+    return index >= 0 && index < size ? new TagPath(path, index, offset) : null;
   }
 
-  static fromNode(node, childrenIndex) {
-    return TagPath.from(Path.from(node), childrenIndex);
+  static fromNode(node, tagsIndex, wrapperIndex) {
+    return TagPath.from(Path.from(node), tagsIndex, wrapperIndex);
   }
 
   get child() {
@@ -642,117 +950,129 @@ export class TagPath {
   }
 
   get nextSibling() {
-    const { path, childrenIndex } = this;
+    const { path, tagsIndex, wrapperIndex } = this;
 
-    const child =
-      childrenIndex + 1 >= Children.getSize(path.node.children)
-        ? null
-        : Children.getAt(childrenIndex + 1, path.node.children);
+    let propPath = new TagPath(path, tagsIndex);
 
-    return child && new TagPath(path, childrenIndex + 1);
+    if (wrapperIndex != null && wrapperIndex + 1 < Tags.getSize(propPath.tag.value.tags)) {
+      return new TagPath(path, tagsIndex, wrapperIndex + 1);
+    } else if (tagsIndex + 1 < Tags.getSize(path.node.tags)) {
+      return new TagPath(path, tagsIndex + 1, 0);
+    }
+
+    return TagPath.from(path, tagsIndex + 1, 0);
   }
 
   get next() {
-    let { path, childrenIndex } = this;
+    let { path, tagsIndex, wrapperIndex } = this;
 
     let leaving = false;
 
     for (;;) {
-      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 lastRef = Tags.getAt(tagsIndex, path.node.tags, 0);
+      let tag = Tags.getAt(tagsIndex, path.node.tags);
+      let wrapperTag = tag;
+      let isInitialTag =
+        path.node === this.path.node &&
+        tagsIndex === this.tagsIndex &&
+        wrapperIndex === this.wrapperIndex;
       let wasLeaving = leaving;
       leaving = false;
 
       if (!tag) return null;
 
+      wrapperIndex =
+        tag.type === PropertyWrapper ? (wrapperIndex == null ? 0 : wrapperIndex) : null;
+
+      if (wrapperIndex != null) {
+        wrapperTag = tag.value.tags[wrapperIndex];
+      }
+
       // done
-      if (!isInitialTag && tag.type !== Property) {
-        return new TagPath(path, childrenIndex);
+      if (!isInitialTag && wrapperTag.type !== Property) {
+        return new TagPath(path, tagsIndex, wrapperIndex);
       }
 
       // in
-      if (tag.type === Property && !wasLeaving) {
-        // jump to gap tag?
-        if (
-          path.parent &&
-          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 { reference: ref } = tag.value;
-          let shiftStack = path.node.properties[ref.name].node;
+      if (wrapperTag.type === Property && !wasLeaving) {
+        if (tag.value.tags[1]?.type === InitializerTag || !tag.value.property.node) {
+        } else {
+          // jump to gap tag?
+          let tag1;
+          if (
+            path.parent &&
+            tag.value.property.reference.flags.expression &&
+            (tagsIndex === 1 ||
+              (tagsIndex === 2 &&
+                (tag1 = Tags.getAt(1, path.node.tags)).type === PropertyWrapper &&
+                tag1.value.tags[1].type === InitializerTag)) &&
+            Tags.getAt(path.parentIndex, path.parent.node.tags, 0)?.type === ShiftTag
+          ) {
+            let shiftStack = tag.value.property.node.bounds[0];
+
+            let gapNode = BTree.getAt(-1, shiftStack).node;
 
-          if (ref.isArray) {
-            shiftStack = btree.getAt(-1, shiftStack).node;
+            path = new Path(path, gapNode, tagsIndex);
+            tagsIndex = 0;
+            continue;
           }
-          let gapNode = btree.getAt(0, shiftStack).node;
 
-          path = new Path(path, gapNode, childrenIndex - 2);
-          childrenIndex = 0;
+          path = new Path(path, tag.value.property.node, tagsIndex);
+          tagsIndex = 0;
           continue;
         }
-
-        path = path.push(tag.value.node, childrenIndex - 2);
-        childrenIndex = 0;
-        continue;
       }
 
+      tag;
       // shift
-      if (tag.type === BindingTag && prevTag.type === ShiftTag) {
-        let refIndex = childrenIndex - 1 - prevTag.value.index * 3;
+      if (wrapperTag.type === BindingTag && lastRef.type === ShiftTag) {
+        let refIndex = tagsIndex - lastRef.value.index;
         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) {
-          index = getChildPropertyIndex(path.node, refIndex);
-          pathDesc = buildPathSegment(name, index);
-        }
+        let refTag = Tags.getAt(refIndex, path.node.tags, 0);
 
-        // HMM
-        pathDesc.shiftIndex = prevTag.value.height;
+        if (refTag.type !== ReferenceTag) throw new Error();
 
-        if (index !== -1) {
-          path = path.get([pathDesc]);
+        if (Tags.getAt(refIndex, path.node.tags, 1).type !== InitializerTag) {
+          path = new Path(path, tag.value.property.node, tagsIndex);
 
           if (!path) return null;
 
-          childrenIndex = 0;
+          tagsIndex = 0;
           continue;
         }
       }
 
       // over
-      if (path.node && childrenIndex + 1 < Children.getSize(path.node.children)) {
-        childrenIndex++;
+      if (tag.type === PropertyWrapper && wrapperIndex + 1 < tag.value.tags.length) {
+        wrapperIndex++;
+        continue;
+      } else if (path.node && tagsIndex + 1 < Tags.getSize(path.node.tags)) {
+        tagsIndex++;
+        wrapperIndex = 0;
         continue;
       }
 
       // out
-      if (path.referenceIndex != null && path.parent) {
+      if (path.parentIndex != null && path.parent) {
         do {
           if (
             path.parent &&
-            Children.getAt(path.referenceIndex, path.parent.node.children)?.type === ShiftTag
+            Tags.getAt(path.parentIndex, path.parent.node.tags, 0)?.type === ShiftTag
           ) {
-            childrenIndex =
-              Children.getSize(path.parent.node.children) > path.referenceIndex + 2
-                ? path.referenceIndex + 2
+            tagsIndex =
+              Tags.getSize(path.parent.node.tags) > path.parentIndex + 1
+                ? path.parentIndex + 1
                 : null;
           } else {
-            childrenIndex = path.referenceIndex + 2;
+            tagsIndex = path.parentIndex + 1;
           }
 
+          wrapperIndex = 0;
           path = path.parent;
           leaving = true;
 
           if (!path) return null;
-        } while (childrenIndex == null);
+        } while (tagsIndex == null);
 
         leaving = true;
         continue;
@@ -763,64 +1083,77 @@ export class TagPath {
   }
 
   get nextUnshifted() {
-    let { path, childrenIndex } = this;
+    let { path, tagsIndex, wrapperIndex } = this;
 
     let leaving = false;
 
     for (;;) {
-      let tag = Children.getAt(childrenIndex, path.node.children);
-      let isInitialTag = path.node === this.path.node && childrenIndex === this.childrenIndex;
+      let tag = Tags.getAt(tagsIndex, path.node.tags);
+      let wrapperTag = tag;
+      let isInitialTag =
+        path.node === this.path.node &&
+        tagsIndex === this.tagsIndex &&
+        wrapperIndex === this.wrapperIndex;
       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++;
+      wrapperIndex =
+        tag.type === PropertyWrapper ? (wrapperIndex == null ? 0 : wrapperIndex) : null;
+
+      if (wrapperIndex != null) {
+        wrapperTag = tag.value.tags[wrapperIndex];
+      }
+
+      if (wrapperTag.type === ReferenceTag && wrapperTag.value.flags.expression) {
+        // move past shifts
 
-          if (tag_?.type === InitializerTag) break;
-        } while (tag_ && [BindingTag, ShiftTag].includes(tag_.type));
-        if (!tag_) {
-          return null;
+        let shifts = 0;
+        let tag = Tags.getAt(tagsIndex + 1, path.node.tags);
+
+        while (tag?.type === PropertyWrapper && tag.value.tags[0].type === ShiftTag) {
+          shifts++;
+          wrapperIndex = 1;
+          tag = Tags.getAt(tagsIndex + shifts + 1, path.node.tags);
+        }
+        if (shifts) {
+          tagsIndex += shifts;
+          continue;
         }
       }
 
       // done
-      if (!isInitialTag && tag.type !== Property) {
-        return new TagPath(path, childrenIndex);
+      if (!isInitialTag && wrapperTag.type !== Property) {
+        return new TagPath(path, tagsIndex, wrapperIndex);
       }
 
       // in
-      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;
+      if (tag.type === PropertyWrapper) {
+        if (wrapperIndex + 1 < tag.value.tags.length) {
+          wrapperIndex++;
+          continue;
+        } else if (!wasLeaving && tag.value.tags[1] && tag.value.tags[1].type !== InitializerTag) {
+          path = path.push(tag.value.property.node, tagsIndex);
+          tagsIndex = 0;
+          continue;
+        }
       }
 
       // over
-      if (path.node && childrenIndex + 1 < Children.getSize(path.node.children)) {
-        childrenIndex++;
+      if (path.node && tagsIndex + 1 < Tags.getSize(path.node.tags)) {
+        tagsIndex++;
         continue;
       }
 
       // out
-      if (path.referenceIndex != null) {
+      if (path.parentIndex != null) {
         do {
-          childrenIndex = path.referenceIndex + 2;
+          tagsIndex = path.parentIndex + 1;
 
           path = path.parent;
           leaving = true;
-        } while (childrenIndex == null);
+        } while (tagsIndex == null);
 
         leaving = true;
         continue;
@@ -831,63 +1164,15 @@ export class TagPath {
   }
 
   get previousSibling() {
-    const { path, childrenIndex } = this;
-
-    const child = childrenIndex - 1 < 0 ? null : btree.getAt(childrenIndex - 1, path.node.children);
-
-    return child && new TagPath(path, childrenIndex - 1);
-  }
-
-  get previous() {
-    throw new Error('not implemented');
-  }
+    const { path, tagsIndex, wrapperIndex } = this;
 
-  get previousUnshifted() {
-    let { path, childrenIndex } = this;
-
-    let leaving = false;
-
-    for (;;) {
-      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;
-
-      // done
-      if (!isInitialTag && tag.type !== ShiftTag && tag.type !== Property) {
-        return new TagPath(path, childrenIndex);
-      }
-
-      // in
-      if (tag.type === Property && !wasLeaving) {
-        path = path.push(tag.value.node, childrenIndex - 1);
-        childrenIndex = Children.getSize(tag.value.children) - 1;
-        continue;
-      }
-
-      // over
-      if (path.node && childrenIndex + 1 < Children.getSize(path.node.children)) {
-        childrenIndex--;
-        continue;
-      }
-
-      // out
-      if (path.referenceIndex != null) {
-        do {
-          childrenIndex = path.referenceIndex;
-
-          path = path.parent;
-          leaving = true;
-        } while (childrenIndex == null);
+    if (wrapperIndex > 0) {
+      return new TagPath(path, tagsIndex, wrapperIndex - 1);
+    }
 
-        leaving = true;
-        continue;
-      }
+    const child = tagsIndex - 1 < 0 ? null : BTree.getAt(tagsIndex - 1, path.node.tags);
 
-      return null;
-    }
+    return child && TagPath.from(path, tagsIndex - 1, -1);
   }
 
   get innerNode() {
@@ -895,18 +1180,19 @@ export class TagPath {
   }
 
   get inner() {
-    let { tag, previousSibling } = this;
+    let { path, tagsIndex, tag, previousSibling } = this;
 
-    let refPath = previousSibling?.previousSibling;
+    let refPath = TagPath.from(path, tagsIndex, 0);
 
-    if (tag.type !== Property) {
+    if (tag.type !== PropertyWrapper) {
       return null;
     }
 
     let shiftPath = null;
     if (refPath.tag.type === ShiftTag) {
       shiftPath = refPath;
-      refPath = TagPath.from(this.path, this.childrenIndex - refPath.tag.value.index * 3 - 2);
+      throw new Error('not implemented');
+      refPath = TagPath.from(this.path, this.tagsIndex - refPath.tag.value.index - 2);
     }
 
     if (refPath.tag.type !== ReferenceTag) throw new Error();
@@ -917,13 +1203,13 @@ export class TagPath {
       buildFullPathSegment(
         type,
         name,
-        getChildPropertyIndex(refPath.path.node, refPath.childrenIndex),
+        getChildPropertyIndex(refPath.path.node, refPath.tagsIndex),
         shiftPath?.tag.value.index,
       ),
     ]);
   }
 
   equalTo(tagPath) {
-    return this.node === tagPath.node && this.childrenIndex === tagPath.childrenIndex;
+    return this.node === tagPath.node && this.tagsIndex === tagPath.tagsIndex;
   }
 }