@bablr/agast-helpers 0.7.1 → 0.9.0

package/lib/tree.js

@@ -7,6 +7,16 @@ import {
   buildLiteralTag,
   buildCloseNodeTag,
   tokenFlags,
+  buildInitializerTag,
+  buildBindingTag,
+  buildProperty,
+  buildChild,
+  buildShiftTag,
+  buildGapTag,
+  buildBinding,
+  buildReference,
+  multiFragmentFlags,
+  buildPropertyWrapper,
 } from './builders.js';
 import {
   printPrettyCSTML as printPrettyCSTMLFromStream,
@@ -23,15 +33,21 @@ import {
   NullTag,
   InitializerTag,
   LiteralTag,
-  EmbeddedNode,
+  AttributeDefinition,
+  BindingTag,
+  Property,
+  ShiftTag,
+  PropertyWrapper,
 } from './symbols.js';
-import * as btree from './btree.js';
-import * as sumtree from './sumtree.js';
+import * as BTree from './btree.js';
+import * as Tags from './tags.js';
 export * from './builders.js';
 export * from './print.js';
 import {
-  add,
   get,
+  getOr,
+  has,
+  list,
   TagPath,
   Path,
   isFragmentNode,
@@ -39,14 +55,30 @@ import {
   isGapNode,
   getOpenTag,
   getCloseTag,
-  getShifted,
+  getRoot,
+  getRootArray,
+  isStubTag,
+  wrapperIsFull,
 } from './path.js';
+import { isPlainObject } from './object.js';
 
-export { add, get, isFragmentNode, isNullNode, isGapNode, getOpenTag, getCloseTag };
+export {
+  get,
+  getOr,
+  has,
+  list,
+  isFragmentNode,
+  isNullNode,
+  isGapNode,
+  getOpenTag,
+  getCloseTag,
+  getRoot,
+  getRootArray,
+};
 
-export const buildToken = (language, type, value, attributes = {}) => {
+export const buildToken = (type, value, attributes = {}) => {
   return treeFromStreamSync([
-    buildOpenNodeTag(tokenFlags, language, type, attributes),
+    buildOpenNodeTag(tokenFlags, type, attributes),
     buildLiteralTag(value),
     buildCloseNodeTag(),
   ]);
@@ -55,72 +87,36 @@ export const buildToken = (language, type, value, attributes = {}) => {
 const isString = (str) => typeof str === 'string';
 
 const { isArray } = Array;
-const { freeze } = Object;
-
-export const parseReference = (str) => {
-  let {
-    1: name,
-    2: isArray,
-    3: index,
-    4: expressionToken,
-    5: hasGapToken,
-  } = /^\s*([.#@]|[a-zA-Z]+)\s*(\[\s*(\d+\s*)?\])?\s*(\+)?(\$)?\s*$/.exec(str);
-
-  let flags = {
-    expression: !!expressionToken,
-    hasGap: !!hasGapToken,
-  };
-
-  index = index ? parseInt(index, 10) : null;
-  isArray = !!isArray;
-  name = name || null;
-
-  return buildReferenceTag(name, isArray, flags, index);
-};
+const { freeze, hasOwn } = Object;
 
 export const mergeReferences = (outer, inner) => {
-  let {
-    name,
-    isArray,
-    index,
-    flags: { expression, hasGap },
-  } = outer.value;
+  let { type, name, isArray, index, flags: { expression, hasGap } = {} } = outer;
 
   if (
-    name != null &&
-    name !== '.' &&
-    inner.value.name != null &&
-    inner.value.name !== '.' &&
-    name !== inner.value.name
+    (name != null && inner.name != null && name !== inner.name) ||
+    (type != null && inner.type != null && type !== inner.type && inner.type !== '.')
   ) {
     return inner;
   }
 
-  isArray = isArray || inner.value.isArray;
-  expression = !!(expression || inner.value.flags.expression);
-  hasGap = !!(hasGap || inner.value.flags.hasGap);
-  name = name === '.' ? inner.value.name : name;
-
-  return buildReferenceTag(name, isArray, { expression, hasGap }, index);
-};
+  isArray = isArray || inner.isArray;
+  expression = !!(expression || inner.flags.expression);
+  hasGap = !!(hasGap || inner.flags.hasGap);
+  name = type === '.' ? inner.name : name;
+  type = type === '.' ? inner.type : type;
 
-export const isEmptyReference = (ref) => {
-  let { name, isArray, flags } = ref.value;
-  return name === '.' && !isArray && !(flags.expression || flags.hasGap);
+  return buildReferenceTag(type, name, isArray, { expression, hasGap }, index).value;
 };
 
-export const defineAttribute = (node, key, value) => {
-  const openTag = getOpenTag(node);
-
-  if (value != null) {
-    const { flags, language, type } = openTag.value;
-    const attributes = { ...openTag.value.attributes, [key]: value };
-    const newOpenTag = buildOpenNodeTag(flags, language, type, attributes);
+export const mergeReferenceTags = (outer, inner) => {
+  let value = mergeReferences(outer.value, inner.value);
 
-    node.attributes = attributes;
+  return buildChild(ReferenceTag, value);
+};
 
-    node.children = sumtree.replaceAt(0, node.children, newOpenTag);
-  }
+export const isEmptyReference = (ref) => {
+  let { type, isArray, flags } = ref.value;
+  return type === '.' && !isArray && !(flags.expression || flags.hasGap);
 };
 
 function* __treeFromStream(tags, options) {
@@ -130,7 +126,8 @@ function* __treeFromStream(tags, options) {
   let doctype = null;
   const co = new Coroutine(getStreamIterator(tags));
   const expressionsCo = new Coroutine(getStreamIterator(options.expressions || []));
-  let reference = null;
+  let referenceTag = null;
+  let bindingTag = null;
 
   for (;;) {
     co.advance();
@@ -160,20 +157,30 @@ function* __treeFromStream(tags, options) {
 
     switch (tag.type) {
       case LiteralTag:
+        break;
+
       case CloseNodeTag: {
+        let { node } = path;
+        if (!node.tags[1]) throw new Error();
         break;
       }
 
       case ReferenceTag: {
-        reference = tag;
+        referenceTag = tag;
+        suppressTag = true;
+        break;
+      }
+
+      case BindingTag: {
+        bindingTag = tag;
         suppressTag = true;
         break;
       }
 
       case InitializerTag: {
-        add(path.node, reference, []);
+        add(path.node, referenceTag, []);
         suppressTag = true;
-        reference = null;
+        referenceTag = null;
         break;
       }
 
@@ -185,19 +192,20 @@ function* __treeFromStream(tags, options) {
 
         const isGap = tag.type === GapTag;
 
-        if (path.parent && reference.type !== ReferenceTag) throw new Error();
+        if (path.parent && referenceTag.type !== ReferenceTag) throw new Error();
 
         let node = createNode(tag);
 
+        suppressTag = true;
+
         if (isGap) {
           if (held) {
             node = held;
-            add(path.node, reference, node);
-            suppressTag = true;
+            add(path.node, referenceTag, node, bindingTag);
           } else if (!expressionsCo.done) {
             expressionsCo.advance();
 
-            let outerReference = reference;
+            let outerReference = referenceTag;
 
             if (!expressionsCo.done) {
               node =
@@ -206,20 +214,21 @@ function* __treeFromStream(tags, options) {
                   : expressionsCo.value == null
                   ? buildStubNode(buildNullTag())
                   : expressionsCo.value;
-              suppressTag = true;
 
               if (isFragmentNode(node)) {
                 const parentNode = path.node;
 
-                let reference;
+                let referenceTag;
+                let bindingTag;
 
-                for (const tag of sumtree.traverse(node.children)) {
+                for (const tag of Tags.traverse(node.tags)) {
                   switch (tag.type) {
                     case DoctypeTag: {
                       break;
                     }
-                    case OpenNodeTag:
-                    case CloseNodeTag: {
+
+                    case OpenNodeTag: {
+                      referenceTag = bindingTag = null;
                       if (!tag.value.type) {
                         break;
                       } else {
@@ -228,29 +237,28 @@ function* __treeFromStream(tags, options) {
                     }
 
                     case ReferenceTag:
-                      // combine tags for .
-
-                      reference = tag;
+                      referenceTag = tag;
                       break;
 
                     case InitializerTag: {
-                      add(parentNode, mergeReferences(outerReference, reference), []);
+                      add(parentNode, mergeReferenceTags(outerReference, referenceTag), []);
                       break;
                     }
 
-                    case EmbeddedNode: {
-                      add(parentNode, mergeReferences(outerReference, reference), tag.value);
-                      break;
-                    }
-
-                    case GapTag: {
-                      const resolvedNode = getShifted(shift, reference, node);
-                      add(parentNode, mergeReferences(outerReference, reference), resolvedNode);
+                    case BindingTag: {
+                      bindingTag = tag;
                       break;
                     }
 
+                    case GapTag:
                     case NullTag: {
-                      add(parentNode, mergeReferences(outerReference, reference), null);
+                      add(
+                        parentNode,
+                        mergeReferenceTags(outerReference, referenceTag),
+                        buildStubNode(tag),
+                        bindingTag,
+                      );
+                      referenceTag = bindingTag = null;
                       break;
                     }
 
@@ -262,28 +270,28 @@ function* __treeFromStream(tags, options) {
                 if (path.node.flags.token) {
                   throw new Error('not implemented');
                 }
-                add(path.node, reference, node);
+                add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
               }
             } else {
               if (!path.node.flags.token) {
-                add(path.node, reference, node);
+                add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
               }
             }
           }
         }
 
-        reference = null;
+        referenceTag = null;
         held = isGap ? null : held;
 
         if (!path.node.flags.token) {
-          path = { parent: path, node, depth: (path.depth || -1) + 1, arrays: new Set() };
+          path = { parent: path, node, depth: (path.depth ?? -1) + 1, arrays: new Set() };
         }
 
         break;
       }
 
       // case ShiftTag: {
-      //   const { children, properties } = path.node;
+      //   const { tags, properties } = path.node;
 
       //   let property = properties[ref.value.name];
       //   let node;
@@ -301,35 +309,21 @@ function* __treeFromStream(tags, options) {
       // }
 
       case OpenNodeTag: {
+        const node = createNode(tag);
         if (path) {
-          const node = createNode(tag);
-
           if (path) {
-            add(path.node, reference, node);
-            reference = null;
+            add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
+            referenceTag = null;
           }
 
           path = { parent: path, node, depth: (path ? path.depth : -1) + 1, arrays: new Set() };
         } else {
-          const { language, type, flags, attributes } = tag.value;
-
-          const attributes_ = doctype?.value.attributes ?? attributes;
-          const language_ = attributes?.['bablrLanguage'] ?? language;
-
-          const node = {
-            flags,
-            language: language_,
-            type,
-            children: [],
-            properties: {},
-            attributes: attributes_,
-          };
-
           path = { parent: null, node, depth: 0, arrays: new Set() };
 
           rootPath = path;
         }
 
+        suppressTag = true;
         break;
       }
 
@@ -339,7 +333,7 @@ function* __treeFromStream(tags, options) {
     }
 
     if (!suppressTag) {
-      path.node.children = sumtree.push(path.node.children, tag);
+      path.node.tags = Tags.push(path.node.tags, tag);
     }
 
     switch (tag.type) {
@@ -403,41 +397,22 @@ export const evaluateReturnAsync = async (generator) => {
   return co.value;
 };
 
-export const streamFromTree = (rootNode, options = {}) => __streamFromTree(rootNode, options);
-
 export const isEmpty = (node) => {
-  const { properties } = node;
-
-  let ref = null;
-
-  for (const tag of sumtree.traverse(node.children)) {
+  for (const tag of Tags.traverseInner(node.tags)) {
     switch (tag.type) {
-      case ReferenceTag: {
-        const { name } = tag.value;
-
-        ref = tag;
-
-        if (properties[name]) {
-          const property = properties[name];
+      case Property: {
+        if (tag.value.reference.type === '@') {
+          return false;
+        } else {
+          const property = tag.value;
 
-          if (
-            property != null ||
-            (isArray(property) && property.length) ||
-            !isNullNode(property.node)
-          ) {
+          if (!isNullNode(property.node)) {
             return false;
           }
         }
         break;
       }
 
-      case EmbeddedNode: {
-        if (ref.value.name === '@') {
-          return false;
-        }
-        break;
-      }
-
       case LiteralTag:
       case GapTag:
         return false;
@@ -446,67 +421,193 @@ export const isEmpty = (node) => {
   return true;
 };
 
+let buildGapProperty = () =>
+  buildProperty(buildReference('.'), buildBinding(), buildStubNode(buildGapTag()));
+
+export const buildBounds = (
+  openBoundary = BTree.fromValues([buildGapProperty()]),
+  closeBoundary = openBoundary,
+) => {
+  return freeze([openBoundary, closeBoundary]);
+};
+
 export const buildStubNode = (tag) => {
+  if (!isStubTag(tag)) throw new Error();
   return freeze({
     flags: nodeFlags,
-    language: null,
     type: null,
-    children: freeze([tag]),
-    properties: freeze({}),
+    bounds: buildBounds(null, null),
+    tags: Tags.from(tag),
     attributes: freeze({}),
   });
 };
 
-function* __streamFromTree(rootNode, options) {
+export const streamFromTree = (tree, options = {}) => {
+  let rootNode = isPlainObject(tree) ? tree : tree.node;
+
+  return __streamFromTree(null, rootNode, options);
+};
+
+function* __streamFromTree(doctypeTag, rootNode, options) {
   const { unshift = false } = options;
-  if (!rootNode || !sumtree.getSize(rootNode.children)) return;
+  if (!rootNode || !Tags.getSize(rootNode.tags)) return;
 
   let tagPath = TagPath.fromNode(rootNode, 0);
 
   let count = 0;
 
+  if (doctypeTag) {
+    yield doctypeTag;
+  }
+
   do {
-    if (tagPath.tag.type === OpenNodeTag) count++;
+    if (tagPath.tag.type === OpenNodeTag && !tagPath.tag.value.literalValue) count++;
     if (tagPath.tag.type === CloseNodeTag) count--;
 
-    yield tagPath.tag;
+    if (
+      !(
+        tagPath.tag.type === AttributeDefinition ||
+        (tagPath.tag.type === BindingTag && !tagPath.tag.value.languagePath?.length)
+      )
+    ) {
+      yield tagPath.tag;
+    }
   } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
 
   if (count !== 0) throw new Error();
 }
 
+export const vcsStreamFromTree = (rootNode) => {
+  let rootNode_ = isPlainObject(rootNode) ? rootNode : rootNode.node;
+
+  return __vcsStreamFromTree(rootNode_);
+};
+
+function* __vcsStreamFromTree(rootNode) {
+  let stack = null;
+  let agastNode = rootNode;
+  let depth = 0;
+  let nodeShifted = false;
+  let i = 0;
+  let seenFirstProperty = false;
+  let node = Tags.getValues(rootNode.tags);
+
+  outer: while (node) {
+    while (i >= node.length) {
+      if (stack) {
+        let oldAgastNode = agastNode;
+        let hadSeenFirst = seenFirstProperty;
+        ({ stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty } = stack);
+        if (oldAgastNode === agastNode) {
+          seenFirstProperty = hadSeenFirst;
+          yield buildCloseNodeTag();
+        }
+
+        i++;
+      } else {
+        return;
+      }
+    }
+
+    let child = node[i];
+
+    if (isArray(child)) {
+      stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty };
+
+      yield buildOpenNodeTag(multiFragmentFlags);
+
+      node = Tags.getValues(child);
+      depth++;
+      i = 0;
+    } else {
+      let wrappedTag = child;
+
+      if (wrappedTag.type === PropertyWrapper) {
+        for (let tag of wrappedTag.value.tags) {
+          switch (tag.type) {
+            case Property: {
+              let replaceWithGap = nodeShifted && !seenFirstProperty;
+
+              if (replaceWithGap) {
+                yield buildGapTag();
+
+                seenFirstProperty = true;
+
+                break;
+              } else {
+                stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty: true };
+                node = Tags.getValues(tag.value.node.tags);
+
+                depth++;
+                i = 0;
+                agastNode = tag.value.node;
+                nodeShifted = wrappedTag.value.tags[0].type === ShiftTag;
+                seenFirstProperty = false;
+                continue outer;
+              }
+            }
+
+            default: {
+              yield tag;
+
+              if (tag.type === OpenNodeTag && tag.value.literalValue) {
+                ({ stack, agastNode, node, depth, i, nodeShifted } = stack);
+                seenFirstProperty = true;
+              }
+
+              break;
+            }
+          }
+        }
+      } else {
+        yield wrappedTag;
+
+        if (wrappedTag.type === OpenNodeTag && wrappedTag.value.literalValue) {
+          ({ stack, agastNode, node, depth, i, nodeShifted } = stack);
+          seenFirstProperty = true;
+        }
+      }
+      i++;
+    }
+  }
+}
+
 export const getCooked = (cookable) => {
   if (!cookable || isGapNode(cookable.type)) {
     return '';
   }
 
-  const children = cookable.children || cookable;
+  const tags = cookable.tags || cookable;
 
   let cooked = '';
 
   // const openTag = getOpenTag(cookable);
   // const closeTag = getCloseTag(cookable);
 
-  let reference = null;
+  let referenceTag = null;
 
-  for (const tag of sumtree.traverse(children)) {
+  for (let tag of Tags.traverse(tags)) {
     switch (tag.type) {
       case ReferenceTag: {
-        const { name } = tag.value;
+        let { type } = tag.value;
 
-        if (!(name === '#' || name === '@')) {
+        if (!(type === '#' || type === '@')) {
           throw new Error('cookable nodes must not contain other nodes');
         }
 
-        reference = tag;
+        referenceTag = tag;
         break;
       }
 
-      case EmbeddedNode: {
-        const { attributes } = tag.value;
+      case BindingTag:
+        break;
+
+      case PropertyWrapper: {
+        let { node, reference } = tag.value.property;
+        let { attributes } = node;
 
-        if (reference.value.name === '@') {
-          const { cooked: cookedValue } = attributes;
+        if (reference.type === '@') {
+          let { cooked: cookedValue } = attributes;
 
           if (!isString(cookedValue))
             throw new Error('cannot cook string: it contains uncooked escapes');
@@ -539,45 +640,44 @@ export const getCooked = (cookable) => {
   return cooked;
 };
 
-export const printCSTML = (rootNode) => {
-  return printCSTMLFromStream(streamFromTree(rootNode));
+export const printCSTML = (tree) => {
+  return printCSTMLFromStream(streamFromTree(tree));
 };
 
-export const printPrettyCSTML = (rootNode, options = {}) => {
-  return printPrettyCSTMLFromStream(streamFromTree(rootNode), options);
+export const printPrettyCSTML = (tree, options = {}) => {
+  return printPrettyCSTMLFromStream(streamFromTree(tree), options);
 };
 
-export const printSource = (rootNode) => {
-  return printSourceFromStream(streamFromTree(rootNode, { unshift: true }));
+export const printSource = (tree) => {
+  return printSourceFromStream(streamFromTree(tree, { unshift: true }));
 };
 
 export const sourceTextFor = printSource;
 
 export const getRange = (node) => {
-  const { children } = node;
+  const { tags } = node;
   let path = Path.from(node);
-  return sumtree.getSize(children) ? [TagPath.from(path, 0), TagPath.from(path, -1)] : null;
+  return Tags.getSize(tags) ? [TagPath.from(path, 0), TagPath.from(path, -1)] : null;
 };
 
 export const createNode = (openTag) => {
+  let bounds = buildBounds();
+  let literalTags = [];
+  let tags = openTag ? Tags.fromValues([openTag, ...literalTags]) : Tags.fromValues(literalTags);
+  let flags, type, attributes;
+
   if (!openTag || openTag.type === GapTag || openTag.type === NullTag) {
-    return {
-      flags: nodeFlags,
-      language: openTag?.language,
-      type: openTag && ([NullTag, GapTag].includes(openTag.type) ? null : openTag.type),
-      children: [],
-      properties: {},
-      attributes: openTag?.attributes || {},
-    };
+    flags = nodeFlags;
+    type = openTag && ([NullTag, GapTag].includes(openTag.type) ? null : openTag.type);
+    attributes = openTag?.attributes || {};
   } else {
-    const { flags, language, type, attributes = {} } = openTag.value || {};
-    return { flags, language, type, children: [], properties: {}, attributes };
+    ({ flags, type, attributes = {} } = openTag.value || {});
   }
+  return { flags, type, bounds, tags, attributes };
 };
 
 export const finalizeNode = (node) => {
   freeze(node);
-  freeze(node.properties);
   freeze(node.attributes);
   return node;
 };
@@ -590,54 +690,132 @@ export const isNull = (node) => {
   return node == null || isNullNode(node);
 };
 
-export const branchProperties = (properties) => {
-  const copy = { ...properties };
+export const addProperty = (node, property) => {
+  if (!node || !property) throw new Error();
+  if (!Object.isFrozen(property)) throw new Error();
 
-  for (const { 0: key, 1: value } of Object.entries(copy)) {
-    if (isArray(value)) {
-      copy[key] = btree.treeFromValues(value);
-    }
+  if (property.node === null) {
+    throw new Error();
   }
 
-  return copy;
-};
+  let { node: value, binding, reference } = property;
+
+  let isArrayInitializer = reference.type !== '_' && isArray(value);
+  let isInitializer = value === undefined || isArrayInitializer;
+
+  if (isArrayInitializer && value.length) throw new Error();
+
+  if (!isInitializer && property.node.type && !property.binding) {
+    throw new Error();
+  }
+
+  if (reference.type === '_') {
+    node.tags = Tags.push(node.tags, value);
+    return node;
+  }
+
+  let referenceTag = buildChild(ReferenceTag, reference);
+  let propertyWrapper;
+
+  if (isInitializer) {
+    let tags = freeze([referenceTag, buildInitializerTag(isArrayInitializer)]);
+
+    propertyWrapper = buildPropertyWrapper(
+      tags,
+      buildProperty(reference, null, isArrayInitializer ? [] : null),
+    );
+  } else {
+    let tags = freeze([
+      referenceTag,
+      buildChild(BindingTag, binding),
+      buildChild(Property, property),
+    ]);
+
+    propertyWrapper = buildPropertyWrapper(tags, property);
+  }
 
-export const branchNode = (node) => {
-  const { flags, language, type, children, properties, attributes } = node;
-  return {
-    flags,
-    language,
-    type,
-    children,
-    properties: branchProperties(properties),
-    attributes: { ...attributes },
-  };
+  let lastTag = Tags.getAt(-1, node.tags);
+  let unboundProperty = lastTag.type === PropertyWrapper && lastTag.value.tags.length < 3;
+
+  if (unboundProperty) {
+    node.tags = Tags.replaceAt(-1, node.tags, buildChild(PropertyWrapper, propertyWrapper));
+  } else {
+    node.tags = Tags.push(node.tags, buildChild(PropertyWrapper, propertyWrapper));
+  }
+
+  return node;
 };
 
-export const acceptNode = (node, accepted) => {
-  const { children, properties, attributes } = accepted;
-  node.children = children;
-  node.properties = properties;
-  node.attributes = attributes;
+export const shiftProperty = (node, property) => {
+  if (!node || !property) throw new Error();
+  if (!property.reference) throw new Error();
+  if (!Object.isFrozen(property)) throw new Error();
+
+  if (property.node === null) {
+    property.node = buildNullNode();
+  }
+
+  let { node: value } = property;
+
+  let isArrayInitializer = isArray(value);
+  let isInitializer = value === undefined || isArrayInitializer;
+
+  if (isInitializer || !property.binding) {
+    throw new Error();
+  }
+
+  let existingProperty = Tags.getAt(-1, node.tags);
+
+  if (!wrapperIsFull(existingProperty)) {
+    existingProperty = Tags.getAt(-2, node.tags);
+  }
+
+  let existingRef = existingProperty?.value.tags[0];
+
+  let bindingTag = buildChild(BindingTag, property.binding);
+
+  let shiftStack = existingProperty?.value.property.node.bounds[0] || BTree.fromValues([]);
+  let stackSize = shiftStack && property.reference.flags.expression ? BTree.getSize(shiftStack) : 0;
+
+  let index = existingRef.type === ReferenceTag ? 1 : existingRef.value.index + 1;
+  let height = BTree.getSize(shiftStack) + 1;
+
+  let shiftTag = stackSize ? buildShiftTag(index, height) : existingRef;
+
+  let tags = freeze([shiftTag, bindingTag, buildChild(Property, property)]);
+
+  let lastTag = Tags.getAt(-1, node.tags);
+  let unboundProperty = lastTag.type === PropertyWrapper && lastTag.value.tags.length < 3;
+
+  let propertyWrapper = buildPropertyWrapper(tags, property);
+
+  if (unboundProperty) {
+    node.tags = Tags.replaceAt(-1, node.tags, buildChild(PropertyWrapper, propertyWrapper));
+  } else {
+    node.tags = Tags.push(node.tags, buildChild(PropertyWrapper, propertyWrapper));
+  }
+
   return node;
 };
 
-export const getRoot = (node) => {
-  return node == null ? node : isFragmentNode(node) ? node.properties['.'].node : node;
+export const add = (node, referenceTag, value, bindingTag) => {
+  let lastChild = Tags.getAt(-1, node.tags);
+  let reference = referenceTag.value;
+  let binding = bindingTag
+    ? bindingTag.value
+    : lastChild?.type === BindingTag
+    ? lastChild.value
+    : buildBinding();
+  return addProperty(node, buildProperty(reference, binding, value));
 };
 
-export function* traverseProperties(properties) {
-  for (const value of Object.values(properties)) {
-    if (isArray(value)) {
-      for (let item of btree.traverse(value)) {
-        if (isArray(item.node)) {
-          yield btree.getAt(-1, item.node);
-        } else {
-          yield item.node;
-        }
-      }
-    } else {
-      yield value.node;
-    }
-  }
-}
+export const shift = (node, referenceTag, value, bindingTag) => {
+  let lastChild = Tags.getAt(-1, node.tags);
+  let reference = referenceTag.value;
+  let binding = bindingTag
+    ? bindingTag.value
+    : lastChild.type === BindingTag
+    ? lastChild.value
+    : buildBinding();
+  return shiftProperty(node, buildProperty(reference, binding, value));
+};