@yorkie-js/react 0.6.28 → 0.6.29

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

@@ -8663,8 +8663,7 @@ class CRDTObject extends CRDTContainer {
     }
   }
   /**
-   * eslint-disable-next-line jsdoc/require-jsdoc
-   * @internal
+   * `[Symbol.iterator]` returns an iterator for the entries in this object.
    */
   *[Symbol.iterator]() {
     const keySet = /* @__PURE__ */ new Set();
@@ -10456,9 +10455,7 @@ class RGATreeList {
    * `findNextBeforeExecutedAt` returns the node by the given createdAt and
    * executedAt. It passes through nodes created after executedAt from the
    * given node and returns the next node.
-   * @param createdAt - created time
-   * @param executedAt - executed time
-   * @returns next node
+   * @returns the next node of the given createdAt and executedAt
    */
   findNextBeforeExecutedAt(createdAt, executedAt) {
     let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
@@ -10794,8 +10791,7 @@ class CRDTArray extends CRDTContainer {
     return this.elements.length;
   }
   /**
-   * eslint-disable-next-line jsdoc/require-jsdoc
-   * @internal
+   * `[Symbol.iterator]` returns an iterator for the elements in this array.
    */
   *[Symbol.iterator]() {
     for (const node of this.elements) {
@@ -11698,8 +11694,6 @@ class CRDTText extends CRDTElement {
   }
   /**
    * `edit` edits the given range with the given value and attributes.
-   *
-   * @internal
    */
   edit(range, content, editedAt, attributes, versionVector) {
     const crdtTextValue = content ? CRDTTextValue.create(content) : void 0;
@@ -11736,7 +11730,6 @@ class CRDTText extends CRDTElement {
    * @param range - range of RGATreeSplitNode
    * @param attributes - style attributes
    * @param editedAt - edited time
-   * @internal
    */
   setStyle(range, attributes, editedAt, versionVector) {
     const diff = { data: 0, meta: 0 };
@@ -11890,8 +11883,6 @@ class CRDTText extends CRDTElement {
   }
   /**
    * `getRGATreeSplit` returns rgaTreeSplit.
-   *
-   * @internal
    */
   getRGATreeSplit() {
     return this.rgaTreeSplit;
@@ -14004,8 +13995,6 @@ class CRDTTree extends CRDTElement {
   }
   /**
    * `toJSForTest` returns value with meta data for testing.
-   *
-   * @internal
    */
   toJSForTest() {
     return {
@@ -14016,8 +14005,6 @@ class CRDTTree extends CRDTElement {
   }
   /**
    * `toJSInfoForTest` returns detailed TreeNode information for use in Devtools.
-   *
-   * @internal
    */
   toJSInfoForTest() {
     const rootNode = this.indexTree.getRoot();
@@ -17571,11 +17558,11 @@ function uuid() {
 class Attachment {
   constructor(reconnectStreamDelay, doc, docID, syncMode, unsubscribeBroadcastEvent) {
     // TODO(hackerwins): Consider to changing the modifiers of the following properties to private.
-    __publicField(this, "reconnectStreamDelay");
     __publicField(this, "doc");
     __publicField(this, "docID");
     __publicField(this, "syncMode");
     __publicField(this, "remoteChangeEventReceived");
+    __publicField(this, "reconnectStreamDelay");
     __publicField(this, "cancelled");
     __publicField(this, "watchStream");
     __publicField(this, "watchLoopTimerID");
@@ -17649,156 +17636,6 @@ class Attachment {
     this.watchLoopTimerID = void 0;
   }
 }
-function validateYorkieRuleset(data, ruleset) {
-  const errors = [];
-  for (const rule of ruleset) {
-    const value = getValueByPath(data, rule.path);
-    const result = validateValue(value, rule);
-    if (!result.valid) {
-      for (const error of result.errors || []) {
-        errors.push(error);
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-function getValueByPath(obj, path) {
-  if (!path.startsWith("$")) {
-    throw new Error(`Path must start with $, got ${path}`);
-  }
-  const keys = path.split(".");
-  let current = obj;
-  for (let i = 1; i < keys.length; i++) {
-    const key = keys[i];
-    if (!(current instanceof CRDTObject)) {
-      return void 0;
-    }
-    current = current.get(key);
-  }
-  return current;
-}
-function validateValue(value, rule) {
-  switch (rule.type) {
-    case "string":
-    case "boolean":
-    case "integer":
-    case "double":
-    case "long":
-    case "date":
-    case "bytes":
-    case "null":
-      return validatePrimitiveValue(value, rule);
-    case "object":
-      if (!(value instanceof CRDTObject)) {
-        return {
-          valid: false,
-          errors: [
-            {
-              path: rule.path,
-              message: `expected object at path ${rule.path}`
-            }
-          ]
-        };
-      }
-      break;
-    case "array":
-      if (!(value instanceof CRDTArray)) {
-        return {
-          valid: false,
-          errors: [
-            {
-              path: rule.path,
-              message: `expected array at path ${rule.path}`
-            }
-          ]
-        };
-      }
-      break;
-    case "yorkie.Text":
-      if (!(value instanceof CRDTText)) {
-        return {
-          valid: false,
-          errors: [
-            {
-              path: rule.path,
-              message: `expected yorkie.Text at path ${rule.path}`
-            }
-          ]
-        };
-      }
-      break;
-    case "yorkie.Tree":
-      if (!(value instanceof CRDTTree)) {
-        return {
-          valid: false,
-          errors: [
-            {
-              path: rule.path,
-              message: `expected yorkie.Tree at path ${rule.path}`
-            }
-          ]
-        };
-      }
-      break;
-    case "yorkie.Counter":
-      if (!(value instanceof CRDTCounter)) {
-        return {
-          valid: false,
-          errors: [
-            {
-              path: rule.path,
-              message: `expected yorkie.Counter at path ${rule.path}`
-            }
-          ]
-        };
-      }
-      break;
-    default:
-      throw new Error(`Unknown rule type: ${rule.type}`);
-  }
-  return {
-    valid: true
-  };
-}
-function getPrimitiveType(type) {
-  switch (type) {
-    case "null":
-      return PrimitiveType.Null;
-    case "boolean":
-      return PrimitiveType.Boolean;
-    case "integer":
-      return PrimitiveType.Integer;
-    case "long":
-      return PrimitiveType.Long;
-    case "double":
-      return PrimitiveType.Double;
-    case "string":
-      return PrimitiveType.String;
-    case "bytes":
-      return PrimitiveType.Bytes;
-    case "date":
-      return PrimitiveType.Date;
-    default:
-      throw new Error(`Unknown primitive type: ${type}`);
-  }
-}
-function validatePrimitiveValue(value, rule) {
-  if (value instanceof Primitive && value.getType() === getPrimitiveType(rule.type)) {
-    return { valid: true };
-  }
-  return {
-    valid: false,
-    errors: [
-      {
-        path: rule.path,
-        message: `expected ${rule.type} at path ${rule.path}`
-      }
-    ]
-  };
-}
 const Noop = () => {
 };
 class ObserverProxy {
@@ -18073,332 +17910,66 @@ class ChangeContext {
     this.root.acc(diff);
   }
 }
-class CRDTRoot {
-  constructor(rootObject) {
-    /**
-     * `rootObject` is the root object of the document.
-     */
-    __publicField(this, "rootObject");
-    /**
-     * `elementPairMapByCreatedAt` is a hash table that maps the creation time of
-     * an element to the element itself and its parent.
-     */
-    __publicField(this, "elementPairMapByCreatedAt");
-    /**
-     * `gcElementSetByCreatedAt` is a hash set that contains the creation
-     * time of the removed element. It is used to find the removed element when
-     * executing garbage collection.
-     */
-    __publicField(this, "gcElementSetByCreatedAt");
-    /**
-     * `gcPairMap` is a hash table that maps the IDString of GCChild to the
-     * element itself and its parent.
-     */
-    __publicField(this, "gcPairMap");
-    /**
-     * `docSize` is a structure that represents the size of the document.
-     */
-    __publicField(this, "docSize");
-    this.rootObject = rootObject;
-    this.elementPairMapByCreatedAt = /* @__PURE__ */ new Map();
-    this.gcElementSetByCreatedAt = /* @__PURE__ */ new Set();
-    this.gcPairMap = /* @__PURE__ */ new Map();
-    this.docSize = { live: { data: 0, meta: 0 }, gc: { data: 0, meta: 0 } };
-    this.registerElement(rootObject, void 0);
-    rootObject.getDescendants((elem) => {
-      if (elem.getRemovedAt()) {
-        this.registerRemovedElement(elem);
-      }
-      if (elem instanceof CRDTText || elem instanceof CRDTTree) {
-        for (const pair of elem.getGCPairs()) {
-          this.registerGCPair(pair);
+function createJSONObject(context, target) {
+  const objectProxy = new ObjectProxy(context);
+  return new Proxy(target, objectProxy.getHandlers());
+}
+class ObjectProxy {
+  constructor(context) {
+    __publicField(this, "context");
+    __publicField(this, "handlers");
+    this.context = context;
+    this.handlers = {
+      set: (target, key, value) => {
+        if (logger.isEnabled(LogLevel.Trivial)) {
+          logger.trivial(`obj[${key}]=${JSON.stringify(value)}`);
+        }
+        ObjectProxy.setInternal(context, target, key, value);
+        return true;
+      },
+      get: (target, keyOrMethod) => {
+        if (logger.isEnabled(LogLevel.Trivial)) {
+          logger.trivial(`obj[${keyOrMethod}]`);
+        }
+        if (keyOrMethod === "getID") {
+          return () => {
+            return target.getCreatedAt();
+          };
+        } else if (keyOrMethod === "toJSON" || keyOrMethod === "toString") {
+          return () => {
+            return target.toJSON();
+          };
+        } else if (keyOrMethod === "toJS") {
+          return () => {
+            return target.toJS();
+          };
+        } else if (keyOrMethod === "toJSForTest") {
+          return () => {
+            return target.toJSForTest();
+          };
+        }
+        return toJSONElement(context, target.get(keyOrMethod));
+      },
+      ownKeys: (target) => {
+        return target.getKeys();
+      },
+      getOwnPropertyDescriptor: () => {
+        return {
+          enumerable: true,
+          configurable: true
+        };
+      },
+      deleteProperty: (target, key) => {
+        if (logger.isEnabled(LogLevel.Trivial)) {
+          logger.trivial(`obj[${key}]`);
         }
+        ObjectProxy.deleteInternal(context, target, key);
+        return true;
       }
-      return false;
-    });
+    };
   }
   /**
-   * `create` creates a new instance of Root.
-   */
-  static create() {
-    return new CRDTRoot(CRDTObject.create(InitialTimeTicket));
-  }
-  /**
-   * `findByCreatedAt` returns the element of given creation time.
-   */
-  findByCreatedAt(createdAt) {
-    const pair = this.elementPairMapByCreatedAt.get(createdAt.toIDString());
-    if (!pair) {
-      return;
-    }
-    return pair.element;
-  }
-  /**
-   * `findElementPairByCreatedAt` returns the element and parent pair
-   * of given creation time.
-   */
-  findElementPairByCreatedAt(createdAt) {
-    return this.elementPairMapByCreatedAt.get(createdAt.toIDString());
-  }
-  /**
-   * `createSubPaths` creates an array of the sub paths for the given element.
-   */
-  createSubPaths(createdAt) {
-    let pair = this.elementPairMapByCreatedAt.get(createdAt.toIDString());
-    if (!pair) {
-      return [];
-    }
-    const subPaths = [];
-    while (pair.parent) {
-      const createdAt2 = pair.element.getCreatedAt();
-      const subPath = pair.parent.subPathOf(createdAt2);
-      if (subPath === void 0) {
-        throw new YorkieError(
-          Code.ErrInvalidArgument,
-          `cant find the given element: ${createdAt2.toIDString()}`
-        );
-      }
-      subPaths.unshift(subPath);
-      pair = this.elementPairMapByCreatedAt.get(
-        pair.parent.getCreatedAt().toIDString()
-      );
-    }
-    subPaths.unshift("$");
-    return subPaths;
-  }
-  /**
-   * `createPath` creates path of the given element.
-   */
-  createPath(createdAt) {
-    return this.createSubPaths(createdAt).join(".");
-  }
-  /**
-   * `registerElement` registers the given element and its descendants to hash table.
-   */
-  registerElement(element, parent) {
-    this.elementPairMapByCreatedAt.set(element.getCreatedAt().toIDString(), {
-      parent,
-      element
-    });
-    addDataSizes(this.docSize.live, element.getDataSize());
-    if (element instanceof CRDTContainer) {
-      element.getDescendants((elem, par) => {
-        this.elementPairMapByCreatedAt.set(elem.getCreatedAt().toIDString(), {
-          parent: par,
-          element: elem
-        });
-        addDataSizes(this.docSize.live, elem.getDataSize());
-        return false;
-      });
-    }
-  }
-  /**
-   * `deregisterElement` deregister the given element and its descendants from hash table.
-   */
-  deregisterElement(element) {
-    let count = 0;
-    const deregisterElementInternal = (elem) => {
-      const createdAt = elem.getCreatedAt().toIDString();
-      subDataSize(this.docSize.gc, elem.getDataSize());
-      this.elementPairMapByCreatedAt.delete(createdAt);
-      this.gcElementSetByCreatedAt.delete(createdAt);
-      count++;
-    };
-    deregisterElementInternal(element);
-    if (element instanceof CRDTContainer) {
-      element.getDescendants((e) => {
-        deregisterElementInternal(e);
-        return false;
-      });
-    }
-    return count;
-  }
-  /**
-   * `registerRemovedElement` registers the given element to the hash set.
-   */
-  registerRemovedElement(element) {
-    addDataSizes(this.docSize.gc, element.getDataSize());
-    subDataSize(this.docSize.live, element.getDataSize());
-    this.docSize.live.meta += TimeTicketSize;
-    this.gcElementSetByCreatedAt.add(element.getCreatedAt().toIDString());
-  }
-  /**
-   * `registerGCPair` registers the given pair to hash table.
-   */
-  registerGCPair(pair) {
-    const prev = this.gcPairMap.get(pair.child.toIDString());
-    if (prev) {
-      this.gcPairMap.delete(pair.child.toIDString());
-      return;
-    }
-    this.gcPairMap.set(pair.child.toIDString(), pair);
-    const size = this.gcPairMap.get(pair.child.toIDString()).child.getDataSize();
-    addDataSizes(this.docSize.gc, size);
-    subDataSize(this.docSize.live, size);
-    if (!(pair.child instanceof RHTNode)) {
-      this.docSize.live.meta += TimeTicketSize;
-    }
-  }
-  /**
-   * `getElementMapSize` returns the size of element map.
-   */
-  getElementMapSize() {
-    return this.elementPairMapByCreatedAt.size;
-  }
-  /**
-   * `getGarbageElementSetSize()` returns the size of removed element set.
-   */
-  getGarbageElementSetSize() {
-    const seen = /* @__PURE__ */ new Set();
-    for (const createdAt of this.gcElementSetByCreatedAt) {
-      seen.add(createdAt);
-      const pair = this.elementPairMapByCreatedAt.get(createdAt);
-      if (pair.element instanceof CRDTContainer) {
-        pair.element.getDescendants((el) => {
-          seen.add(el.getCreatedAt().toIDString());
-          return false;
-        });
-      }
-    }
-    return seen.size;
-  }
-  /**
-   * `getObject` returns root object.
-   */
-  getObject() {
-    return this.rootObject;
-  }
-  /**
-   * `getGarbageLen` returns length of nodes which can be garbage collected.
-   */
-  getGarbageLen() {
-    return this.getGarbageElementSetSize() + this.gcPairMap.size;
-  }
-  /**
-   * `getDocSize` returns the size of the document.
-   */
-  getDocSize() {
-    return this.docSize;
-  }
-  /**
-   * `deepcopy` copies itself deeply.
-   */
-  deepcopy() {
-    return new CRDTRoot(this.rootObject.deepcopy());
-  }
-  /**
-   * `garbageCollect` purges elements that were removed before the given time.
-   */
-  garbageCollect(minSyncedVersionVector) {
-    let count = 0;
-    for (const createdAt of this.gcElementSetByCreatedAt) {
-      const pair = this.elementPairMapByCreatedAt.get(createdAt);
-      const removedAt = pair.element.getRemovedAt();
-      if (removedAt && (minSyncedVersionVector == null ? void 0 : minSyncedVersionVector.afterOrEqual(removedAt))) {
-        pair.parent.purge(pair.element);
-        count += this.deregisterElement(pair.element);
-      }
-    }
-    for (const [, pair] of this.gcPairMap) {
-      const removedAt = pair.child.getRemovedAt();
-      if (removedAt && (minSyncedVersionVector == null ? void 0 : minSyncedVersionVector.afterOrEqual(removedAt))) {
-        pair.parent.purge(pair.child);
-        this.gcPairMap.delete(pair.child.toIDString());
-        count += 1;
-      }
-    }
-    return count;
-  }
-  /**
-   * `toJSON` returns the JSON encoding of this root object.
-   */
-  toJSON() {
-    return this.rootObject.toJSON();
-  }
-  /**
-   * `toSortedJSON` returns the sorted JSON encoding of this root object.
-   */
-  toSortedJSON() {
-    return this.rootObject.toSortedJSON();
-  }
-  /**
-   * `getStats` returns the current statistics of the root object.
-   * This includes counts of various types of elements and structural information.
-   */
-  getStats() {
-    return {
-      elements: this.getElementMapSize(),
-      gcPairs: this.gcPairMap.size,
-      gcElements: this.getGarbageElementSetSize()
-    };
-  }
-  /**
-   * `acc` accumulates the given DataSize to Live.
-   */
-  acc(diff) {
-    addDataSizes(this.docSize.live, diff);
-  }
-}
-function createJSONObject(context, target) {
-  const objectProxy = new ObjectProxy(context);
-  return new Proxy(target, objectProxy.getHandlers());
-}
-class ObjectProxy {
-  constructor(context) {
-    __publicField(this, "context");
-    __publicField(this, "handlers");
-    this.context = context;
-    this.handlers = {
-      set: (target, key, value) => {
-        if (logger.isEnabled(LogLevel.Trivial)) {
-          logger.trivial(`obj[${key}]=${JSON.stringify(value)}`);
-        }
-        ObjectProxy.setInternal(context, target, key, value);
-        return true;
-      },
-      get: (target, keyOrMethod) => {
-        if (logger.isEnabled(LogLevel.Trivial)) {
-          logger.trivial(`obj[${keyOrMethod}]`);
-        }
-        if (keyOrMethod === "getID") {
-          return () => {
-            return target.getCreatedAt();
-          };
-        } else if (keyOrMethod === "toJSON" || keyOrMethod === "toString") {
-          return () => {
-            return target.toJSON();
-          };
-        } else if (keyOrMethod === "toJS") {
-          return () => {
-            return target.toJS();
-          };
-        } else if (keyOrMethod === "toJSForTest") {
-          return () => {
-            return target.toJSForTest();
-          };
-        }
-        return toJSONElement(context, target.get(keyOrMethod));
-      },
-      ownKeys: (target) => {
-        return target.getKeys();
-      },
-      getOwnPropertyDescriptor: () => {
-        return {
-          enumerable: true,
-          configurable: true
-        };
-      },
-      deleteProperty: (target, key) => {
-        if (logger.isEnabled(LogLevel.Trivial)) {
-          logger.trivial(`obj[${key}]`);
-        }
-        ObjectProxy.deleteInternal(context, target, key);
-        return true;
-      }
-    };
-  }
-  /**
-   * `setInternal` sets a new Object for the given key
+   * `setInternal` sets a new Object for the given key
    */
   static setInternal(context, target, key, value) {
     if (key.includes(".")) {
@@ -19043,7 +18614,6 @@ class Text {
   }
   /**
    * `initialize` initialize this text with context and internal text.
-   * @internal
    */
   initialize(context, text) {
     this.context = context;
@@ -19253,7 +18823,6 @@ class Text {
   }
   /**
    * `toJSForTest` returns value with meta data for testing.
-   * @internal
    */
   toJSForTest() {
     if (!this.context || !this.text) {
@@ -19289,7 +18858,6 @@ class Counter {
   }
   /**
    * `initialize` initialize this text with context and internal text.
-   * @internal
    */
   initialize(context, counter) {
     this.valueType = counter.getValueType();
@@ -19305,7 +18873,6 @@ class Counter {
   }
   /**
    * `getValue` returns the value of this counter;
-   * @internal
    */
   getValue() {
     return this.value;
@@ -19341,7 +18908,6 @@ class Counter {
   }
   /**
    * `toJSForTest` returns value with meta data for testing.
-   * @internal
    */
   toJSForTest() {
     if (!this.context || !this.counter) {
@@ -19540,7 +19106,6 @@ class Tree {
   }
   /**
    * `initialize` initialize this tree with context and internal tree.
-   * @internal
    */
   initialize(context, tree) {
     this.context = context;
@@ -19552,593 +19117,857 @@ class Tree {
   getID() {
     return this.tree.getID();
   }
-  /**
-   * `buildRoot` builds the root of this tree with the given initial root
-   * which set by the user.
-   */
-  buildRoot(context) {
-    if (!this.initialRoot) {
-      return CRDTTreeNode.create(
-        CRDTTreeNodeID.of(context.issueTimeTicket(), 0),
-        DefaultRootType
+  /**
+   * `buildRoot` builds the root of this tree with the given initial root
+   * which set by the user.
+   */
+  buildRoot(context) {
+    if (!this.initialRoot) {
+      return CRDTTreeNode.create(
+        CRDTTreeNodeID.of(context.issueTimeTicket(), 0),
+        DefaultRootType
+      );
+    }
+    const root = CRDTTreeNode.create(
+      CRDTTreeNodeID.of(context.issueTimeTicket(), 0),
+      this.initialRoot.type
+    );
+    for (const child of this.initialRoot.children) {
+      buildDescendants(child, root, context);
+    }
+    return root;
+  }
+  /**
+   * `getSize` returns the size of this tree.
+   */
+  getSize() {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    return this.tree.getSize();
+  }
+  /**
+   * `getNodeSize` returns the node size of this tree.
+   */
+  getNodeSize() {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    return this.tree.getNodeSize();
+  }
+  /**
+   * `getIndexTree` returns the index tree of this tree.
+   */
+  getIndexTree() {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    return this.tree.getIndexTree();
+  }
+  /**
+   * `splitByPath` splits the tree by the given path.
+   */
+  splitByPath(path) {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    if (!path.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "path should not be empty"
+      );
+    }
+    const treePos = this.tree.pathToTreePos(path);
+    const commands = separateSplit(treePos, path);
+    for (const command of commands) {
+      const { fromPath, toPath, content } = command;
+      const fromPos = this.tree.pathToPos(fromPath);
+      const toPos = this.tree.pathToPos(toPath);
+      this.editInternal(fromPos, toPos, content ? [content] : [], 0);
+    }
+  }
+  /**
+   * `mergeByPath` merges the tree by the given path.
+   */
+  mergeByPath(path) {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    if (!path.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "path should not be empty"
+      );
+    }
+    const treePos = this.tree.pathToTreePos(path);
+    if (treePos.node.isText) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "text node cannot be merged"
+      );
+    }
+    const commands = separateMerge(treePos, path);
+    for (const command of commands) {
+      const { fromPath, toPath, content } = command;
+      const fromPos = this.tree.pathToPos(fromPath);
+      const toPos = this.tree.pathToPos(toPath);
+      this.editInternal(fromPos, toPos, content ?? [], 0);
+    }
+  }
+  /**
+   * `styleByPath` sets the attributes to the elements of the given path.
+   */
+  styleByPath(path, attributes) {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    if (!path.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "path should not be empty"
+      );
+    }
+    const [fromPos, toPos] = this.tree.pathToPosRange(path);
+    const ticket = this.context.issueTimeTicket();
+    const attrs = attributes ? stringifyObjectValues(attributes) : void 0;
+    const [pairs, , diff] = this.tree.style([fromPos, toPos], attrs, ticket);
+    this.context.acc(diff);
+    for (const pair of pairs) {
+      this.context.registerGCPair(pair);
+    }
+    this.context.push(
+      TreeStyleOperation.create(
+        this.tree.getCreatedAt(),
+        fromPos,
+        toPos,
+        attrs ? new Map(Object.entries(attrs)) : /* @__PURE__ */ new Map(),
+        ticket
+      )
+    );
+  }
+  /**
+   * `style` sets the attributes to the elements of the given range.
+   */
+  style(fromIdx, toIdx, attributes) {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    if (fromIdx > toIdx) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "from should be less than or equal to to"
+      );
+    }
+    const fromPos = this.tree.findPos(fromIdx);
+    const toPos = this.tree.findPos(toIdx);
+    const ticket = this.context.issueTimeTicket();
+    const attrs = attributes ? stringifyObjectValues(attributes) : void 0;
+    const [pairs, , diff] = this.tree.style([fromPos, toPos], attrs, ticket);
+    this.context.acc(diff);
+    for (const pair of pairs) {
+      this.context.registerGCPair(pair);
+    }
+    this.context.push(
+      TreeStyleOperation.create(
+        this.tree.getCreatedAt(),
+        fromPos,
+        toPos,
+        attrs ? new Map(Object.entries(attrs)) : /* @__PURE__ */ new Map(),
+        ticket
+      )
+    );
+  }
+  /**
+   * `removeStyle` removes the attributes to the elements of the given range.
+   */
+  removeStyle(fromIdx, toIdx, attributesToRemove) {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    if (fromIdx > toIdx) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "from should be less than or equal to to"
+      );
+    }
+    const fromPos = this.tree.findPos(fromIdx);
+    const toPos = this.tree.findPos(toIdx);
+    const ticket = this.context.issueTimeTicket();
+    const [pairs, , diff] = this.tree.removeStyle(
+      [fromPos, toPos],
+      attributesToRemove,
+      ticket
+    );
+    this.context.acc(diff);
+    for (const pair of pairs) {
+      this.context.registerGCPair(pair);
+    }
+    this.context.push(
+      TreeStyleOperation.createTreeRemoveStyleOperation(
+        this.tree.getCreatedAt(),
+        fromPos,
+        toPos,
+        attributesToRemove,
+        ticket
+      )
+    );
+  }
+  editInternal(fromPos, toPos, contents, splitLevel = 0) {
+    var _a2;
+    if (contents.length !== 0 && contents[0]) {
+      validateTreeNodes(contents);
+      if (contents[0].type !== DefaultTextType) {
+        for (const content of contents) {
+          const { children = [] } = content;
+          validateTreeNodes(children);
+        }
+      }
+    }
+    const ticket = this.context.getLastTimeTicket();
+    let crdtNodes = new Array();
+    if (((_a2 = contents[0]) == null ? void 0 : _a2.type) === DefaultTextType) {
+      let compVal = "";
+      for (const content of contents) {
+        const { value } = content;
+        compVal += value;
+      }
+      crdtNodes.push(
+        CRDTTreeNode.create(
+          CRDTTreeNodeID.of(this.context.issueTimeTicket(), 0),
+          DefaultTextType,
+          compVal
+        )
       );
+    } else {
+      crdtNodes = contents.map((content) => content && createCRDTTreeNode(this.context, content)).filter((a) => a);
     }
-    const root = CRDTTreeNode.create(
-      CRDTTreeNodeID.of(context.issueTimeTicket(), 0),
-      this.initialRoot.type
+    const [, pairs, diff] = this.tree.edit(
+      [fromPos, toPos],
+      crdtNodes.length ? crdtNodes.map((crdtNode) => crdtNode == null ? void 0 : crdtNode.deepcopy()) : void 0,
+      splitLevel,
+      ticket,
+      () => this.context.issueTimeTicket()
     );
-    for (const child of this.initialRoot.children) {
-      buildDescendants(child, root, context);
+    this.context.acc(diff);
+    for (const pair of pairs) {
+      this.context.registerGCPair(pair);
     }
-    return root;
+    this.context.push(
+      TreeEditOperation.create(
+        this.tree.getCreatedAt(),
+        fromPos,
+        toPos,
+        crdtNodes.length ? crdtNodes : void 0,
+        splitLevel,
+        ticket
+      )
+    );
+    return true;
   }
   /**
-   * `getSize` returns the size of this tree.
+   * `editByPath` edits this tree with the given node and path.
    */
-  getSize() {
+  editByPath(fromPath, toPath, content, splitLevel = 0) {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    return this.tree.getSize();
+    if (fromPath.length !== toPath.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "path length should be equal"
+      );
+    }
+    if (!fromPath.length || !toPath.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "path should not be empty"
+      );
+    }
+    const fromPos = this.tree.pathToPos(fromPath);
+    const toPos = this.tree.pathToPos(toPath);
+    return this.editInternal(
+      fromPos,
+      toPos,
+      content ? [content] : [],
+      splitLevel
+    );
   }
   /**
-   * `getNodeSize` returns the node size of this tree.
+   * `editBulkByPath` edits this tree with the given node and path.
    */
-  getNodeSize() {
+  editBulkByPath(fromPath, toPath, contents, splitLevel = 0) {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    return this.tree.getNodeSize();
+    if (fromPath.length !== toPath.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "path length should be equal"
+      );
+    }
+    if (!fromPath.length || !toPath.length) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "path should not be empty"
+      );
+    }
+    const fromPos = this.tree.pathToPos(fromPath);
+    const toPos = this.tree.pathToPos(toPath);
+    return this.editInternal(fromPos, toPos, contents, splitLevel);
   }
   /**
-   * `getIndexTree` returns the index tree of this tree.
+   * `edit` edits this tree with the given nodes.
    */
-  getIndexTree() {
+  edit(fromIdx, toIdx, content, splitLevel = 0) {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    return this.tree.getIndexTree();
+    if (fromIdx > toIdx) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "from should be less than or equal to to"
+      );
+    }
+    const fromPos = this.tree.findPos(fromIdx);
+    const toPos = this.tree.findPos(toIdx);
+    return this.editInternal(
+      fromPos,
+      toPos,
+      content ? [content] : [],
+      splitLevel
+    );
   }
   /**
-   * `splitByPath` splits the tree by the given path.
+   * `editBulk` edits this tree with the given nodes.
    */
-  splitByPath(path) {
+  editBulk(fromIdx, toIdx, contents, splitLevel = 0) {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    if (!path.length) {
+    if (fromIdx > toIdx) {
       throw new YorkieError(
         Code.ErrInvalidArgument,
-        "path should not be empty"
+        "from should be less than or equal to to"
       );
     }
-    const treePos = this.tree.pathToTreePos(path);
-    const commands = separateSplit(treePos, path);
-    for (const command of commands) {
-      const { fromPath, toPath, content } = command;
-      const fromPos = this.tree.pathToPos(fromPath);
-      const toPos = this.tree.pathToPos(toPath);
-      this.editInternal(fromPos, toPos, content ? [content] : [], 0);
-    }
+    const fromPos = this.tree.findPos(fromIdx);
+    const toPos = this.tree.findPos(toIdx);
+    return this.editInternal(fromPos, toPos, contents, splitLevel);
   }
   /**
-   * `mergeByPath` merges the tree by the given path.
+   * `toXML` returns the XML string of this tree.
    */
-  mergeByPath(path) {
+  toXML() {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    if (!path.length) {
+    return this.tree.toXML();
+  }
+  /**
+   * `toJSON` returns the JSON string of this tree.
+   */
+  toJSON() {
+    if (!this.context || !this.tree) {
       throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "path should not be empty"
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
       );
     }
-    const treePos = this.tree.pathToTreePos(path);
-    if (treePos.node.isText) {
+    return this.tree.toJSON();
+  }
+  /**
+   * `toJSForTest` returns value with meta data for testing.
+   */
+  toJSForTest() {
+    if (!this.context || !this.tree) {
       throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "text node cannot be merged"
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
       );
     }
-    const commands = separateMerge(treePos, path);
-    for (const command of commands) {
-      const { fromPath, toPath, content } = command;
-      const fromPos = this.tree.pathToPos(fromPath);
-      const toPos = this.tree.pathToPos(toPath);
-      this.editInternal(fromPos, toPos, content ?? [], 0);
-    }
+    return this.tree.toJSForTest();
   }
   /**
-   * `styleByPath` sets the attributes to the elements of the given path.
+   * `toJSInfoForTest` returns detailed TreeNode information for use in Devtools.
    */
-  styleByPath(path, attributes) {
+  toJSInfoForTest() {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    if (!path.length) {
+    return this.tree.toJSInfoForTest();
+  }
+  /**
+   * `getRootTreeNode` returns TreeNode of this tree.
+   */
+  getRootTreeNode() {
+    if (!this.context || !this.tree) {
       throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "path should not be empty"
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
       );
     }
-    const [fromPos, toPos] = this.tree.pathToPosRange(path);
-    const ticket = this.context.issueTimeTicket();
-    const attrs = attributes ? stringifyObjectValues(attributes) : void 0;
-    const [pairs, , diff] = this.tree.style([fromPos, toPos], attrs, ticket);
-    this.context.acc(diff);
-    for (const pair of pairs) {
-      this.context.registerGCPair(pair);
-    }
-    this.context.push(
-      TreeStyleOperation.create(
-        this.tree.getCreatedAt(),
-        fromPos,
-        toPos,
-        attrs ? new Map(Object.entries(attrs)) : /* @__PURE__ */ new Map(),
-        ticket
-      )
-    );
+    return this.tree.getRootTreeNode();
   }
   /**
-   * `style` sets the attributes to the elements of the given range.
+   * `indexToPath` returns the path of the given index.
    */
-  style(fromIdx, toIdx, attributes) {
+  indexToPath(index) {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    if (fromIdx > toIdx) {
+    return this.tree.indexToPath(index);
+  }
+  /**
+   * `pathToIndex` returns the index of given path.
+   */
+  pathToIndex(path) {
+    if (!this.context || !this.tree) {
       throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "from should be less than or equal to to"
-      );
-    }
-    const fromPos = this.tree.findPos(fromIdx);
-    const toPos = this.tree.findPos(toIdx);
-    const ticket = this.context.issueTimeTicket();
-    const attrs = attributes ? stringifyObjectValues(attributes) : void 0;
-    const [pairs, , diff] = this.tree.style([fromPos, toPos], attrs, ticket);
-    this.context.acc(diff);
-    for (const pair of pairs) {
-      this.context.registerGCPair(pair);
-    }
-    this.context.push(
-      TreeStyleOperation.create(
-        this.tree.getCreatedAt(),
-        fromPos,
-        toPos,
-        attrs ? new Map(Object.entries(attrs)) : /* @__PURE__ */ new Map(),
-        ticket
-      )
-    );
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
+      );
+    }
+    return this.tree.pathToIndex(path);
   }
   /**
-   * `removeStyle` removes the attributes to the elements of the given range.
+   * `pathRangeToPosRange` converts the path range into the position range.
    */
-  removeStyle(fromIdx, toIdx, attributesToRemove) {
+  pathRangeToPosRange(range) {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    if (fromIdx > toIdx) {
+    const indexRange = [
+      this.tree.pathToIndex(range[0]),
+      this.tree.pathToIndex(range[1])
+    ];
+    const posRange = this.tree.indexRangeToPosRange(indexRange);
+    return [posRange[0].toStruct(), posRange[1].toStruct()];
+  }
+  /**
+   * `indexRangeToPosRange` converts the index range into the position range.
+   */
+  indexRangeToPosRange(range) {
+    if (!this.context || !this.tree) {
       throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "from should be less than or equal to to"
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
       );
     }
-    const fromPos = this.tree.findPos(fromIdx);
-    const toPos = this.tree.findPos(toIdx);
-    const ticket = this.context.issueTimeTicket();
-    const [pairs, , diff] = this.tree.removeStyle(
-      [fromPos, toPos],
-      attributesToRemove,
-      ticket
-    );
-    this.context.acc(diff);
-    for (const pair of pairs) {
-      this.context.registerGCPair(pair);
-    }
-    this.context.push(
-      TreeStyleOperation.createTreeRemoveStyleOperation(
-        this.tree.getCreatedAt(),
-        fromPos,
-        toPos,
-        attributesToRemove,
-        ticket
-      )
-    );
+    return this.tree.indexRangeToPosStructRange(range);
   }
-  editInternal(fromPos, toPos, contents, splitLevel = 0) {
-    var _a2;
-    if (contents.length !== 0 && contents[0]) {
-      validateTreeNodes(contents);
-      if (contents[0].type !== DefaultTextType) {
-        for (const content of contents) {
-          const { children = [] } = content;
-          validateTreeNodes(children);
-        }
-      }
-    }
-    const ticket = this.context.getLastTimeTicket();
-    let crdtNodes = new Array();
-    if (((_a2 = contents[0]) == null ? void 0 : _a2.type) === DefaultTextType) {
-      let compVal = "";
-      for (const content of contents) {
-        const { value } = content;
-        compVal += value;
-      }
-      crdtNodes.push(
-        CRDTTreeNode.create(
-          CRDTTreeNodeID.of(this.context.issueTimeTicket(), 0),
-          DefaultTextType,
-          compVal
-        )
+  /**
+   * `posRangeToIndexRange` converts the position range into the index range.
+   */
+  posRangeToIndexRange(range) {
+    if (!this.context || !this.tree) {
+      throw new YorkieError(
+        Code.ErrNotInitialized,
+        "Tree is not initialized yet"
       );
-    } else {
-      crdtNodes = contents.map((content) => content && createCRDTTreeNode(this.context, content)).filter((a) => a);
-    }
-    const [, pairs, diff] = this.tree.edit(
-      [fromPos, toPos],
-      crdtNodes.length ? crdtNodes.map((crdtNode) => crdtNode == null ? void 0 : crdtNode.deepcopy()) : void 0,
-      splitLevel,
-      ticket,
-      () => this.context.issueTimeTicket()
-    );
-    this.context.acc(diff);
-    for (const pair of pairs) {
-      this.context.registerGCPair(pair);
     }
-    this.context.push(
-      TreeEditOperation.create(
-        this.tree.getCreatedAt(),
-        fromPos,
-        toPos,
-        crdtNodes.length ? crdtNodes : void 0,
-        splitLevel,
-        ticket
-      )
-    );
-    return true;
+    const posRange = [
+      CRDTTreePos.fromStruct(range[0]),
+      CRDTTreePos.fromStruct(range[1])
+    ];
+    return this.tree.posRangeToIndexRange(posRange);
   }
   /**
-   * `editByPath` edits this tree with the given node and path.
+   * `posRangeToPathRange` converts the position range into the path range.
    */
-  editByPath(fromPath, toPath, content, splitLevel = 0) {
+  posRangeToPathRange(range) {
     if (!this.context || !this.tree) {
       throw new YorkieError(
         Code.ErrNotInitialized,
         "Tree is not initialized yet"
       );
     }
-    if (fromPath.length !== toPath.length) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "path length should be equal"
+    const posRange = [
+      CRDTTreePos.fromStruct(range[0]),
+      CRDTTreePos.fromStruct(range[1])
+    ];
+    return this.tree.posRangeToPathRange(posRange);
+  }
+}
+function createJSON(context, target) {
+  return createJSONObject(context, target);
+}
+function toWrappedElement(context, elem) {
+  if (!elem) {
+    return;
+  } else if (elem instanceof Primitive) {
+    return elem;
+  } else if (elem instanceof CRDTObject) {
+    return createJSONObject(context, elem);
+  } else if (elem instanceof CRDTArray) {
+    return createJSONArray(context, elem);
+  } else if (elem instanceof CRDTText) {
+    return new Text(context, elem);
+  } else if (elem instanceof CRDTCounter) {
+    const counter = new Counter(CounterType.Int, 0);
+    counter.initialize(context, elem);
+    return counter;
+  } else if (elem instanceof CRDTTree) {
+    const tree = new Tree();
+    tree.initialize(context, elem);
+    return tree;
+  }
+  throw new TypeError(`Unsupported type of element: ${typeof elem}`);
+}
+function toJSONElement(context, elem) {
+  const wrappedElement = toWrappedElement(context, elem);
+  if (wrappedElement instanceof Primitive) {
+    return wrappedElement.getValue();
+  }
+  return wrappedElement;
+}
+function buildCRDTElement(context, value, createdAt) {
+  let element;
+  if (Primitive.isSupport(value)) {
+    element = Primitive.of(value, createdAt);
+  } else if (Array.isArray(value)) {
+    element = CRDTArray.create(
+      createdAt,
+      ArrayProxy.buildArrayElements(context, value)
+    );
+  } else if (typeof value === "object") {
+    if (value instanceof Text) {
+      element = CRDTText.create(RGATreeSplit.create(), createdAt);
+      value.initialize(context, element);
+    } else if (value instanceof Counter) {
+      element = CRDTCounter.create(
+        value.getValueType(),
+        value.getValue(),
+        createdAt
       );
-    }
-    if (!fromPath.length || !toPath.length) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "path should not be empty"
+      value.initialize(context, element);
+    } else if (value instanceof Tree) {
+      element = CRDTTree.create(value.buildRoot(context), createdAt);
+      value.initialize(context, element);
+    } else {
+      element = CRDTObject.create(
+        createdAt,
+        ObjectProxy.buildObjectMembers(context, value)
       );
     }
-    const fromPos = this.tree.pathToPos(fromPath);
-    const toPos = this.tree.pathToPos(toPath);
-    return this.editInternal(
-      fromPos,
-      toPos,
-      content ? [content] : [],
-      splitLevel
-    );
+  } else {
+    throw new TypeError(`Unsupported type of value: ${typeof value}`);
+  }
+  return element;
+}
+class CRDTRoot {
+  constructor(rootObject) {
+    /**
+     * `rootObject` is the root object of the document.
+     */
+    __publicField(this, "rootObject");
+    /**
+     * `elementPairMapByCreatedAt` is a hash table that maps the creation time of
+     * an element to the element itself and its parent.
+     */
+    __publicField(this, "elementPairMapByCreatedAt");
+    /**
+     * `gcElementSetByCreatedAt` is a hash set that contains the creation
+     * time of the removed element. It is used to find the removed element when
+     * executing garbage collection.
+     */
+    __publicField(this, "gcElementSetByCreatedAt");
+    /**
+     * `gcPairMap` is a hash table that maps the IDString of GCChild to the
+     * element itself and its parent.
+     */
+    __publicField(this, "gcPairMap");
+    /**
+     * `docSize` is a structure that represents the size of the document.
+     */
+    __publicField(this, "docSize");
+    this.rootObject = rootObject;
+    this.elementPairMapByCreatedAt = /* @__PURE__ */ new Map();
+    this.gcElementSetByCreatedAt = /* @__PURE__ */ new Set();
+    this.gcPairMap = /* @__PURE__ */ new Map();
+    this.docSize = { live: { data: 0, meta: 0 }, gc: { data: 0, meta: 0 } };
+    this.registerElement(rootObject, void 0);
+    rootObject.getDescendants((elem) => {
+      if (elem.getRemovedAt()) {
+        this.registerRemovedElement(elem);
+      }
+      if (elem instanceof CRDTText || elem instanceof CRDTTree) {
+        for (const pair of elem.getGCPairs()) {
+          this.registerGCPair(pair);
+        }
+      }
+      return false;
+    });
+  }
+  /**
+   * `create` creates a new instance of Root.
+   */
+  static create() {
+    return new CRDTRoot(CRDTObject.create(InitialTimeTicket));
+  }
+  /**
+   * `findByCreatedAt` returns the element of given creation time.
+   */
+  findByCreatedAt(createdAt) {
+    const pair = this.elementPairMapByCreatedAt.get(createdAt.toIDString());
+    if (!pair) {
+      return;
+    }
+    return pair.element;
   }
   /**
-   * `editBulkByPath` edits this tree with the given node and path.
+   * `findElementPairByCreatedAt` returns the element and parent pair
+   * of given creation time.
    */
-  editBulkByPath(fromPath, toPath, contents, splitLevel = 0) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    if (fromPath.length !== toPath.length) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "path length should be equal"
-      );
+  findElementPairByCreatedAt(createdAt) {
+    return this.elementPairMapByCreatedAt.get(createdAt.toIDString());
+  }
+  /**
+   * `createSubPaths` creates an array of the sub paths for the given element.
+   */
+  createSubPaths(createdAt) {
+    let pair = this.elementPairMapByCreatedAt.get(createdAt.toIDString());
+    if (!pair) {
+      return [];
     }
-    if (!fromPath.length || !toPath.length) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "path should not be empty"
+    const subPaths = [];
+    while (pair.parent) {
+      const createdAt2 = pair.element.getCreatedAt();
+      const subPath = pair.parent.subPathOf(createdAt2);
+      if (subPath === void 0) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `cant find the given element: ${createdAt2.toIDString()}`
+        );
+      }
+      subPaths.unshift(subPath);
+      pair = this.elementPairMapByCreatedAt.get(
+        pair.parent.getCreatedAt().toIDString()
       );
     }
-    const fromPos = this.tree.pathToPos(fromPath);
-    const toPos = this.tree.pathToPos(toPath);
-    return this.editInternal(fromPos, toPos, contents, splitLevel);
+    subPaths.unshift("$");
+    return subPaths;
   }
   /**
-   * `edit` edits this tree with the given nodes.
+   * `createPath` creates path of the given element.
    */
-  edit(fromIdx, toIdx, content, splitLevel = 0) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
+  createPath(createdAt) {
+    return this.createSubPaths(createdAt).join(".");
+  }
+  /**
+   * `registerElement` registers the given element and its descendants to hash table.
+   */
+  registerElement(element, parent) {
+    this.elementPairMapByCreatedAt.set(element.getCreatedAt().toIDString(), {
+      parent,
+      element
+    });
+    addDataSizes(this.docSize.live, element.getDataSize());
+    if (element instanceof CRDTContainer) {
+      element.getDescendants((elem, par) => {
+        this.elementPairMapByCreatedAt.set(elem.getCreatedAt().toIDString(), {
+          parent: par,
+          element: elem
+        });
+        addDataSizes(this.docSize.live, elem.getDataSize());
+        return false;
+      });
     }
-    if (fromIdx > toIdx) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "from should be less than or equal to to"
-      );
+  }
+  /**
+   * `deregisterElement` deregister the given element and its descendants from hash table.
+   */
+  deregisterElement(element) {
+    let count = 0;
+    const deregisterElementInternal = (elem) => {
+      const createdAt = elem.getCreatedAt().toIDString();
+      subDataSize(this.docSize.gc, elem.getDataSize());
+      this.elementPairMapByCreatedAt.delete(createdAt);
+      this.gcElementSetByCreatedAt.delete(createdAt);
+      count++;
+    };
+    deregisterElementInternal(element);
+    if (element instanceof CRDTContainer) {
+      element.getDescendants((e) => {
+        deregisterElementInternal(e);
+        return false;
+      });
     }
-    const fromPos = this.tree.findPos(fromIdx);
-    const toPos = this.tree.findPos(toIdx);
-    return this.editInternal(
-      fromPos,
-      toPos,
-      content ? [content] : [],
-      splitLevel
-    );
+    return count;
   }
   /**
-   * `editBulk` edits this tree with the given nodes.
+   * `registerRemovedElement` registers the given element to the hash set.
    */
-  editBulk(fromIdx, toIdx, contents, splitLevel = 0) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
+  registerRemovedElement(element) {
+    addDataSizes(this.docSize.gc, element.getDataSize());
+    subDataSize(this.docSize.live, element.getDataSize());
+    this.docSize.live.meta += TimeTicketSize;
+    this.gcElementSetByCreatedAt.add(element.getCreatedAt().toIDString());
+  }
+  /**
+   * `registerGCPair` registers the given pair to hash table.
+   */
+  registerGCPair(pair) {
+    const prev = this.gcPairMap.get(pair.child.toIDString());
+    if (prev) {
+      this.gcPairMap.delete(pair.child.toIDString());
+      return;
     }
-    if (fromIdx > toIdx) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        "from should be less than or equal to to"
-      );
+    this.gcPairMap.set(pair.child.toIDString(), pair);
+    const size = this.gcPairMap.get(pair.child.toIDString()).child.getDataSize();
+    addDataSizes(this.docSize.gc, size);
+    subDataSize(this.docSize.live, size);
+    if (!(pair.child instanceof RHTNode)) {
+      this.docSize.live.meta += TimeTicketSize;
     }
-    const fromPos = this.tree.findPos(fromIdx);
-    const toPos = this.tree.findPos(toIdx);
-    return this.editInternal(fromPos, toPos, contents, splitLevel);
   }
   /**
-   * `toXML` returns the XML string of this tree.
+   * `getElementMapSize` returns the size of element map.
    */
-  toXML() {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    return this.tree.toXML();
+  getElementMapSize() {
+    return this.elementPairMapByCreatedAt.size;
   }
   /**
-   * `toJSON` returns the JSON string of this tree.
+   * `getGarbageElementSetSize()` returns the size of removed element set.
    */
-  toJSON() {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
+  getGarbageElementSetSize() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const createdAt of this.gcElementSetByCreatedAt) {
+      seen.add(createdAt);
+      const pair = this.elementPairMapByCreatedAt.get(createdAt);
+      if (pair.element instanceof CRDTContainer) {
+        pair.element.getDescendants((el) => {
+          seen.add(el.getCreatedAt().toIDString());
+          return false;
+        });
+      }
     }
-    return this.tree.toJSON();
+    return seen.size;
   }
   /**
-   * `toJSForTest` returns value with meta data for testing.
-   * @internal
+   * `getObject` returns root object.
    */
-  toJSForTest() {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    return this.tree.toJSForTest();
+  getObject() {
+    return this.rootObject;
   }
   /**
-   * `toJSInfoForTest` returns detailed TreeNode information for use in Devtools.
-   *
-   * @internal
+   * `getGarbageLen` returns length of nodes which can be garbage collected.
    */
-  toJSInfoForTest() {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    return this.tree.toJSInfoForTest();
+  getGarbageLen() {
+    return this.getGarbageElementSetSize() + this.gcPairMap.size;
   }
   /**
-   * `getRootTreeNode` returns TreeNode of this tree.
+   * `getDocSize` returns the size of the document.
    */
-  getRootTreeNode() {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    return this.tree.getRootTreeNode();
+  getDocSize() {
+    return this.docSize;
   }
   /**
-   * `indexToPath` returns the path of the given index.
+   * `deepcopy` copies itself deeply.
    */
-  indexToPath(index) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    return this.tree.indexToPath(index);
+  deepcopy() {
+    return new CRDTRoot(this.rootObject.deepcopy());
   }
   /**
-   * `pathToIndex` returns the index of given path.
+   * `garbageCollect` purges elements that were removed before the given time.
    */
-  pathToIndex(path) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
+  garbageCollect(minSyncedVersionVector) {
+    let count = 0;
+    for (const createdAt of this.gcElementSetByCreatedAt) {
+      const pair = this.elementPairMapByCreatedAt.get(createdAt);
+      const removedAt = pair.element.getRemovedAt();
+      if (removedAt && (minSyncedVersionVector == null ? void 0 : minSyncedVersionVector.afterOrEqual(removedAt))) {
+        pair.parent.purge(pair.element);
+        count += this.deregisterElement(pair.element);
+      }
+    }
+    for (const [, pair] of this.gcPairMap) {
+      const removedAt = pair.child.getRemovedAt();
+      if (removedAt && (minSyncedVersionVector == null ? void 0 : minSyncedVersionVector.afterOrEqual(removedAt))) {
+        pair.parent.purge(pair.child);
+        subDataSize(this.docSize.gc, pair.child.getDataSize());
+        this.gcPairMap.delete(pair.child.toIDString());
+        count += 1;
+      }
     }
-    return this.tree.pathToIndex(path);
+    return count;
   }
   /**
-   * `pathRangeToPosRange` converts the path range into the position range.
+   * `toJSON` returns the JSON encoding of this root object.
    */
-  pathRangeToPosRange(range) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    const indexRange = [
-      this.tree.pathToIndex(range[0]),
-      this.tree.pathToIndex(range[1])
-    ];
-    const posRange = this.tree.indexRangeToPosRange(indexRange);
-    return [posRange[0].toStruct(), posRange[1].toStruct()];
+  toJSON() {
+    return this.rootObject.toJSON();
   }
   /**
-   * `indexRangeToPosRange` converts the index range into the position range.
+   * `toSortedJSON` returns the sorted JSON encoding of this root object.
    */
-  indexRangeToPosRange(range) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    return this.tree.indexRangeToPosStructRange(range);
+  toSortedJSON() {
+    return this.rootObject.toSortedJSON();
   }
   /**
-   * `posRangeToIndexRange` converts the position range into the index range.
+   * `getStats` returns the current statistics of the root object.
+   * This includes counts of various types of elements and structural information.
    */
-  posRangeToIndexRange(range) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    const posRange = [
-      CRDTTreePos.fromStruct(range[0]),
-      CRDTTreePos.fromStruct(range[1])
-    ];
-    return this.tree.posRangeToIndexRange(posRange);
+  getStats() {
+    return {
+      elements: this.getElementMapSize(),
+      gcPairs: this.gcPairMap.size,
+      gcElements: this.getGarbageElementSetSize()
+    };
   }
   /**
-   * `posRangeToPathRange` converts the position range into the path range.
+   * `acc` accumulates the given DataSize to Live.
    */
-  posRangeToPathRange(range) {
-    if (!this.context || !this.tree) {
-      throw new YorkieError(
-        Code.ErrNotInitialized,
-        "Tree is not initialized yet"
-      );
-    }
-    const posRange = [
-      CRDTTreePos.fromStruct(range[0]),
-      CRDTTreePos.fromStruct(range[1])
-    ];
-    return this.tree.posRangeToPathRange(posRange);
-  }
-}
-function createJSON(context, target) {
-  return createJSONObject(context, target);
-}
-function toWrappedElement(context, elem) {
-  if (!elem) {
-    return;
-  } else if (elem instanceof Primitive) {
-    return elem;
-  } else if (elem instanceof CRDTObject) {
-    return createJSONObject(context, elem);
-  } else if (elem instanceof CRDTArray) {
-    return createJSONArray(context, elem);
-  } else if (elem instanceof CRDTText) {
-    return new Text(context, elem);
-  } else if (elem instanceof CRDTCounter) {
-    const counter = new Counter(CounterType.Int, 0);
-    counter.initialize(context, elem);
-    return counter;
-  } else if (elem instanceof CRDTTree) {
-    const tree = new Tree();
-    tree.initialize(context, elem);
-    return tree;
-  }
-  throw new TypeError(`Unsupported type of element: ${typeof elem}`);
-}
-function toJSONElement(context, elem) {
-  const wrappedElement = toWrappedElement(context, elem);
-  if (wrappedElement instanceof Primitive) {
-    return wrappedElement.getValue();
-  }
-  return wrappedElement;
-}
-function buildCRDTElement(context, value, createdAt) {
-  let element;
-  if (Primitive.isSupport(value)) {
-    element = Primitive.of(value, createdAt);
-  } else if (Array.isArray(value)) {
-    element = CRDTArray.create(
-      createdAt,
-      ArrayProxy.buildArrayElements(context, value)
-    );
-  } else if (typeof value === "object") {
-    if (value instanceof Text) {
-      element = CRDTText.create(RGATreeSplit.create(), createdAt);
-      value.initialize(context, element);
-    } else if (value instanceof Counter) {
-      element = CRDTCounter.create(
-        value.getValueType(),
-        value.getValue(),
-        createdAt
-      );
-      value.initialize(context, element);
-    } else if (value instanceof Tree) {
-      element = CRDTTree.create(value.buildRoot(context), createdAt);
-      value.initialize(context, element);
-    } else {
-      element = CRDTObject.create(
-        createdAt,
-        ObjectProxy.buildObjectMembers(context, value)
-      );
-    }
-  } else {
-    throw new TypeError(`Unsupported type of value: ${typeof value}`);
+  acc(diff) {
+    addDataSizes(this.docSize.live, diff);
   }
-  return element;
 }
 class Presence {
   constructor(changeContext, presence) {
@@ -20168,7 +19997,6 @@ class Presence {
   }
   /**
    * `clear` clears the presence.
-   * @internal
    */
   clear() {
     this.presence = {};
@@ -20270,6 +20098,156 @@ class History {
     replace(this.redoStack);
   }
 }
+function validateYorkieRuleset(data, ruleset) {
+  const errors = [];
+  for (const rule of ruleset) {
+    const value = getValueByPath(data, rule.path);
+    const result = validateValue(value, rule);
+    if (!result.valid) {
+      for (const error of result.errors || []) {
+        errors.push(error);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function getValueByPath(obj, path) {
+  if (!path.startsWith("$")) {
+    throw new Error(`Path must start with $, got ${path}`);
+  }
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 1; i < keys.length; i++) {
+    const key = keys[i];
+    if (!(current instanceof CRDTObject)) {
+      return void 0;
+    }
+    current = current.get(key);
+  }
+  return current;
+}
+function validateValue(value, rule) {
+  switch (rule.type) {
+    case "string":
+    case "boolean":
+    case "integer":
+    case "double":
+    case "long":
+    case "date":
+    case "bytes":
+    case "null":
+      return validatePrimitiveValue(value, rule);
+    case "object":
+      if (!(value instanceof CRDTObject)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `expected object at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "array":
+      if (!(value instanceof CRDTArray)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `expected array at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "yorkie.Text":
+      if (!(value instanceof CRDTText)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `expected yorkie.Text at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "yorkie.Tree":
+      if (!(value instanceof CRDTTree)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `expected yorkie.Tree at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "yorkie.Counter":
+      if (!(value instanceof CRDTCounter)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `expected yorkie.Counter at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    default:
+      throw new Error(`Unknown rule type: ${rule.type}`);
+  }
+  return {
+    valid: true
+  };
+}
+function getPrimitiveType(type) {
+  switch (type) {
+    case "null":
+      return PrimitiveType.Null;
+    case "boolean":
+      return PrimitiveType.Boolean;
+    case "integer":
+      return PrimitiveType.Integer;
+    case "long":
+      return PrimitiveType.Long;
+    case "double":
+      return PrimitiveType.Double;
+    case "string":
+      return PrimitiveType.String;
+    case "bytes":
+      return PrimitiveType.Bytes;
+    case "date":
+      return PrimitiveType.Date;
+    default:
+      throw new Error(`Unknown primitive type: ${type}`);
+  }
+}
+function validatePrimitiveValue(value, rule) {
+  if (value instanceof Primitive && value.getType() === getPrimitiveType(rule.type)) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    errors: [
+      {
+        path: rule.path,
+        message: `expected ${rule.type} at path ${rule.path}`
+      }
+    ]
+  };
+}
 const EventSourceDevPanel = "yorkie-devtools-panel";
 const EventSourceSDK = "yorkie-devtools-sdk";
 function isDocEventForReplay(event) {
@@ -20405,57 +20383,44 @@ class Document {
     __publicField(this, "key");
     __publicField(this, "status");
     __publicField(this, "opts");
+    __publicField(this, "maxSizeLimit");
+    __publicField(this, "schemaRules");
     __publicField(this, "changeID");
     __publicField(this, "checkpoint");
     __publicField(this, "localChanges");
-    __publicField(this, "maxSizeLimit");
-    __publicField(this, "schemaRules");
     __publicField(this, "root");
+    __publicField(this, "presences");
     __publicField(this, "clone");
+    __publicField(this, "internalHistory");
+    __publicField(this, "isUpdating");
+    __publicField(this, "onlineClients");
     __publicField(this, "eventStream");
     __publicField(this, "eventStreamObserver");
-    /**
-     * `onlineClients` is a set of client IDs that are currently online.
-     */
-    __publicField(this, "onlineClients");
-    /**
-     * `presences` is a map of client IDs to their presence information.
-     */
-    __publicField(this, "presences");
     /**
      * `history` is exposed to the user to manage undo/redo operations.
      */
     __publicField(this, "history");
-    /**
-     * `internalHistory` is used to manage undo/redo operations internally.
-     */
-    __publicField(this, "internalHistory");
-    /**
-     * `isUpdating` is whether the document is updating by updater or not. It is
-     * used to prevent the updater from calling undo/redo.
-     */
-    __publicField(this, "isUpdating");
-    this.opts = opts || {};
     this.key = key;
     this.status = "detached";
-    this.root = CRDTRoot.create();
+    this.opts = opts || {};
+    this.maxSizeLimit = 0;
+    this.schemaRules = [];
     this.changeID = InitialChangeID;
     this.checkpoint = InitialCheckpoint;
     this.localChanges = [];
-    this.maxSizeLimit = 0;
-    this.schemaRules = [];
-    this.eventStream = createObservable((observer) => {
-      this.eventStreamObserver = observer;
-    });
-    this.onlineClients = /* @__PURE__ */ new Set();
+    this.root = CRDTRoot.create();
     this.presences = /* @__PURE__ */ new Map();
-    this.isUpdating = false;
+    this.onlineClients = /* @__PURE__ */ new Set();
     this.internalHistory = new History();
+    this.isUpdating = false;
+    this.eventStream = createObservable(
+      (observer) => this.eventStreamObserver = observer
+    );
     this.history = {
-      canUndo: this.canUndo.bind(this),
-      canRedo: this.canRedo.bind(this),
-      undo: this.undo.bind(this),
-      redo: this.redo.bind(this)
+      canUndo: () => this.internalHistory.hasUndo() && !this.isUpdating,
+      canRedo: () => this.internalHistory.hasRedo() && !this.isUpdating,
+      undo: () => this.executeUndoRedo(true),
+      redo: () => this.executeUndoRedo(false)
     };
     setupDevtools(this);
   }
@@ -20469,7 +20434,7 @@ class Document {
     }
     this.ensureClone();
     const actorID = this.changeID.getActorID();
-    const context = ChangeContext.create(
+    const ctx = ChangeContext.create(
       this.changeID,
       this.clone.root,
       this.clone.presences.get(actorID) || {},
@@ -20477,29 +20442,23 @@ class Document {
     );
     try {
       const proxy = createJSON(
-        context,
+        ctx,
         this.clone.root.getObject()
       );
       if (!this.presences.has(actorID)) {
         this.clone.presences.set(actorID, {});
       }
       this.isUpdating = true;
-      updater(
-        proxy,
-        new Presence(context, this.clone.presences.get(actorID))
-      );
+      updater(proxy, new Presence(ctx, this.clone.presences.get(actorID)));
     } catch (err) {
       this.clone = void 0;
       throw err;
     } finally {
       this.isUpdating = false;
     }
-    const schemaRules = this.getSchemaRules();
-    if (!context.isPresenceOnlyChange() && schemaRules.length > 0) {
-      const result = validateYorkieRuleset(
-        (_a2 = this.clone) == null ? void 0 : _a2.root.getObject(),
-        schemaRules
-      );
+    const rules = this.getSchemaRules();
+    if (!ctx.isPresenceOnlyChange() && rules.length) {
+      const result = validateYorkieRuleset((_a2 = this.clone) == null ? void 0 : _a2.root.getObject(), rules);
       if (!result.valid) {
         this.clone = void 0;
         throw new YorkieError(
@@ -20509,18 +20468,18 @@ class Document {
       }
     }
     const size = totalDocSize((_c2 = this.clone) == null ? void 0 : _c2.root.getDocSize());
-    if (!context.isPresenceOnlyChange() && this.maxSizeLimit > 0 && this.maxSizeLimit < size) {
+    if (!ctx.isPresenceOnlyChange() && this.maxSizeLimit > 0 && this.maxSizeLimit < size) {
       this.clone = void 0;
       throw new YorkieError(
         Code.ErrDocumentSizeExceedsLimit,
         `document size exceeded: ${size} > ${this.maxSizeLimit}`
       );
     }
-    if (context.hasChange()) {
+    if (ctx.hasChange()) {
       if (logger.isEnabled(LogLevel.Trivial)) {
         logger.trivial(`trying to update a local change: ${this.toJSON()}`);
       }
-      const change = context.toChange();
+      const change = ctx.toChange();
       const { opInfos, reverseOps } = change.execute(
         this.root,
         this.presences,
@@ -20534,7 +20493,7 @@ class Document {
           );
         }
       }
-      const reversePresence = context.getReversePresence();
+      const reversePresence = ctx.getReversePresence();
       if (reversePresence) {
         reverseOps.push({
           type: "presence",
@@ -20542,15 +20501,15 @@ class Document {
         });
       }
       this.localChanges.push(change);
-      if (reverseOps.length > 0) {
+      if (reverseOps.length) {
         this.internalHistory.pushUndo(reverseOps);
       }
-      if (opInfos.length > 0) {
+      if (opInfos.length) {
         this.internalHistory.clearRedo();
       }
-      this.changeID = context.getNextID();
+      this.changeID = ctx.getNextID();
       const event = [];
-      if (opInfos.length > 0) {
+      if (opInfos.length) {
         event.push({
           type: "local-change",
           source: OpSource.Local,
@@ -20772,32 +20731,9 @@ class Document {
    * `publish` triggers an event in this document, which can be received by
    * callback functions from document.subscribe().
    */
-  publish(event) {
+  publish(events) {
     if (this.eventStreamObserver) {
-      this.eventStreamObserver.next(event);
-    }
-  }
-  isSameElementOrChildOf(elem, parent) {
-    if (parent === elem) {
-      return true;
-    }
-    const nodePath = elem.split(".");
-    const targetPath = parent.split(".");
-    return targetPath.every((path, index) => path === nodePath[index]);
-  }
-  /**
-   * `removePushedLocalChanges` removes local changes that have been applied to
-   * the server from the local changes.
-   *
-   * @param clientSeq - client sequence number to remove local changes before it
-   */
-  removePushedLocalChanges(clientSeq) {
-    while (this.localChanges.length) {
-      const change = this.localChanges[0];
-      if (change.getID().getClientSeq() > clientSeq) {
-        break;
-      }
-      this.localChanges.shift();
+      this.eventStreamObserver.next(events);
     }
   }
   /**
@@ -20805,13 +20741,9 @@ class Document {
    * 1. Remove local changes applied to server.
    * 2. Update the checkpoint.
    * 3. Do Garbage collection.
-   *
-   * @param pack - change pack
-   * @internal
    */
   applyChangePack(pack) {
-    const hasSnapshot = pack.hasSnapshot();
-    if (hasSnapshot) {
+    if (pack.hasSnapshot()) {
       this.applySnapshot(
         pack.getCheckpoint().getServerSeq(),
         pack.getVersionVector(),
@@ -20823,7 +20755,7 @@ class Document {
       this.removePushedLocalChanges(pack.getCheckpoint().getClientSeq());
     }
     this.checkpoint = this.checkpoint.forward(pack.getCheckpoint());
-    if (!hasSnapshot) {
+    if (!pack.hasSnapshot()) {
       this.garbageCollect(pack.getVersionVector());
     }
     if (pack.getIsRemoved()) {
@@ -20838,16 +20770,12 @@ class Document {
   }
   /**
    * `getCheckpoint` returns the checkpoint of this document.
-   *
-   * @internal
    */
   getCheckpoint() {
     return this.checkpoint;
   }
   /**
    * `getChangeID` returns the change id of this document.
-   *
-   * @internal
    */
   getChangeID() {
     return this.changeID;
@@ -20860,8 +20788,6 @@ class Document {
   }
   /**
    * `ensureClone` make a clone of root.
-   *
-   * @internal
    */
   ensureClone() {
     if (this.clone) {
@@ -20875,8 +20801,6 @@ class Document {
   /**
    * `createChangePack` create change pack of the local changes to send to the
    * remote server.
-   *
-   * @internal
    */
   createChangePack() {
     const changes = Array.from(this.localChanges);
@@ -20892,8 +20816,6 @@ class Document {
   /**
    * `setActor` sets actor into this document. This is also applied in the local
    * changes the document has.
-   *
-   * @internal
    */
   setActor(actorID) {
     for (const change of this.localChanges) {
@@ -20927,8 +20849,6 @@ class Document {
   }
   /**
    * `getCloneRoot` returns clone object.
-   *
-   * @internal
    */
   getCloneRoot() {
     if (!this.clone) {
@@ -20941,12 +20861,12 @@ class Document {
    */
   getRoot() {
     this.ensureClone();
-    const context = ChangeContext.create(
+    const ctx = ChangeContext.create(
       this.changeID.next(),
       this.clone.root,
       this.clone.presences.get(this.changeID.getActorID()) || {}
     );
-    return createJSON(context, this.clone.root.getObject());
+    return createJSON(ctx, this.clone.root.getObject());
   }
   /**
    * `getDocSize` returns the size of this document.
@@ -20980,8 +20900,6 @@ class Document {
   }
   /**
    * `garbageCollect` purges elements that were removed before the given time.
-   *
-   * @internal
    */
   garbageCollect(minSyncedVersionVector) {
     if (this.opts.disableGC) {
@@ -20994,16 +20912,12 @@ class Document {
   }
   /**
    * `getRootObject` returns root object.
-   *
-   * @internal
    */
   getRootObject() {
     return this.root.getObject();
   }
   /**
    * `getGarbageLen` returns the length of elements should be purged.
-   *
-   * @internal
    */
   getGarbageLen() {
     return this.root.getGarbageLen();
@@ -21098,13 +21012,13 @@ class Document {
   applyChange(change, source) {
     this.ensureClone();
     change.execute(this.clone.root, this.clone.presences, source);
-    const event = [];
+    const events = [];
     const actorID = change.getID().getActorID();
     if (change.hasPresenceChange() && this.onlineClients.has(actorID)) {
       const presenceChange = change.getPresenceChange();
       switch (presenceChange.type) {
         case PresenceChangeType.Put:
-          event.push(
+          events.push(
             this.presences.has(actorID) ? {
               type: "presence-changed",
               source,
@@ -21123,7 +21037,7 @@ class Document {
           );
           break;
         case PresenceChangeType.Clear:
-          event.push({
+          events.push({
             type: "unwatched",
             source: OpSource.Remote,
             value: {
@@ -21137,9 +21051,9 @@ class Document {
     }
     const { opInfos } = change.execute(this.root, this.presences, source);
     this.changeID = this.changeID.syncClocks(change.getID());
-    if (opInfos.length > 0) {
+    if (opInfos.length) {
       const rawChange = this.isEnableDevtools() ? change.toStruct() : void 0;
-      event.push(
+      events.push(
         source === OpSource.Remote ? {
           type: "remote-change",
           source,
@@ -21165,8 +21079,8 @@ class Document {
         }
       );
     }
-    if (event.length > 0) {
-      this.publish(event);
+    if (events.length) {
+      this.publish(events);
     }
   }
   /**
@@ -21194,14 +21108,14 @@ class Document {
     }
     if (resp.body.case === "event") {
       const { type, publisher } = resp.body.value;
-      const event = [];
+      const events = [];
       if (type === DocEventType$1.DOCUMENT_WATCHED) {
         if (this.onlineClients.has(publisher) && this.hasPresence(publisher)) {
           return;
         }
         this.addOnlineClient(publisher);
         if (this.hasPresence(publisher)) {
-          event.push({
+          events.push({
             type: "watched",
             source: OpSource.Remote,
             value: {
@@ -21214,7 +21128,7 @@ class Document {
         const presence = this.getPresence(publisher);
         this.removeOnlineClient(publisher);
         if (presence) {
-          event.push({
+          events.push({
             type: "unwatched",
             source: OpSource.Remote,
             value: { clientID: publisher, presence }
@@ -21224,7 +21138,7 @@ class Document {
         if (resp.body.value.body) {
           const { topic, payload } = resp.body.value.body;
           const decoder = new TextDecoder();
-          event.push({
+          events.push({
             type: "broadcast",
             value: {
               clientID: publisher,
@@ -21234,8 +21148,8 @@ class Document {
           });
         }
       }
-      if (event.length > 0) {
-        this.publish(event);
+      if (events.length) {
+        this.publish(events);
       }
     }
   }
@@ -21256,62 +21170,51 @@ class Document {
     ]);
   }
   /**
-   * `applyDocEventForReplay` applies the given event into this document.
+   * `applyDocEventsForReplay` applies the given events into this document.
    */
-  applyDocEventForReplay(event) {
-    if (event.type === "status-changed") {
-      this.applyStatus(event.value.status);
-      if (event.value.status === "attached") {
-        this.setActor(event.value.actorID);
+  applyDocEventsForReplay(events) {
+    for (const event of events) {
+      if (event.type === "status-changed") {
+        this.applyStatus(event.value.status);
+        if (event.value.status === "attached") {
+          this.setActor(event.value.actorID);
+        }
+        continue;
       }
-      return;
-    }
-    if (event.type === "snapshot") {
-      const { snapshot, serverSeq, snapshotVector } = event.value;
-      if (!snapshot) return;
-      this.applySnapshot(
-        BigInt(serverSeq),
-        converter.hexToVersionVector(snapshotVector),
-        converter.hexToBytes(snapshot)
-      );
-      return;
-    }
-    if (event.type === "local-change" || event.type === "remote-change") {
-      if (!event.rawChange) return;
-      const change = Change.fromStruct(event.rawChange);
-      this.applyChange(change, event.source);
-    }
-    if (event.type === "initialized") {
-      const onlineClients = /* @__PURE__ */ new Set();
-      for (const { clientID, presence } of event.value) {
-        onlineClients.add(clientID);
+      if (event.type === "snapshot") {
+        const { snapshot, serverSeq, snapshotVector } = event.value;
+        if (!snapshot) continue;
+        this.applySnapshot(
+          BigInt(serverSeq),
+          converter.hexToVersionVector(snapshotVector),
+          converter.hexToBytes(snapshot)
+        );
+        continue;
+      }
+      if (event.type === "local-change" || event.type === "remote-change") {
+        if (!event.rawChange) continue;
+        const change = Change.fromStruct(event.rawChange);
+        this.applyChange(change, event.source);
+      }
+      if (event.type === "initialized") {
+        const onlineClients = /* @__PURE__ */ new Set();
+        for (const { clientID, presence } of event.value) {
+          onlineClients.add(clientID);
+          this.presences.set(clientID, presence);
+        }
+        this.setOnlineClients(onlineClients);
+      } else if (event.type === "watched") {
+        const { clientID, presence } = event.value;
+        this.addOnlineClient(clientID);
+        this.presences.set(clientID, presence);
+      } else if (event.type === "unwatched") {
+        const { clientID } = event.value;
+        this.removeOnlineClient(clientID);
+        this.presences.delete(clientID);
+      } else if (event.type === "presence-changed") {
+        const { clientID, presence } = event.value;
         this.presences.set(clientID, presence);
       }
-      this.setOnlineClients(onlineClients);
-      return;
-    }
-    if (event.type === "watched") {
-      const { clientID, presence } = event.value;
-      this.addOnlineClient(clientID);
-      this.presences.set(clientID, presence);
-      return;
-    }
-    if (event.type === "unwatched") {
-      const { clientID } = event.value;
-      this.removeOnlineClient(clientID);
-      this.presences.delete(clientID);
-    }
-    if (event.type === "presence-changed") {
-      const { clientID, presence } = event.value;
-      this.presences.set(clientID, presence);
-    }
-  }
-  /**
-   * `applyDocEventsForReplay` applies the given events into this document.
-   */
-  applyDocEventsForReplay(event) {
-    for (const docEvent of event) {
-      this.applyDocEventForReplay(docEvent);
     }
   }
   /**
@@ -21324,51 +21227,41 @@ class Document {
         `path must start with "$"`
       );
     }
-    const pathArr = path.split(".");
-    pathArr.shift();
+    const paths = path.split(".");
+    paths.shift();
     let value = this.getRoot();
-    for (const key of pathArr) {
+    for (const key of paths) {
       value = value[key];
-      if (value === void 0) return void 0;
+      if (!value) return void 0;
     }
     return value;
   }
   /**
    * `setOnlineClients` sets the given online client set.
-   *
-   * @internal
    */
   setOnlineClients(onlineClients) {
     this.onlineClients = onlineClients;
   }
   /**
    * `resetOnlineClients` resets the online client set.
-   *
-   * @internal
    */
   resetOnlineClients() {
     this.onlineClients = /* @__PURE__ */ new Set();
   }
   /**
    * `addOnlineClient` adds the given clientID into the online client set.
-   *
-   * @internal
    */
   addOnlineClient(clientID) {
     this.onlineClients.add(clientID);
   }
   /**
    * `removeOnlineClient` removes the clientID from the online client set.
-   *
-   * @internal
    */
   removeOnlineClient(clientID) {
     this.onlineClients.delete(clientID);
   }
   /**
    * `hasPresence` returns whether the given clientID has a presence or not.
-   *
-   * @internal
    */
   hasPresence(clientID) {
     return this.presences.has(clientID);
@@ -21432,8 +21325,6 @@ class Document {
   /**
    * `getPresenceForTest` returns the presence of the given clientID
    * regardless of whether the client is online or not.
-   *
-   * @internal
    */
   getPresenceForTest(clientID) {
     const p = this.presences.get(clientID);
@@ -21441,8 +21332,6 @@ class Document {
   }
   /**
    * `getSelfForTest` returns the client that has attached this document.
-   *
-   * @internal
    */
   getSelfForTest() {
     return {
@@ -21452,193 +21341,135 @@ class Document {
   }
   /**
    * `getOthersForTest` returns all the other clients in online, sorted by clientID.
-   *
-   * @internal
    */
   getOthersForTest() {
     const myClientID = this.getChangeID().getActorID();
     return this.getPresences().filter((a) => a.clientID !== myClientID).sort((a, b) => a.clientID > b.clientID ? 1 : -1);
   }
   /**
-   * `canUndo` returns whether there are any operations to undo.
+   * `getUndoStackForTest` returns the undo stack for test.
    */
-  canUndo() {
-    return this.internalHistory.hasUndo() && !this.isUpdating;
+  getUndoStackForTest() {
+    return this.internalHistory.getUndoStackForTest();
   }
   /**
-   * `canRedo` returns whether there are any operations to redo.
+   * `getRedoStackForTest` returns the redo stack for test.
    */
-  canRedo() {
-    return this.internalHistory.hasRedo() && !this.isUpdating;
+  getRedoStackForTest() {
+    return this.internalHistory.getRedoStackForTest();
   }
   /**
-   * `undo` undoes the last operation executed by the current client.
-   * It does not impact operations made by other clients.
+   * `broadcast` the payload to the given topic.
    */
-  undo() {
-    if (this.isUpdating) {
-      throw new YorkieError(
-        Code.ErrRefused,
-        "Undo is not allowed during an update"
-      );
-    }
-    const undoOps = this.internalHistory.popUndo();
-    if (undoOps === void 0) {
-      throw new YorkieError(
-        Code.ErrRefused,
-        "There is no operation to be undone"
-      );
-    }
-    this.ensureClone();
-    const context = ChangeContext.create(
-      this.changeID,
-      this.clone.root,
-      this.clone.presences.get(this.changeID.getActorID()) || {}
-    );
-    for (const undoOp of undoOps) {
-      if (!(undoOp instanceof Operation)) {
-        const presence = new Presence(
-          context,
-          deepcopy(this.clone.presences.get(this.changeID.getActorID()))
-        );
-        presence.set(undoOp.value, { addToHistory: true });
-        continue;
-      }
-      const ticket = context.issueTimeTicket();
-      undoOp.setExecutedAt(ticket);
-      if (undoOp instanceof ArraySetOperation) {
-        const prev = undoOp.getCreatedAt();
-        undoOp.getValue().setCreatedAt(ticket);
-        this.internalHistory.reconcileCreatedAt(prev, ticket);
-      } else if (undoOp instanceof AddOperation) {
-        const prev = undoOp.getValue().getCreatedAt();
-        undoOp.getValue().setCreatedAt(ticket);
-        this.internalHistory.reconcileCreatedAt(prev, ticket);
+  broadcast(topic, payload, options) {
+    this.publish([
+      {
+        type: "local-broadcast",
+        value: { topic, payload },
+        options
       }
-      context.push(undoOp);
-    }
-    const change = context.toChange();
-    change.execute(this.clone.root, this.clone.presences, OpSource.UndoRedo);
-    const { opInfos, reverseOps } = change.execute(
-      this.root,
-      this.presences,
-      OpSource.UndoRedo
-    );
-    const reversePresence = context.getReversePresence();
-    if (reversePresence) {
-      reverseOps.push({
-        type: "presence",
-        value: reversePresence
-      });
-    }
-    if (reverseOps.length > 0) {
-      this.internalHistory.pushRedo(reverseOps);
-    }
-    if (!change.hasPresenceChange() && opInfos.length === 0) {
-      return;
-    }
-    this.localChanges.push(change);
-    this.changeID = context.getNextID();
-    const actorID = this.changeID.getActorID();
-    const event = [];
-    if (opInfos.length > 0) {
-      event.push({
-        type: "local-change",
-        source: OpSource.UndoRedo,
-        value: {
-          message: change.getMessage() || "",
-          operations: opInfos,
-          actor: actorID,
-          clientSeq: change.getID().getClientSeq(),
-          serverSeq: change.getID().getServerSeq()
-        },
-        rawChange: this.isEnableDevtools() ? change.toStruct() : void 0
-      });
+    ]);
+  }
+  /**
+   * `getVersionVector` returns the version vector of document
+   */
+  getVersionVector() {
+    return this.changeID.getVersionVector();
+  }
+  isSameElementOrChildOf(elem, parent) {
+    if (parent === elem) {
+      return true;
     }
-    if (change.hasPresenceChange()) {
-      event.push({
-        type: "presence-changed",
-        source: OpSource.UndoRedo,
-        value: {
-          clientID: actorID,
-          presence: this.getPresence(actorID)
-        }
-      });
+    const nodePath = elem.split(".");
+    return parent.split(".").every((path, index) => path === nodePath[index]);
+  }
+  /**
+   * `removePushedLocalChanges` removes local changes that have been applied to
+   * the server from the local changes.
+   *
+   * @param clientSeq - client sequence number to remove local changes before it
+   */
+  removePushedLocalChanges(clientSeq) {
+    while (this.localChanges.length) {
+      const change = this.localChanges[0];
+      if (change.getID().getClientSeq() > clientSeq) {
+        break;
+      }
+      this.localChanges.shift();
     }
-    this.publish(event);
   }
   /**
-   * `redo` redoes the last operation executed by the current client.
-   * It does not impact operations made by other clients.
+   * `executeUndoRedo` executes undo or redo operation with shared logic.
    */
-  redo() {
+  executeUndoRedo(isUndo) {
     if (this.isUpdating) {
       throw new YorkieError(
         Code.ErrRefused,
-        "Redo is not allowed during an update"
+        `${isUndo ? "Undo" : "Redo"} is not allowed during an update`
       );
     }
-    const redoOps = this.internalHistory.popRedo();
-    if (redoOps === void 0) {
+    const ops = isUndo ? this.internalHistory.popUndo() : this.internalHistory.popRedo();
+    if (!ops) {
       throw new YorkieError(
         Code.ErrRefused,
-        "There is no operation to be redone"
+        `There is no operation to be ${isUndo ? "undone" : "redone"}`
       );
     }
     this.ensureClone();
-    const context = ChangeContext.create(
+    const ctx = ChangeContext.create(
       this.changeID,
       this.clone.root,
       this.clone.presences.get(this.changeID.getActorID()) || {}
     );
-    for (const redoOp of redoOps) {
-      if (!(redoOp instanceof Operation)) {
+    for (const op of ops) {
+      if (!(op instanceof Operation)) {
         const presence = new Presence(
-          context,
+          ctx,
           deepcopy(this.clone.presences.get(this.changeID.getActorID()))
         );
-        presence.set(redoOp.value, { addToHistory: true });
+        presence.set(op.value, { addToHistory: true });
         continue;
       }
-      const ticket = context.issueTimeTicket();
-      redoOp.setExecutedAt(ticket);
-      if (redoOp instanceof ArraySetOperation) {
-        const prev = redoOp.getCreatedAt();
-        redoOp.getValue().setCreatedAt(ticket);
+      const ticket = ctx.issueTimeTicket();
+      op.setExecutedAt(ticket);
+      if (op instanceof ArraySetOperation) {
+        const prev = op.getCreatedAt();
+        op.getValue().setCreatedAt(ticket);
         this.internalHistory.reconcileCreatedAt(prev, ticket);
-      } else if (redoOp instanceof AddOperation) {
-        const prev = redoOp.getValue().getCreatedAt();
-        redoOp.getValue().setCreatedAt(ticket);
+      } else if (op instanceof AddOperation) {
+        const prev = op.getValue().getCreatedAt();
+        op.getValue().setCreatedAt(ticket);
         this.internalHistory.reconcileCreatedAt(prev, ticket);
       }
-      context.push(redoOp);
+      ctx.push(op);
     }
-    const change = context.toChange();
+    const change = ctx.toChange();
     change.execute(this.clone.root, this.clone.presences, OpSource.UndoRedo);
     const { opInfos, reverseOps } = change.execute(
       this.root,
       this.presences,
       OpSource.UndoRedo
     );
-    const reversePresence = context.getReversePresence();
-    if (reversePresence) {
-      reverseOps.push({
-        type: "presence",
-        value: reversePresence
-      });
+    const reverse = ctx.getReversePresence();
+    if (reverse) {
+      reverseOps.push({ type: "presence", value: reverse });
     }
-    if (reverseOps.length > 0) {
-      this.internalHistory.pushUndo(reverseOps);
+    if (reverseOps.length) {
+      if (isUndo) {
+        this.internalHistory.pushRedo(reverseOps);
+      } else {
+        this.internalHistory.pushUndo(reverseOps);
+      }
     }
-    if (!change.hasPresenceChange() && opInfos.length === 0) {
+    if (!change.hasPresenceChange() && !opInfos.length) {
       return;
     }
     this.localChanges.push(change);
-    this.changeID = context.getNextID();
+    this.changeID = ctx.getNextID();
     const actorID = this.changeID.getActorID();
-    const event = [];
-    if (opInfos.length > 0) {
-      event.push({
+    const events = [];
+    if (opInfos.length) {
+      events.push({
         type: "local-change",
         source: OpSource.UndoRedo,
         value: {
@@ -21652,7 +21483,7 @@ class Document {
       });
     }
     if (change.hasPresenceChange()) {
-      event.push({
+      events.push({
         type: "presence-changed",
         source: OpSource.UndoRedo,
         value: {
@@ -21661,36 +21492,7 @@ class Document {
         }
       });
     }
-    this.publish(event);
-  }
-  /**
-   * `getUndoStackForTest` returns the undo stack for test.
-   */
-  getUndoStackForTest() {
-    return this.internalHistory.getUndoStackForTest();
-  }
-  /**
-   * `getRedoStackForTest` returns the redo stack for test.
-   */
-  getRedoStackForTest() {
-    return this.internalHistory.getRedoStackForTest();
-  }
-  /**
-   * `broadcast` the payload to the given topic.
-   */
-  broadcast(topic, payload, options) {
-    const broadcastEvent = {
-      type: "local-broadcast",
-      value: { topic, payload },
-      options
-    };
-    this.publish([broadcastEvent]);
-  }
-  /**
-   * `getVersionVector` returns the version vector of document
-   */
-  getVersionVector() {
-    return this.changeID.getVersionVector();
+    this.publish(events);
   }
 }
 function createAuthInterceptor(apiKey, token) {
@@ -21713,7 +21515,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name$1 = "@yorkie-js/sdk";
-const version$1 = "0.6.28";
+const version$1 = "0.6.29";
 const pkg$1 = {
   name: name$1,
   version: version$1
@@ -21811,11 +21613,10 @@ class Client {
           createMetricInterceptor(opts == null ? void 0 : opts.userAgent)
         ],
         fetch: (input, init) => {
-          const newInit = {
+          return fetch(input, {
             ...init,
             keepalive: this.keepalive
-          };
-          return fetch(input, newInit);
+          });
         }
       })
     );
@@ -22609,7 +22410,7 @@ if (typeof globalThis !== "undefined") {
   };
 }
 const name = "@yorkie-js/react";
-const version = "0.6.28";
+const version = "0.6.29";
 const pkg = {
   name,
   version