@bablr/agast-vm 0.9.0 → 0.11.0

package/lib/evaluate.js

@@ -1,3 +1,4 @@
+/* global WeakSet */
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -6,23 +7,33 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  InitializerTag,
   LiteralTag,
   AttributeDefinition,
   BindingTag,
   Property,
+  TreeNode,
+  NullNode,
+  GapNode,
 } from '@bablr/agast-helpers/symbols';
 import { State } from './state.js';
-import { facades } from './facades.js';
-import { getFirstNode, TagPath } from '@bablr/agast-helpers/path';
-import * as sumtree from '@bablr/agast-helpers/children';
-import { NodeFacade } from './node.js';
+import {
+  getAttributes,
+  getFirstNode,
+  isGapNode,
+  isNodeTag,
+  TagPath,
+} from '@bablr/agast-helpers/path';
+import * as BTree from '@bablr/agast-helpers/btree';
+import * as Tags from '@bablr/agast-helpers/tags';
+import { isObject } from '@bablr/agast-helpers/object';
+
+const validNodes = new WeakSet();
+
+export const isKnownValid = (node) => validNodes.has(node);
 
 let { isArray } = Array;
 
 export const agast = (options = {}) => {
-  if (options.held?.properties) throw new Error();
-
   let state = State.from(options.held);
 
   let vm = __agast(state, options);
@@ -31,7 +42,14 @@ export const agast = (options = {}) => {
 
   Object.freeze(options);
 
-  return Object.freeze({ options, state: facades.get(state), vm });
+  let getState = () => ({
+    path: state.path,
+    node: state.path.node,
+    resultPath: state.resultPath,
+    held: state.held,
+  });
+
+  return Object.freeze({ options, getState, vm });
 };
 
 function* __agast(s) {
@@ -39,22 +57,19 @@ function* __agast(s) {
   for (;;) {
     let returnValue = null;
 
-    if (s.resultPath && !s.path) {
-      throw new Error('Cannot advance after completion');
-    }
-
-    if (
-      s.held &&
-      ![OpenNodeTag, ReferenceTag, InitializerTag, Property, BindingTag].includes(tag.type) &&
-      !(
-        (tag.type === Property &&
-          (sumtree.getSize(tag.value.node.children) <= 1 ||
-            getFirstNode(tag.value.node) === s.held.node)) ||
-        tag.value.node === s.held.node
-      )
-    ) {
-      throw new Error('Cannot advance while holding');
-    }
+    // if (
+    //   s.held &&
+    //   ![OpenNodeTag, ReferenceTag, TreeNode, GapNode, BindingTag, Property, GapTag].includes(
+    //     tag.type,
+    //   ) &&
+    //   !(
+    //     (isNodeTag(tag) &&
+    //       (Tags.getSize(tag.value.tags) <= 1 || getFirstNode(tag.value) === s.held)) ||
+    //     tag.value === s.held
+    //   )
+    // ) {
+    //   throw new Error('Cannot advance while holding');
+    // }
 
     switch (tag.type) {
       case DoctypeTag: {
@@ -62,109 +77,125 @@ function* __agast(s) {
           throw new Error();
         }
 
-        s.advance(tag);
+        s.path = s.path.advance(tag);
         break;
       }
 
-      case LiteralTag: {
-        if (!s.node.flags.token) {
-          throw new Error('literals must occur inside tokens');
-        }
-
-        if (s.held) {
-          throw new Error('Cannot consume input while hold register is full');
-        }
-
-        s.advance(tag);
+      case ReferenceTag: {
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
         break;
       }
 
-      case ReferenceTag: {
-        const { type } = tag.value;
-
-        if (s.node?.flags.token && type !== '@') {
-          throw new Error('A token node cannot contain a reference');
-        }
+      case LiteralTag: {
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        break;
+      }
 
-        s.advance(tag);
+      case AttributeDefinition: {
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
         break;
       }
 
       case BindingTag: {
-        const { languagePath } = tag.value;
+        const { segments } = tag.value;
 
-        if (languagePath && !isArray(languagePath)) throw new Error();
+        if (segments && !isArray(segments)) throw new Error();
 
-        s.advance(tag);
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, [-1, -1]);
         break;
       }
 
       case NullTag:
       case GapTag: {
-        s.advance(tag);
-        returnValue = new NodeFacade(s.resultPath.node);
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        returnValue = s.resultPath.node;
         break;
       }
 
       case AttributeDefinition: {
-        if (s.atReference) throw new Error();
-
-        s.advance(tag);
+        s.path = s.path.advance(tag);
         break;
       }
 
-      case InitializerTag: {
-        if (!s.atReference) throw new Error();
-
-        s.advance(tag);
+      case ShiftTag: {
+        let previousPropertyPath = s.path.tagPathAt(-1);
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        s.held = previousPropertyPath.inner.node;
         break;
       }
 
-      case ShiftTag: {
-        const { index } = tag.value;
-        if (s.resultPath.tag.type !== Property) throw new Error();
+      case OpenNodeTag: {
+        s.path = !s.path ? TagPath.fromTag(tag).path : s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
 
-        let prevRef = s.resultPath.previousSibling.previousSibling;
+        if (s.path) {
+          let queue = [getAttributes(s.node)];
+          while (queue.length) {
+            for (let value of Object.values(queue[queue.length - 1])) {
+              if (value === undefined) {
+              } else if (isArray(value) || isObject(value)) {
+                queue.push(value);
+              }
+            }
+            queue.pop();
+          }
+        }
 
-        if (prevRef.tag.type === ShiftTag) {
-          if (prevRef.tag.value.index + 1 !== index) throw new Error('bad shift index');
+        returnValue = s.node || s.resultPath.node;
+        break;
+      }
+
+      case CloseNodeTag: {
+        if (!s.path) {
+          s.done = true;
         }
 
-        let refPath = TagPath.from(
-          s.resultPath.path,
-          s.resultPath.childrenIndex - (index - 1) * 3 - 2,
-        );
+        validNodes.add(s.node);
 
-        if (refPath.tag.type !== ReferenceTag) throw new Error();
+        returnValue = s.node;
 
-        if (!refPath.tag.value.flags.expression) {
-          throw new Error();
-        }
+        let donePath = s.path;
+
+        s.path = s.path.advance(tag);
 
-        s.advance(tag);
+        s.resultPath = donePath.tagPathAt(-1, -1);
         break;
       }
 
-      case OpenNodeTag: {
-        s.advance(tag);
+      case Property: {
+        let { tags, node } = tag.value;
+
+        for (tag of Tags.traverse(tags)) {
+          s.path = s.path.advance(tag);
+        }
+        returnValue = node;
 
-        returnValue = new NodeFacade(s.node);
         break;
       }
 
-      case CloseNodeTag: {
-        returnValue = new NodeFacade(s.node);
+      case NullNode:
+      case GapNode:
+      case TreeNode: {
+        let node = tag;
 
-        s.advance(tag);
-        break;
-      }
+        // let clearedHeld =
+        //   s.held &&
+        //   (node.type === GapNode ||
+        //     BTree.getAt(-BTree.getSize(s.held.value.bounds[0]), node.value.bounds[0]));
 
-      case Property: {
-        let { node } = tag.value;
+        // if (s.held && !s.path.held) throw new Error();
 
-        s.advance(tag);
+        s.path = s.path.advance(s.held && isGapNode(node) ? s.held : tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        s.held = null;
 
-        returnValue = new NodeFacade(node);
+        returnValue = s.path.node;
         break;
       }
 

package/lib/index.js

@@ -1,4 +1 @@
-export { agast } from './evaluate.js';
-
-export { PathFacade, TagPathFacade } from './path.js';
-export { NodeFacade } from './node.js';
+export { agast, isKnownValid } from './evaluate.js';

package/lib/state.js

@@ -1,164 +1,25 @@
-import {
-  addProperty,
-  finalizeNode,
-  buildStubNode,
-  getRange,
-  createNode,
-  buildNullNode,
-  buildOpenNodeTag,
-  shiftProperty,
-  buildProperty,
-  add,
-  buildBindingTag,
-  buildAttributeDefinition,
-} from '@bablr/agast-helpers/tree';
-import * as sumtree from '@bablr/agast-helpers/children';
-import * as btree from '@bablr/agast-helpers/btree';
-import {
-  getInitializerChildrenIndex,
-  getOpenTag,
-  getOriginalFirstNode,
-  isGapNode,
-  isStubNode,
-  referencesAreEqual,
-  TagPath,
-} from '@bablr/agast-helpers/path';
-import {
-  DoctypeTag,
-  OpenNodeTag,
-  CloseNodeTag,
-  ReferenceTag,
-  ShiftTag,
-  GapTag,
-  NullTag,
-  InitializerTag,
-  LiteralTag,
-  AttributeDefinition,
-  BindingTag,
-  Property,
-} from '@bablr/agast-helpers/symbols';
-import { facades, actuals } from './facades.js';
-import { Path, PathFacade, TagPathFacade } from './path.js';
-import { get, has, immSet, isObject } from '@bablr/agast-helpers/object';
-import { NodeFacade } from './node.js';
-
-const { isArray } = Array;
-const { hasOwn } = Object;
-
-const defineAttribute = (node, tag) => {
-  if (tag.type !== AttributeDefinition) throw new Error();
-
-  let { path, value } = tag.value;
-  let openTag = getOpenTag(node);
-  let { attributes } = node;
-
-  if (!has(attributes, path) && get(attributes, path) !== undefined)
-    throw new Error('Can only define undefined attributes');
-
-  if (value === undefined) throw new Error('cannot define attribute to undefined');
-
-  let { flags, type } = openTag.value;
-  attributes = immSet(attributes, path, value);
-  let newOpenTag = buildOpenNodeTag(flags, type, attributes);
-
-  node.attributes = attributes;
-
-  node.children = sumtree.replaceAt(0, node.children, newOpenTag);
-  node.children = sumtree.push(node.children, tag);
-};
-
-export const StateFacade = class AgastStateFacade {
-  constructor(state) {
-    facades.set(state, this);
-  }
-
-  static create() {
-    return State.create();
-  }
-
-  get resultPath() {
-    let { resultPath } = actuals.get(this);
-    return resultPath && new TagPathFacade(resultPath);
-  }
-
-  get referenceTag() {
-    return actuals.get(this).referenceTag;
-  }
-
-  get referenceTagPath() {
-    let { referenceTagPath } = actuals.get(this);
-    return referenceTagPath && new TagPathFacade(referenceTagPath);
-  }
-
-  get path() {
-    let { path } = actuals.get(this);
-    return path && new PathFacade(path);
-  }
-
-  get node() {
-    let { node } = actuals.get(this);
-    return node && new NodeFacade(node);
-  }
-
-  get done() {
-    return actuals.get(this).done;
-  }
-
-  get parentNode() {
-    let { parentNode } = actuals.get(this);
-    return parentNode && new NodeFacade(parentNode);
-  }
-
-  get held() {
-    let { held } = actuals.get(this);
-    return held && new NodeFacade(held.node);
-  }
-
-  get holding() {
-    return actuals.get(this).holding;
-  }
-
-  get depth() {
-    return actuals.get(this).depth;
-  }
-
-  get parent() {
-    return facades.get(actuals.get(this).parent);
-  }
-};
-
-export const nodeStates = new WeakMap();
+import { offsetForTag, TagPath } from '@bablr/agast-helpers/path';
+import { DoctypeTag, Property } from '@bablr/agast-helpers/symbols';
 
 export const State = class AgastState {
   static create() {
     return new State();
   }
 
+  static from(held) {
+    return new State(held);
+  }
+
   constructor(held = null, path = null, resultPath = null) {
     this.held = held;
     this.path = path;
     this.resultPath = resultPath;
     this.done = false;
-    this.referenceTagPath = null;
     this.doctype = null;
-
-    new StateFacade(this);
   }
 
-  static from(held) {
-    return new State(held);
-  }
-
-  get holding() {
-    return !!this.held;
-  }
-
-  get atReference() {
-    return [ReferenceTag, ShiftTag].includes(this.resultPath?.tag.type);
-  }
-
-  get atBinding() {
-    return this.resultPath?.tag.type === BindingTag;
+  get node() {
+    return this.path.node;
   }
 
   advance(tag) {
@@ -180,313 +41,13 @@ export const State = class AgastState {
         break;
       }
 
-      case ReferenceTag: {
-        let { type, isArray, name, flags } = tag.value;
-
-        if (this.atReference) throw new Error('invalid location for reference');
-        if (!name && !type) throw new Error();
-        if (type && !['.', '#', '@'].includes(type)) throw new Error();
-        if (['#', '@'].includes(type) && isArray) throw new Error();
-
-        if (this.held && sumtree.getAt(2, this.node.children)?.type === InitializerTag) {
-          if (
-            !referencesAreEqual(sumtree.getAt(1, this.node.children), tag) ||
-            sumtree.getSize(this.node.children) > 3
-          ) {
-            throw new Error();
-          }
-        }
-
-        if (this.node.properties[name] && this.node.properties[name]?.node === undefined) {
-          let existingReferenceIndex = getInitializerChildrenIndex(this.node, tag);
-          let existingReference = sumtree.getAt(existingReferenceIndex, this.node.children);
-          if (!referencesAreEqual(tag, existingReference)) {
-            throw new Error("reference didn't match initializer");
-          }
-        }
-
-        this.node.children = sumtree.push(this.node.children, tag);
-
-        if (flags.hasGap && !this.node.flags.hasGap) {
-          throw new Error('gap reference in gapless node');
-        }
-
-        this.referenceTagPath = TagPath.from(this.path, -1);
-
-        break;
-      }
-
-      case BindingTag: {
-        if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for BindingTag');
-        }
-
-        this.node.children = sumtree.push(this.node.children, tag);
-        break;
-      }
-
-      case OpenNodeTag: {
-        let parentNode = this.node;
-
-        targetPath = this.path;
-
-        if (!this.atBinding && this.parent) {
-          throw new Error('Invalid location for OpenNodeTag');
-        }
-
-        let bindingTag = parentNode && sumtree.getAt(-1, parentNode.children);
-
-        if (bindingTag && !bindingTag.value.languagePath) throw new Error();
-
-        let node = createNode(tag);
-
-        if (!this.path) {
-          this.path = Path.create(node);
-
-          if (!tag.value.type && this.doctype) {
-            node.children = sumtree.push(node.children, this.doctype);
-          }
-        } else {
-          this.path = this.path.push(node, sumtree.getSize(parentNode.children) - 2);
-          add(parentNode, this.referenceTag, node, bindingTag);
-        }
-
-        node.children = sumtree.push(node.children, tag);
-
-        let undefinedAttributes = 0;
-
-        let queue = [this.node.attributes];
-        while (queue.length) {
-          for (let value of Object.values(queue[queue.length - 1])) {
-            if (value === undefined) {
-              undefinedAttributes++;
-            } else if (isArray(value) || isObject(value)) {
-              queue.push(value);
-            }
-          }
-          queue.pop();
-        }
-
-        nodeStates.set(this.node, { undefinedAttributes });
-
-        break;
-      }
-
-      case CloseNodeTag: {
-        if (this.atReference) throw new Error('invalid location for close tag');
-
-        if (this.node.type) {
-          for (const value of Object.values(this.node.properties)) {
-            if (!Array.isArray(value) && value.node === undefined) {
-              addProperty(
-                this.node,
-                buildProperty(value.reference, buildBindingTag().value, buildNullNode()),
-              );
-            }
-          }
-        }
-
-        let path = [];
-        let queue = [this.node.attributes];
-        while (queue.length) {
-          for (const { 0: key, 1: value } of Object.entries(queue[queue.length - 1])) {
-            if (value === undefined) {
-              path.push(key);
-              defineAttribute(this.node, buildAttributeDefinition(path, null));
-              path.pop(key);
-            } else if (isArray(value) || isObject(value)) {
-              queue.push(value);
-              path.push(key);
-            }
-          }
-          queue.pop();
-        }
-
-        this.node.children = sumtree.push(this.node.children, tag);
-
-        if (!this.path) {
-          this.done = true;
-        }
-
-        finalizeNode(this.node);
-
-        this.path = this.path.parent;
-        break;
-      }
-
-      case Property: {
-        let target;
-        let property = tag.value;
-        let { node } = this.path;
-        let lastTagPath = TagPath.from(this.path, -1);
-
-        if (!this.atBinding && !isStubNode(property.node)) {
-          throw new Error('Invalid location for Property');
-        }
-
-        if (this.held) {
-          if (isGapNode(property.node)) {
-            property = buildProperty(property.reference, this.held.binding, this.held.node);
-          } else {
-            let { height } = lastTagPath.previousSibling.tag.value;
-            let matchesHeld =
-              isGapNode(property.node) ||
-              this.held.node === property.node ||
-              this.held.node === getOriginalFirstNode(property.node, (height ?? 1) - 1);
-            if (!matchesHeld) {
-              throw new Error();
-            }
-          }
-        }
-
-        if (this.held && lastTagPath.previousSibling.tag.type !== ShiftTag) {
-          target = this.held.node;
-        } else {
-          // if (!this.node.flags.hasGap) throw new Error('Node must allow gaps');
-
-          target = buildStubNode(tag);
-        }
-
-        const range = getRange(target);
-
-        this.resultPath = range ? range[1] : this.resultPath;
-        this.referenceTagPath = null;
-
-        let lastRefPath = [ShiftTag, ReferenceTag].includes(lastTagPath.tag.type)
-          ? lastTagPath
-          : lastTagPath.previousSibling;
-
-        if (![ShiftTag, ReferenceTag].includes(lastRefPath.tag.type)) throw new Error();
-
-        if (lastRefPath.tag.type === ShiftTag) {
-          shiftProperty(node, property);
-        } else {
-          addProperty(node, property);
-        }
-
-        this.held = null;
-        break;
-      }
-
-      case GapTag:
-      case NullTag: {
-        const { node: parentNode, referenceTag } = this;
-
-        if (this.held) throw new Error();
-
-        if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for NullTag');
-        }
-
-        let stubNode = buildStubNode(tag);
-
-        add(parentNode, referenceTag, stubNode);
-
-        targetPath = this.path.push(stubNode, sumtree.getSize(this.node.children) - 3);
-        break;
-      }
-
-      case AttributeDefinition: {
-        if (this.held) throw new Error('invalid place for an atrribute binding');
-
-        let nodeState = nodeStates.get(this.node);
-
-        nodeState.undefinedAttributes--;
-
-        // add undefined attributes from value
-
-        defineAttribute(this.node, tag);
-
-        break;
-      }
-
-      case InitializerTag: {
-        const { isArray } = tag.value;
-        const { node, referenceTag } = this;
-        const { name } = referenceTag.value;
-
-        if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for InitializerTag');
-        }
-
-        if (this.held && sumtree.getAt(2, node.children)?.type === InitializerTag) {
-          throw new Error();
-        }
-
-        if (
-          hasOwn(node.properties, name) &&
-          (isArray
-            ? btree.getSize(node.properties[name])
-            : node.properties[name]?.node !== undefined)
-        ) {
-          throw new Error();
-        }
-
-        add(node, referenceTag, isArray ? [] : undefined);
-        break;
-      }
-
-      case ShiftTag: {
-        if (this.resultPath.tag.type !== Property) throw new Error('invalid location for shift');
-
-        let heldProperty = this.resultPath.tag.value;
-
-        if (!this.held) {
-          this.held = heldProperty;
-        }
-
-        if (!heldProperty.reference.flags.expression) throw new Error();
-
-        this.node.children = sumtree.push(this.node.children, tag);
-
-        this.referenceTagPath = TagPath.from(this.path, -1);
-
-        // this.path = finishedPath;
-        targetPath = this.path;
-        break;
-      }
-
-      case LiteralTag:
-        if (typeof tag.value !== 'string') throw new Error();
-
-        this.node.children = sumtree.push(this.node.children, tag);
-        break;
-
       default:
         throw new Error();
     }
 
-    this.resultPath = targetPath && TagPath.from(targetPath, -1);
+    this.resultPath =
+      targetPath && TagPath.from(targetPath, -1, tag.type === Property ? -1 : offsetForTag(tag));
 
     return tag;
   }
-
-  get isGap() {
-    return this.tag.type === GapTag;
-  }
-
-  get speculative() {
-    return !!this.parent;
-  }
-
-  get parentNode() {
-    return this.path.parent.node;
-  }
-
-  get referenceTag() {
-    return this.referenceTagPath?.tag;
-  }
-
-  get bindingPath() {
-    let path = this.referenceTagPath.nextSibling;
-    return path.tag.type === BindingTag ? path : null;
-  }
-
-  get binding() {
-    return this.bindingPath?.tag;
-  }
-
-  get node() {
-    return this.path?.node;
-  }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -11,20 +11,30 @@
     ".": "./lib/index.js"
   },
   "sideEffects": false,
+  "scripts": {
+    "test": "mocha test/*.test.js"
+  },
   "dependencies": {
-    "@bablr/agast-helpers": "0.8.0",
-    "@bablr/agast-vm-helpers": "0.8.0"
+    "@iter-tools/imm-stack": "1.2.0",
+    "@bablr/agast-helpers": "0.10.0",
+    "@bablr/agast-vm-helpers": "0.10.0"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "@bablr/boot": "*",
     "enhanced-resolve": "^5.12.0",
+    "expect": "30.1.2",
     "eslint": "^8.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
     "eslint-plugin-import": "^2.27.5",
     "iter-tools-es": "^7.3.1",
+    "mocha": "11.7.2",
     "prettier": "^2.6.2"
   },
-  "repository": "github:bablr-lang/agast-vm",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bablr-lang/agast-vm.git"
+  },
   "homepage": "https://github.com/bablr-lang/agast-vm",
   "license": "MIT"
 }

package/lib/facades.js

@@ -1,3 +0,0 @@
-import { buildFacadeLayer } from '@bablr/agast-vm-helpers/facades';
-
-export const { facades, actuals } = buildFacadeLayer();

package/lib/node.js

@@ -1,176 +0,0 @@
-import {
-  buildPathSegment,
-  get,
-  getChildPropertyIndex,
-  getCloseTag,
-  getProperties,
-  getPropertyChildrenIndex,
-} from '@bablr/agast-helpers/path';
-import * as sumtree from '@bablr/agast-helpers/children';
-import * as btree from '@bablr/agast-helpers/btree';
-import { DoctypeTag, GapTag, NullTag, OpenNodeTag } from '@bablr/agast-helpers/symbols';
-import { nodeFlags } from '@bablr/agast-helpers/builders';
-import { nodeStates } from './state.js';
-
-let { freeze, hasOwn } = Object;
-
-export const nodes = new WeakMap();
-
-export class NodeChildrenFacade {
-  constructor(node) {
-    nodes.set(this, node);
-    let tree = node.children;
-
-    if (!Object.isFrozen(tree)) throw new Error(); // just a sanity check right now
-
-    this.size = sumtree.getSize(tree);
-
-    freeze(this);
-  }
-
-  at(idx) {
-    return sumtree.getAt(idx, nodes.get(this).children);
-  }
-
-  [Symbol.iterator]() {
-    return sumtree.traverse(nodes.get(this).children);
-  }
-}
-
-export class ListFacade {
-  constructor(tree) {
-    nodes.set(this, tree);
-
-    this.size = btree.getSize(tree);
-
-    freeze(this);
-  }
-
-  at(idx) {
-    return btree.getAt(idx, nodes.get(this));
-  }
-
-  [Symbol.iterator]() {
-    return btree.traverse(nodes.get(this));
-  }
-}
-
-export class NodePropertiesFacade {
-  constructor(node) {
-    nodes.set(this, node);
-
-    freeze(this);
-  }
-
-  at(name, index = -1, shiftIndex = 0) {
-    let { properties } = nodes.get(this);
-
-    if (hasOwn(properties, name)) {
-      let prop = properties[name];
-
-      if (Array.isArray(prop.node) && index === -1) {
-        return new ListFacade(prop.node);
-      }
-
-      if (Array.isArray(prop.node)) {
-        prop = btree.getAt(index ?? -1, prop.node);
-      }
-
-      if (!prop) return index === -1 ? prop : null;
-      if (prop.reference.flags.expression) {
-        return NodeFacade.from(btree.getAt(shiftIndex + 1, prop.node)?.node);
-      } else {
-        return NodeFacade.from(prop.node);
-      }
-    }
-    return null;
-  }
-
-  has(name, index = -1) {
-    let { properties } = nodes.get(this);
-    if (!hasOwn(properties, name)) return false;
-
-    if (index >= 0 && !getProperties(name, index, properties)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  referenceAt(name, index = -1) {
-    return getProperties(buildPathSegment(name, index), nodes.get(this).properties)?.reference;
-  }
-
-  [Symbol.iterator]() {
-    return Object.entries(nodes.get(this))[Symbol.iterator]();
-  }
-}
-
-export class NodeFacade {
-  static from(node) {
-    return node && new NodeFacade(node);
-  }
-
-  constructor(node) {
-    let sigilTag = sumtree.getAt(0, node.children);
-
-    if (sigilTag.type === DoctypeTag) {
-      sigilTag = sumtree.getAt(1, node.children);
-    }
-
-    this.sigilTag = sigilTag;
-
-    if ([NullTag, GapTag].includes(sigilTag.type)) {
-      this.flags = nodeFlags;
-      this.type = null;
-    } else if (sigilTag.type === OpenNodeTag) {
-      let { flags, type } = sigilTag.value;
-
-      this.flags = flags;
-      this.type = type;
-    } else {
-      throw new Error();
-    }
-
-    nodes.set(this, node);
-
-    freeze(this);
-  }
-
-  get children() {
-    return new NodeChildrenFacade(nodes.get(this));
-  }
-
-  get properties() {
-    return new NodePropertiesFacade(nodes.get(this));
-  }
-
-  get attributes() {
-    return nodes.get(this).attributes;
-  }
-
-  get undefinedAttributes() {
-    return nodeStates.get(nodes.get(this)).undefinedAttributes;
-  }
-
-  get node() {
-    let node = nodes.get(this);
-
-    return getCloseTag(node) || [NullTag, GapTag].includes(sumtree.getAt(0, node.children).type)
-      ? node
-      : undefined;
-  }
-
-  get(path, shiftIndex = null) {
-    if (shiftIndex !== null) throw new Error('bad get');
-    return NodeFacade.from(get(path, nodes.get(this)));
-  }
-
-  getChildPropertyIndex(childrenIndex) {
-    return getChildPropertyIndex(nodes.get(this), childrenIndex);
-  }
-
-  getPropertyChildrenIndex(type, name) {
-    return getPropertyChildrenIndex(nodes.get(this), type, name);
-  }
-}

package/lib/path.js

@@ -1,162 +0,0 @@
-import { Property } from '@bablr/agast-helpers/symbols';
-import { NodeFacade, nodes } from './node.js';
-import { Path, TagPath } from '@bablr/agast-helpers/path';
-import { buildChild, buildFacadeProperty, buildProperty } from '@bablr/agast-helpers/builders';
-
-export { Path, TagPath } from '@bablr/agast-helpers/path';
-
-export { allTagPathsFor, ownTagPathsFor } from '@bablr/agast-helpers/path';
-
-let { freeze } = Object;
-
-let paths = new WeakMap();
-
-export class TagPathFacade {
-  static from(path, childrenIndex) {
-    return path && new TagPathFacade(TagPath.from(paths.get(path), childrenIndex));
-  }
-
-  static fromNode(node, childrenIndex) {
-    let path = node && TagPath.fromNode(nodes.get(node), childrenIndex);
-    return path && new TagPathFacade(path);
-  }
-
-  static wrap(tagPath) {
-    return tagPath && new TagPathFacade(tagPath);
-  }
-
-  constructor(tagPath) {
-    if (!(tagPath instanceof TagPath)) throw new Error();
-    paths.set(this, tagPath);
-
-    let { tag } = tagPath;
-
-    this.path = new PathFacade(tagPath.path);
-    this.node = new NodeFacade(tagPath.node);
-    this.tag =
-      tag.type === Property
-        ? buildChild(
-            Property,
-            buildFacadeProperty(
-              tag.value.reference,
-              tag.value.binding,
-              new NodeFacade(tag.value.node),
-            ),
-          )
-        : tag;
-    this.childrenIndex = tagPath.childrenIndex;
-
-    freeze(this);
-  }
-
-  get child() {
-    return this.tag;
-  }
-
-  siblingAt(index) {
-    return TagPathFacade.wrap(paths.get(this).siblingAt(index));
-  }
-
-  get nextSibling() {
-    return TagPathFacade.wrap(paths.get(this).nextSibling);
-  }
-
-  get next() {
-    return TagPathFacade.wrap(paths.get(this).next);
-  }
-
-  get nextUnshifted() {
-    return TagPathFacade.wrap(paths.get(this).nextUnshifted);
-  }
-
-  get previousSibling() {
-    return TagPathFacade.wrap(paths.get(this).previousSibling);
-  }
-
-  get previous() {
-    return TagPathFacade.wrap(paths.get(this).previous);
-  }
-
-  get previousUnshifted() {
-    return TagPathFacade.wrap(paths.get(this).previousUnshifted);
-  }
-
-  get inner() {
-    return PathFacade.wrap(paths.get(this).inner);
-  }
-
-  equalTo(tagPath) {
-    if (tagPath == null) return false;
-
-    let { path, childrenIndex } = paths.get(this);
-    let tagPath_ = paths.get(tagPath);
-    return path.node === tagPath_.path.node && childrenIndex === tagPath_.childrenIndex;
-  }
-}
-
-export class PathFacade {
-  static from(node) {
-    return node && new PathFacade(Path.from(nodes.get(node)));
-  }
-
-  static wrap(path) {
-    return path && new PathFacade(path);
-  }
-
-  constructor(path) {
-    if (!(path instanceof Path)) throw new Error();
-    this.depth = path.depth;
-
-    this.node = new NodeFacade(path.node);
-    this.referenceIndex = path.referenceIndex;
-
-    paths.set(this, path);
-
-    freeze(this);
-  }
-
-  get parent() {
-    // not a stable reference. can/should it be?
-    return PathFacade.wrap(paths.get(this).parent);
-  }
-
-  get openTagPath() {
-    return TagPathFacade.wrap(paths.get(this).openTagPath);
-  }
-
-  get openTag() {
-    return paths.get(this).openTag;
-  }
-
-  get closeTagPath() {
-    return TagPathFacade.wrap(paths.get(this).closeTagPath);
-  }
-
-  get closeTag() {
-    return paths.get(this).closeTag;
-  }
-
-  get reference() {
-    return paths.get(this).reference;
-  }
-
-  get referenceTagPath() {
-    return TagPathFacade.wrap(paths.get(this).referenceTagPath);
-  }
-
-  get(path, shiftIndex = null) {
-    return new PathFacade(paths.get(this).get(path, shiftIndex));
-  }
-
-  tagPathAt(childrenIndex) {
-    return TagPathFacade.wrap(TagPath.from(paths.get(this), childrenIndex));
-  }
-
-  tagAt(childrenIndex) {
-    return this.tagPathAt(childrenIndex).tag;
-  }
-
-  atDepth(depth) {
-    return new PathFacade(paths.get(this).atDepth(depth));
-  }
-}