@yorkie-js/sdk 0.7.10 → 0.7.11

package/dist/yorkie-js-sdk.es.js

@@ -6567,447 +6567,432 @@ class Operation {
     this.executedAt = executedAt;
   }
 }
-class SplayNode {
+class TreeListNode {
   value;
   left;
   right;
   parent;
   weight;
+  count;
+  red;
   constructor(value) {
     this.value = value;
-    this.initWeight();
-  }
-  /**
-   * `getNodeString` returns a string of weight and value of this node.
-   */
-  getNodeString() {
-    return `${this.weight}${this.value}`;
+    this.red = true;
+    this.weight = this.size();
+    this.count = 1;
   }
   /**
-   * `getValue` returns value of this node.
+   * `getValue` returns the value of this node.
    */
   getValue() {
     return this.value;
   }
   /**
-   * `getLeftWeight` returns left weight of this node.
+   * `size` returns 1 if the node is live, 0 if removed (tombstone).
    */
-  getLeftWeight() {
-    return !this.hasLeft() ? 0 : this.left.getWeight();
+  size() {
+    return this.value.isRemoved() ? 0 : 1;
   }
   /**
-   * `getRightWeight` returns right weight of this node.
+   * `getLeft` returns the left child.
    */
-  getRightWeight() {
-    return !this.hasRight() ? 0 : this.right.getWeight();
+  getLeft() {
+    return this.left;
   }
   /**
-   * `getWeight` returns weight of this node.
+   * `setLeft` sets the left child.
    */
-  getWeight() {
-    return this.weight;
+  setLeft(node) {
+    this.left = node;
   }
   /**
-   * `getLeft` returns a left node.
+   * `getRight` returns the right child.
    */
-  getLeft() {
-    return this.left;
+  getRight() {
+    return this.right;
   }
   /**
-   * `getRight` returns a right node.
+   * `setRight` sets the right child.
    */
-  getRight() {
-    return this.right;
+  setRight(node) {
+    this.right = node;
   }
   /**
-   * `getParent` returns parent of this node.
+   * `getParent` returns the parent.
    */
   getParent() {
     return this.parent;
   }
   /**
-   * `hasLeft` check if the left node exists
+   * `setParent` sets the parent.
    */
-  hasLeft() {
-    return !!this.left;
+  setParent(node) {
+    this.parent = node;
   }
   /**
-   * `hasRight` check if the right node exists
+   * `getWeight` returns the cached live-node weight of this subtree.
    */
-  hasRight() {
-    return !!this.right;
+  getWeight() {
+    return this.weight;
   }
   /**
-   * `hasParent` check if the parent node exists
+   * `setWeight` sets the cached live-node weight of this subtree.
    */
-  hasParent() {
-    return !!this.parent;
+  setWeight(w) {
+    this.weight = w;
   }
   /**
-   * `setLeft` sets a left node.
+   * `getCount` returns the cached total node count of this subtree.
    */
-  setLeft(left) {
-    this.left = left;
+  getCount() {
+    return this.count;
   }
   /**
-   * `setRight` sets a right node.
+   * `setCount` sets the cached total node count of this subtree.
    */
-  setRight(right) {
-    this.right = right;
+  setCount(c) {
+    this.count = c;
   }
   /**
-   * `setParent` sets a parent node.
+   * `isRed` reports whether this node is colored red.
    */
-  setParent(parent) {
-    this.parent = parent;
+  isRed() {
+    return this.red;
   }
   /**
-   * `unlink` unlink parent, right and left node.
+   * `setRed` sets the color of this node.
    */
-  unlink() {
-    this.parent = void 0;
-    this.right = void 0;
-    this.left = void 0;
+  setRed(red) {
+    this.red = red;
   }
   /**
-   * `hasLinks` checks if parent, right and left node exists.
+   * `leftWeight` returns the live-node weight of the left subtree, or 0 if absent.
    */
-  hasLinks() {
-    return this.hasParent() || this.hasLeft() || this.hasRight();
+  leftWeight() {
+    return this.left ? this.left.weight : 0;
   }
   /**
-   * `increaseWeight` increases weight.
+   * `rightWeight` returns the live-node weight of the right subtree, or 0 if absent.
    */
-  increaseWeight(weight) {
-    this.weight += weight;
+  rightWeight() {
+    return this.right ? this.right.weight : 0;
   }
   /**
-   * `initWeight` sets initial weight of this node.
+   * `leftCount` returns the total node count of the left subtree, or 0 if absent.
    */
-  initWeight() {
-    this.weight = this.getLength();
+  leftCount() {
+    return this.left ? this.left.count : 0;
+  }
+  /**
+   * `rightCount` returns the total node count of the right subtree, or 0 if absent.
+   */
+  rightCount() {
+    return this.right ? this.right.count : 0;
   }
 }
-class SplayTree {
+function isRed(node) {
+  return !!node && node.isRed();
+}
+function updateNode(node) {
+  node.setWeight(node.leftWeight() + node.size() + node.rightWeight());
+  node.setCount(node.leftCount() + 1 + node.rightCount());
+}
+function rotateLeft(node) {
+  const right = node.getRight();
+  node.setRight(right.getLeft());
+  if (node.getRight()) {
+    node.getRight().setParent(node);
+  }
+  right.setLeft(node);
+  right.setParent(node.getParent());
+  node.setParent(right);
+  right.setRed(node.isRed());
+  node.setRed(true);
+  updateNode(node);
+  updateNode(right);
+  return right;
+}
+function rotateRight(node) {
+  const left = node.getLeft();
+  node.setLeft(left.getRight());
+  if (node.getLeft()) {
+    node.getLeft().setParent(node);
+  }
+  left.setRight(node);
+  left.setParent(node.getParent());
+  node.setParent(left);
+  left.setRed(node.isRed());
+  node.setRed(true);
+  updateNode(node);
+  updateNode(left);
+  return left;
+}
+function flipColors(node) {
+  node.setRed(!node.isRed());
+  node.getLeft().setRed(!node.getLeft().isRed());
+  node.getRight().setRed(!node.getRight().isRed());
+}
+function moveRedLeft(node) {
+  flipColors(node);
+  if (isRed(node.getRight().getLeft())) {
+    node.setRight(rotateRight(node.getRight()));
+    node.getRight().setParent(node);
+    node = rotateLeft(node);
+    flipColors(node);
+  }
+  return node;
+}
+function moveRedRight(node) {
+  flipColors(node);
+  if (isRed(node.getLeft().getLeft())) {
+    node = rotateRight(node);
+    flipColors(node);
+  }
+  return node;
+}
+function removeMin(node) {
+  if (!node.getLeft()) {
+    return void 0;
+  }
+  if (!isRed(node.getLeft()) && !isRed(node.getLeft().getLeft())) {
+    node = moveRedLeft(node);
+  }
+  node.setLeft(removeMin(node.getLeft()));
+  if (node.getLeft()) {
+    node.getLeft().setParent(node);
+  }
+  return fixUp(node);
+}
+function minNode(node) {
+  while (node.getLeft()) {
+    node = node.getLeft();
+  }
+  return node;
+}
+function fixUp(node) {
+  if (isRed(node.getRight()) && !isRed(node.getLeft())) {
+    node = rotateLeft(node);
+  }
+  if (isRed(node.getLeft()) && isRed(node.getLeft().getLeft())) {
+    node = rotateRight(node);
+  }
+  if (isRed(node.getLeft()) && isRed(node.getRight())) {
+    flipColors(node);
+  }
+  updateNode(node);
+  return node;
+}
+function traverseInOrder(node, cb) {
+  if (!node) {
+    return;
+  }
+  traverseInOrder(node.getLeft(), cb);
+  cb(node);
+  traverseInOrder(node.getRight(), cb);
+}
+class TreeList {
   root;
   constructor(root) {
+    if (root) {
+      root.setRed(false);
+    }
     this.root = root;
   }
   /**
-   * `length` returns the size of this tree.
+   * `length` returns the number of non-removed (live) nodes.
    */
   get length() {
     return this.root ? this.root.getWeight() : 0;
   }
   /**
-   * `findForText` returns the Node and offset of the given position (cursor).
-   * Used for Text where cursor placed between characters.
+   * `insertAfter` inserts the target node right after prev in the in-order
+   * traversal. It uses structural (count-based) indexing to correctly handle
+   * tombstone nodes.
    */
-  findForText(pos) {
-    if (!this.root || pos < 0) {
-      return [void 0, 0];
+  insertAfter(prev, target) {
+    if (!prev || !target) {
+      return;
     }
-    let node = this.root;
-    for (; ; ) {
-      if (node.hasLeft() && pos <= node.getLeftWeight()) {
-        node = node.getLeft();
-      } else if (node.hasRight() && node.getLeftWeight() + node.getLength() < pos) {
-        pos -= node.getLeftWeight() + node.getLength();
-        node = node.getRight();
-      } else {
-        pos -= node.getLeftWeight();
-        break;
-      }
+    target.setLeft(void 0);
+    target.setRight(void 0);
+    target.setParent(void 0);
+    target.setRed(true);
+    target.setWeight(target.size());
+    target.setCount(1);
+    const idx = this.structuralIndexOf(prev);
+    this.root = this.insertByCount(this.root, idx + 1, target);
+    this.root.setRed(false);
+    this.root.setParent(void 0);
+  }
+  /**
+   * `insertByCount` inserts newNode at the given structural index within the
+   * subtree rooted at node, descending the tree using each node's left count
+   * (tombstones included) and rebalancing on the way back up.
+   */
+  insertByCount(node, index, newNode) {
+    if (!node) {
+      return newNode;
     }
-    if (pos > node.getLength()) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        `out of index range: pos: ${pos} > node.length: ${node.getLength()}`
+    if (index <= node.leftCount()) {
+      node.setLeft(this.insertByCount(node.getLeft(), index, newNode));
+      node.getLeft().setParent(node);
+    } else {
+      node.setRight(
+        this.insertByCount(
+          node.getRight(),
+          index - node.leftCount() - 1,
+          newNode
+        )
       );
+      node.getRight().setParent(node);
     }
-    this.splayNode(node);
-    return [node, pos];
+    return fixUp(node);
   }
   /**
-   * `findForArray` returns the Node of the given position (index).
-   * Used for Array where index points to the element.
+   * `find` returns the node at the given logical index (among non-removed
+   * nodes). Throws when the index is out of range.
    */
-  findForArray(idx) {
-    if (!this.root) {
-      return void 0;
-    }
-    if (idx < 0 || idx >= this.length) {
+  find(index) {
+    if (!this.root || index < 0 || index >= this.length) {
       throw new YorkieError(
         Code.ErrInvalidArgument,
-        `out of index range: idx: ${idx}, length: ${this.length}`
+        `out of index: tree size ${this.length}, index ${index}`
       );
     }
     let node = this.root;
     for (; ; ) {
-      if (node.hasLeft() && idx < node.getLeftWeight()) {
+      if (index < node.leftWeight()) {
         node = node.getLeft();
-      } else if (node.hasRight() && node.getLeftWeight() + node.getLength() <= idx) {
-        idx -= node.getLeftWeight() + node.getLength();
-        node = node.getRight();
-      } else {
+      } else if (index < node.leftWeight() + node.size()) {
         break;
+      } else {
+        index -= node.leftWeight() + node.size();
+        node = node.getRight();
       }
     }
-    this.splayNode(node);
     return node;
   }
   /**
-   * Find the index of the given node in BST.
-   *
-   * @param node - the given node
-   * @returns the index of given node
+   * `delete` physically removes a node from the tree. Unlike tombstoning,
+   * this completely removes the node from the tree structure. It uses
+   * structural (count-based) indexing and swaps the node structure (not
+   * values) with its successor to preserve node identity.
    */
-  indexOf(node) {
-    if (!node || node !== this.root && !node.hasLinks()) {
-      return -1;
+  delete(node) {
+    if (!node || !this.root) {
+      return;
+    }
+    if (!isRed(this.root.getLeft()) && !isRed(this.root.getRight())) {
+      this.root.setRed(true);
+    }
+    const idx = this.structuralIndexOf(node);
+    this.root = this.deleteByCount(this.root, idx);
+    if (this.root) {
+      this.root.setRed(false);
+      this.root.setParent(void 0);
     }
-    this.splayNode(node);
-    return this.root.getLeftWeight();
-  }
-  /**
-   * `getRoot` returns root of this tree.
-   */
-  getRoot() {
-    return this.root;
-  }
-  /**
-   * `insert` inserts the node at the last.
-   */
-  insert(newNode) {
-    return this.insertAfter(this.root, newNode);
   }
   /**
-   * `insertAfter` inserts the node after the given previous node.
+   * `deleteByCount` removes the node at the given structural index within the
+   * subtree rooted at node. When deleting an internal node, it swaps in the
+   * in-order successor by re-parenting rather than copying values so external
+   * references to the surviving node remain valid.
    */
-  insertAfter(target, newNode) {
-    if (!target) {
-      this.root = newNode;
-      return newNode;
-    }
-    this.splayNode(target);
-    this.root = newNode;
-    newNode.setRight(target.getRight());
-    if (target.hasRight()) {
-      target.getRight().setParent(newNode);
+  deleteByCount(node, index) {
+    if (index < node.leftCount()) {
+      if (!isRed(node.getLeft()) && !isRed(node.getLeft().getLeft())) {
+        node = moveRedLeft(node);
+      }
+      node.setLeft(this.deleteByCount(node.getLeft(), index));
+      if (node.getLeft()) {
+        node.getLeft().setParent(node);
+      }
+    } else {
+      if (isRed(node.getLeft())) {
+        node = rotateRight(node);
+      }
+      if (index === node.leftCount() && !node.getRight()) {
+        return void 0;
+      }
+      if (!isRed(node.getRight()) && !isRed(node.getRight().getLeft())) {
+        node = moveRedRight(node);
+      }
+      if (index === node.leftCount()) {
+        const successor = minNode(node.getRight());
+        const newRight = removeMin(node.getRight());
+        successor.setLeft(node.getLeft());
+        successor.setRight(newRight);
+        successor.setRed(node.isRed());
+        if (successor.getLeft()) {
+          successor.getLeft().setParent(successor);
+        }
+        if (successor.getRight()) {
+          successor.getRight().setParent(successor);
+        }
+        node.setLeft(void 0);
+        node.setRight(void 0);
+        node.setParent(void 0);
+        node = successor;
+      } else {
+        node.setRight(
+          this.deleteByCount(node.getRight(), index - node.leftCount() - 1)
+        );
+        if (node.getRight()) {
+          node.getRight().setParent(node);
+        }
+      }
     }
-    newNode.setLeft(target);
-    target.setParent(newNode);
-    target.setRight();
-    this.updateWeight(target);
-    this.updateWeight(newNode);
-    return newNode;
+    return fixUp(node);
   }
   /**
-   * `updateWeight` recalculates the weight of this node with the value and children.
+   * `updateWeight` propagates weight changes from the given node up to the
+   * root. Call this after a node's isRemoved() status changes (i.e., after
+   * tombstoning).
    */
   updateWeight(node) {
-    node.initWeight();
-    if (node.hasLeft()) {
-      node.increaseWeight(node.getLeftWeight());
-    }
-    if (node.hasRight()) {
-      node.increaseWeight(node.getRightWeight());
+    for (let cur = node; cur !== void 0; cur = cur.getParent()) {
+      cur.setWeight(cur.leftWeight() + cur.size() + cur.rightWeight());
     }
   }
-  updateTreeWeight(node) {
-    while (node) {
-      this.updateWeight(node);
-      node = node.getParent();
-    }
+  /**
+   * `toTestString` returns a string containing the metadata of the node for
+   * debugging purpose.
+   */
+  toTestString() {
+    let s = "";
+    traverseInOrder(this.root, (node) => {
+      s += `[${node.getWeight()},${node.size()}]${node.getValue().toString()}`;
+    });
+    return s;
   }
   /**
-   * `splayNode` moves the given node to the root.
+   * `indexOf` returns the logical (live-node) index of the given node, or -1
+   * if the node is a tombstone.
    */
-  splayNode(node) {
-    if (!node) {
-      return;
+  indexOf(node) {
+    if (node.size() === 0) {
+      return -1;
     }
-    for (; ; ) {
-      if (this.isLeftChild(node.getParent()) && this.isRightChild(node)) {
-        this.rotateLeft(node);
-        this.rotateRight(node);
-      } else if (this.isRightChild(node.getParent()) && this.isLeftChild(node)) {
-        this.rotateRight(node);
-        this.rotateLeft(node);
-      } else if (this.isLeftChild(node.getParent()) && this.isLeftChild(node)) {
-        this.rotateRight(node.getParent());
-        this.rotateRight(node);
-      } else if (this.isRightChild(node.getParent()) && this.isRightChild(node)) {
-        this.rotateLeft(node.getParent());
-        this.rotateLeft(node);
-      } else {
-        if (this.isLeftChild(node)) {
-          this.rotateRight(node);
-        } else if (this.isRightChild(node)) {
-          this.rotateLeft(node);
-        }
-        this.updateWeight(node);
-        return;
+    let index = node.leftWeight();
+    for (let cur = node; cur.getParent() !== void 0; cur = cur.getParent()) {
+      if (cur === cur.getParent().getRight()) {
+        index += cur.getParent().leftWeight() + cur.getParent().size();
       }
     }
+    return index;
   }
   /**
-   * `delete` deletes target node of this tree.
+   * `structuralIndexOf` returns the structural position of the node, counting
+   * all nodes including tombstones.
    */
-  delete(node) {
-    this.splayNode(node);
-    const leftTree = new SplayTree(node.getLeft());
-    if (leftTree.root) {
-      leftTree.root.setParent();
-    }
-    const rightTree = new SplayTree(node.getRight());
-    if (rightTree.root) {
-      rightTree.root.setParent();
+  structuralIndexOf(node) {
+    let index = node.leftCount();
+    for (let cur = node; cur.getParent() !== void 0; cur = cur.getParent()) {
+      if (cur === cur.getParent().getRight()) {
+        index += cur.getParent().leftCount() + 1;
+      }
     }
-    if (leftTree.root) {
-      const rightmostNode = leftTree.getRightmost();
-      leftTree.splayNode(rightmostNode);
-      leftTree.root.setRight(rightTree.root);
-      if (rightTree.root) {
-        rightTree.root.setParent(leftTree.root);
-      }
-      this.root = leftTree.root;
-    } else {
-      this.root = rightTree.root;
-    }
-    node.unlink();
-    if (this.root) {
-      this.updateWeight(this.root);
-    }
-  }
-  /**
-   * `deleteRange` separates the range between given 2 boundaries from this Tree.
-   * This function separates the range to delete as a subtree
-   * by splaying outer boundary nodes.
-   * leftBoundary must exist because of 0-indexed initial dummy node of tree,
-   * but rightBoundary can be nil means range to delete includes the end of tree.
-   * Refer to the design document in https://github.com/yorkie-team/yorkie/tree/main/design
-   */
-  deleteRange(leftBoundary, rightBoundary) {
-    if (!rightBoundary) {
-      this.splayNode(leftBoundary);
-      this.cutOffRight(leftBoundary);
-      return;
-    }
-    this.splayNode(leftBoundary);
-    this.splayNode(rightBoundary);
-    if (rightBoundary.getLeft() != leftBoundary) {
-      this.rotateRight(leftBoundary);
-    }
-    this.cutOffRight(leftBoundary);
-  }
-  cutOffRight(root) {
-    const nodesToFreeWeight = [];
-    this.traversePostorder(root.getRight(), nodesToFreeWeight);
-    for (const node of nodesToFreeWeight) {
-      node.initWeight();
-    }
-    this.updateTreeWeight(root);
-  }
-  /**
-   * `toTestString` returns a string containing the meta data of the Node
-   * for debugging purpose.
-   */
-  toTestString() {
-    const metaString = [];
-    this.traverseInorder(this.root, metaString);
-    return metaString.map((n) => `[${n.getWeight()},${n.getLength()}]${n.getValue() || ""}`).join("");
-  }
-  /**
-   * `checkWeight` returns false when there is an incorrect weight node.
-   * for debugging purpose.
-   */
-  checkWeight() {
-    const nodes = [];
-    this.traverseInorder(this.root, nodes);
-    for (const node of nodes) {
-      if (node.getWeight() != node.getLength() + node.getLeftWeight() + node.getRightWeight()) {
-        return false;
-      }
-    }
-    return true;
-  }
-  getRightmost() {
-    let node = this.root;
-    while (node.hasRight()) {
-      node = node.getRight();
-    }
-    return node;
-  }
-  traverseInorder(node, stack) {
-    if (!node) {
-      return;
-    }
-    this.traverseInorder(node.getLeft(), stack);
-    stack.push(node);
-    this.traverseInorder(node.getRight(), stack);
-  }
-  traversePostorder(node, stack) {
-    if (!node) {
-      return;
-    }
-    this.traversePostorder(node.getLeft(), stack);
-    this.traversePostorder(node.getRight(), stack);
-    stack.push(node);
-  }
-  rotateLeft(pivot) {
-    const root = pivot.getParent();
-    if (root.hasParent()) {
-      if (root === root.getParent().getLeft()) {
-        root.getParent().setLeft(pivot);
-      } else {
-        root.getParent().setRight(pivot);
-      }
-    } else {
-      this.root = pivot;
-    }
-    pivot.setParent(root.getParent());
-    root.setRight(pivot.getLeft());
-    if (root.hasRight()) {
-      root.getRight().setParent(root);
-    }
-    pivot.setLeft(root);
-    pivot.getLeft().setParent(pivot);
-    this.updateWeight(root);
-    this.updateWeight(pivot);
-  }
-  rotateRight(pivot) {
-    const root = pivot.getParent();
-    if (root.hasParent()) {
-      if (root === root.getParent().getLeft()) {
-        root.getParent().setLeft(pivot);
-      } else {
-        root.getParent().setRight(pivot);
-      }
-    } else {
-      this.root = pivot;
-    }
-    pivot.setParent(root.getParent());
-    root.setLeft(pivot.getRight());
-    if (root.hasLeft()) {
-      root.getLeft().setParent(root);
-    }
-    pivot.setRight(root);
-    pivot.getRight().setParent(pivot);
-    this.updateWeight(root);
-    this.updateWeight(pivot);
-  }
-  isLeftChild(node) {
-    if (node && node.hasParent()) {
-      return node.getParent().getLeft() === node;
-    }
-    return false;
-  }
-  isRightChild(node) {
-    if (node && node.hasParent()) {
-      return node.getParent().getRight() === node;
-    }
-    return false;
+    return index;
   }
 }
 const removeDecimal = (number) => number < 0 ? Math.ceil(number) : Math.floor(number);
@@ -7297,14 +7282,14 @@ class ElementEntry {
     this.elem = elem;
   }
 }
-class RGATreeListNode extends SplayNode {
+class RGATreeListNode {
+  indexNode;
   _elementEntry;
   _createdAt;
   _removedAt;
   prev;
   next;
-  constructor(elem, createdAt) {
-    super(elem);
+  constructor(createdAt) {
     this._createdAt = createdAt;
   }
   /**
@@ -7312,9 +7297,10 @@ class RGATreeListNode extends SplayNode {
    */
   static createWithElement(elem) {
     const entry = new ElementEntry(elem);
-    const node = new RGATreeListNode(elem, elem.getCreatedAt());
-    entry.positionNode = node;
+    const node = new RGATreeListNode(elem.getCreatedAt());
     node._elementEntry = entry;
+    entry.positionNode = node;
+    node.indexNode = new TreeListNode(node);
     return node;
   }
   /**
@@ -7322,7 +7308,9 @@ class RGATreeListNode extends SplayNode {
    * (used for move).
    */
   static createBarePosition(createdAt) {
-    return new RGATreeListNode(void 0, createdAt);
+    const node = new RGATreeListNode(createdAt);
+    node.indexNode = new TreeListNode(node);
+    return node;
   }
   /**
    * `createAfter` creates a new node with the given element after
@@ -7394,14 +7382,14 @@ class RGATreeListNode extends SplayNode {
     this.next = void 0;
   }
   /**
-   * `getLength` returns the length of this node.
-   * Dead nodes (no element) return 0, removed elements return 0.
+   * `toString` returns a string representation of this node's value, used by
+   * TreeList for debugging.
    */
-  getLength() {
-    if (!this._elementEntry || this.isRemoved()) {
-      return 0;
+  toString() {
+    if (!this._elementEntry) {
+      return "";
     }
-    return 1;
+    return this._elementEntry.elem.toJSON();
   }
   /**
    * `getPrev` returns a previous node.
@@ -7419,9 +7407,6 @@ class RGATreeListNode extends SplayNode {
    * `getValue` returns the element value.
    */
   getValue() {
-    if (!this._elementEntry) {
-      return this.value;
-    }
     return this._elementEntry.elem;
   }
   /**
@@ -7510,10 +7495,11 @@ class RGATreeList {
     dummyValue.setRemovedAt(InitialTimeTicket);
     this.dummyHead = RGATreeListNode.createWithElement(dummyValue);
     this.last = this.dummyHead;
-    this.nodeMapByIndex = new SplayTree();
+    this.nodeMapByIndex = new TreeList(
+      this.dummyHead.indexNode
+    );
     this.nodeMapByCreatedAt = /* @__PURE__ */ new Map();
     this.elementMapByCreatedAt = /* @__PURE__ */ new Map();
-    this.nodeMapByIndex.insert(this.dummyHead);
     this.nodeMapByCreatedAt.set(
       this.dummyHead.getCreatedAt().toIDString(),
       this.dummyHead
@@ -7546,7 +7532,7 @@ class RGATreeList {
       this.last = node.getPrev();
     }
     node.release();
-    this.nodeMapByIndex.delete(node);
+    this.nodeMapByIndex.delete(node.indexNode);
     this.nodeMapByCreatedAt.delete(node.getPositionCreatedAt().toIDString());
   }
   /**
@@ -7574,7 +7560,7 @@ class RGATreeList {
     if (prevNode === this.last) {
       this.last = newNode;
     }
-    this.nodeMapByIndex.insertAfter(prevNode, newNode);
+    this.nodeMapByIndex.insertAfter(prevNode.indexNode, newNode.indexNode);
     this.nodeMapByCreatedAt.set(value.getCreatedAt().toIDString(), newNode);
     this.elementMapByCreatedAt.set(
       value.getCreatedAt().toIDString(),
@@ -7601,7 +7587,7 @@ class RGATreeList {
     if (prevNode === this.last) {
       this.last = newNode;
     }
-    this.nodeMapByIndex.insertAfter(prevNode, newNode);
+    this.nodeMapByIndex.insertAfter(prevNode.indexNode, newNode.indexNode);
     this.nodeMapByCreatedAt.set(executedAt.toIDString(), newNode);
     return newNode;
   }
@@ -7630,19 +7616,19 @@ class RGATreeList {
       }
       const deadPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
       deadPosNode.setRemovedAt(executedAt);
-      this.nodeMapByIndex.splayNode(deadPosNode);
+      this.nodeMapByIndex.updateWeight(deadPosNode.indexNode);
       return deadPosNode;
     }
     const newPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
     const oldPosNode = entry.positionNode;
     oldPosNode.setElementEntry(void 0);
     oldPosNode.setRemovedAt(executedAt);
-    this.nodeMapByIndex.splayNode(oldPosNode);
+    this.nodeMapByIndex.updateWeight(oldPosNode.indexNode);
     newPosNode.setElementEntry(entry);
     entry.positionNode = newPosNode;
     entry.posMovedAt = executedAt;
     entry.elem.setMovedAt(executedAt);
-    this.nodeMapByIndex.splayNode(newPosNode);
+    this.nodeMapByIndex.updateWeight(newPosNode.indexNode);
     return oldPosNode;
   }
   /**
@@ -7673,9 +7659,9 @@ class RGATreeList {
       if (!node) {
         return;
       }
-      return String(this.nodeMapByIndex.indexOf(node));
+      return String(this.nodeMapByIndex.indexOf(node.indexNode));
     }
-    return String(this.nodeMapByIndex.indexOf(entry.positionNode));
+    return String(this.nodeMapByIndex.indexOf(entry.positionNode.indexNode));
   }
   /**
    * `purge` physically purges the given child. Handles both dead
@@ -7708,8 +7694,7 @@ class RGATreeList {
     if (idx >= this.length) {
       return;
     }
-    const node = this.nodeMapByIndex.findForArray(idx);
-    return node;
+    return this.nodeMapByIndex.find(idx).getValue();
   }
   /**
    * `findPrevCreatedAt` returns the position node's createdAt of the
@@ -7757,7 +7742,7 @@ class RGATreeList {
     const node = entry.positionNode;
     const alreadyRemoved = node.isRemoved();
     if (entry.elem.remove(editedAt) && !alreadyRemoved) {
-      this.nodeMapByIndex.splayNode(node);
+      this.nodeMapByIndex.updateWeight(node.indexNode);
     }
     return entry.elem;
   }
@@ -7783,7 +7768,7 @@ class RGATreeList {
       return;
     }
     if (node.remove(editedAt)) {
-      this.nodeMapByIndex.splayNode(node);
+      this.nodeMapByIndex.updateWeight(node.indexNode);
     }
     return node.getValue();
   }
@@ -7794,10 +7779,15 @@ class RGATreeList {
     return this.dummyHead.getValue();
   }
   /**
-   * `getLast` returns the value of last elements.
+   * `getLast` returns the value of last elements. Skips bare position nodes
+   * (created by moveAfter/addDeadPosition) that have no element.
    */
   getLast() {
-    return this.last.getValue();
+    let node = this.last;
+    while (!node.getElementEntry() && node !== this.dummyHead) {
+      node = node.getPrev();
+    }
+    return node.getValue();
   }
   /**
    * `getLastCreatedAt` returns the position node's createdAt of the
@@ -7832,7 +7822,7 @@ class RGATreeList {
     const prevNode = this.last;
     RGATreeListNode.insertNodeAfter(prevNode, node);
     this.last = node;
-    this.nodeMapByIndex.insertAfter(prevNode, node);
+    this.nodeMapByIndex.insertAfter(prevNode.indexNode, node.indexNode);
     this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
   }
   /**
@@ -7848,7 +7838,7 @@ class RGATreeList {
     const prevNode = this.last;
     RGATreeListNode.insertNodeAfter(prevNode, node);
     this.last = node;
-    this.nodeMapByIndex.insertAfter(prevNode, node);
+    this.nodeMapByIndex.insertAfter(prevNode.indexNode, node.indexNode);
     this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
     this.elementMapByCreatedAt.set(elem.getCreatedAt().toIDString(), entry);
   }
@@ -8014,9 +8004,10 @@ class CRDTArray extends CRDTContainer {
    */
   *[Symbol.iterator]() {
     for (const node of this.elements) {
-      if (node.getElementEntry() && !node.isRemoved()) {
-        yield node.getValue();
+      if (node.isRemoved()) {
+        continue;
       }
+      yield node.getValue();
     }
   }
   /**
@@ -8441,127 +8432,570 @@ class SetOperation extends Operation {
     return `${this.getParentCreatedAt().toTestString()}.SET.${this.key}=${this.value.toSortedJSON()}`;
   }
   /**
-   * `getKey` returns the key of this operation.
+   * `getKey` returns the key of this operation.
+   */
+  getKey() {
+    return this.key;
+  }
+  /**
+   * `getValue` returns the value of this operation.
+   */
+  getValue() {
+    return this.value;
+  }
+}
+class MoveOperation extends Operation {
+  prevCreatedAt;
+  createdAt;
+  constructor(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
+    super(parentCreatedAt, executedAt);
+    this.prevCreatedAt = prevCreatedAt;
+    this.createdAt = createdAt;
+  }
+  /**
+   * `create` creates a new instance of MoveOperation.
+   */
+  static create(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
+    return new MoveOperation(
+      parentCreatedAt,
+      prevCreatedAt,
+      createdAt,
+      executedAt
+    );
+  }
+  /**
+   * `execute` executes this operation on the given `CRDTRoot`.
+   */
+  execute(root) {
+    const parentObject = root.findByCreatedAt(this.getParentCreatedAt());
+    if (!parentObject) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `fail to find ${this.getParentCreatedAt()}`
+      );
+    }
+    if (!(parentObject instanceof CRDTArray)) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `fail to execute, only array can execute move`
+      );
+    }
+    const array = parentObject;
+    const reverseOp = this.toReverseOperation(array);
+    const previousIndex = Number(array.subPathOf(this.createdAt));
+    const deadNode = array.moveAfter(
+      this.prevCreatedAt,
+      this.createdAt,
+      this.getExecutedAt()
+    );
+    if (deadNode) {
+      root.registerGCPair({
+        parent: array.getRGATreeList(),
+        child: deadNode
+      });
+    }
+    const index = Number(array.subPathOf(this.createdAt));
+    return {
+      opInfos: [
+        {
+          type: "move",
+          path: root.createPath(this.getParentCreatedAt()),
+          index,
+          previousIndex
+        }
+      ],
+      reverseOp
+    };
+  }
+  toReverseOperation(array) {
+    const preservePrevCreatedAt = array.getPrevCreatedAt(this.createdAt);
+    return MoveOperation.create(
+      this.getParentCreatedAt(),
+      preservePrevCreatedAt,
+      this.createdAt
+    );
+  }
+  /**
+   * `getEffectedCreatedAt` returns the creation time of the
+   * effected element.
+   */
+  getEffectedCreatedAt() {
+    return this.createdAt;
+  }
+  /**
+   * `toTestString` returns a string containing the meta data.
+   */
+  toTestString() {
+    return `${this.getParentCreatedAt().toTestString()}.MOVE`;
+  }
+  /**
+   * `getPrevCreatedAt` returns the creation time of previous
+   * element.
+   */
+  getPrevCreatedAt() {
+    return this.prevCreatedAt;
+  }
+  /**
+   * `getCreatedAt` returns the creation time of the target element.
+   */
+  getCreatedAt() {
+    return this.createdAt;
+  }
+  /**
+   * `setPrevCreatedAt` sets the creation time of the previous
+   * element.
+   */
+  setPrevCreatedAt(createdAt) {
+    this.prevCreatedAt = createdAt;
+  }
+  /**
+   * `setCreatedAt` sets the creation time of the target element.
+   */
+  setCreatedAt(createdAt) {
+    this.createdAt = createdAt;
+  }
+}
+class SplayNode {
+  value;
+  left;
+  right;
+  parent;
+  weight;
+  constructor(value) {
+    this.value = value;
+    this.initWeight();
+  }
+  /**
+   * `getNodeString` returns a string of weight and value of this node.
+   */
+  getNodeString() {
+    return `${this.weight}${this.value}`;
+  }
+  /**
+   * `getValue` returns value of this node.
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * `getLeftWeight` returns left weight of this node.
+   */
+  getLeftWeight() {
+    return !this.hasLeft() ? 0 : this.left.getWeight();
+  }
+  /**
+   * `getRightWeight` returns right weight of this node.
+   */
+  getRightWeight() {
+    return !this.hasRight() ? 0 : this.right.getWeight();
+  }
+  /**
+   * `getWeight` returns weight of this node.
+   */
+  getWeight() {
+    return this.weight;
+  }
+  /**
+   * `getLeft` returns a left node.
+   */
+  getLeft() {
+    return this.left;
+  }
+  /**
+   * `getRight` returns a right node.
+   */
+  getRight() {
+    return this.right;
+  }
+  /**
+   * `getParent` returns parent of this node.
+   */
+  getParent() {
+    return this.parent;
+  }
+  /**
+   * `hasLeft` check if the left node exists
+   */
+  hasLeft() {
+    return !!this.left;
+  }
+  /**
+   * `hasRight` check if the right node exists
+   */
+  hasRight() {
+    return !!this.right;
+  }
+  /**
+   * `hasParent` check if the parent node exists
+   */
+  hasParent() {
+    return !!this.parent;
+  }
+  /**
+   * `setLeft` sets a left node.
+   */
+  setLeft(left) {
+    this.left = left;
+  }
+  /**
+   * `setRight` sets a right node.
+   */
+  setRight(right) {
+    this.right = right;
+  }
+  /**
+   * `setParent` sets a parent node.
+   */
+  setParent(parent) {
+    this.parent = parent;
+  }
+  /**
+   * `unlink` unlink parent, right and left node.
+   */
+  unlink() {
+    this.parent = void 0;
+    this.right = void 0;
+    this.left = void 0;
+  }
+  /**
+   * `hasLinks` checks if parent, right and left node exists.
+   */
+  hasLinks() {
+    return this.hasParent() || this.hasLeft() || this.hasRight();
+  }
+  /**
+   * `increaseWeight` increases weight.
+   */
+  increaseWeight(weight) {
+    this.weight += weight;
+  }
+  /**
+   * `initWeight` sets initial weight of this node.
+   */
+  initWeight() {
+    this.weight = this.getLength();
+  }
+}
+class SplayTree {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  /**
+   * `length` returns the size of this tree.
+   */
+  get length() {
+    return this.root ? this.root.getWeight() : 0;
+  }
+  /**
+   * `findForText` returns the Node and offset of the given position (cursor).
+   * Used for Text where cursor placed between characters.
+   */
+  findForText(pos) {
+    if (!this.root || pos < 0) {
+      return [void 0, 0];
+    }
+    let node = this.root;
+    for (; ; ) {
+      if (node.hasLeft() && pos <= node.getLeftWeight()) {
+        node = node.getLeft();
+      } else if (node.hasRight() && node.getLeftWeight() + node.getLength() < pos) {
+        pos -= node.getLeftWeight() + node.getLength();
+        node = node.getRight();
+      } else {
+        pos -= node.getLeftWeight();
+        break;
+      }
+    }
+    if (pos > node.getLength()) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `out of index range: pos: ${pos} > node.length: ${node.getLength()}`
+      );
+    }
+    this.splayNode(node);
+    return [node, pos];
+  }
+  /**
+   * `findForArray` returns the Node of the given position (index).
+   * Used for Array where index points to the element.
+   */
+  findForArray(idx) {
+    if (!this.root) {
+      return void 0;
+    }
+    if (idx < 0 || idx >= this.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `out of index range: idx: ${idx}, length: ${this.length}`
+      );
+    }
+    let node = this.root;
+    for (; ; ) {
+      if (node.hasLeft() && idx < node.getLeftWeight()) {
+        node = node.getLeft();
+      } else if (node.hasRight() && node.getLeftWeight() + node.getLength() <= idx) {
+        idx -= node.getLeftWeight() + node.getLength();
+        node = node.getRight();
+      } else {
+        break;
+      }
+    }
+    this.splayNode(node);
+    return node;
+  }
+  /**
+   * Find the index of the given node in BST.
+   *
+   * @param node - the given node
+   * @returns the index of given node
+   */
+  indexOf(node) {
+    if (!node || node !== this.root && !node.hasLinks()) {
+      return -1;
+    }
+    this.splayNode(node);
+    return this.root.getLeftWeight();
+  }
+  /**
+   * `getRoot` returns root of this tree.
+   */
+  getRoot() {
+    return this.root;
+  }
+  /**
+   * `insert` inserts the node at the last.
+   */
+  insert(newNode) {
+    return this.insertAfter(this.root, newNode);
+  }
+  /**
+   * `insertAfter` inserts the node after the given previous node.
+   */
+  insertAfter(target, newNode) {
+    if (!target) {
+      this.root = newNode;
+      return newNode;
+    }
+    this.splayNode(target);
+    this.root = newNode;
+    newNode.setRight(target.getRight());
+    if (target.hasRight()) {
+      target.getRight().setParent(newNode);
+    }
+    newNode.setLeft(target);
+    target.setParent(newNode);
+    target.setRight();
+    this.updateWeight(target);
+    this.updateWeight(newNode);
+    return newNode;
+  }
+  /**
+   * `updateWeight` recalculates the weight of this node with the value and children.
+   */
+  updateWeight(node) {
+    node.initWeight();
+    if (node.hasLeft()) {
+      node.increaseWeight(node.getLeftWeight());
+    }
+    if (node.hasRight()) {
+      node.increaseWeight(node.getRightWeight());
+    }
+  }
+  updateTreeWeight(node) {
+    while (node) {
+      this.updateWeight(node);
+      node = node.getParent();
+    }
+  }
+  /**
+   * `splayNode` moves the given node to the root.
+   */
+  splayNode(node) {
+    if (!node) {
+      return;
+    }
+    for (; ; ) {
+      if (this.isLeftChild(node.getParent()) && this.isRightChild(node)) {
+        this.rotateLeft(node);
+        this.rotateRight(node);
+      } else if (this.isRightChild(node.getParent()) && this.isLeftChild(node)) {
+        this.rotateRight(node);
+        this.rotateLeft(node);
+      } else if (this.isLeftChild(node.getParent()) && this.isLeftChild(node)) {
+        this.rotateRight(node.getParent());
+        this.rotateRight(node);
+      } else if (this.isRightChild(node.getParent()) && this.isRightChild(node)) {
+        this.rotateLeft(node.getParent());
+        this.rotateLeft(node);
+      } else {
+        if (this.isLeftChild(node)) {
+          this.rotateRight(node);
+        } else if (this.isRightChild(node)) {
+          this.rotateLeft(node);
+        }
+        this.updateWeight(node);
+        return;
+      }
+    }
+  }
+  /**
+   * `delete` deletes target node of this tree.
    */
-  getKey() {
-    return this.key;
+  delete(node) {
+    this.splayNode(node);
+    const leftTree = new SplayTree(node.getLeft());
+    if (leftTree.root) {
+      leftTree.root.setParent();
+    }
+    const rightTree = new SplayTree(node.getRight());
+    if (rightTree.root) {
+      rightTree.root.setParent();
+    }
+    if (leftTree.root) {
+      const rightmostNode = leftTree.getRightmost();
+      leftTree.splayNode(rightmostNode);
+      leftTree.root.setRight(rightTree.root);
+      if (rightTree.root) {
+        rightTree.root.setParent(leftTree.root);
+      }
+      this.root = leftTree.root;
+    } else {
+      this.root = rightTree.root;
+    }
+    node.unlink();
+    if (this.root) {
+      this.updateWeight(this.root);
+    }
   }
   /**
-   * `getValue` returns the value of this operation.
+   * `deleteRange` separates the range between given 2 boundaries from this Tree.
+   * This function separates the range to delete as a subtree
+   * by splaying outer boundary nodes.
+   * leftBoundary must exist because of 0-indexed initial dummy node of tree,
+   * but rightBoundary can be nil means range to delete includes the end of tree.
+   * Refer to the design document in https://github.com/yorkie-team/yorkie/tree/main/design
    */
-  getValue() {
-    return this.value;
+  deleteRange(leftBoundary, rightBoundary) {
+    if (!rightBoundary) {
+      this.splayNode(leftBoundary);
+      this.cutOffRight(leftBoundary);
+      return;
+    }
+    this.splayNode(leftBoundary);
+    this.splayNode(rightBoundary);
+    if (rightBoundary.getLeft() != leftBoundary) {
+      this.rotateRight(leftBoundary);
+    }
+    this.cutOffRight(leftBoundary);
   }
-}
-class MoveOperation extends Operation {
-  prevCreatedAt;
-  createdAt;
-  constructor(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
-    super(parentCreatedAt, executedAt);
-    this.prevCreatedAt = prevCreatedAt;
-    this.createdAt = createdAt;
+  cutOffRight(root) {
+    const nodesToFreeWeight = [];
+    this.traversePostorder(root.getRight(), nodesToFreeWeight);
+    for (const node of nodesToFreeWeight) {
+      node.initWeight();
+    }
+    this.updateTreeWeight(root);
   }
   /**
-   * `create` creates a new instance of MoveOperation.
+   * `toTestString` returns a string containing the meta data of the Node
+   * for debugging purpose.
    */
-  static create(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
-    return new MoveOperation(
-      parentCreatedAt,
-      prevCreatedAt,
-      createdAt,
-      executedAt
-    );
+  toTestString() {
+    const metaString = [];
+    this.traverseInorder(this.root, metaString);
+    return metaString.map((n) => `[${n.getWeight()},${n.getLength()}]${n.getValue() || ""}`).join("");
   }
   /**
-   * `execute` executes this operation on the given `CRDTRoot`.
+   * `checkWeight` returns false when there is an incorrect weight node.
+   * for debugging purpose.
    */
-  execute(root) {
-    const parentObject = root.findByCreatedAt(this.getParentCreatedAt());
-    if (!parentObject) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        `fail to find ${this.getParentCreatedAt()}`
-      );
-    }
-    if (!(parentObject instanceof CRDTArray)) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        `fail to execute, only array can execute move`
-      );
-    }
-    const array = parentObject;
-    const reverseOp = this.toReverseOperation(array);
-    const previousIndex = Number(array.subPathOf(this.createdAt));
-    const deadNode = array.moveAfter(
-      this.prevCreatedAt,
-      this.createdAt,
-      this.getExecutedAt()
-    );
-    if (deadNode) {
-      root.registerGCPair({
-        parent: array.getRGATreeList(),
-        child: deadNode
-      });
+  checkWeight() {
+    const nodes = [];
+    this.traverseInorder(this.root, nodes);
+    for (const node of nodes) {
+      if (node.getWeight() != node.getLength() + node.getLeftWeight() + node.getRightWeight()) {
+        return false;
+      }
     }
-    const index = Number(array.subPathOf(this.createdAt));
-    return {
-      opInfos: [
-        {
-          type: "move",
-          path: root.createPath(this.getParentCreatedAt()),
-          index,
-          previousIndex
-        }
-      ],
-      reverseOp
-    };
+    return true;
   }
-  toReverseOperation(array) {
-    const preservePrevCreatedAt = array.getPrevCreatedAt(this.createdAt);
-    return MoveOperation.create(
-      this.getParentCreatedAt(),
-      preservePrevCreatedAt,
-      this.createdAt
-    );
+  getRightmost() {
+    let node = this.root;
+    while (node.hasRight()) {
+      node = node.getRight();
+    }
+    return node;
   }
-  /**
-   * `getEffectedCreatedAt` returns the creation time of the
-   * effected element.
-   */
-  getEffectedCreatedAt() {
-    return this.createdAt;
+  traverseInorder(node, stack) {
+    if (!node) {
+      return;
+    }
+    this.traverseInorder(node.getLeft(), stack);
+    stack.push(node);
+    this.traverseInorder(node.getRight(), stack);
   }
-  /**
-   * `toTestString` returns a string containing the meta data.
-   */
-  toTestString() {
-    return `${this.getParentCreatedAt().toTestString()}.MOVE`;
+  traversePostorder(node, stack) {
+    if (!node) {
+      return;
+    }
+    this.traversePostorder(node.getLeft(), stack);
+    this.traversePostorder(node.getRight(), stack);
+    stack.push(node);
   }
-  /**
-   * `getPrevCreatedAt` returns the creation time of previous
-   * element.
-   */
-  getPrevCreatedAt() {
-    return this.prevCreatedAt;
+  rotateLeft(pivot) {
+    const root = pivot.getParent();
+    if (root.hasParent()) {
+      if (root === root.getParent().getLeft()) {
+        root.getParent().setLeft(pivot);
+      } else {
+        root.getParent().setRight(pivot);
+      }
+    } else {
+      this.root = pivot;
+    }
+    pivot.setParent(root.getParent());
+    root.setRight(pivot.getLeft());
+    if (root.hasRight()) {
+      root.getRight().setParent(root);
+    }
+    pivot.setLeft(root);
+    pivot.getLeft().setParent(pivot);
+    this.updateWeight(root);
+    this.updateWeight(pivot);
   }
-  /**
-   * `getCreatedAt` returns the creation time of the target element.
-   */
-  getCreatedAt() {
-    return this.createdAt;
+  rotateRight(pivot) {
+    const root = pivot.getParent();
+    if (root.hasParent()) {
+      if (root === root.getParent().getLeft()) {
+        root.getParent().setLeft(pivot);
+      } else {
+        root.getParent().setRight(pivot);
+      }
+    } else {
+      this.root = pivot;
+    }
+    pivot.setParent(root.getParent());
+    root.setLeft(pivot.getRight());
+    if (root.hasLeft()) {
+      root.getLeft().setParent(root);
+    }
+    pivot.setRight(root);
+    pivot.getRight().setParent(pivot);
+    this.updateWeight(root);
+    this.updateWeight(pivot);
   }
-  /**
-   * `setPrevCreatedAt` sets the creation time of the previous
-   * element.
-   */
-  setPrevCreatedAt(createdAt) {
-    this.prevCreatedAt = createdAt;
+  isLeftChild(node) {
+    if (node && node.hasParent()) {
+      return node.getParent().getLeft() === node;
+    }
+    return false;
   }
-  /**
-   * `setCreatedAt` sets the creation time of the target element.
-   */
-  setCreatedAt(createdAt) {
-    this.createdAt = createdAt;
+  isRightChild(node) {
+    if (node && node.hasParent()) {
+      return node.getParent().getRight() === node;
+    }
+    return false;
   }
 }
 const DefaultComparator = (a, b) => {
@@ -8579,10 +9013,10 @@ class LLRBNode {
   left;
   right;
   isRed;
-  constructor(key, value, isRed) {
+  constructor(key, value, isRed2) {
     this.key = key;
     this.value = value;
-    this.isRed = isRed;
+    this.isRed = isRed2;
   }
 }
 class SortedMapIterator {
@@ -13766,6 +14200,26 @@ class ChangeID {
     newID.versionVector.set(this.actor, lamport);
     return newID;
   }
+  /**
+   * `syncLamport` advances the lamport clock against the given ID without
+   * merging its version vector into the receiver's. It is the counterpart
+   * of `syncClocks` for attachments that have opted out of GC participation
+   * (see docs/design/disable-gc-on-attach.md in the server repo): the
+   * receiver does not need other actors' entries in its VV because it
+   * never produces or consumes tombstones, and dropping them keeps each
+   * subsequent local Change's VV at O(1) instead of O(num_actors).
+   * Lamport must still advance so that TimeTickets produced locally
+   * remain ordered against remote operations.
+   */
+  syncLamport(other) {
+    if (!other.hasClocks()) {
+      return this;
+    }
+    const lamport = other.lamport > this.lamport ? other.lamport + 1n : this.lamport + 1n;
+    const vector = this.versionVector.deepcopy();
+    vector.set(this.actor, lamport);
+    return new ChangeID(this.clientSeq, lamport, this.actor, vector);
+  }
   /**
    * `setClocks` sets the given clocks to this ID. This is used when the snapshot
    * is given from the server.
@@ -19642,6 +20096,12 @@ class Document {
   onlineClients;
   eventStream;
   eventStreamObserver;
+  // `disableGC`, when true, declares that this document does not produce or
+  // consume tombstones (see disable-gc-on-attach in the server repo). It is
+  // set by the client on Attach and consumed by applyChange to skip merging
+  // remote actors' version vectors into changeID, keeping each subsequent
+  // local Change's VV at O(1) for high-fan-out Counter workloads.
+  disableGC;
   /**
    * `history` is exposed to the user to manage undo/redo operations.
    */
@@ -19655,6 +20115,7 @@ class Document {
     this.changeID = InitialChangeID;
     this.checkpoint = InitialCheckpoint;
     this.localChanges = [];
+    this.disableGC = false;
     this.root = CRDTRoot.create();
     this.presences = /* @__PURE__ */ new Map();
     this.onlineClients = /* @__PURE__ */ new Set();
@@ -20063,6 +20524,14 @@ class Document {
     }
     this.changeID = this.changeID.setActor(actorID);
   }
+  /**
+   * `setDisableGC` records whether this document participates in GC. The
+   * client calls this on attach so subsequent applyChange runs use the
+   * lamport-only sync path.
+   */
+  setDisableGC(disableGC) {
+    this.disableGC = disableGC;
+  }
   /**
    * `isEnableDevtools` returns whether devtools is enabled or not.
    */
@@ -20301,7 +20770,7 @@ class Document {
         );
       }
     }
-    this.changeID = this.changeID.syncClocks(change.getID());
+    this.changeID = this.disableGC ? this.changeID.syncLamport(change.getID()) : this.changeID.syncClocks(change.getID());
     if (opInfos.length) {
       const rawChange = this.isEnableDevtools() ? change.toStruct() : void 0;
       events.push(
@@ -20984,7 +21453,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name = "@yorkie-js/sdk";
-const version = "0.7.10";
+const version = "0.7.11";
 const pkg = {
   name,
   version
@@ -21545,6 +22014,7 @@ class Client {
           doc.setSchemaRules(converter.fromSchemaRules(res.schemaRules));
         }
         const pack = converter.fromChangePack(res.changePack);
+        doc.setDisableGC(opts.disableGC ?? false);
         doc.applyChangePack(pack);
         if (doc.getStatus() === DocStatus.Removed) {
           return doc;