@ones-editor/editor 2.1.0-beta.4 → 2.1.1-beta.1

package/dist/index.js

@@ -3433,9 +3433,6 @@ div.editor-root.readonly div.editor-content div[data-type=editor-container] div[
 }
 .comment-item-root:hover:not(.comment-item-editing) .item-head-tools {
   visibility: visible;
-}
-.comment-item-root.readonly .item-head-tools {
-  display: none;
 }.mobile-comment-item {
   margin-top: 4px;
   background-color: var(--editor-comment-layer-bg-color);
@@ -3691,9 +3688,6 @@ div.editor-root.readonly div.editor-content div[data-type=editor-container] div[
 .editor-web-comment-root .comment-groups-container .comment-group-item-root.active .item-head-switch {
   visibility: visible;
 }
-.editor-web-comment-root .comment-groups-container .comment-group-item-root.readonly .comment-quick-reply {
-  display: none;
-}
 .editor-mobile-comments-root {
   position: fixed;
   left: 0;
@@ -7358,7 +7352,7 @@ var __publicField = (obj, key, value) => {
       imageExportFailed: "\u753B\u50CF\u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F"
     }
   };
-  const logger$4z = getLogger("i18n");
+  const logger$4A = getLogger("i18n");
   const langs$3 = {
     "en-US": enUS$x,
     "zh-CN": zhCN$x,
@@ -7378,7 +7372,7 @@ var __publicField = (obj, key, value) => {
   function t$8(key, args) {
     const ret = i18n.get(key, args);
     if (ret === key) {
-      logger$4z.warn(`no locale value for key ${key}`);
+      logger$4A.warn(`no locale value for key ${key}`);
     }
     return ret;
   }
@@ -7991,7 +7985,7 @@ var __publicField = (obj, key, value) => {
       this._callbacks.clear();
     }
   }
-  const logger$4y = getLogger("await-locker");
+  const logger$4z = getLogger("await-locker");
   class AwaitLock {
     constructor() {
       __publicField(this, "_acquired", false);
@@ -8033,7 +8027,7 @@ var __publicField = (obj, key, value) => {
       }
       if (this._waitingResolvers.length > 0) {
         const resolve = this._waitingResolvers.shift();
-        assert(logger$4y, resolve, "Resolver missing");
+        assert(logger$4z, resolve, "Resolver missing");
         resolve(void 0);
       } else {
         this._acquired = false;
@@ -8116,7 +8110,7 @@ var __publicField = (obj, key, value) => {
     isMobileSafari: false
   };
   clientType.isMobileSafari = clientType.isMobile && clientType.isSafari;
-  const logger$4x = getLogger("dom-utils");
+  const logger$4y = getLogger("dom-utils");
   function addClass(dom, ...className) {
     if (dom && dom.nodeType === Node.ELEMENT_NODE) {
       dom.classList.add(...className);
@@ -8170,7 +8164,7 @@ var __publicField = (obj, key, value) => {
       range.setStart(node, offset);
       return range;
     } catch (err) {
-      assert(logger$4x, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
+      assert(logger$4y, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
     }
   }
   function createExpandedRange(startNode, startOffset, endNode, endOffset) {
@@ -8180,17 +8174,17 @@ var __publicField = (obj, key, value) => {
       range.setEnd(endNode, endOffset);
       return range;
     } catch (err) {
-      assert(logger$4x, false, `failed to create expanded range: ${startNode.childNodes.length}, ${startOffset}, ${endNode.childNodes.length}, ${endOffset}, ${err.message}`);
+      assert(logger$4y, false, `failed to create expanded range: ${startNode.childNodes.length}, ${startOffset}, ${endNode.childNodes.length}, ${endOffset}, ${err.message}`);
     }
   }
   function getFirstClientRect(elem) {
     const rects = elem.getClientRects();
-    assert(logger$4x, rects.length >= 1, "getFirstClientRect: no rects");
+    assert(logger$4y, rects.length >= 1, "getFirstClientRect: no rects");
     return rects[0];
   }
   function getLastClientRect(elem) {
     const rects = elem.getClientRects();
-    assert(logger$4x, rects.length >= 1, "getLastClientRect: no rects");
+    assert(logger$4y, rects.length >= 1, "getLastClientRect: no rects");
     return rects[rects.length - 1];
   }
   function getDistanceSquare(rect, x, y) {
@@ -8237,7 +8231,7 @@ var __publicField = (obj, key, value) => {
       return 0;
     }
     if (!elem1.parentElement || !elem2.parentElement) {
-      assert(logger$4x, false, "invalid dom node to compare");
+      assert(logger$4y, false, "invalid dom node to compare");
     }
     if (elem1.parentElement === elem2.parentElement) {
       const children = Array.from(elem1.parentElement.children);
@@ -8254,7 +8248,7 @@ var __publicField = (obj, key, value) => {
     const parents1 = getParents(elem1);
     const parents2 = getParents(elem2);
     if (parents1[0] !== parents2[0]) {
-      assert(logger$4x, false, "invalid dom node to compare, different tree");
+      assert(logger$4y, false, "invalid dom node to compare, different tree");
     }
     for (let i = 1; ; i++) {
       const parent1 = parents1[i];
@@ -8797,7 +8791,7 @@ var __publicField = (obj, key, value) => {
     }
   }
   const MIN_DISTANCE_THRESHOLD$1 = 3;
-  const logger$4w = getLogger("drag-drop");
+  const logger$4x = getLogger("drag-drop");
   class DragDrop {
     constructor(options) {
       __publicField(this, "dragStarted", false);
@@ -8817,7 +8811,7 @@ var __publicField = (obj, key, value) => {
         var _a;
         event.preventDefault();
         event.stopPropagation();
-        assert(logger$4w, this.mouseDownEvent, "no mouse down event");
+        assert(logger$4x, this.mouseDownEvent, "no mouse down event");
         const deltaX = event.x - this.mouseDownEvent.x;
         const deltaY = event.y - this.mouseDownEvent.y;
         if (this.dragStarted) {
@@ -8831,7 +8825,7 @@ var __publicField = (obj, key, value) => {
       });
       __publicField(this, "handleMouseUp", (event) => {
         if (event.button === 0) {
-          assert(logger$4w, this.mouseDownEvent, "no mouse down event");
+          assert(logger$4x, this.mouseDownEvent, "no mouse down event");
           const deltaX = event.x - this.mouseDownEvent.x;
           const deltaY = event.y - this.mouseDownEvent.y;
           this.onDragEnd(event, deltaX, deltaY);
@@ -8904,7 +8898,7 @@ var __publicField = (obj, key, value) => {
     const dragDrop = new DragDrop(options);
     return dragDrop;
   }
-  const logger$4v = getLogger("character");
+  const logger$4w = getLogger("character");
   function checkChar(charCode, rangeList) {
     for (let i = 0; i < rangeList.length; i++) {
       const start = rangeList[i][0];
@@ -8951,7 +8945,7 @@ var __publicField = (obj, key, value) => {
   }
   function trimChar(s, char) {
     let c = char;
-    assert(logger$4v, c.length === 1, "invalid char length");
+    assert(logger$4w, c.length === 1, "invalid char length");
     if (c === "]")
       c = "\\]";
     if (c === "\\")
@@ -9285,7 +9279,7 @@ var __publicField = (obj, key, value) => {
     const metrics = context.measureText(text2);
     return metrics.width + 4;
   }
-  const logger$4u = getLogger("editor-clipboard");
+  const logger$4v = getLogger("editor-clipboard");
   async function setClipboardDataByEvent(items, event) {
     if (event.clipboardData) {
       const data2 = event.clipboardData;
@@ -9335,7 +9329,7 @@ var __publicField = (obj, key, value) => {
       document.body.removeChild(textarea2);
       return true;
     } catch (ex) {
-      logger$4u.error(ex);
+      logger$4v.error(ex);
       document.body.removeChild(textarea2);
       return false;
     }
@@ -9356,7 +9350,7 @@ var __publicField = (obj, key, value) => {
       document.body.removeChild(div);
       return true;
     } catch (ex) {
-      logger$4u.error(ex);
+      logger$4v.error(ex);
       document.body.removeChild(div);
       return false;
     }
@@ -9383,7 +9377,7 @@ var __publicField = (obj, key, value) => {
       await navigator.clipboard.write([clipboardItems]);
       return true;
     } catch (err) {
-      logger$4u.error(err);
+      logger$4v.error(err);
       return await execCommandCopy(items);
     }
   }
@@ -9439,7 +9433,7 @@ var __publicField = (obj, key, value) => {
     a.click();
     a.remove();
   }
-  const logger$4t = getLogger("auto-scroll");
+  const logger$4u = getLogger("auto-scroll");
   function scrollable(scrollElement, direction) {
     if (scrollElement.scrollHeight === scrollElement.clientHeight) {
       return false;
@@ -9463,7 +9457,7 @@ var __publicField = (obj, key, value) => {
     const isHorizontal = direction === "left" || direction === "right";
     const scroll = () => {
       if (!scrollable(scrollElement, direction)) {
-        logger$4t.debug("No need for scroll");
+        logger$4u.debug("No need for scroll");
         return null;
       }
       if (isHorizontal) {
@@ -9521,7 +9515,7 @@ var __publicField = (obj, key, value) => {
           if (this.scrolling) {
             return;
           }
-          logger$4t.debug(`scroll direction: ${direction}`);
+          logger$4u.debug(`scroll direction: ${direction}`);
           this.cancelScroll = continuousScroll(scrollElement, {
             direction,
             step
@@ -9772,7 +9766,7 @@ var __publicField = (obj, key, value) => {
     const colorIndex = Math.abs(typeof content === "string" && content.trim() ? hashCode(content.trim()) : 0) % ColorNames.length;
     return ColorNames[colorIndex];
   }
-  const logger$4s = getLogger("container");
+  const logger$4t = getLogger("container");
   function isContainer(elem) {
     return elem.getAttribute("data-type") === "editor-container";
   }
@@ -9784,9 +9778,9 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerId(container) {
     const id = container.getAttribute("data-container-id");
-    assert(logger$4s, id, "no id for container");
+    assert(logger$4t, id, "no id for container");
     if (isRootContainer(container)) {
-      assert(logger$4s, id === "root", `invalid root container id, : ${id}`);
+      assert(logger$4t, id === "root", `invalid root container id, : ${id}`);
     }
     return id;
   }
@@ -9797,7 +9791,7 @@ var __publicField = (obj, key, value) => {
   function generateEditorContainerId(containerId) {
     return `ones-editor-container-${containerId}`;
   }
-  const logger$4r = getLogger("element");
+  const logger$4s = getLogger("element");
   function createContainerElement(parent, type, containerId) {
     const container = createElement("div", [type], parent);
     container.setAttribute("data-type", "editor-container");
@@ -9808,7 +9802,7 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerById(editor, containerId) {
     const container = editor.rootElement.querySelector(`[data-container-id=${containerId}]`);
-    assert(logger$4r, container, `no container: ${containerId}`);
+    assert(logger$4s, container, `no container: ${containerId}`);
     return container;
   }
   function getExistsContainerById(editor, containerId) {
@@ -9817,7 +9811,7 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerBlocksElement(container) {
     const blocks = container.querySelector(":scope > .container-blocks");
-    assert(logger$4r, blocks, "no container blocks element");
+    assert(logger$4s, blocks, "no container blocks element");
     return blocks;
   }
   function getContainerToolsElement(container) {
@@ -9830,11 +9824,11 @@ var __publicField = (obj, key, value) => {
   function isContainerBlocksElement(element) {
     return element.classList.contains("container-blocks");
   }
-  const logger$4q = getLogger("container-children");
+  const logger$4r = getLogger("container-children");
   function getChildBlocks(container, traverseChild) {
     const content = getContainerBlocksElement(container);
     const blocks = Array.from(content.children);
-    assert(logger$4q, blocks.length > 0, "container have not any child block");
+    assert(logger$4r, blocks.length > 0, "container have not any child block");
     if (traverseChild) {
       const { condition, editor } = traverseChild;
       return blocks.reduce((result, block) => {
@@ -9857,7 +9851,7 @@ var __publicField = (obj, key, value) => {
   }
   function getFirstChildBlock(container) {
     const block = container.querySelector(":scope > .container-blocks > div[data-type=editor-block]");
-    assert(logger$4q, block, "container have not any child block");
+    assert(logger$4r, block, "container have not any child block");
     return block;
   }
   function getLastChildBlock(container) {
@@ -9869,7 +9863,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockByIndex(container, blockIndex) {
     const block = getChildBlocks(container)[blockIndex];
-    assert(logger$4q, block, `container have not block at index ${blockIndex}`);
+    assert(logger$4r, block, `container have not block at index ${blockIndex}`);
     return block;
   }
   function findBlockByIndex(container, blockIndex) {
@@ -9975,18 +9969,18 @@ var __publicField = (obj, key, value) => {
       });
     }
   }
-  const logger$4p = getLogger("block-class");
+  const logger$4q = getLogger("block-class");
   function getBlockClass(editor, block) {
     return editor.editorBlocks.getBlockClass(getBlockType(block));
   }
   function getTextBlockClass(editor, block) {
     const text2 = editor.editorBlocks.getBlockClass(getBlockType(block));
-    assert(logger$4p, text2.blockKind === "text", `is not a text block, ${text2.blockType}`);
+    assert(logger$4q, text2.blockKind === "text", `is not a text block, ${text2.blockType}`);
     return text2;
   }
   function getComplexBlockClass(editor, block) {
     const complex = editor.editorBlocks.getBlockClass(getBlockType(block));
-    assert(logger$4p, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
+    assert(logger$4q, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
     return complex;
   }
   function getBlockClassByType(editor, type) {
@@ -10187,7 +10181,7 @@ var __publicField = (obj, key, value) => {
       return { classes, attributes: newAttributes, styles: newStyles };
     }
   }
-  const logger$4o = getLogger("block-dom");
+  const logger$4p = getLogger("block-dom");
   function isBlock(node) {
     if (!(node instanceof HTMLDivElement)) {
       return false;
@@ -10208,12 +10202,12 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockId(block) {
     const { id } = block;
-    assert(logger$4o, id, "no block id");
+    assert(logger$4p, id, "no block id");
     return id;
   }
   function getBlockType(block) {
     const type = block.getAttribute("data-block-type");
-    assert(logger$4o, type, "invalid block dom, no data-type");
+    assert(logger$4p, type, "invalid block dom, no data-type");
     return type;
   }
   function getParentBlock(node) {
@@ -10236,12 +10230,12 @@ var __publicField = (obj, key, value) => {
   }
   function getParentContainer(block) {
     const container = block.closest("div[data-type=editor-container]");
-    assert(logger$4o, container, "failed to get block container");
+    assert(logger$4p, container, "failed to get block container");
     return container;
   }
   function getBlockContent(block) {
     const content = block.querySelector(":scope >div[data-type=block-content]");
-    assert(logger$4o, content, "no block content");
+    assert(logger$4p, content, "no block content");
     return content;
   }
   function getBlockTools(block) {
@@ -10250,7 +10244,7 @@ var __publicField = (obj, key, value) => {
       tools = createElement("div", [], block);
       tools.setAttribute("data-type", "block-tools");
     }
-    assert(logger$4o, tools, "no block tools");
+    assert(logger$4p, tools, "no block tools");
     return tools;
   }
   function getExistsBlockTools(block) {
@@ -10271,7 +10265,7 @@ var __publicField = (obj, key, value) => {
   function createBlockElement(editor, path, data2) {
     const blockData = editor.editorDecorators.decorateBlock(path, data2);
     const { id, type } = blockData;
-    assert(logger$4o, id, "no block id");
+    assert(logger$4p, id, "no block id");
     const elem = createElement("div", [`${type}-block`], null);
     elem.id = id;
     elem.setAttribute("data-type", "editor-block");
@@ -10309,7 +10303,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxTypeFromElement(box) {
     const type = box.getAttribute("data-box-type");
-    assert(logger$4o, type, "not a valid box element, no type");
+    assert(logger$4p, type, "not a valid box element, no type");
     return type;
   }
   function isBox(node) {
@@ -10320,7 +10314,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxId(box) {
     const { id } = box;
-    assert(logger$4o, id, "no box id");
+    assert(logger$4p, id, "no box id");
     return id;
   }
   function getParentBox(node) {
@@ -10342,7 +10336,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxContent(box) {
     const content = box.querySelector("span[data-type=box-content]");
-    assert(logger$4o, content, "invalid box dom, no content");
+    assert(logger$4p, content, "invalid box dom, no content");
     return content;
   }
   function createInsertionElement(type, id, attributes) {
@@ -10374,7 +10368,7 @@ var __publicField = (obj, key, value) => {
   }
   function getInsertionContent(insertion) {
     const content = insertion.querySelector("span[data-type=insertion-content]");
-    assert(logger$4o, content, "invalid insertion-child dom, no content");
+    assert(logger$4p, content, "invalid insertion-child dom, no content");
     return content;
   }
   function getPrevBlock(block) {
@@ -10421,7 +10415,7 @@ var __publicField = (obj, key, value) => {
     const container = getParentContainer(block);
     const children = getChildBlocks(container);
     const index2 = children.indexOf(block);
-    assert(logger$4o, index2 !== -1, "invalid block & container dom, failed to get block index");
+    assert(logger$4p, index2 !== -1, "invalid block & container dom, failed to get block index");
     return index2;
   }
   function isInBlock(target) {
@@ -10446,7 +10440,7 @@ var __publicField = (obj, key, value) => {
   function isTitleBlock$2(block) {
     return block.hasAttribute("data-document-title");
   }
-  const logger$4n = getLogger("text-block-child");
+  const logger$4o = getLogger("text-block-child");
   function isTextBlockContentChild(elem) {
     if (elem.tagName !== "SPAN") {
       return false;
@@ -10454,14 +10448,14 @@ var __publicField = (obj, key, value) => {
     return true;
   }
   function isTextBlockContentBoxChild(elem) {
-    assert(logger$4n, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$4o, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-box") {
       return true;
     }
     return false;
   }
   function isTextBlockContentInsertionChild(elem) {
-    assert(logger$4n, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$4o, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-insertion") {
       return true;
     }
@@ -10471,7 +10465,7 @@ var __publicField = (obj, key, value) => {
     return !isTextBlockContentBoxChild(elem) && !isTextBlockContentInsertionChild(elem);
   }
   function getTextBlockContentChildType(child) {
-    assert(logger$4n, isTextBlockContentChild(child), "not a valid text child");
+    assert(logger$4o, isTextBlockContentChild(child), "not a valid text child");
     if (isTextBlockContentBoxChild(child)) {
       return "box";
     }
@@ -10486,15 +10480,15 @@ var __publicField = (obj, key, value) => {
       return 0;
     if (type === "box")
       return 1;
-    assert(logger$4n, child.textContent !== null, "text block content is undefined");
-    assert(logger$4n, child.textContent.length >= 0, "text block content length is negative");
+    assert(logger$4o, child.textContent !== null, "text block content is undefined");
+    assert(logger$4o, child.textContent.length >= 0, "text block content length is negative");
     return child.textContent.length;
   }
   function getTextBlockContentChildren(block) {
     const content = getBlockContent(block);
     const children = Array.from(content.children);
     children.forEach((child) => {
-      assert(logger$4n, isTextBlockContentChild(child), "not a valid text child");
+      assert(logger$4o, isTextBlockContentChild(child), "not a valid text child");
     });
     return children;
   }
@@ -10523,17 +10517,17 @@ var __publicField = (obj, key, value) => {
         };
       }
       const offset = blockOffset - start;
-      assert(logger$4n, offset > 0, "invalid offset value");
-      assert(logger$4n, !isTextBlockContentBoxChild(child), "invalid box child");
+      assert(logger$4o, offset > 0, "invalid offset value");
+      assert(logger$4o, !isTextBlockContentBoxChild(child), "invalid box child");
       return {
         prev: child,
         next: child,
         offset
       };
     }
-    assert(logger$4n, false, `invalid block child at position: ${blockOffset}`);
+    assert(logger$4o, false, `invalid block child at position: ${blockOffset}`);
   }
-  const logger$4m = getLogger("block-path");
+  const logger$4n = getLogger("block-path");
   function getBlockPath(block) {
     const ret = [];
     let current = block;
@@ -10547,26 +10541,26 @@ var __publicField = (obj, key, value) => {
         return ret;
       }
       const parentBlock = getParentBlock(container);
-      assert(logger$4m, parentBlock, "no parent block");
+      assert(logger$4n, parentBlock, "no parent block");
       current = parentBlock;
     }
-    assert(logger$4m, false, "no parent block");
+    assert(logger$4n, false, "no parent block");
     return [];
   }
-  const logger$4l = getLogger("child-container-path");
+  const logger$4m = getLogger("child-container-path");
   function getContainerBlockPath(container) {
     if (isRootContainer(container)) {
       return [];
     }
     const parentBlock = getParentBlock(container);
-    assert(logger$4l, parentBlock, "no parent block");
+    assert(logger$4m, parentBlock, "no parent block");
     return getBlockPath(parentBlock);
   }
-  const logger$4k = getLogger("load-blocks");
+  const logger$4l = getLogger("load-blocks");
   function loadBlocks(editor, container, path) {
     const containerId = getContainerId(container);
     const blocks = getContainerBlocks$1(container, editor.doc);
-    assert(logger$4k, blocks.length > 0, "no blocks in container");
+    assert(logger$4l, blocks.length > 0, "no blocks in container");
     const fragment = document.createDocumentFragment();
     blocks.forEach((b, index2) => {
       const block = editor.editorBlocks.createBlock([...path, { containerId, blockIndex: index2 }], container, b);
@@ -10582,7 +10576,7 @@ var __publicField = (obj, key, value) => {
       return block;
     }
     const blocks = getChildBlocks(container);
-    assert(logger$4k, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
+    assert(logger$4l, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
     if (blockIndex === blocks.length) {
       containerBlocksElement.appendChild(block);
     } else {
@@ -10600,7 +10594,7 @@ var __publicField = (obj, key, value) => {
     insertBlockAt(container, blockIndex, block);
     return block;
   }
-  const logger$4j = getLogger("root-container");
+  const logger$4k = getLogger("root-container");
   const MIN_DISTANCE_THRESHOLD = 3;
   class RootContainer {
     constructor(editor, rootContainer) {
@@ -10620,7 +10614,7 @@ var __publicField = (obj, key, value) => {
           this.editor.selection.updateSelection(null);
           this.editor.emit("resize", this.editor);
         } catch (err) {
-          logger$4j.warn(`failed to update selection while container resizing: ${err.message}`);
+          logger$4k.warn(`failed to update selection while container resizing: ${err.message}`);
         }
       });
       __publicField(this, "handleClick", (event) => {
@@ -10653,7 +10647,7 @@ var __publicField = (obj, key, value) => {
         const box = getParentBox(elem);
         if (box) {
           const block2 = getParentBlock(box);
-          assert(logger$4j, block2, "no parent block");
+          assert(logger$4k, block2, "no parent block");
           (_b = (_a = this.editor.editorBoxes.getBoxClass(getBoxTypeFromElement(box))) == null ? void 0 : _a.handleClickBox) == null ? void 0 : _b.call(_a, this.editor, box, event);
           return;
         }
@@ -10705,7 +10699,7 @@ var __publicField = (obj, key, value) => {
         }
       });
       __publicField(this, "handleMouseMove", (event) => {
-        assert(logger$4j, this.mouseDownEvent, "no mouse down event");
+        assert(logger$4k, this.mouseDownEvent, "no mouse down event");
         const deltaX = event.x - this.mouseDownEvent.x;
         const deltaY = event.y - this.mouseDownEvent.y;
         if (Math.abs(deltaX) >= MIN_DISTANCE_THRESHOLD || Math.abs(deltaY) >= MIN_DISTANCE_THRESHOLD) {
@@ -10792,7 +10786,7 @@ var __publicField = (obj, key, value) => {
     loadBlocks(editor, container, path);
     return container;
   }
-  const logger$4i = getLogger("block");
+  const logger$4j = getLogger("block");
   function getBlockTextLength$6(editor, block) {
     return getBlockClass(editor, block).getBlockTextLength(block);
   }
@@ -10811,7 +10805,7 @@ var __publicField = (obj, key, value) => {
         return block;
       }
       const parent = getParentBlock(container);
-      assert(logger$4i, parent, "no parent block exists for child container");
+      assert(logger$4j, parent, "no parent block exists for child container");
       block = parent;
     }
   }
@@ -10847,7 +10841,7 @@ var __publicField = (obj, key, value) => {
       }
       return fun(editor, block, options);
     } catch (err) {
-      logger$4i.debug(`unsupported block type: ${type}`);
+      logger$4j.debug(`unsupported block type: ${type}`);
       return null;
     }
   }
@@ -10867,7 +10861,7 @@ var __publicField = (obj, key, value) => {
     const styles = Object.fromEntries(Object.entries(data2).filter(([key]) => key.startsWith("style-")));
     Object.entries(styles).forEach(([, value]) => {
       const type = typeof value;
-      assert(logger$4i, type === "string" || type === "number" || type === "boolean", "invalid style value");
+      assert(logger$4j, type === "string" || type === "number" || type === "boolean", "invalid style value");
     });
     return styles;
   }
@@ -10992,7 +10986,7 @@ var __publicField = (obj, key, value) => {
     }
     return { element: null, blockCommands: [], boxCommands: [] };
   }
-  const logger$4h = getLogger("embed-block-common");
+  const logger$4i = getLogger("embed-block-common");
   function isColumnsBlock(block) {
     return getBlockType(block) === "layout";
   }
@@ -11000,9 +10994,9 @@ var __publicField = (obj, key, value) => {
     return getBlockType(block) === "embed";
   }
   function getEmbedType(block) {
-    assert(logger$4h, isEmbedBlock(block), "not an embed block");
+    assert(logger$4i, isEmbedBlock(block), "not an embed block");
     const type = block.getAttribute("data-embed-type");
-    assert(logger$4h, type, "no embed data type");
+    assert(logger$4i, type, "no embed data type");
     return type;
   }
   function getEmbedClassFromBlock(editor, block) {
@@ -11068,10 +11062,10 @@ var __publicField = (obj, key, value) => {
       data: (_c = overrideOptions == null ? void 0 : overrideOptions.data) != null ? _c : data2
     });
   }
-  const logger$4g = getLogger("execute-block-command");
+  const logger$4h = getLogger("execute-block-command");
   function executeEmbedBlockCommand(editor, block, commandGroup, item) {
     var _a;
-    assert(logger$4g, isEmbedBlock(block), "not a embed block");
+    assert(logger$4h, isEmbedBlock(block), "not a embed block");
     const embedType = getEmbedType(block);
     const embed = getEmbedClassByType(editor, embedType);
     if (!embed.getOptions) {
@@ -11104,14 +11098,14 @@ var __publicField = (obj, key, value) => {
     }
     return void 0;
   }
-  const logger$4f = getLogger("block-class");
+  const logger$4g = getLogger("block-class");
   function isHeadingBlock$1(block) {
     return !!block.getAttribute("data-style-heading");
   }
   function getBlockHeading(block) {
     var _a;
     const heading = Number.parseInt((_a = block.getAttribute("data-style-heading")) != null ? _a : "", 10);
-    assert(logger$4f, heading, "not a heading block");
+    assert(logger$4g, heading, "not a heading block");
     return heading;
   }
   function isExpandedHeadingBlock(block) {
@@ -11122,7 +11116,7 @@ var __publicField = (obj, key, value) => {
   }
   function getHeadingBlockChildren(block, oldHeading) {
     if (!oldHeading) {
-      assert(logger$4f, isHeadingBlock$1(block), "not a heading block");
+      assert(logger$4g, isHeadingBlock$1(block), "not a heading block");
     }
     const children = [];
     const heading = oldHeading != null ? oldHeading : getBlockHeading(block);
@@ -11152,7 +11146,7 @@ var __publicField = (obj, key, value) => {
     }
     return children;
   }
-  const logger$4e = getLogger("complex-block-position");
+  const logger$4f = getLogger("complex-block-position");
   class EditorComplexBlockPosition {
     constructor(block, childContainerId, custom) {
       __publicField(this, "blockId");
@@ -11161,7 +11155,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$4e, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$4f, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.childContainerId = childContainerId;
@@ -11173,7 +11167,7 @@ var __publicField = (obj, key, value) => {
       return false;
     }
   }
-  const logger$4d = getLogger("simple-block-position");
+  const logger$4e = getLogger("simple-block-position");
   class EditorSimpleBlockPosition {
     constructor(block, offset, type) {
       __publicField(this, "blockId");
@@ -11182,7 +11176,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$4d, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$4e, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.offset = offset;
@@ -11192,7 +11186,7 @@ var __publicField = (obj, key, value) => {
       return true;
     }
   }
-  const logger$4c = getLogger("editor-position");
+  const logger$4d = getLogger("editor-position");
   function createSimpleBlockPosition(block, offset, type) {
     return new EditorSimpleBlockPosition(block, offset, type);
   }
@@ -11214,7 +11208,7 @@ var __publicField = (obj, key, value) => {
       }
       const block1 = editor.getBlockById(pos1.blockId);
       const block2 = editor.getBlockById(pos2.blockId);
-      assert(logger$4c, block1 !== block2, "comparePosition: blocks are the same");
+      assert(logger$4d, block1 !== block2, "comparePosition: blocks are the same");
       return compareElement(block1, block2);
     }
     if (isComplexBlockPosition(pos1) && isComplexBlockPosition(pos2)) {
@@ -11225,13 +11219,13 @@ var __publicField = (obj, key, value) => {
       }
       const container1 = editor.getContainerById(p1.childContainerId);
       const container2 = editor.getContainerById(p2.childContainerId);
-      assert(logger$4c, container1 !== container2, "comparePosition: containers are the same");
+      assert(logger$4d, container1 !== container2, "comparePosition: containers are the same");
       return compareElement(container1, container2);
     }
-    assert(logger$4c, false, "invalid ");
+    assert(logger$4d, false, "invalid ");
     return 0;
   }
-  const logger$4b = getLogger("simple-range");
+  const logger$4c = getLogger("simple-range");
   class EditorSimpleSelectionRange {
     constructor(editor, options) {
       __publicField(this, "editor");
@@ -11280,11 +11274,11 @@ var __publicField = (obj, key, value) => {
       const { editor } = this;
       const startBlock = editor.getBlockById(this.start.blockId);
       const endBlock = editor.getBlockById(this.end.blockId);
-      assert(logger$4b, startBlock, "no start block");
-      assert(logger$4b, endBlock, "no end block");
+      assert(logger$4c, startBlock, "no start block");
+      assert(logger$4c, endBlock, "no end block");
       const startContainer = getParentContainer(startBlock);
       const endContainer = getParentContainer(endBlock);
-      assert(logger$4b, startContainer === endContainer, "invalid range");
+      assert(logger$4c, startContainer === endContainer, "invalid range");
       const ret = [];
       if (startBlock === endBlock) {
         ret.push({
@@ -11295,7 +11289,7 @@ var __publicField = (obj, key, value) => {
       } else {
         const startIndex = getBlockIndex(startBlock);
         const endIndex = getBlockIndex(endBlock);
-        assert(logger$4b, startIndex < endIndex, "invalid range, start > index");
+        assert(logger$4c, startIndex < endIndex, "invalid range, start > index");
         ret.push({
           block: startBlock,
           start: this.start,
@@ -11394,7 +11388,7 @@ var __publicField = (obj, key, value) => {
     clearSelection: clearSelection$6,
     convertTo: convertTo$m
   };
-  const logger$4a = getLogger("editor-blocks");
+  const logger$4b = getLogger("editor-blocks");
   class EditorBlocks {
     constructor(editor) {
       __publicField(this, "blocks", /* @__PURE__ */ new Map());
@@ -11403,12 +11397,12 @@ var __publicField = (obj, key, value) => {
     registerBlockClass(blockClass) {
       const type = blockClass.blockType;
       const exists = this.blocks.get(type);
-      assert(logger$4a, !exists, `duplicated block type: ${type}`);
+      assert(logger$4b, !exists, `duplicated block type: ${type}`);
       this.blocks.set(type, blockClass);
     }
     getBlockClass(type) {
       const exists = this.blocks.get(type);
-      assert(logger$4a, exists, `unknown block type: ${type}`);
+      assert(logger$4b, exists, `unknown block type: ${type}`);
       return exists;
     }
     hasBlock(type) {
@@ -11424,7 +11418,7 @@ var __publicField = (obj, key, value) => {
       }
       const content = blockClass.createBlockContent(this.editor, path, container, blockElement, block);
       if (content.parentElement !== blockElement) {
-        logger$4a.warn("content parent is not block");
+        logger$4b.warn("content parent is not block");
         blockElement.appendChild(content);
       }
       this.editor.blockHooks.forEach((hook) => {
@@ -11445,7 +11439,7 @@ var __publicField = (obj, key, value) => {
       return newBlock;
     }
   }
-  const logger$49 = getLogger("editor-embeds");
+  const logger$4a = getLogger("editor-embeds");
   class EditorEmbeds {
     constructor(editor) {
       __publicField(this, "objects", /* @__PURE__ */ new Map());
@@ -11454,12 +11448,12 @@ var __publicField = (obj, key, value) => {
     registerEmbedClass(embedClass) {
       const type = embedClass.embedType;
       const exists = this.objects.get(type);
-      assert(logger$49, !exists, `duplicated embed object type: ${type}`);
+      assert(logger$4a, !exists, `duplicated embed object type: ${type}`);
       this.objects.set(type, embedClass);
     }
     getEmbedClass(type) {
       const exists = this.objects.get(type);
-      assert(logger$49, exists, `unknown embed type: ${type}`);
+      assert(logger$4a, exists, `unknown embed type: ${type}`);
       return exists;
     }
     getEmbedClassFromBlock(block) {
@@ -11469,12 +11463,12 @@ var __publicField = (obj, key, value) => {
       this.objects.forEach(callback);
     }
   }
-  const logger$48 = getLogger("embed-block");
+  const logger$49 = getLogger("embed-block");
   function createBlockContent$6(editor, path, container, blockElement, blockData) {
     const content = createBlockContentElement(blockElement, "div");
-    assert(logger$48, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
+    assert(logger$49, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
     const embedBlockData = blockData;
-    assert(logger$48, embedBlockData.embedType && embedBlockData.embedData, `not an embed data: ${JSON.stringify(embedBlockData)}`);
+    assert(logger$49, embedBlockData.embedType && embedBlockData.embedData, `not an embed data: ${JSON.stringify(embedBlockData)}`);
     const embedClass = editor.editorEmbeds.getEmbedClass(embedBlockData.embedType);
     embedClass.createEmbedContent(editor, content, embedBlockData, path, container, blockElement);
     blockElement.setAttribute("data-embed-type", embedBlockData.embedType);
@@ -11638,18 +11632,18 @@ var __publicField = (obj, key, value) => {
     toStandardDoc: toStandardDoc$2,
     getResources: getResources$2
   };
-  const logger$47 = getLogger("complex-block-helper");
+  const logger$48 = getLogger("complex-block-helper");
   function complexBlockGetAllChildContainers(editor, block, options) {
     const blockClass = getComplexBlockClass(editor, block);
     return blockClass.getChildContainers(editor, block, options);
   }
   function complexBlockGetSelectedContainers(editor, block, start, end) {
     if (start.isSimple()) {
-      assert(logger$47, end.isSimple(), "invalid start and end position");
+      assert(logger$48, end.isSimple(), "invalid start and end position");
       return complexBlockGetAllChildContainers(editor, block);
     }
-    assert(logger$47, !start.isSimple(), "invalid start pos");
-    assert(logger$47, !end.isSimple(), "invalid end pos");
+    assert(logger$48, !start.isSimple(), "invalid start pos");
+    assert(logger$48, !end.isSimple(), "invalid end pos");
     const blockClass = getComplexBlockClass(editor, block);
     return blockClass.getSelectedContainers(editor, block, start, end);
   }
@@ -11660,11 +11654,11 @@ var __publicField = (obj, key, value) => {
     const parentComplexBlock = getParentBlock(getParentContainer(childBlock));
     if (!parentComplexBlock)
       return false;
-    assert(logger$47, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$48, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainer = getParentContainer(childBlock);
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock);
     const index2 = childContainers.indexOf(childContainer);
-    assert(logger$47, index2 >= 0, "not valid child container");
+    assert(logger$48, index2 >= 0, "not valid child container");
     return index2 === 0;
   }
   function complexBlockGetFirstSimpleChild(editor, complexBlock, options) {
@@ -11717,13 +11711,13 @@ var __publicField = (obj, key, value) => {
     return block;
   }
   function findPrevSimpleBlockBeforeChildContainer(editor, childContainer, options) {
-    assert(logger$47, isChildContainer(childContainer), "not a child container");
+    assert(logger$48, isChildContainer(childContainer), "not a child container");
     const parentComplexBlock = getParentBlock(childContainer);
-    assert(logger$47, parentComplexBlock, "no parent block");
-    assert(logger$47, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$48, parentComplexBlock, "no parent block");
+    assert(logger$48, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock, options);
     const containerIndex = childContainers.indexOf(childContainer);
-    assert(logger$47, containerIndex !== -1, "child container not found");
+    assert(logger$48, containerIndex !== -1, "child container not found");
     if (containerIndex === 0) {
       const prevBlock = getPrevBlock(parentComplexBlock);
       if (!prevBlock)
@@ -11741,9 +11735,9 @@ var __publicField = (obj, key, value) => {
     return lastBlock2;
   }
   function complexBlockGetTopChildContainers(editor, complexBlock) {
-    assert(logger$47, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$48, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$47, childContainers.length > 0, "no child container");
+    assert(logger$48, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -11768,9 +11762,9 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function complexBlockGetBottomChildContainers(editor, complexBlock) {
-    assert(logger$47, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$48, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$47, childContainers.length > 0, "no child container");
+    assert(logger$48, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -11813,8 +11807,8 @@ var __publicField = (obj, key, value) => {
   }
   function complexBlockAdjustSelectionPos(editor, complexBlock, anchor2, focus) {
     const blockId = getBlockId(complexBlock);
-    assert(logger$47, blockId === anchor2.blockId, "invalid start pos");
-    assert(logger$47, blockId === focus.blockId, "invalid end pos");
+    assert(logger$48, blockId === anchor2.blockId, "invalid start pos");
+    assert(logger$48, blockId === focus.blockId, "invalid end pos");
     const blockClass = getComplexBlockClass(editor, complexBlock);
     if (blockClass.adjustSelectionPos) {
       return blockClass.adjustSelectionPos(editor, complexBlock, anchor2, focus);
@@ -11897,13 +11891,13 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$46 = getLogger("selection-range");
+  const logger$47 = getLogger("selection-range");
   function createEditorSelectionRange(editor, options) {
     const { anchor: anchor2, focus } = options;
     if (anchor2 instanceof EditorSimpleBlockPosition && focus instanceof EditorSimpleBlockPosition) {
       return new EditorSimpleSelectionRange(editor, { anchor: anchor2, focus });
     }
-    assert(logger$46, anchor2 instanceof EditorComplexBlockPosition && focus instanceof EditorComplexBlockPosition, "start position type does not math end type");
+    assert(logger$47, anchor2 instanceof EditorComplexBlockPosition && focus instanceof EditorComplexBlockPosition, "start position type does not math end type");
     return new EditorComplexSelectionRange(editor, { anchor: anchor2, focus });
   }
   function createBlockSimpleRange(editor, block, anchor2, focus) {
@@ -11925,7 +11919,7 @@ var __publicField = (obj, key, value) => {
     const focus = createSimpleBlockPosition(range.focus.blockId, range.focus.offset, "normal");
     return createEditorSelectionRange(editor, { anchor: anchor2, focus });
   }
-  const logger$45 = getLogger("range-from-point");
+  const logger$46 = getLogger("range-from-point");
   function getBlockRangeFromPoint(editor, pointX, pointY) {
     const yOffsets = [0, -12, 12];
     let x = pointX;
@@ -11956,7 +11950,7 @@ var __publicField = (obj, key, value) => {
       const rect = elem.getBoundingClientRect();
       if (rect.width && rect.top && i === 0) {
         if (rect.left + rect.width < x || rect.top + rect.height < y) {
-          logger$45.debug("click on scrollbar, out of element rect");
+          logger$46.debug("click on scrollbar, out of element rect");
           return null;
         }
       }
@@ -11994,7 +11988,7 @@ var __publicField = (obj, key, value) => {
     let block = getLastChildBlock(container);
     if (!isVisibleBlock(block)) {
       const preBlock = getPrevVisibleBlock(block);
-      assert(logger$45, preBlock, "container must have visible block");
+      assert(logger$46, preBlock, "container must have visible block");
       block = preBlock;
     }
     const range = getBlockClass(editor, block).getRangeFromPoint(editor, block, x, block.getBoundingClientRect().bottom - 4);
@@ -12013,7 +12007,7 @@ var __publicField = (obj, key, value) => {
       if (range instanceof EditorSimpleSelectionRange) {
         return range;
       }
-      assert(logger$45, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
+      assert(logger$46, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
       const complexRange = range;
       const container2 = editor.getContainerById(complexRange.start.childContainerId);
       return getRangeInContainer(editor, container2, x, y);
@@ -12082,11 +12076,11 @@ var __publicField = (obj, key, value) => {
     return result;
   }
   const anchor = "";
-  const logger$44 = getLogger("text-range");
+  const logger$45 = getLogger("text-range");
   function getBlockRangeInfo(block, blockOffset) {
     const getChildRange = (child, offset) => {
       if (isTextBlockContentInsertionChild(child)) {
-        assert(logger$44, offset === 0, `invalid offset for insertion child: ${offset}`);
+        assert(logger$45, offset === 0, `invalid offset for insertion child: ${offset}`);
         const childOffset = 2;
         return {
           child,
@@ -12095,7 +12089,7 @@ var __publicField = (obj, key, value) => {
         };
       }
       if (isTextBlockContentBoxChild(child)) {
-        assert(logger$44, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
+        assert(logger$45, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
         const childOffset = offset === 0 ? 1 : 2;
         return {
           child,
@@ -12104,17 +12098,17 @@ var __publicField = (obj, key, value) => {
         };
       }
       const textNode = child.firstChild;
-      assert(logger$44, textNode, "no child node for text child");
-      assert(logger$44, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
+      assert(logger$45, textNode, "no child node for text child");
+      assert(logger$45, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
       if (textNode instanceof HTMLBRElement) {
-        assert(logger$44, offset >= 0 && offset <= 0, "invalid offset for text child");
+        assert(logger$45, offset >= 0 && offset <= 0, "invalid offset for text child");
         return {
           child,
           container: textNode,
           offset
         };
       }
-      assert(logger$44, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
+      assert(logger$45, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
       return {
         child,
         container: textNode,
@@ -12143,38 +12137,38 @@ var __publicField = (obj, key, value) => {
       }
       start += childLength;
     }
-    assert(logger$44, false, "failed to get range info");
+    assert(logger$45, false, "failed to get range info");
   }
   function createChildRange(child, start, end) {
     if (start === end) {
-      assert(logger$44, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
+      assert(logger$45, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
     } else {
-      assert(logger$44, start < end, `invalid start & end: ${start}, ${end}`);
+      assert(logger$45, start < end, `invalid start & end: ${start}, ${end}`);
     }
     if (isTextBlockContentInsertionChild(child)) {
-      assert(logger$44, start === end, `invalid insertion child range offset: ${start}, ${end}`);
-      assert(logger$44, start === 0, `invalid insertion child range start: ${start}`);
+      assert(logger$45, start === end, `invalid insertion child range offset: ${start}, ${end}`);
+      assert(logger$45, start === 0, `invalid insertion child range start: ${start}`);
       const insertionElem = child;
-      assert(logger$44, insertionElem.children.length === 3, `invalid insertion dom, children.length = ${insertionElem.children.length}`);
+      assert(logger$45, insertionElem.children.length === 3, `invalid insertion dom, children.length = ${insertionElem.children.length}`);
       const range = createExpandedRange(insertionElem, 1, insertionElem, 2);
       return range;
     }
     if (isTextBlockContentBoxChild(child)) {
-      assert(logger$44, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
-      assert(logger$44, start === 0, `invalid box child range start: ${start}`);
+      assert(logger$45, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
+      assert(logger$45, start === 0, `invalid box child range start: ${start}`);
       const box = child;
-      assert(logger$44, box.children.length === 3, `invalid box dom, children.length = ${box.children.length}`);
+      assert(logger$45, box.children.length === 3, `invalid box dom, children.length = ${box.children.length}`);
       const range = createExpandedRange(box, 1, box, 2);
       return range;
     }
     const length = getTextBlockContentChildTextLength(child);
-    assert(logger$44, end <= length, `invalid child end: ${end}, ${length}`);
+    assert(logger$45, end <= length, `invalid child end: ${end}, ${length}`);
     const textNode = child.firstChild;
-    assert(logger$44, textNode instanceof Text, "invalid block text child");
-    assert(logger$44, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
+    assert(logger$45, textNode instanceof Text, "invalid block text child");
+    assert(logger$45, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
     return createExpandedRange(textNode, start, textNode, end);
   }
-  const logger$43 = getLogger("caret-rect");
+  const logger$44 = getLogger("caret-rect");
   function getChildClientRects(block, child) {
     if (isBox(child)) {
       const box = child;
@@ -12183,7 +12177,7 @@ var __publicField = (obj, key, value) => {
         const blockContent = getBlockContent(block);
         const lineHeight = Number.parseFloat(window.getComputedStyle(blockContent).lineHeight) || boxContent.getBoundingClientRect().height;
         const rects = Array.from(boxContent.getClientRects());
-        assert(logger$43, rects.length > 0, "no box client rects");
+        assert(logger$44, rects.length > 0, "no box client rects");
         const blockRect = blockContent.getBoundingClientRect();
         const firstRect = rects[0];
         const lastRect = new DOMRect(blockRect.left, firstRect.bottom, 1, lineHeight);
@@ -12203,22 +12197,22 @@ var __publicField = (obj, key, value) => {
         const rect2 = getLastClientRect(ranges[0].child);
         return new DOMRect(rect2.right, rect2.top, 1, rect2.height);
       }
-      assert(logger$43, ranges[1], "invalid ranges");
+      assert(logger$44, ranges[1], "invalid ranges");
       const rect = getFirstClientRect(ranges[1].child);
       return new DOMRect(rect.left, rect.top, 1, rect.height);
     }
     let rangeInfo = ranges[0];
-    assert(logger$43, ranges.length >= 1, "failed to get block range");
+    assert(logger$44, ranges.length >= 1, "failed to get block range");
     if (ranges.length === 1) {
       rangeInfo = ranges[0];
     } else {
-      assert(logger$43, ranges.length >= 2, `invalid range info length: ${ranges.length}`);
+      assert(logger$44, ranges.length >= 2, `invalid range info length: ${ranges.length}`);
       if (isTextBlockContentInsertionChild(ranges[ranges.length - 1].child)) {
         rangeInfo = ranges[ranges.length - 1];
         const child = rangeInfo.child;
         const content = getInsertionContent(child);
         const rects2 = content.getClientRects();
-        assert(logger$43, rects2.length >= 1, "no client rects for box content");
+        assert(logger$44, rects2.length >= 1, "no client rects for box content");
         const rect = rects2[rects2.length - 1];
         return new DOMRect(rect.right, rect.y, 1, rect.height);
       }
@@ -12235,9 +12229,9 @@ var __publicField = (obj, key, value) => {
       }
     }
     if (rangeInfo.container instanceof HTMLBRElement) {
-      assert(logger$43, pos.offset === 0, "invalid offset for empty block text");
+      assert(logger$44, pos.offset === 0, "invalid offset for empty block text");
       const parent = rangeInfo.container.parentElement;
-      assert(logger$43, parent, "invalid br parent");
+      assert(logger$44, parent, "invalid br parent");
       const rect = parent.getBoundingClientRect();
       const ret = new DOMRect(rect.left, rect.top, 1, rect.height);
       return ret;
@@ -12245,11 +12239,11 @@ var __publicField = (obj, key, value) => {
     const range = createRange(rangeInfo.container, rangeInfo.offset);
     const rects = Array.from(range.getClientRects());
     if (rects.length === 0) {
-      assert(logger$43, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
-      assert(logger$43, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
+      assert(logger$44, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
+      assert(logger$44, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
       const child = rangeInfo.child;
       const rects2 = getChildClientRects(block, child);
-      assert(logger$43, rects2.length >= 1, "no client rects for box content");
+      assert(logger$44, rects2.length >= 1, "no client rects for box content");
       if (rangeInfo.offset === 1) {
         const rect2 = rects2[0];
         return new DOMRect(rect2.x, rect2.y, 1, rect2.height);
@@ -12295,13 +12289,13 @@ var __publicField = (obj, key, value) => {
         });
       }
     }
-    assert(logger$43, rects.length > 0, "no client rects for range");
+    assert(logger$44, rects.length > 0, "no client rects for range");
     if (pos.type === "home") {
       return rects[rects.length - 1];
     }
     return rects[0];
   }
-  const logger$42 = getLogger("core");
+  const logger$43 = getLogger("core");
   function createBlockAnchor(editor, block, id, refClientRect) {
     const tools = getBlockTools(block);
     let elem = tools.querySelector(`.block-anchor[data-id=${id}]`);
@@ -12319,7 +12313,7 @@ var __publicField = (obj, key, value) => {
     return elem;
   }
   function createBlockCaretAnchor(editor, block, offset, id) {
-    assert(logger$42, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$43, isTextKindBlock(editor, block), "not a text kind block");
     const caretRect = getTextCaretRect(block, createSimpleBlockPosition(block, offset, "normal"));
     const blockRect = block.getBoundingClientRect();
     const tools = getBlockTools(block);
@@ -12678,19 +12672,19 @@ var __publicField = (obj, key, value) => {
     return result + (index2 ? "-" : "") + word.toLowerCase();
   });
   const kebabCase$1 = kebabCase;
-  const logger$41 = getLogger("box");
+  const logger$42 = getLogger("box");
   function isBoxOp(op) {
     if (!op.attributes)
       return false;
     if (!op.attributes.box)
       return false;
-    assert(logger$41, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
-    assert(logger$41, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
+    assert(logger$42, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
+    assert(logger$42, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
     return true;
   }
-  const logger$40 = getLogger("text-op");
+  const logger$41 = getLogger("text-op");
   function getOpLength(op) {
-    assert(logger$40, typeof op.insert === "string", "invalid op, no insert");
+    assert(logger$41, typeof op.insert === "string", "invalid op, no insert");
     return op.insert.length;
   }
   function getOpAt(text2, offset) {
@@ -12698,7 +12692,7 @@ var __publicField = (obj, key, value) => {
     let pos = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$40, typeof op.insert === "string", "invalid text op, no insert");
+      assert(logger$41, typeof op.insert === "string", "invalid text op, no insert");
       const end = pos + getOpLength(op);
       if (end > offset) {
         return [op];
@@ -12714,22 +12708,22 @@ var __publicField = (obj, key, value) => {
     }
     return [];
   }
-  const logger$3$ = getLogger("rich-text-length");
+  const logger$40 = getLogger("rich-text-length");
   function getTextOpLength(op) {
-    assert(logger$3$, typeof op.insert === "string", "op.insert is not string");
+    assert(logger$40, typeof op.insert === "string", "op.insert is not string");
     return op.insert.length;
   }
   function getTextLength(ops) {
     let count = 0;
     ops.forEach((op) => {
       if (op.insert) {
-        assert(logger$3$, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$40, typeof op.insert === "string", "op.insert is not string");
         count += getTextOpLength(op);
       }
     });
     return count;
   }
-  const logger$3_ = getLogger("split-text");
+  const logger$3$ = getLogger("split-text");
   function splitText(ops, offset, splitResult) {
     ops = cloneDeep__default.default(ops);
     if (offset === 0) {
@@ -12747,8 +12741,8 @@ var __publicField = (obj, key, value) => {
     let counted = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$3_, typeof op === "object", `invalid op type, ${typeof op}`);
-      assert(logger$3_, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
+      assert(logger$3$, typeof op === "object", `invalid op type, ${typeof op}`);
+      assert(logger$3$, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
       const subLen = getTextOpLength(op);
       if (counted + subLen < offset) {
         counted += subLen;
@@ -12758,18 +12752,18 @@ var __publicField = (obj, key, value) => {
           right: ops.slice(i + 1)
         };
       } else {
-        assert(logger$3_, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
+        assert(logger$3$, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
         const splitIndex = offset - counted;
         const copied = cloneDeep__default.default(op);
-        assert(logger$3_, copied.insert, "no copied.insert");
-        assert(logger$3_, typeof copied.insert === "string", "invalid copied.insert type");
+        assert(logger$3$, copied.insert, "no copied.insert");
+        assert(logger$3$, typeof copied.insert === "string", "invalid copied.insert type");
         copied.insert = copied.insert.substr(0, splitIndex);
         op.insert = op.insert.substr(splitIndex);
         if (copied.insert === "") {
-          assert(logger$3_, false, "invalid copied.insert, is empty string");
+          assert(logger$3$, false, "invalid copied.insert, is empty string");
         }
         if (op.insert === "") {
-          assert(logger$3_, false, "invalid op.insert, is empty string");
+          assert(logger$3$, false, "invalid op.insert, is empty string");
         }
         const right = [
           op,
@@ -12788,9 +12782,9 @@ var __publicField = (obj, key, value) => {
     throw new Error(`invalid split offset: ${offset}, ${JSON.stringify(ops)}`);
   }
   function splitToThree(text2, offset, length) {
-    assert(logger$3_, offset >= 0, "invalid offset, < 0");
-    assert(logger$3_, length > 0, "invalid length, <= 0");
-    assert(logger$3_, offset + length <= getTextLength(text2), "invalid offset + length < text length");
+    assert(logger$3$, offset >= 0, "invalid offset, < 0");
+    assert(logger$3$, length > 0, "invalid length, <= 0");
+    assert(logger$3$, offset + length <= getTextLength(text2), "invalid offset + length < text length");
     const { left: temp, right } = splitText(text2, offset + length);
     const { left, right: middle } = splitText(temp, offset);
     return { left, middle, right };
@@ -13013,9 +13007,9 @@ var __publicField = (obj, key, value) => {
     }
     return [color, backgroundColor];
   }
-  const logger$3Z = getLogger("text-block-content");
+  const logger$3_ = getLogger("text-block-content");
   function updateBlockContentCore(editor, blockPath, content, blockText, insertions) {
-    assert(logger$3Z, blockText, "no text for block");
+    assert(logger$3_, blockText, "no text for block");
     if (blockText.length === 0 && (!insertions || insertions.size === 0)) {
       content.innerHTML = "<span><br></span>";
       return;
@@ -13047,9 +13041,9 @@ var __publicField = (obj, key, value) => {
       for (let i2 = 0; i2 < text2.length; i2++) {
         const op = text2[i2];
         if (isBoxOp(op)) {
-          assert(logger$3Z, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
+          assert(logger$3_, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
           const span2 = editor.editorBoxes.createBox(content, op.attributes);
-          assert(logger$3Z, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
+          assert(logger$3_, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
           const ret = editor.editorBlockRenders.renderBox(blockPath, op.attributes);
           if (ret.classes) {
             addClass(span2, ...ret.classes);
@@ -13067,7 +13061,7 @@ var __publicField = (obj, key, value) => {
           fragment.appendChild(span2);
           continue;
         }
-        assert(logger$3Z, op.insert, `no insert in op: ${JSON.stringify(op)}`);
+        assert(logger$3_, op.insert, `no insert in op: ${JSON.stringify(op)}`);
         const span = createElement("span", ["text"], fragment, op.insert);
         if (op.attributes) {
           const ret = editor.editorBlockRenders.renderText(blockPath, op.attributes);
@@ -13098,7 +13092,7 @@ var __publicField = (obj, key, value) => {
     const compositionText = editor.compositingText;
     if (compositionText) {
       const pos = editor.selection.range.start;
-      assert(logger$3Z, pos.isSimple(), "not an simple position while compositing");
+      assert(logger$3_, pos.isSimple(), "not an simple position while compositing");
       if (pos.blockId === blockId) {
         const attributes = getAttributesAt(text2, 0);
         insertions.set(pos.offset, [{
@@ -13114,11 +13108,11 @@ var __publicField = (obj, key, value) => {
   function clearAllTempCompositionText(editor) {
     const children = editor.rootContainer.querySelectorAll('span[data-type="editor-insertion"].inputting-insertion');
     if (children.length) {
-      logger$3Z.debug(`remove ${children.length} temp composition span`);
+      logger$3_.debug(`remove ${children.length} temp composition span`);
     }
     Array.from(children).forEach((c) => c.remove());
   }
-  const logger$3Y = getLogger("client-rects");
+  const logger$3Z = getLogger("client-rects");
   function getChildrenOffsets(block) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -13136,15 +13130,15 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function getChildrenInRange(editor, block, from, to) {
-    assert(logger$3Y, from < to, `invalid from & to: ${from}, ${to}`);
+    assert(logger$3Z, from < to, `invalid from & to: ${from}, ${to}`);
     const blockLength = getBlockTextLength$6(editor, block);
-    assert(logger$3Y, from >= 0 && to >= 0 && from <= blockLength && to <= blockLength, `invalid offset: ${from}, ${to}, length: ${blockLength}`);
+    assert(logger$3Z, from >= 0 && to >= 0 && from <= blockLength && to <= blockLength, `invalid offset: ${from}, ${to}, length: ${blockLength}`);
     const offsets = getChildrenOffsets(block);
     const startIndex = offsets.findIndex((c) => c.startBlockOffset <= from && from < c.endBlockOffset);
     const endIndex = offsets.findIndex((c) => c.startBlockOffset < to && to <= c.endBlockOffset);
-    assert(logger$3Y, startIndex !== -1, "failed to find start child");
-    assert(logger$3Y, endIndex !== -1, "failed to find end child");
-    assert(logger$3Y, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
+    assert(logger$3Z, startIndex !== -1, "failed to find start child");
+    assert(logger$3Z, endIndex !== -1, "failed to find end child");
+    assert(logger$3Z, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
     if (startIndex === endIndex) {
       const child = offsets[startIndex];
       return [{
@@ -13219,20 +13213,20 @@ var __publicField = (obj, key, value) => {
     return rects;
   }
   function getRangeClientRects(editor, block, range) {
-    assert(logger$3Y, range instanceof EditorSimpleSelectionRange, "invalid range");
+    assert(logger$3Z, range instanceof EditorSimpleSelectionRange, "invalid range");
     const start = range.start;
     const end = range.end;
-    assert(logger$3Y, start.isSimple(), "text block only allow simple position");
-    assert(logger$3Y, end.isSimple(), "text block only allow simple position");
-    assert(logger$3Y, start.blockId === end.blockId, "only allow update one text block selection");
-    assert(logger$3Y, start.blockId === getBlockId(block), "only allow update one text block selection");
+    assert(logger$3Z, start.isSimple(), "text block only allow simple position");
+    assert(logger$3Z, end.isSimple(), "text block only allow simple position");
+    assert(logger$3Z, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$3Z, start.blockId === getBlockId(block), "only allow update one text block selection");
     return getClientRects$2(editor, block, start, end);
   }
-  const logger$3X = getLogger("selection-background");
+  const logger$3Y = getLogger("selection-background");
   function updateSelection$4(editor, block, start, end) {
-    assert(logger$3X, start.isSimple(), "text block only allow simple position");
-    assert(logger$3X, end.isSimple(), "text block only allow simple position");
-    assert(logger$3X, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$3Y, start.isSimple(), "text block only allow simple position");
+    assert(logger$3Y, end.isSimple(), "text block only allow simple position");
+    assert(logger$3Y, start.blockId === end.blockId, "only allow update one text block selection");
     const from = start.offset;
     const to = end.offset;
     if (from === to) {
@@ -13280,7 +13274,7 @@ var __publicField = (obj, key, value) => {
       }
     });
   }
-  const logger$3W = getLogger("line-breaker");
+  const logger$3X = getLogger("line-breaker");
   function mergeTextRects(rects) {
     const result = [];
     let lastRect = null;
@@ -13407,7 +13401,7 @@ var __publicField = (obj, key, value) => {
       }
       const textChild = child;
       const rects = mergeTextRects(textChild.getClientRects());
-      assert(logger$3W, rects.length > 0, "invalid text child dom");
+      assert(logger$3X, rects.length > 0, "invalid text child dom");
       if (rects.length === 1) {
         const nextChild = children[i + 1];
         if (!nextChild) {
@@ -13432,10 +13426,10 @@ var __publicField = (obj, key, value) => {
         continue;
       }
       const textNode = textChild.firstChild;
-      assert(logger$3W, textNode, "invalid text child, no text node");
-      assert(logger$3W, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
+      assert(logger$3X, textNode, "invalid text child, no text node");
+      assert(logger$3X, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
       const textChildLength = getTextBlockContentChildTextLength(textChild);
-      assert(logger$3W, textNode.data.length === textChildLength, "text node data length not equal child text length");
+      assert(logger$3X, textNode.data.length === textChildLength, "text node data length not equal child text length");
       const textRects = getTextRects(textNode);
       for (let rIndex = 0; rIndex < textRects.length - 1; rIndex++) {
         const rect = textRects[rIndex];
@@ -13477,7 +13471,7 @@ var __publicField = (obj, key, value) => {
         }
       }
     }
-    assert(logger$3W, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
+    assert(logger$3X, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
     return {
       lineIndex: lineBreaks.length,
       lineBreaks
@@ -22250,7 +22244,7 @@ var __publicField = (obj, key, value) => {
   const Graphemer_1 = __importDefault(Graphemer$1);
   var _default = lib$1.default = Graphemer_1.default;
   const splitter = new _default();
-  const logger$3V = getLogger("text-offset");
+  const logger$3W = getLogger("text-offset");
   function getChildOffset(block, child) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -22266,26 +22260,26 @@ var __publicField = (obj, key, value) => {
       }
       start += testLength;
     }
-    assert(logger$3V, false, "can not find child in children");
+    assert(logger$3W, false, "can not find child in children");
   }
   function isValidOffset(block, blockOffset) {
-    assert(logger$3V, blockOffset >= 0, `invalid offset: ${blockOffset}`);
+    assert(logger$3W, blockOffset >= 0, `invalid offset: ${blockOffset}`);
     const childInfo = getTextBlockChild(block, blockOffset);
     const { prev, next, offset } = childInfo;
     if (!prev && !next) {
-      assert(logger$3V, false, "invalid offset, no prev & next child at offset");
+      assert(logger$3W, false, "invalid offset, no prev & next child at offset");
     }
     if (prev !== next) {
       return true;
     }
     const child = prev;
-    assert(logger$3V, child, "no child");
+    assert(logger$3W, child, "no child");
     if (isTextBlockContentBoxChild(child)) {
-      assert(logger$3V, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
+      assert(logger$3W, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
       return true;
     }
     const text2 = child.textContent;
-    assert(logger$3V, text2, "no content for text child");
+    assert(logger$3W, text2, "no content for text child");
     const chars = splitter.splitGraphemes(text2);
     const validOffsets = /* @__PURE__ */ new Set();
     let start = 0;
@@ -22315,7 +22309,7 @@ var __publicField = (obj, key, value) => {
   }
   function getNextValidOffset(block, blockOffset) {
     const length = getTextBlockLength(block);
-    assert(logger$3V, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
+    assert(logger$3W, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
     if (blockOffset === length) {
       return length;
     }
@@ -22329,7 +22323,7 @@ var __publicField = (obj, key, value) => {
     }
     return ret;
   }
-  const logger$3U = getLogger("line-offset");
+  const logger$3V = getLogger("line-offset");
   function getLineOffsets(block) {
     const lineBreaks = getLineBreaks(block);
     const ret = [];
@@ -22350,7 +22344,7 @@ var __publicField = (obj, key, value) => {
   }
   function getLineOffset(block, lineIndex) {
     const lines = getLineOffsets(block);
-    assert(logger$3U, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
+    assert(logger$3V, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
     return lines[lineIndex];
   }
   function getLineOffsetByPos(block, pos) {
@@ -22407,7 +22401,7 @@ var __publicField = (obj, key, value) => {
   function getLineCount(block) {
     return getLineOffsets(block).length;
   }
-  const logger$3T = getLogger("find-text-position");
+  const logger$3U = getLogger("find-text-position");
   function isWrappedLine(block, lineIndex) {
     const { start, end } = getLineOffset(block, lineIndex);
     const blockId = getBlockId(block);
@@ -22418,13 +22412,13 @@ var __publicField = (obj, key, value) => {
       return false;
     }
     const childInfo = getTextBlockChild(block, start);
-    assert(logger$3T, childInfo.next, "no next child at offset");
-    assert(logger$3T, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
+    assert(logger$3U, childInfo.next, "no next child at offset");
+    assert(logger$3U, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
     return true;
   }
   function getWrappedLineOffsets(block, lineIndex) {
     const blockId = getBlockId(block);
-    assert(logger$3T, isWrappedLine(block, lineIndex), "line is not wrapped");
+    assert(logger$3U, isWrappedLine(block, lineIndex), "line is not wrapped");
     const { start, end } = getLineOffset(block, lineIndex);
     const homePos = createSimpleBlockPosition(blockId, start, "home");
     for (let offset = start + 1; offset <= end; offset += 1) {
@@ -22439,11 +22433,11 @@ var __publicField = (obj, key, value) => {
         return offset - 1;
       }
     }
-    assert(logger$3T, false, "failed to find wrapped offset");
+    assert(logger$3U, false, "failed to find wrapped offset");
     return 0;
   }
   function findTextPositionInLine(editor, block, lineIndex, sourceBlock, pos, findDirection, suggestedX) {
-    assert(logger$3T, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
+    assert(logger$3U, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
     const { start, end } = getLineOffset(block, lineIndex);
     let from = start;
     const blockId = getBlockId(block);
@@ -22485,11 +22479,11 @@ var __publicField = (obj, key, value) => {
     return retPos;
   }
   function findPrevTextBlockPosition(editor, block, sourceBlock, pos, suggestedX) {
-    assert(logger$3T, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$3U, isTextKindBlock(editor, block), "not a text block");
     return findTextPositionInLine(editor, block, getLineCount(block) - 1, sourceBlock, pos, "up", suggestedX);
   }
   function findNextTextBlockPosition(editor, block, sourceBlock, pos, suggestedX) {
-    assert(logger$3T, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$3U, isTextKindBlock(editor, block), "not a text block");
     return findTextPositionInLine(editor, block, 0, sourceBlock, pos, "down", suggestedX);
   }
   function moveDown(editor, block, position, suggestedX) {
@@ -22597,7 +22591,7 @@ var __publicField = (obj, key, value) => {
     }
     return pos;
   }
-  const logger$3S = getLogger("move-caret");
+  const logger$3T = getLogger("move-caret");
   function moveTextCaret(editor, block, position, direction) {
     if (direction === "ArrowLeft") {
       const ret = moveLeft(block, position);
@@ -22627,9 +22621,9 @@ var __publicField = (obj, key, value) => {
       }
       return createSimpleBlockPosition(getBlockId(block), ret.offset, ret.type);
     }
-    assert(logger$3S, false, `invalid navigation direction: ${direction}`);
+    assert(logger$3T, false, `invalid navigation direction: ${direction}`);
   }
-  const logger$3R = getLogger("text-range");
+  const logger$3S = getLogger("text-range");
   function getBlockRects(block) {
     const ret = [];
     const children = getTextBlockContentChildren(block);
@@ -22705,9 +22699,9 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const children = getTextBlockContentChildren(block);
-    assert(logger$3R, children.indexOf(child) !== -1, "failed to find child in children");
+    assert(logger$3S, children.indexOf(child) !== -1, "failed to find child in children");
     const offsetInfo = getChildOffset(block, child);
-    assert(logger$3R, offsetInfo, "failed to get child offset");
+    assert(logger$3S, offsetInfo, "failed to get child offset");
     const { start } = offsetInfo;
     let offset;
     let length;
@@ -22718,7 +22712,7 @@ var __publicField = (obj, key, value) => {
       offset = start;
       length = 0;
     } else {
-      assert(logger$3R, child.firstChild instanceof Text, "child is not text");
+      assert(logger$3S, child.firstChild instanceof Text, "child is not text");
       offset = start + textNodeOffsetFromPoint(child.firstChild, x, y);
       length = 0;
     }
@@ -22742,9 +22736,9 @@ var __publicField = (obj, key, value) => {
     }
     return new EditorSimpleSelectionRange(editor, { anchor: startPos, focus: endPos != null ? endPos : startPos });
   }
-  const logger$3Q = getLogger("create-text-op");
+  const logger$3R = getLogger("create-text-op");
   function createTextOp(text2, attributes) {
-    assert(logger$3Q, text2, "text is empty");
+    assert(logger$3R, text2, "text is empty");
     const ret = {
       insert: text2
     };
@@ -22767,7 +22761,7 @@ var __publicField = (obj, key, value) => {
     }
     return result;
   }
-  const logger$3P = getLogger("merge-ops");
+  const logger$3Q = getLogger("merge-ops");
   function mergeOps(text2) {
     if (text2.length <= 1) {
       return text2;
@@ -22789,10 +22783,10 @@ var __publicField = (obj, key, value) => {
         return false;
       }
       if (op1.attributes === void 0) {
-        assert(logger$3P, op2.attributes === void 0, "op2.attributes is not undefined");
+        assert(logger$3Q, op2.attributes === void 0, "op2.attributes is not undefined");
         return true;
       }
-      assert(logger$3P, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
+      assert(logger$3Q, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
       return isEqual__default.default(op1.attributes, op2.attributes);
     };
     const newOps = [];
@@ -22801,8 +22795,8 @@ var __publicField = (obj, key, value) => {
     for (let i = 1; i < text2.length; i += 1) {
       const op = text2[i];
       if (isSameTypeOp(before, op)) {
-        assert(logger$3P, typeof before.insert === "string", "before.insert is not string");
-        assert(logger$3P, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$3Q, typeof before.insert === "string", "before.insert is not string");
+        assert(logger$3Q, typeof op.insert === "string", "op.insert is not string");
         before.insert += op.insert;
       } else {
         newOps.push(op);
@@ -22830,15 +22824,15 @@ var __publicField = (obj, key, value) => {
     }
     return text2.slice(0, i + 1);
   }
-  const logger$3O = getLogger("delete-text");
+  const logger$3P = getLogger("delete-text");
   function deleteText(richText2, offset, count) {
     const { left, right } = splitToThree(richText2, offset, count);
     const result = [...left, ...right];
     return mergeOps(result);
   }
   function createDeleteOps(offset, count) {
-    assert(logger$3O, offset >= 0, `invalid offset: ${offset}`);
-    assert(logger$3O, count >= 1, `invalid delete count: ${count}`);
+    assert(logger$3P, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$3P, count >= 1, `invalid delete count: ${count}`);
     const ops = [];
     if (offset !== 0) {
       ops.push({
@@ -22850,7 +22844,7 @@ var __publicField = (obj, key, value) => {
     });
     return ops;
   }
-  const logger$3N = getLogger("delta");
+  const logger$3O = getLogger("delta");
   function diffRichText(oldText, newText) {
     const delta1D = new Delta__default.default(oldText);
     const delta2D = new Delta__default.default(newText);
@@ -22860,7 +22854,7 @@ var __publicField = (obj, key, value) => {
     return new Delta__default.default(ops).transformPosition(cursor, !isLocalOp);
   }
   function isValidDocText(text2) {
-    assert(logger$3N, text2, "ops is null or undefined");
+    assert(logger$3O, text2, "ops is null or undefined");
     for (let i = 0; i < text2.length; i++) {
       const op = text2[i];
       if (op.insert === null || op.insert === void 0) {
@@ -22880,7 +22874,7 @@ var __publicField = (obj, key, value) => {
   }
   class RichText {
     static ensureValidText(text2) {
-      assert(logger$3N, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
+      assert(logger$3O, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
     }
     static diff(oldText, newText) {
       this.ensureValidText(oldText);
@@ -22902,9 +22896,9 @@ var __publicField = (obj, key, value) => {
       return resultText;
     }
   }
-  const logger$3M = getLogger("insert-text");
+  const logger$3N = getLogger("insert-text");
   function insertText(richText2, offset, text2, attributes) {
-    assert(logger$3M, text2, `invalid text to insert: ${text2}`);
+    assert(logger$3N, text2, `invalid text to insert: ${text2}`);
     const { left, right } = splitText(richText2, offset);
     const insertedText = typeof text2 === "string" ? [createTextOp(text2, attributes)] : text2;
     const result = [...left, ...insertedText, ...right];
@@ -22917,7 +22911,7 @@ var __publicField = (obj, key, value) => {
     };
   }
   function createInsertOps(offset, text2, attributes) {
-    assert(logger$3M, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$3N, offset >= 0, `invalid offset: ${offset}`);
     if (text2.length === 0) {
       return [];
     }
@@ -22947,7 +22941,7 @@ var __publicField = (obj, key, value) => {
   function cloneText(text2) {
     return cloneDeep__default.default(text2);
   }
-  const logger$3L = getLogger("update-op-attribute");
+  const logger$3M = getLogger("update-op-attribute");
   function updateOpAttributes(orgOps, key, value, newAttributes) {
     const ops = cloneText(orgOps);
     const index2 = ops.findIndex((op2) => {
@@ -22955,7 +22949,7 @@ var __publicField = (obj, key, value) => {
         return false;
       return op2.attributes[key] === value;
     });
-    assert(logger$3L, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
+    assert(logger$3M, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
     const op = ops[index2];
     op.attributes = {
       ...op.attributes,
@@ -23037,11 +23031,11 @@ var __publicField = (obj, key, value) => {
     ]);
   }
   const FILL_CHAR = "\u200B";
-  const logger$3K = getLogger("to-plain-text");
+  const logger$3L = getLogger("to-plain-text");
   function toPlainText(ops, options) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3K, typeof op.insert === "string", "invalid op");
+      assert(logger$3L, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         if (options == null ? void 0 : options.boxReplacement) {
           text2 += options.boxReplacement;
@@ -23096,11 +23090,11 @@ var __publicField = (obj, key, value) => {
       focus: pos
     };
   }
-  const logger$3J = getLogger("block-to-text");
+  const logger$3K = getLogger("block-to-text");
   function textBlockToText$1(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3J, typeof op.insert === "string", "invalid op");
+      assert(logger$3K, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -23118,11 +23112,11 @@ var __publicField = (obj, key, value) => {
     });
     return text2;
   }
-  const logger$3I = getLogger("block-to-text");
+  const logger$3J = getLogger("block-to-text");
   function textToMarkdownText(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3I, typeof op.insert === "string", "invalid op");
+      assert(logger$3J, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -23245,11 +23239,11 @@ var __publicField = (obj, key, value) => {
         return void 0;
     }
   }
-  const logger$3H = getLogger("block-to-text");
+  const logger$3I = getLogger("block-to-text");
   function textBlockToHtml(editor, ops, doc2) {
     let html = "";
     ops.forEach((op) => {
-      assert(logger$3H, typeof op.insert === "string", "invalid op");
+      assert(logger$3I, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -23318,16 +23312,16 @@ var __publicField = (obj, key, value) => {
     }
     return `<p>${html}</p>`;
   }
-  const logger$3G = getLogger("text-block");
+  const logger$3H = getLogger("text-block");
   function createBlockContent$5(editor, path, container, blockElement, blockData) {
     const { text: text2 } = blockData;
-    assert(logger$3G, text2, "no text for text block");
+    assert(logger$3H, text2, "no text for text block");
     const content = createBlockContentElement(blockElement, "div");
     updateBlockContent$1(editor, path, blockData.id, content, text2);
     return content;
   }
   function updateBlockText$1(editor, block, text2) {
-    assert(logger$3G, text2, "no text to update");
+    assert(logger$3H, text2, "no text to update");
     const newContent = createBlockContentElement(null, "div");
     updateBlockContent$1(editor, getBlockPath(block), getBlockId(block), newContent, text2);
     const oldContent = getBlockContent(block);
@@ -23354,7 +23348,7 @@ var __publicField = (obj, key, value) => {
     return res.trim();
   }
   function getBlockProperties$c(editor, block) {
-    assert(logger$3G, isTextKindBlock(editor, block), "block in not textBlock");
+    assert(logger$3H, isTextKindBlock(editor, block), "block in not textBlock");
     const range = editor.selection.range;
     let abstract = "";
     if (range.isCollapsed()) {
@@ -23364,7 +23358,7 @@ var __publicField = (obj, key, value) => {
       const blockId = getBlockId(block);
       const selectedBlock = getAllSelectedBlocks(editor, { simpleBlockOnly: true }).find((b) => getBlockId(b.block) === blockId);
       if (selectedBlock && !isEmptyTextBlock(editor, selectedBlock.block)) {
-        assert(logger$3G, selectedBlock.block === block, "block not match");
+        assert(logger$3H, selectedBlock.block === block, "block not match");
         const blockOps = editor.getBlockText(block);
         const { start, end } = selectedBlock;
         const offset = start.offset;
@@ -23380,7 +23374,7 @@ var __publicField = (obj, key, value) => {
     };
   }
   function convertTo$k(editor, blockData, doc2, type) {
-    assert(logger$3G, blockData.text, "no text for text block");
+    assert(logger$3H, blockData.text, "no text for text block");
     if (type === "text") {
       return textBlockToText$1(editor, blockData.text, doc2);
     }
@@ -23394,7 +23388,7 @@ var __publicField = (obj, key, value) => {
     blockData.id = genId();
     info == null ? void 0 : info.blockIdMap.set(srcBlockData.id, blockData.id);
     const { text: text2 } = blockData;
-    assert(logger$3G, text2, "no text for text block");
+    assert(logger$3H, text2, "no text for text block");
     text2.forEach((op) => {
       if (op.insert && op.attributes && op.attributes.box === true) {
         const boxId = genId();
@@ -23427,7 +23421,7 @@ var __publicField = (obj, key, value) => {
     blockToDoc: blockToDoc$1
   };
   const updateTextBlockContent = updateBlockContent$1;
-  const logger$3F = getLogger("action-helper");
+  const logger$3G = getLogger("action-helper");
   function editorGetBlockData(editor, block) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -23435,10 +23429,10 @@ var __publicField = (obj, key, value) => {
     return editor.doc.getBlockData(containerId, blockIndex);
   }
   function editorGetBlockText(editor, block) {
-    assert(logger$3F, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3G, isTextKindBlock(editor, block), "not a text kind block");
     const data2 = editorGetBlockData(editor, block);
     const text2 = data2.text;
-    assert(logger$3F, text2, "no text in block");
+    assert(logger$3G, text2, "no text in block");
     return text2;
   }
   function editorGetBlockTextEx(editor, block, length) {
@@ -23446,7 +23440,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetBoxData(editor, box) {
     const block = getParentBlock(box);
-    assert(logger$3F, block, "no parent block");
+    assert(logger$3G, block, "no parent block");
     const text2 = editorGetBlockText(editor, block);
     const id = getBoxId(box);
     const op = text2.find((op2) => {
@@ -23456,60 +23450,60 @@ var __publicField = (obj, key, value) => {
       }
       return false;
     });
-    assert(logger$3F, op, "failed to find box");
+    assert(logger$3G, op, "failed to find box");
     return op.attributes;
   }
-  const logger$3E = getLogger("block-text");
+  const logger$3F = getLogger("block-text");
   function getTextAfterOffset(editor, block, offset) {
-    assert(logger$3E, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3E, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3E, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3F, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3F, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3F, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3E, false, `no text after offset: ${offset}`);
+      assert(logger$3F, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3E, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3F, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3E, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3F, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getTextBeforeOffset(editor, block, offset) {
-    assert(logger$3E, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3E, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3E, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3F, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3F, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3F, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3E, false, `no text before offset: ${offset}`);
+      assert(logger$3F, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3E, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3F, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3E, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3F, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getOffsetInfoBefore(editor, block, offset) {
-    assert(logger$3E, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3E, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3E, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3F, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3F, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3F, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3E, false, `no text before offset: ${offset}`);
+      assert(logger$3F, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3E, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3F, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -23527,17 +23521,17 @@ var __publicField = (obj, key, value) => {
     };
   }
   function getOffsetInfoAfter(editor, block, offset) {
-    assert(logger$3E, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3E, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3E, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3F, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3F, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3F, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3E, false, `no text after offset: ${offset}`);
+      assert(logger$3F, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3E, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3F, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -23601,7 +23595,7 @@ var __publicField = (obj, key, value) => {
     return null;
   }
   function findWordLeft(editor, block, offset) {
-    assert(logger$3E, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3F, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -23629,7 +23623,7 @@ var __publicField = (obj, key, value) => {
     return startInfo.offset + startInfo.length;
   }
   function findWordEnd(editor, block, offset) {
-    assert(logger$3E, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3F, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -23656,10 +23650,10 @@ var __publicField = (obj, key, value) => {
       return getBlockTextLength$6(editor, block);
     return startInfo.offset;
   }
-  const logger$3D = getLogger("text-box");
+  const logger$3E = getLogger("text-box");
   function updateBoxContent$8(editor, boxElement, boxContent, boxData) {
-    assert(logger$3D, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
-    assert(logger$3D, typeof boxData.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3E, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3E, typeof boxData.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
     createElement("span", [], boxContent, boxData.text);
   }
   function convertTo$j(editor, boxData, doc2, type) {
@@ -23693,7 +23687,7 @@ var __publicField = (obj, key, value) => {
     updateBoxContent: updateBoxContent$7,
     convertTo: convertTo$i
   };
-  const logger$3C = getLogger("editor-boxes");
+  const logger$3D = getLogger("editor-boxes");
   class EditorBoxes {
     constructor(editor) {
       __publicField(this, "boxes", /* @__PURE__ */ new Map());
@@ -23702,12 +23696,12 @@ var __publicField = (obj, key, value) => {
     registerBoxClass(boxClass) {
       const type = boxClass.boxType;
       const exists = this.boxes.get(type);
-      assert(logger$3C, !exists, `duplicated box type: ${type}`);
+      assert(logger$3D, !exists, `duplicated box type: ${type}`);
       this.boxes.set(type, boxClass);
     }
     getBoxClass(type) {
       const exists = this.boxes.get(type);
-      assert(logger$3C, exists, `unknown box type: ${type}`);
+      assert(logger$3D, exists, `unknown box type: ${type}`);
       return exists;
     }
     createBox(blockContent, box) {
@@ -23758,7 +23752,7 @@ var __publicField = (obj, key, value) => {
     insertionType: "inputting",
     updateInsertionContent: updateInsertionContent$1
   };
-  const logger$3B = getLogger("editor-insertion");
+  const logger$3C = getLogger("editor-insertion");
   class EditorInsertions {
     constructor(editor) {
       __publicField(this, "insertions", /* @__PURE__ */ new Map());
@@ -23767,12 +23761,12 @@ var __publicField = (obj, key, value) => {
     registerInsertionClass(insertionClass) {
       const type = insertionClass.insertionType;
       const exists = this.insertions.get(type);
-      assert(logger$3B, !exists, `duplicated insertion type: ${type}`);
+      assert(logger$3C, !exists, `duplicated insertion type: ${type}`);
       this.insertions.set(type, insertionClass);
     }
     getInsertionClass(type) {
       const exists = this.insertions.get(type);
-      assert(logger$3B, exists, `unknown insertion type: ${type}`);
+      assert(logger$3C, exists, `unknown insertion type: ${type}`);
       return exists;
     }
     createInsertion(blockContent, insertion) {
@@ -23878,7 +23872,7 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$3A = getLogger("editor-input");
+  const logger$3B = getLogger("editor-input");
   class EditorInput {
     constructor(editor, callbacks) {
       __publicField(this, "editor");
@@ -24000,7 +23994,7 @@ var __publicField = (obj, key, value) => {
           return;
         }
         this.callbacks.onCut(event);
-        logger$3A.debug("on cut");
+        logger$3B.debug("on cut");
       });
       __publicField(this, "handlePaste", (event) => {
         if (event.isTrusted) {
@@ -24107,11 +24101,11 @@ var __publicField = (obj, key, value) => {
       this.callbacks.removeHandler(handler);
     }
     defaultInsertText(editor, containerId, blockIndex, offset, text2) {
-      assert(logger$3A, editor === this.editor, "invalid editor");
+      assert(logger$3B, editor === this.editor, "invalid editor");
       this.callbacks.defaultInsertText(editor, containerId, blockIndex, offset, text2);
     }
     defaultHandleKeydown(editor, event) {
-      assert(logger$3A, editor === this.editor, "invalid editor");
+      assert(logger$3B, editor === this.editor, "invalid editor");
       return this.callbacks.defaultHandleKeydown(editor, event);
     }
     forEach(callback) {
@@ -24136,7 +24130,7 @@ var __publicField = (obj, key, value) => {
     input2.style.left = `${x / scale}px`;
     input2.style.top = `${y / scale}px`;
   }
-  const logger$3z = getLogger("editor-caret");
+  const logger$3A = getLogger("editor-caret");
   function getFirefoxVersion() {
     const userAgent = window.navigator.userAgent;
     const match = userAgent.match(/Firefox\/(\d+)\./);
@@ -24199,11 +24193,11 @@ var __publicField = (obj, key, value) => {
         return;
       }
       const { range } = this.editor.selection;
-      assert(logger$3z, range.isCollapsed, "range is not collapsed");
+      assert(logger$3A, range.isCollapsed, "range is not collapsed");
       const pos = range.start;
-      assert(logger$3z, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
+      assert(logger$3A, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
       const block = this.editor.getBlockById(pos.blockId);
-      assert(logger$3z, isTextKindBlock(this.editor, block), "only text kind block can has caret");
+      assert(logger$3A, isTextKindBlock(this.editor, block), "only text kind block can has caret");
       let rect;
       const compositionSpan = block.querySelector("span.inputting-insertion");
       if (compositionSpan) {
@@ -24241,7 +24235,7 @@ var __publicField = (obj, key, value) => {
     clearAllSelection(editor);
     editor.selection.range.getSelectedBlocks().forEach((s) => updateBlockSelection(editor, s.block, s.start, s.end));
   }
-  const logger$3y = getLogger("editor-dom");
+  const logger$3z = getLogger("editor-dom");
   function editorGetClientHeight(editor) {
     const scrollContainer = getScrollContainer$1(editor.rootContainer);
     return scrollContainer.clientHeight;
@@ -24322,7 +24316,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorScrollIntoView(editor) {
     if (!isElementVisible(editor.rootContainer)) {
-      logger$3y.warn("editorScrollIntoView: editor is not visible");
+      logger$3z.warn("editorScrollIntoView: editor is not visible");
       return;
     }
     const rootClientRect = editor.rootContainer.getBoundingClientRect();
@@ -24387,7 +24381,7 @@ var __publicField = (obj, key, value) => {
     const { start, end } = range;
     return start.blockId === getBlockId(firstChildBlock) && start.offset === 0 && end.blockId === getBlockId(lastChildBlock) && end.offset === getBlockTextLength$6(editor, lastChildBlock);
   }
-  const logger$3x = getLogger("range-in-block");
+  const logger$3y = getLogger("range-in-block");
   function rangeInBlock(block, range) {
     const editor = range.getEditor();
     const start = editor.getBlockById(range.start.blockId);
@@ -24408,16 +24402,16 @@ var __publicField = (obj, key, value) => {
       while (prevBlock && !blocks.has(getBlockId(prevBlock))) {
         prevBlock = getPrevVisibleBlock(prevBlock);
       }
-      assert(logger$3x, prevBlock, "no prev block while deleting a block");
+      assert(logger$3y, prevBlock, "no prev block while deleting a block");
       newRange = createBlockSimpleRange(editor, prevBlock, getBlockTextLength$6(editor, prevBlock));
     } else {
       const nextBlock = getNextVisibleBlock(block);
-      assert(logger$3x, nextBlock, "no prev and next block while deleting a block");
+      assert(logger$3y, nextBlock, "no prev and next block while deleting a block");
       newRange = createBlockSimpleRange(editor, nextBlock, 0);
     }
     return newRange;
   }
-  const logger$3w = getLogger("block-to-html");
+  const logger$3x = getLogger("block-to-html");
   function blockToHtml(editor, blockData, doc2, path) {
     const blockClass = getBlockClassByType(editor, blockData.type);
     if (blockClass.convertTo) {
@@ -24426,15 +24420,15 @@ var __publicField = (obj, key, value) => {
     if (blockClass.blockKind !== "text") {
       return `[${blockData.type}]`;
     }
-    assert(logger$3w, blockData.text, "no text");
+    assert(logger$3x, blockData.text, "no text");
     const plainText = toPlainText(blockData.text);
     return `<div>${escapeHtmlText(plainText)}</div>`;
   }
-  const logger$3v = getLogger("block-to-text");
+  const logger$3w = getLogger("block-to-text");
   function textBlockToText(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3v, typeof op.insert === "string", "invalid op");
+      assert(logger$3w, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -24460,7 +24454,7 @@ var __publicField = (obj, key, value) => {
     if (blockClass.blockKind !== "text") {
       return `[${blockData.type}]`;
     }
-    assert(logger$3v, blockData.text, "no text");
+    assert(logger$3w, blockData.text, "no text");
     const plainText = textBlockToText(editor, blockData.text, doc2);
     return plainText;
   }
@@ -24493,11 +24487,11 @@ var __publicField = (obj, key, value) => {
     const markdown = lines.join("\n");
     return markdown;
   }
-  const logger$3u = getLogger("get-text-position");
+  const logger$3v = getLogger("get-text-position");
   function editorGetTextPosition(editor, insertPos) {
     const pos = insertPos != null ? insertPos : editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3u, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3v, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
@@ -24513,14 +24507,14 @@ var __publicField = (obj, key, value) => {
       offset
     };
   }
-  const logger$3t = getLogger("insert-text");
+  const logger$3u = getLogger("insert-text");
   function getTextAttributes(editor, containerId, blockIndex, offset) {
     var _a;
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3t, blockData, "no block data");
-    assert(logger$3t, blockData.text, "no block text");
+    assert(logger$3u, blockData, "no block data");
+    assert(logger$3u, blockData.text, "no block text");
     if (getTextLength(blockData.text) === 0) {
-      assert(logger$3t, offset === 0, "invalid text offset");
+      assert(logger$3u, offset === 0, "invalid text offset");
       return editor.editorCommandProviders.getEmptyBlockTextAttributes(editor, blockData.id);
     }
     if (offset === 0) {
@@ -24562,7 +24556,7 @@ var __publicField = (obj, key, value) => {
     }
     for (let i = 0; i < text2.length; i++) {
       const op = text2[i];
-      assert(logger$3t, typeof op.insert === "string", "invalid text op, no insert");
+      assert(logger$3u, typeof op.insert === "string", "invalid text op, no insert");
       const endPos = pos + getOpLength(op);
       if (endPos === start) {
         return false;
@@ -24576,8 +24570,8 @@ var __publicField = (obj, key, value) => {
   }
   function editorInsertTextToBlockEx(editor, text2, containerId, blockIndex, offset) {
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3t, blockData, "no block data");
-    assert(logger$3t, blockData.text, "no block text");
+    assert(logger$3u, blockData, "no block data");
+    assert(logger$3u, blockData.text, "no block text");
     const attributes = getTextAttributes(editor, containerId, blockIndex, offset);
     if (attributes && Object.keys(attributes).includes("link")) {
       const inOp = checkRangeInOp(blockData.text, offset);
@@ -24596,21 +24590,21 @@ var __publicField = (obj, key, value) => {
     const { containerId, blockIndex, offset } = editorGetTextPosition(editor);
     editorInsertTextToBlockEx(editor, text2, containerId, blockIndex, offset);
   }
-  const logger$3s = getLogger("update-composition-text");
+  const logger$3t = getLogger("update-composition-text");
   function editorUpdateCompositionText(editor) {
     const pos = editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3s, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3t, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
-    assert(logger$3s, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3t, isTextKindBlock(editor, block), "not a text kind block");
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3s, blockData, "no block data in doc");
-    assert(logger$3s, blockData.text, "no text data in text block");
+    assert(logger$3t, blockData, "no block data in doc");
+    assert(logger$3t, blockData.text, "no text data in text block");
     const blockContent = getBlockContent(block);
     updateBlockContent$1(editor, getBlockPath(block), blockId, blockContent, blockData.text);
   }
@@ -24622,25 +24616,25 @@ var __publicField = (obj, key, value) => {
     const block = editor.getBlockById(blockData.id);
     return block;
   }
-  const logger$3r = getLogger("delete-block-text");
+  const logger$3s = getLogger("delete-block-text");
   function editorDeleteBlockText(editor, block, offset, count, options) {
     if (!editor.isBlockWritable(block)) {
-      logger$3r.error("block is not writable");
+      logger$3s.error("block is not writable");
       return 0;
     }
-    assert(logger$3r, isTextKindBlock(editor, block), "block is not a text kind block");
+    assert(logger$3s, isTextKindBlock(editor, block), "block is not a text kind block");
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3r, blockData, "no block data in doc");
-    assert(logger$3r, blockData.text, "no text data in text block");
+    assert(logger$3s, blockData, "no block data in doc");
+    assert(logger$3s, blockData.text, "no text data in text block");
     let from = offset;
     if (!isValidOffset(block, offset)) {
       from = getPrevValidOffset(block, from);
     }
     let to = offset + count;
-    assert(logger$3r, to <= getBlockTextLength$6(editor, block), `invalid offset and count: ${offset}, ${count}`);
+    assert(logger$3s, to <= getBlockTextLength$6(editor, block), `invalid offset and count: ${offset}, ${count}`);
     if (!isValidOffset(block, to)) {
       to = getNextValidOffset(block, to);
     }
@@ -24649,7 +24643,7 @@ var __publicField = (obj, key, value) => {
     editor.doc.localUpdateBlockText(containerId, blockIndex, actions2, options);
     return deleteCount;
   }
-  const logger$3q = getLogger("break-text-block");
+  const logger$3r = getLogger("break-text-block");
   function copyBlockAttributes(editor, block) {
     const blockData = editor.getBlockData(block);
     const quoted = blockData.quoted;
@@ -24661,8 +24655,8 @@ var __publicField = (obj, key, value) => {
     return {};
   }
   function editorBreakTextBlock(editor, block, offset, options) {
-    assert(logger$3q, isTextKindBlock(editor, block), `block is not a text kind block: ${getBlockType(block)}`);
-    assert(logger$3q, offset >= 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3r, isTextKindBlock(editor, block), `block is not a text kind block: ${getBlockType(block)}`);
+    assert(logger$3r, offset >= 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
@@ -24692,7 +24686,7 @@ var __publicField = (obj, key, value) => {
         };
       }
     }
-    assert(logger$3q, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3r, isValidOffset(block, offset), "not a valid offset");
     const text2 = editorGetBlockText(editor, block);
     const { right } = splitText(text2, offset);
     const rightLength = getTextLength(right);
@@ -24718,12 +24712,12 @@ var __publicField = (obj, key, value) => {
       newBlock
     };
   }
-  const logger$3p = getLogger("prepare-insert-new-block");
+  const logger$3q = getLogger("prepare-insert-new-block");
   function editorPrepareInsertNewBlock(editor, containerId, blockIndex) {
     if (containerId && blockIndex !== void 0 && blockIndex !== null) {
       const container = editor.getContainerById(containerId);
       const blocks = getChildBlocks(container);
-      assert(logger$3p, blockIndex >= 0 && blockIndex <= blocks.length, `invalid blockIndex: ${blockIndex}`);
+      assert(logger$3q, blockIndex >= 0 && blockIndex <= blocks.length, `invalid blockIndex: ${blockIndex}`);
       return {
         containerId,
         blockIndex
@@ -24757,15 +24751,15 @@ var __publicField = (obj, key, value) => {
       blockIndex: getBlockIndex(newBlock)
     };
   }
-  const logger$3o = getLogger("auto-insert-block");
+  const logger$3p = getLogger("auto-insert-block");
   function editorAutoInsertBlock(editor, blockData, containerId, blockIndex, newRange, insertBlockOptions) {
     const result = editorPrepareInsertNewBlock(editor, containerId, blockIndex);
-    assert(logger$3o, result, `not an valid insert position: ${editor.selection.range}`);
+    assert(logger$3p, result, `not an valid insert position: ${editor.selection.range}`);
     const defaultPos = { blockId: blockData.id, offset: 0 };
     const defaultRange = { anchor: defaultPos, focus: defaultPos };
     return editorInsertBlock(editor, result.containerId, result.blockIndex, blockData, newRange != null ? newRange : defaultRange, insertBlockOptions);
   }
-  const logger$3n = getLogger("delete-block");
+  const logger$3o = getLogger("delete-block");
   function getAllChildContainers(editor, blockData, containerIds) {
     if (blockData.children) {
       containerIds.push(...blockData.children);
@@ -24782,7 +24776,7 @@ var __publicField = (obj, key, value) => {
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3n, blockData, "no block data in doc");
+    assert(logger$3o, blockData, "no block data in doc");
     editor.doc.localDeleteBlock(containerId, blockIndex, createEditorSelectionRange(editor, { anchor: newRange.start, focus: newRange.end }));
     return blockData;
   }
@@ -24828,15 +24822,15 @@ var __publicField = (obj, key, value) => {
     });
     editor.doc.localDeleteChildContainers(containerIds);
   }
-  const logger$3m = getLogger("merge-text-block");
+  const logger$3n = getLogger("merge-text-block");
   function editorMergeTextBlock(editor, block1, block2) {
-    assert(logger$3m, isTextKindBlock(editor, block1), "only text block can be merged");
-    assert(logger$3m, isTextKindBlock(editor, block2), "only text block can be merged");
+    assert(logger$3n, isTextKindBlock(editor, block1), "only text block can be merged");
+    assert(logger$3n, isTextKindBlock(editor, block2), "only text block can be merged");
     const data1 = editorGetBlockData(editor, block1);
     const data2 = editorGetBlockData(editor, block2);
     const text1 = data1.text;
     const text2 = data2.text;
-    assert(logger$3m, text1 && text2, "block data has no text");
+    assert(logger$3n, text1 && text2, "block data has no text");
     const container = getParentContainer(block1);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block1);
@@ -24846,15 +24840,15 @@ var __publicField = (obj, key, value) => {
     editorDeleteBlock(editor, block2, newRange);
     return block;
   }
-  const logger$3l = getLogger("clear-selected-contents");
+  const logger$3m = getLogger("clear-selected-contents");
   function deleteTextBlockSelection(editor, selectedBlock) {
-    assert(logger$3l, isTextKindBlock(editor, selectedBlock.block), "not a text kind block");
+    assert(logger$3m, isTextKindBlock(editor, selectedBlock.block), "not a text kind block");
     const { start, end } = selectedBlock;
-    assert(logger$3l, start.isSimple(), "not a simple block position");
-    assert(logger$3l, end.isSimple(), "not a simple block position");
+    assert(logger$3m, start.isSimple(), "not a simple block position");
+    assert(logger$3m, end.isSimple(), "not a simple block position");
     const startOffset = start.offset;
     const endOffset = end.offset;
-    assert(logger$3l, startOffset <= endOffset, `invalid delete text offset: ${startOffset}, ${endOffset}`);
+    assert(logger$3m, startOffset <= endOffset, `invalid delete text offset: ${startOffset}, ${endOffset}`);
     if (startOffset === endOffset) {
       return;
     }
@@ -24879,7 +24873,7 @@ var __publicField = (obj, key, value) => {
       return;
     }
     if (isEmbedBlock(block) || start.isSimple()) {
-      assert(logger$3l, end.isSimple(), "invalid range");
+      assert(logger$3m, end.isSimple(), "invalid range");
       const container = getParentContainer(block);
       const blockIndex = getBlockIndex(block);
       const newBlock = editor.insertTextBlock("", getContainerId(container), blockIndex);
@@ -24887,8 +24881,8 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
       return;
     }
-    assert(logger$3l, isComplexKindBlock(editor, block), "invalid block kind");
-    assert(logger$3l, !start.isSimple() && !end.isSimple(), "invalid range");
+    assert(logger$3m, isComplexKindBlock(editor, block), "invalid block kind");
+    assert(logger$3m, !start.isSimple() && !end.isSimple(), "invalid range");
     complexBlockGetSelectedContainers(editor, block, start, end);
     const containers = editor.selection.range.getSelectedContainers();
     containers.forEach((container, index2) => {
@@ -24906,7 +24900,7 @@ var __publicField = (obj, key, value) => {
       return;
     }
     const selectedBlocks = range.getSelectedBlocks();
-    assert(logger$3l, selectedBlocks.length > 0, "no selected block");
+    assert(logger$3m, selectedBlocks.length > 0, "no selected block");
     if (selectedBlocks.length === 1) {
       clearOneBlock(editor, selectedBlocks[0]);
       return;
@@ -24914,7 +24908,7 @@ var __publicField = (obj, key, value) => {
     const firstSelectedBlock = selectedBlocks[0];
     const firstBlock = firstSelectedBlock.block;
     const container = getParentContainer(firstBlock);
-    assert(logger$3l, selectedBlocks.length > 1, "no selected block");
+    assert(logger$3m, selectedBlocks.length > 1, "no selected block");
     const lastSelectedBlock = selectedBlocks[selectedBlocks.length - 1];
     const lastBlock2 = lastSelectedBlock.block;
     if (isTextKindBlock(editor, firstBlock)) {
@@ -24944,7 +24938,7 @@ var __publicField = (obj, key, value) => {
     }
     const prevBlock = getPrevBlock(firstBlock);
     const nextBlock = getNextBlock(lastBlock2);
-    assert(logger$3l, prevBlock || nextBlock, "no prev or next block");
+    assert(logger$3m, prevBlock || nextBlock, "no prev or next block");
     selectedBlocks.forEach((selectedBlock) => editor.deleteBlock(selectedBlock.block));
   }
   function editorClearSelectedContents(editor) {
@@ -24963,7 +24957,7 @@ var __publicField = (obj, key, value) => {
       editor.emit("afterClearSelection", editor);
     });
   }
-  const logger$3k = getLogger("core");
+  const logger$3l = getLogger("core");
   function editorUpdateBlockText(editor, block, ops, options) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -24976,7 +24970,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorSetBlockText(editor, block, newText, options) {
     if (!editor.isBlockWritable(block)) {
-      logger$3k.error("block is not writable");
+      logger$3l.error("block is not writable");
       return;
     }
     const oldText = editor.getBlockText(block);
@@ -24989,7 +24983,7 @@ var __publicField = (obj, key, value) => {
     const ops = RichText.diff(oldText, newText);
     return editorUpdateBlockText(editor, block, ops);
   }
-  const logger$3j = getLogger("update-block-data");
+  const logger$3k = getLogger("update-block-data");
   function editorUpdateBlockData(editor, block, data2, newRange, options) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -25006,17 +25000,17 @@ var __publicField = (obj, key, value) => {
         if (oldKey === "id" || oldKey === "type" || oldKey === "text") {
           return;
         }
-        logger$3j.debug(`delete key: ${oldKey}`);
+        logger$3k.debug(`delete key: ${oldKey}`);
         delta.delete.push(oldKey);
       }
     });
     const entries = Object.entries(data2);
     entries.forEach(([key, value]) => {
-      assert(logger$3j, key !== "id" && key !== "type", `invalid block data delta, ${key}`);
+      assert(logger$3k, key !== "id" && key !== "type", `invalid block data delta, ${key}`);
       const oldValue = oldData[key];
       if (value === null || value === void 0) {
         if (oldValue !== null && oldValue !== void 0) {
-          logger$3j.debug(`delete key: ${key}`);
+          logger$3k.debug(`delete key: ${key}`);
           delta.delete.push(key);
         }
         return;
@@ -25034,10 +25028,10 @@ var __publicField = (obj, key, value) => {
         }
       }
       if (oldKeys.has(key)) {
-        logger$3j.debug(`replace key: ${key}`);
+        logger$3k.debug(`replace key: ${key}`);
         delta.delete.push(key);
       } else {
-        logger$3j.debug(`insert key: ${key}`);
+        logger$3k.debug(`insert key: ${key}`);
       }
       delta.insert[key] = value;
     });
@@ -25082,13 +25076,13 @@ var __publicField = (obj, key, value) => {
       comments: {}
     };
   }
-  const logger$3i = getLogger("clone-block");
+  const logger$3j = getLogger("clone-block");
   function cloneBlock(editorBlocks, oldDoc, data2, info) {
     var _a;
     const blockClass = editorBlocks.getBlockClass(data2.type);
     if (blockClass.blockToDoc) {
       return blockClass.blockToDoc(oldDoc, data2, (oldDoc2, childBlock) => {
-        assert(logger$3i, data2 !== childBlock, "invalid child block");
+        assert(logger$3j, data2 !== childBlock, "invalid child block");
         return cloneBlock(editorBlocks, oldDoc2, data2, info);
       }, info);
     }
@@ -25101,7 +25095,7 @@ var __publicField = (obj, key, value) => {
       }
       const newChildContainerId = genId();
       const childBlocks = oldDoc.blocks[oldChildContainerId];
-      assert(logger$3i, Array.isArray(childBlocks), "invalid child blocks");
+      assert(logger$3j, Array.isArray(childBlocks), "invalid child blocks");
       const newDocs = childBlocks.map((c) => cloneBlock(editorBlocks, oldDoc, c, info));
       const newDoc = mergeDocs(newDocs);
       const { root: root2, ...childContainersData } = newDoc.blocks;
@@ -25130,7 +25124,7 @@ var __publicField = (obj, key, value) => {
           if (key.startsWith(prefix1)) {
             const keyContent = key.substring(prefix1.length);
             const newKey = `${newContainerId}/${keyContent}`;
-            logger$3i.debug(`replace key: ${key} -> ${newKey}`);
+            logger$3j.debug(`replace key: ${key} -> ${newKey}`);
             return newKey;
           }
         }
@@ -25139,7 +25133,7 @@ var __publicField = (obj, key, value) => {
           if (key.startsWith(prefix2)) {
             const keyContent = key.substring(prefix2.length);
             const newKey = `${newContainerId}_${keyContent}`;
-            logger$3i.debug(`replace key: ${key} -> ${newKey}`);
+            logger$3j.debug(`replace key: ${key} -> ${newKey}`);
             return newKey;
           }
         }
@@ -25169,7 +25163,7 @@ var __publicField = (obj, key, value) => {
   }
   function cloneChildContainer(editorBlocks, oldDoc, containerId, info) {
     const blocks = oldDoc.blocks[containerId];
-    assert(logger$3i, Array.isArray(blocks), "invalid child blocks");
+    assert(logger$3j, Array.isArray(blocks), "invalid child blocks");
     const newDocs = blocks.map((c) => cloneBlock(editorBlocks, oldDoc, c, info));
     const newDoc = mergeDocs(newDocs);
     return newDoc;
@@ -25178,10 +25172,10 @@ var __publicField = (obj, key, value) => {
     const docs = doc2.blocks.root.map((b) => cloneBlock(editor.editorBlocks, doc2, b, info));
     return cloneDeep__default.default(mergeDocs(docs));
   }
-  const logger$3h = getLogger("insert-doc");
+  const logger$3i = getLogger("insert-doc");
   function editorInsertDoc(editor, block, offset, insertedDoc, cloneDocResult) {
     if (isComplexKindBlock(editor, block)) {
-      logger$3h.warn("failed to insert doc into a complex block");
+      logger$3i.warn("failed to insert doc into a complex block");
       return;
     }
     const doc2 = cloneDoc(editor, insertedDoc, cloneDocResult);
@@ -25215,7 +25209,7 @@ var __publicField = (obj, key, value) => {
         }
         return;
       }
-      assert(logger$3h, isTextKindBlock(editor, block), "not a text block");
+      assert(logger$3i, isTextKindBlock(editor, block), "not a text block");
       if (isEmptyTextBlock(editor, block)) {
         const blockIndex2 = getBlockIndex(block);
         let lastBlock22;
@@ -25347,11 +25341,11 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
     }
   }
-  const logger$3g = getLogger("add-text-attribute");
+  const logger$3h = getLogger("add-text-attribute");
   function editorRemoveTextAttribute(editor, block, range, attributeName) {
     const { start, end } = range;
-    assert(logger$3g, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
-    assert(logger$3g, attributeName, "invalid attribute name");
+    assert(logger$3h, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3h, attributeName, "invalid attribute name");
     const oldText = editor.getBlockText(block);
     const newText = rangeRemoveAttribute(start.offset, end.offset - start.offset, oldText, attributeName, void 0, { ignoreValue: true });
     editor.setBlockText(block, newText);
@@ -25359,8 +25353,8 @@ var __publicField = (obj, key, value) => {
   }
   function editorAddTextAttribute(editor, block, range, attributeName, value) {
     const { start, end } = range;
-    assert(logger$3g, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
-    assert(logger$3g, attributeName, "invalid attribute name");
+    assert(logger$3h, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3h, attributeName, "invalid attribute name");
     const oldText = editor.getBlockText(block);
     const newText = rangeAddAttribute(start.offset, end.offset - start.offset, oldText, attributeName, value);
     editor.setBlockText(block, newText);
@@ -25368,7 +25362,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorSetTextColor(editor, block, range, type, value) {
     const { start, end } = range;
-    assert(logger$3g, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3h, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
     const oldText = editor.getBlockText(block);
     const newText = rangeSetTextColor(start.offset, end.offset - start.offset, oldText, type, value);
     editor.setBlockText(block, newText);
@@ -25457,7 +25451,7 @@ var __publicField = (obj, key, value) => {
     });
     return [color, backgroundColor];
   }
-  const logger$3f = getLogger("adjust-selection-pos");
+  const logger$3g = getLogger("adjust-selection-pos");
   function getParentContainers(block) {
     const containers = [];
     while (block) {
@@ -25467,10 +25461,10 @@ var __publicField = (obj, key, value) => {
         return containers;
       }
       const newBlock = getParentBlock(container);
-      assert(logger$3f, newBlock, "child container has not parent container");
+      assert(logger$3g, newBlock, "child container has not parent container");
       block = newBlock;
     }
-    assert(logger$3f, false, "should not come here: getParentContainers");
+    assert(logger$3g, false, "should not come here: getParentContainers");
   }
   function getParentBlockInContainer(container, block) {
     while (block) {
@@ -25479,16 +25473,16 @@ var __publicField = (obj, key, value) => {
         return block;
       }
       const newBlock = getParentBlock(parent);
-      assert(logger$3f, newBlock, "could not find parent block for a child container");
+      assert(logger$3g, newBlock, "could not find parent block for a child container");
       block = newBlock;
     }
-    assert(logger$3f, false, "no parent block in specified container");
+    assert(logger$3g, false, "no parent block in specified container");
   }
   function getClosestParentBlock(block1, block2) {
     const containers1 = getParentContainers(block1);
     const containers2 = getParentContainers(block2);
-    assert(logger$3f, containers1.length > 0 && containers2.length > 0, "block has not parent container");
-    assert(logger$3f, containers1[0] === containers2[0], "root container does not equal");
+    assert(logger$3g, containers1.length > 0 && containers2.length > 0, "block has not parent container");
+    assert(logger$3g, containers1[0] === containers2[0], "root container does not equal");
     let parentContainer = containers1[0];
     for (let i = 1; i < containers1.length || containers2.length; i++) {
       if (containers1[i] === containers2[i]) {
@@ -25507,18 +25501,18 @@ var __publicField = (obj, key, value) => {
   }
   function getParentContainerInComplexBlock(parentComplexBlock, element) {
     let block = getParentBlock(element);
-    assert(logger$3f, block, "element is not in a block");
+    assert(logger$3g, block, "element is not in a block");
     while (block) {
       const container = getParentContainer(block);
-      assert(logger$3f, isChildContainer(container), "not a child container");
+      assert(logger$3g, isChildContainer(container), "not a child container");
       const parentBlock = getParentBlock(container);
-      assert(logger$3f, parentBlock, "child container has not parent block");
+      assert(logger$3g, parentBlock, "child container has not parent block");
       if (parentBlock === parentComplexBlock) {
         return container;
       }
       block = parentBlock;
     }
-    assert(logger$3f, false, "failed to find parent container in complex block");
+    assert(logger$3g, false, "failed to find parent container in complex block");
   }
   function adjustSelectionPos$1(editor, anchor2, focus) {
     const anchorBlock = editor.getBlockById(anchor2.blockId);
@@ -25544,8 +25538,8 @@ var __publicField = (obj, key, value) => {
       if (focus instanceof EditorComplexBlockPosition) {
         focus = createSimpleBlockPosition(focusBlock, getBlockTextLength$6(editor, focusBlock), "end");
       }
-      assert(logger$3f, anchor2 instanceof EditorSimpleBlockPosition, "not valid position type");
-      assert(logger$3f, focus instanceof EditorSimpleBlockPosition, "not valid position type");
+      assert(logger$3g, anchor2 instanceof EditorSimpleBlockPosition, "not valid position type");
+      assert(logger$3g, focus instanceof EditorSimpleBlockPosition, "not valid position type");
       return {
         anchor: anchor2,
         focus
@@ -25580,7 +25574,7 @@ var __publicField = (obj, key, value) => {
       const focusChildContainer = getParentContainerInComplexBlock(parentComplexBlock, focusBlock);
       anchor2 = createComplexBlockPosition(newAnchorBlock, getContainerId(anchorChildContainer));
       focus = createComplexBlockPosition(newAnchorBlock, getContainerId(focusChildContainer));
-      logger$3f.debug(`select in complex block: ${anchorChildContainer.id}, ${focusChildContainer.id}`);
+      logger$3g.debug(`select in complex block: ${anchorChildContainer.id}, ${focusChildContainer.id}`);
       return complexBlockAdjustSelectionPos(editor, parentComplexBlock, anchor2, focus);
     }
     let anchorOffsetNormal = reverse ? getBlockTextLength$6(editor, newAnchorBlock) : 0;
@@ -25600,10 +25594,10 @@ var __publicField = (obj, key, value) => {
       focus
     };
   }
-  const logger$3e = getLogger("move-complex-block-position");
+  const logger$3f = getLogger("move-complex-block-position");
   function moveComplexBlockPosition(editor, old, type) {
     const block = editor.getBlockById(old.blockId);
-    assert(logger$3e, isComplexKindBlock(editor, block), "is not a complex block");
+    assert(logger$3f, isComplexKindBlock(editor, block), "is not a complex block");
     const blockClass = getComplexBlockClass(editor, block);
     const focusedContainer = editor.getContainerById(old.childContainerId);
     const nextContainer = blockClass.getNextContainer(editor, block, focusedContainer, type, { noWrap: true });
@@ -25612,24 +25606,24 @@ var __publicField = (obj, key, value) => {
     }
     return createComplexBlockPosition(block, getContainerId(nextContainer));
   }
-  const logger$3d = getLogger("move-simple-block-position");
+  const logger$3e = getLogger("move-simple-block-position");
   function getFirstChildBlockInComplexBlock(editor, complexBlock) {
     const containers = complexBlockGetAllChildContainers(editor, complexBlock, { visibleOnly: true });
     if (containers.length === 0) {
-      logger$3d.warn("complex block has not any child container, not loaded?");
+      logger$3e.warn("complex block has not any child container, not loaded?");
       return null;
     }
-    assert(logger$3d, containers.length > 0, "complex block has not any child container");
+    assert(logger$3e, containers.length > 0, "complex block has not any child container");
     const container = containers[0];
     return getFirstChildBlock(container);
   }
   function getLastChildBlockInComplexBlock(editor, complexBlock) {
     const containers = complexBlockGetAllChildContainers(editor, complexBlock, { visibleOnly: true });
     if (containers.length === 0) {
-      logger$3d.warn("complex block has not any child container, not loaded?");
+      logger$3e.warn("complex block has not any child container, not loaded?");
       return null;
     }
-    assert(logger$3d, containers.length > 0, "complex block has not any child container");
+    assert(logger$3e, containers.length > 0, "complex block has not any child container");
     const container = containers[containers.length - 1];
     return getLastChildBlock(container);
   }
@@ -25674,8 +25668,8 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const parentComplexBlock = getParentBlock(container);
-    assert(logger$3d, parentComplexBlock, "child container has not parent block");
-    assert(logger$3d, isComplexKindBlock(editor, parentComplexBlock), "is not a complex block");
+    assert(logger$3e, parentComplexBlock, "child container has not parent block");
+    assert(logger$3e, isComplexKindBlock(editor, parentComplexBlock), "is not a complex block");
     const nextContainer = getComplexBlockClass(editor, parentComplexBlock).getNextContainer(editor, parentComplexBlock, container, type);
     if (nextContainer) {
       if (isFindPrev(type)) {
@@ -25693,7 +25687,7 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const parentBlock = getParentBlock(container);
-    assert(logger$3d, parentBlock, "child container has not parent block");
+    assert(logger$3e, parentBlock, "child container has not parent block");
     if (isFindPrev(type)) {
       const prev = getPrevBlock(parentBlock);
       if (prev) {
@@ -25748,7 +25742,7 @@ var __publicField = (obj, key, value) => {
     }
     if (!targetBlock) {
       if (isComplexKindBlock(editor, block) && complexBlockGetAllChildContainers(editor, block).length === 0) {
-        logger$3d.warn("complex block has not any child container, not loaded?");
+        logger$3e.warn("complex block has not any child container, not loaded?");
         targetBlock = direction === "ArrowDown" || direction === "ArrowRight" ? getNextVisibleBlock(block) : getPrevVisibleBlock(block);
       }
     }
@@ -25895,10 +25889,10 @@ var __publicField = (obj, key, value) => {
     editorAdjustSelection(editor, "ArrowUp", "select");
     return true;
   }
-  const logger$3c = getLogger("word-offset");
+  const logger$3d = getLogger("word-offset");
   function editorGetWordLeftPos(editor, type) {
     const old = editor.selection.range.focus;
-    assert(logger$3c, old.isSimple(), "invalid range type");
+    assert(logger$3d, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (isEmptyTextBlock(editor, block)) {
       return createSimpleBlockPosition(block, 0, "home");
@@ -25923,7 +25917,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetWordRightPos(editor, type) {
     const old = editor.selection.range.focus;
-    assert(logger$3c, old.isSimple(), "invalid range type");
+    assert(logger$3d, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (isEmptyTextBlock(editor, block)) {
       return createSimpleBlockPosition(block, 0, "end");
@@ -26035,10 +26029,10 @@ var __publicField = (obj, key, value) => {
     editor.selection.setSelection(editor.selection.getAnchorPos(), pos);
     return true;
   }
-  const logger$3b = getLogger("line-offset");
+  const logger$3c = getLogger("line-offset");
   function editorGetLineHomePos(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3b, old.isSimple(), "invalid range type");
+    assert(logger$3c, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (old.offset === 0 || !isTextKindBlock(editor, block)) {
       const newPos2 = createSimpleBlockPosition(block, 0, "home");
@@ -26055,7 +26049,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetLineEndPos(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3b, old.isSimple(), "invalid range type");
+    assert(logger$3c, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (old.offset === getBlockTextLength$6(editor, block) || !isTextKindBlock(editor, block)) {
       const newPos2 = createSimpleBlockPosition(block, getBlockTextLength$6(editor, block), "end");
@@ -26155,7 +26149,7 @@ var __publicField = (obj, key, value) => {
     editorPageDownScroll(editor);
     return true;
   }
-  const logger$3a = getLogger("table-scroll");
+  const logger$3b = getLogger("table-scroll");
   class DomEventHandler {
     constructor(editor, dom, name, handler, data2) {
       __publicField(this, "handleEvent", (event) => {
@@ -26187,7 +26181,7 @@ var __publicField = (obj, key, value) => {
       const existsHandlers = this.handlers.get(element);
       if (existsHandlers) {
         if (existsHandlers.find((handler) => handler.handler === eventHandler && handler.name === eventName)) {
-          logger$3a.warn(`event has already registered: ${eventName}`);
+          logger$3b.warn(`event has already registered: ${eventName}`);
           return;
         }
         existsHandlers.push(new DomEventHandler(this.editor, element, eventName, eventHandler, data2));
@@ -26297,7 +26291,7 @@ var __publicField = (obj, key, value) => {
     });
     return true;
   }
-  const logger$39 = getLogger("select-all");
+  const logger$3a = getLogger("select-all");
   function isContainerSelectedAllChildBlocks(container, range) {
     const firstBlock = getFirstChildBlock(container);
     const lastBlock2 = getLastChildBlock(container);
@@ -26312,8 +26306,8 @@ var __publicField = (obj, key, value) => {
     return range.start.blockId === blockId && range.start.childContainerId === getContainerId(first) && range.end.blockId === blockId && range.end.childContainerId === getContainerId(last);
   }
   function selectComplexBlock(editor, block) {
-    assert(logger$39, block, "no parent block");
-    assert(logger$39, isComplexKindBlock(editor, block), "not a complex block");
+    assert(logger$3a, block, "no parent block");
+    assert(logger$3a, isComplexKindBlock(editor, block), "not a complex block");
     const containers = getComplexBlockClass(editor, block).getChildContainers(editor, block);
     const first = containers[0];
     const last = containers[containers.length - 1];
@@ -26349,13 +26343,13 @@ var __publicField = (obj, key, value) => {
       selectParentContainer(editor, getFirstChildBlock(editor.rootContainer));
       return false;
     }
-    assert(logger$39, !range.isSimple(), "invalid range type");
+    assert(logger$3a, !range.isSimple(), "invalid range type");
     if (isComplexBlockSelectedAllChildContainer(focusedBlock, range)) {
       selectParentContainer(editor, focusedBlock);
       return false;
     }
-    assert(logger$39, focusedBlock, "no parent block");
-    assert(logger$39, isComplexKindBlock(editor, focusedBlock), "not a complex block");
+    assert(logger$3a, focusedBlock, "no parent block");
+    assert(logger$3a, isComplexKindBlock(editor, focusedBlock), "not a complex block");
     selectComplexBlock(editor, focusedBlock);
     return true;
   }
@@ -26446,7 +26440,7 @@ var __publicField = (obj, key, value) => {
     }
     return cloned;
   }
-  const logger$38 = getLogger("selected-block-to-doc");
+  const logger$39 = getLogger("selected-block-to-doc");
   function appendBlockChildren(editor, data2, doc2) {
     if (!data2.children)
       return;
@@ -26467,7 +26461,7 @@ var __publicField = (obj, key, value) => {
     if (isTextKindBlock(editor, selectedBlock.block)) {
       const start = selectedBlock.start;
       const end = selectedBlock.end;
-      assert(logger$38, data2.text, "no block text");
+      assert(logger$39, data2.text, "no block text");
       if (start.offset === end.offset) {
         return {
           blocks: {
@@ -26501,8 +26495,8 @@ var __publicField = (obj, key, value) => {
         comments: {}
       };
     }
-    assert(logger$38, isComplexKindBlock(editor, selectedBlock.block), "not complex block");
-    assert(logger$38, data2.children, "no children");
+    assert(logger$39, isComplexKindBlock(editor, selectedBlock.block), "not complex block");
+    assert(logger$39, data2.children, "no children");
     const ret = {
       blocks: {
         root: [
@@ -26520,9 +26514,9 @@ var __publicField = (obj, key, value) => {
     const end = createSimpleBlockPosition(block, getBlockTextLength$6(editor, block), "end");
     return selectedBlockToDoc(editor, { block, start, end });
   }
-  const logger$37 = getLogger("block-to-doc");
+  const logger$38 = getLogger("block-to-doc");
   function blocksToDoc(editor, blocks) {
-    assert(logger$37, blocks.length > 0, "invalid params, no blocks");
+    assert(logger$38, blocks.length > 0, "invalid params, no blocks");
     const docs = blocks.map((b) => blockToDoc(editor, b));
     return mergeDocs(docs);
   }
@@ -26542,7 +26536,7 @@ var __publicField = (obj, key, value) => {
     const newDocs = selectedBlocks.map((s) => selectedBlockToDoc(editor, s));
     return mergeDocs(newDocs);
   }
-  const logger$36 = getLogger("ensure-block-visible");
+  const logger$37 = getLogger("ensure-block-visible");
   function ensureBlockVisible(editor, block) {
     var _a;
     while (block) {
@@ -26552,16 +26546,16 @@ var __publicField = (obj, key, value) => {
         return;
       }
       const parentComplexBlock = getParentBlock(container);
-      assert(logger$36, parentComplexBlock, "no parent block");
+      assert(logger$37, parentComplexBlock, "no parent block");
       const parentComplexBlockClass = getBlockClass(editor, parentComplexBlock);
       if (parentComplexBlockClass.isChildContainerVisible && !((_a = parentComplexBlockClass.isChildContainerVisible) == null ? void 0 : _a.call(parentComplexBlockClass, editor, parentComplexBlock, container))) {
-        assert(logger$36, parentComplexBlockClass.showChildContainer, "no showChildContainer method");
+        assert(logger$37, parentComplexBlockClass.showChildContainer, "no showChildContainer method");
         parentComplexBlockClass.showChildContainer(editor, parentComplexBlock, container);
       }
       block = parentComplexBlock;
     }
   }
-  const logger$35 = getLogger("editor-selection");
+  const logger$36 = getLogger("editor-selection");
   class EditorSelection {
     constructor(editor) {
       __publicField(this, "editor");
@@ -26574,7 +26568,7 @@ var __publicField = (obj, key, value) => {
         }
         const range = this.range;
         if (rangeInBlock(deletedBlock, range)) {
-          logger$35.debug("adjust selection because remote deleted current block");
+          logger$36.debug("adjust selection because remote deleted current block");
           const newRange = moveSelectionBeforeDeleteBlock(editor, deletedBlock);
           this.setRange(newRange, { noScroll: true });
         }
@@ -26699,14 +26693,14 @@ var __publicField = (obj, key, value) => {
       if (pos.isSimple()) {
         const ok = pos.offset >= 0 && pos.offset <= getBlockTextLength$6(this.editor, block);
         if (!ok) {
-          assert(logger$35, false, "invalid block position, out of range");
+          assert(logger$36, false, "invalid block position, out of range");
         }
       } else {
         const childContainerId = pos.childContainerId;
         const container = this.editor.getContainerById(childContainerId);
         const ok = !!container;
         if (!ok) {
-          assert(logger$35, false, "invalid complex block position, no container found");
+          assert(logger$36, false, "invalid complex block position, no container found");
         }
       }
     }
@@ -26767,7 +26761,7 @@ var __publicField = (obj, key, value) => {
       let container = getParentContainer(block);
       while (isChildContainer(container)) {
         const parentBlock = getParentBlock(container);
-        assert(logger$35, parentBlock, "parent block not found");
+        assert(logger$36, parentBlock, "parent block not found");
         addClass(parentBlock, "child-focused");
         container = getParentContainer(parentBlock);
       }
@@ -26904,15 +26898,15 @@ var __publicField = (obj, key, value) => {
     editor.undoManager.redo();
     return true;
   }
-  const logger$34 = getLogger("delete-text");
+  const logger$35 = getLogger("delete-text");
   function editorDeleteText(editor, type, count, insertPos) {
     const pos = insertPos != null ? insertPos : editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$34, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$35, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
-    assert(logger$34, isTextKindBlock(editor, block), "block is not a text kind block");
+    assert(logger$35, isTextKindBlock(editor, block), "block is not a text kind block");
     let { offset } = pos;
     if (type === "backward") {
       if (offset - count < 0) {
@@ -26942,7 +26936,7 @@ var __publicField = (obj, key, value) => {
     }
     return false;
   }
-  const logger$33 = getLogger("handle-backspace");
+  const logger$34 = getLogger("handle-backspace");
   function tryDeleteEmptyBlock(editor, block) {
     if (!isEmptyTextBlock(editor, block)) {
       return;
@@ -26982,7 +26976,7 @@ var __publicField = (obj, key, value) => {
             }
           } else {
             tryDeleteEmptyBlock(editor, block);
-            assert(logger$33, isEmbedBlock(prevBlock), "prev block is not embed block");
+            assert(logger$34, isEmbedBlock(prevBlock), "prev block is not embed block");
             editor.selection.selectBlock(prevBlock, 1);
           }
         } else {
@@ -27263,7 +27257,7 @@ var __publicField = (obj, key, value) => {
     const doc2 = blockToDoc(editor, block);
     editorCopyDoc(editor, doc2);
   }
-  const logger$32 = getLogger("input-handler-actions");
+  const logger$33 = getLogger("input-handler-actions");
   function editorHandleEnter(editor, event) {
     if (editor.readonly || !editor.isWritable()) {
       return false;
@@ -27309,7 +27303,7 @@ var __publicField = (obj, key, value) => {
         toPlainText: true
       });
     }).catch((err) => {
-      logger$32.error(err);
+      logger$33.error(err);
     });
     return true;
   }
@@ -28051,14 +28045,14 @@ ${codeText}
       editor.selection.updateSelection(null, { focusBlockChanged: true });
     });
   }
-  const logger$31 = getLogger("transform-selection");
+  const logger$32 = getLogger("transform-selection");
   function transformSelection(editor, blockId, delta, local) {
     const { range } = editor.selection;
     const { anchor: anchor2, focus } = range;
     if (anchor2.blockId !== blockId && focus.blockId !== blockId) {
       return range;
     }
-    assert(logger$31, anchor2.isSimple() && focus.isSimple(), "invalid text pos type");
+    assert(logger$32, anchor2.isSimple() && focus.isSimple(), "invalid text pos type");
     let newAnchor = anchor2;
     if (anchor2.blockId === blockId) {
       const newOffset = RichText.transformCursor(anchor2.offset, delta, local);
@@ -28071,12 +28065,12 @@ ${codeText}
     }
     return createEditorSelectionRange(editor, { anchor: newAnchor, focus: newFocus });
   }
-  const logger$30 = getLogger("handle-block-text-changed");
+  const logger$31 = getLogger("handle-block-text-changed");
   function onBlockTextChanged(editor, containerId, blockIndex, actions2, local) {
     const container = editor.getContainerById(containerId);
     const block = getBlockByIndex(container, blockIndex);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$30, blockData.text, "no block text");
+    assert(logger$31, blockData.text, "no block text");
     getTextBlockClass(editor, block).setBlockText(editor, block, blockData.text);
     if (!local) {
       const newRange = transformSelection(editor, blockData.id, actions2, local);
@@ -28108,7 +28102,7 @@ ${codeText}
     });
     handleDeleteBlock$4(editor, block, local, { child: false });
   }
-  const logger$2$ = getLogger("editor-doc");
+  const logger$30 = getLogger("editor-doc");
   class EditorDoc extends EventCallbacks {
     constructor(editor, externalDoc, localEvents) {
       super();
@@ -28147,14 +28141,14 @@ ${codeText}
     }
     verifyBlockWritable(containerId, blockIndex) {
       const block = this.editor.getBlockByIndex(containerId, blockIndex);
-      assert(logger$2$, this.editor.isBlockWritable(block), `block is not writable, ${containerId}, ${blockIndex}`);
+      assert(logger$30, this.editor.isBlockWritable(block), `block is not writable, ${containerId}, ${blockIndex}`);
     }
     localUpdateBlockText(containerId, blockIndex, actions2, options) {
-      assert(logger$2$, !this.editor.readonly, "editor is readonly");
+      assert(logger$30, !this.editor.readonly, "editor is readonly");
       this.verifyBlockWritable(containerId, blockIndex);
       const blockData = this.getBlockData(containerId, blockIndex);
       const oldText = blockData.text;
-      assert(logger$2$, oldText, `no text, ${containerId}, ${blockIndex}`);
+      assert(logger$30, oldText, `no text, ${containerId}, ${blockIndex}`);
       const newRange = transformSelection(this.editor, blockData.id, actions2, true);
       const newText = RichText.apply(oldText, actions2);
       this.localEvents.forEach((event) => event.onBeforeUpdateBlockText(containerId, blockData.id, oldText, newText, newRange.toDocRange()));
@@ -28163,13 +28157,13 @@ ${codeText}
       return ret;
     }
     localUpdateBlockData(containerId, blockIndex, delta, newRange, options) {
-      assert(logger$2$, !this.editor.readonly, "editor is readonly");
+      assert(logger$30, !this.editor.readonly, "editor is readonly");
       const block = this.editor.getBlockByIndex(containerId, blockIndex);
       if (!this.editor.isBlockWritable(block)) {
         const deletedKeys = Array.from(delta.delete).filter((key) => key !== "comments");
         const insertedKeys = Object.keys(delta.insert).filter((key) => key !== "comments");
         if (deletedKeys.length > 0 || insertedKeys.length > 0) {
-          assert(logger$2$, false, `block is not writable, comment supported only, ${JSON.stringify(delta)}}`);
+          assert(logger$30, false, `block is not writable, comment supported only, ${JSON.stringify(delta)}}`);
         }
       }
       const oldData = cloneDeep__default.default(this.getBlockData(containerId, blockIndex));
@@ -28180,7 +28174,7 @@ ${codeText}
       return ret;
     }
     localInsertBlock(containerId, blockIndex, data2, newRange, options) {
-      assert(logger$2$, !this.editor.readonly, "editor is readonly");
+      assert(logger$30, !this.editor.readonly, "editor is readonly");
       this.localEvents.forEach((event) => event.onBeforeInsertBlock(containerId, blockIndex, data2, newRange));
       const ret = this.externalDoc.localInsertBlock(containerId, blockIndex, data2, newRange);
       if (!(options == null ? void 0 : options.noFocus)) {
@@ -28189,7 +28183,7 @@ ${codeText}
       return ret;
     }
     localDeleteBlock(containerId, blockIndex, newRange) {
-      assert(logger$2$, !this.editor.readonly, "editor is readonly");
+      assert(logger$30, !this.editor.readonly, "editor is readonly");
       this.verifyBlockWritable(containerId, blockIndex);
       const blockData = cloneDeep__default.default(this.getBlockData(containerId, blockIndex));
       this.localEvents.forEach((event) => event.onBeforeDeleteBlock(containerId, blockIndex, blockData, newRange));
@@ -28198,7 +28192,7 @@ ${codeText}
       return ret;
     }
     localDeleteChildContainers(containerIds) {
-      assert(logger$2$, !this.editor.readonly, "editor is readonly");
+      assert(logger$30, !this.editor.readonly, "editor is readonly");
       containerIds.forEach((containerId) => {
         const blocks = cloneDeep__default.default(this.getContainerBlocks(containerId));
         this.localEvents.forEach((event) => event.onBeforeDeleteChildContainer(containerId, blocks));
@@ -28206,7 +28200,7 @@ ${codeText}
       return this.externalDoc.localDeleteChildContainers(containerIds);
     }
     localInsertChildContainers(containers) {
-      assert(logger$2$, !this.editor.readonly, "editor is readonly");
+      assert(logger$30, !this.editor.readonly, "editor is readonly");
       const data2 = cloneDeep__default.default(containers);
       data2.forEach((item) => {
         this.localEvents.forEach((event) => event.onBeforeInsertChildContainer(item.containerId, item.blocks));
@@ -28214,7 +28208,7 @@ ${codeText}
       this.externalDoc.localInsertChildContainers(data2);
     }
     onRequestReload(reason) {
-      logger$2$.debug(`reload doc: ${reason}`);
+      logger$30.debug(`reload doc: ${reason}`);
       this.editor.reload();
       this.callbacks.forEach((c) => {
         var _a;
@@ -28328,7 +28322,7 @@ ${codeText}
       return (_c = (_b = (_a = this.externalDoc).getServerMeta) == null ? void 0 : _b.call(_a)) != null ? _c : {};
     }
     reset(doc2) {
-      logger$2$.log("reset doc");
+      logger$30.log("reset doc");
       this.externalDoc = doc2;
       this.externalDoc.registerCallback(this);
       this.editor.reload();
@@ -28346,7 +28340,7 @@ ${codeText}
     }
     last.combine(action);
   }
-  const logger$2_ = getLogger("undo-action");
+  const logger$2$ = getLogger("undo-action");
   class Action {
     constructor(editor, containerId, afterRange) {
       __publicField(this, "beforeRange");
@@ -28362,15 +28356,15 @@ ${codeText}
       return false;
     }
     combinable(other) {
-      assert(logger$2_, other, "no other action");
+      assert(logger$2$, other, "no other action");
       return false;
     }
     combine(other) {
-      assert(logger$2_, false, "no other");
+      assert(logger$2$, false, "no other");
     }
     setAfterRange(range) {
       if (this.afterRange) {
-        logger$2_.warn("after range has already set");
+        logger$2$.warn("after range has already set");
       }
       this.afterRange = range;
     }
@@ -28392,7 +28386,7 @@ ${codeText}
           const containerId = blockData.children[i];
           const container = doc2.blocks[containerId];
           if (!container) {
-            logger$2_.warn(`container (${containerId}) not found, deleted by others?`);
+            logger$2$.warn(`container (${containerId}) not found, deleted by others?`);
             return false;
           }
         }
@@ -28400,7 +28394,7 @@ ${codeText}
       return true;
     }
   }
-  const logger$2Z = getLogger("block-action");
+  const logger$2_ = getLogger("block-action");
   class BlockAction extends Action {
     constructor(editor, containerId, blockIndex, data2, afterRange) {
       super(editor, containerId, afterRange);
@@ -28411,7 +28405,7 @@ ${codeText}
     }
     deleteBlock(editor, newRange) {
       if (!this.hasDocContainerId(editor, this.containerId)) {
-        logger$2Z.warn(`container (${this.containerId}) not found, deleted by others?`);
+        logger$2_.warn(`container (${this.containerId}) not found, deleted by others?`);
         return false;
       }
       const container = editor.getContainerById(this.containerId);
@@ -28425,18 +28419,18 @@ ${codeText}
     }
     insertBlock(editor, newRange) {
       if (!this.hasDocContainerId(editor, this.containerId)) {
-        logger$2Z.warn(`container (${this.containerId}) not found, deleted by others?`);
+        logger$2_.warn(`container (${this.containerId}) not found, deleted by others?`);
         return false;
       }
       if (!this.checkBlockData(editor, this.blockData)) {
         return false;
       }
       if (!editor.findBlockByIndex(this.containerId, Math.max(0, this.blockIndex - 1))) {
-        logger$2Z.warn(`block (${Math.max(0, this.blockIndex - 1)}) not found, deleted by others?`);
+        logger$2_.warn(`block (${Math.max(0, this.blockIndex - 1)}) not found, deleted by others?`);
         return false;
       }
       if (editor.findBlockById(this.blockData.id)) {
-        logger$2Z.warn(`block (${this.blockData.id}) already exists, inserted by others?`);
+        logger$2_.warn(`block (${this.blockData.id}) already exists, inserted by others?`);
         return false;
       }
       editorInsertBlock(editor, this.containerId, this.blockIndex, cloneDeep__default.default(this.blockData), newRange);
@@ -28503,7 +28497,7 @@ ${codeText}
       }
     }
   }
-  const logger$2Y = getLogger("update-block-data-action");
+  const logger$2Z = getLogger("update-block-data-action");
   class UpdateBlockDataAction extends Action {
     constructor(editor, containerId, blockId, oldData, newData, newRange) {
       super(editor, containerId, newRange);
@@ -28511,15 +28505,15 @@ ${codeText}
       __publicField(this, "afterBlockData");
       __publicField(this, "blockId");
       this.blockId = blockId;
-      assert(logger$2Y, this.blockId === oldData.id, "invalid block id");
-      assert(logger$2Y, this.blockId === newData.id, "invalid block id");
+      assert(logger$2Z, this.blockId === oldData.id, "invalid block id");
+      assert(logger$2Z, this.blockId === newData.id, "invalid block id");
       this.beforeBlockData = cloneDeep__default.default(oldData);
       this.afterBlockData = cloneDeep__default.default(newData);
-      assert(logger$2Y, this.beforeBlockData.type === this.afterBlockData.type, "invalid block type");
+      assert(logger$2Z, this.beforeBlockData.type === this.afterBlockData.type, "invalid block type");
     }
     undo(editor) {
       if (!editor.findBlockById(this.blockId)) {
-        logger$2Y.warn(`block (${this.blockId}) not found, deleted by others?`);
+        logger$2Z.warn(`block (${this.blockId}) not found, deleted by others?`);
         return false;
       }
       const block = editor.getBlockById(this.blockId);
@@ -28529,16 +28523,16 @@ ${codeText}
         return false;
       }
       const container = editor.getContainerById(this.containerId);
-      assert(logger$2Y, container, "no container");
+      assert(logger$2Z, container, "no container");
       editorUpdateBlockData(editor, block, UpdateBlockDataAction.toAttributes(this.beforeBlockData), this.beforeRange);
       return true;
     }
     redo(editor) {
       if (!editor.findBlockById(this.blockId)) {
-        logger$2Y.warn(`block (${this.blockId}) not found, deleted by others?`);
+        logger$2Z.warn(`block (${this.blockId}) not found, deleted by others?`);
         return false;
       }
-      assert(logger$2Y, editor, "no editor");
+      assert(logger$2Z, editor, "no editor");
       const block = editor.getBlockById(this.blockId);
       if (!block)
         return false;
@@ -28546,7 +28540,7 @@ ${codeText}
         return false;
       }
       const container = editor.getContainerById(this.containerId);
-      assert(logger$2Y, container, "no container");
+      assert(logger$2Z, container, "no container");
       editorUpdateBlockData(editor, block, UpdateBlockDataAction.toAttributes(this.afterBlockData), this.afterRange);
       return true;
     }
@@ -28557,7 +28551,7 @@ ${codeText}
       return attributes;
     }
   }
-  const logger$2X = getLogger("update-block-text-action");
+  const logger$2Y = getLogger("update-block-text-action");
   class UpdateBlockTextAction extends Action {
     constructor(editor, container, blockId, oldData, newData, newRange) {
       super(editor, container, newRange);
@@ -28571,8 +28565,8 @@ ${codeText}
       this.type = UpdateBlockTextAction.calType(oldData, newData);
     }
     static calType(oldData, newData) {
-      assert(logger$2X, oldData, "no old data");
-      assert(logger$2X, newData, "no new data");
+      assert(logger$2Y, oldData, "no old data");
+      assert(logger$2Y, newData, "no new data");
       const diff = RichText.diff(oldData, newData);
       const ops = diff;
       const type = /* @__PURE__ */ new Set();
@@ -28615,11 +28609,11 @@ ${codeText}
     }
     undo(editor) {
       if (!this.hasDocContainerId(editor, this.containerId)) {
-        logger$2X.warn(`container (${this.containerId}) not found, deleted by others?`);
+        logger$2Y.warn(`container (${this.containerId}) not found, deleted by others?`);
         return false;
       }
       if (!this.findDocBlockById(editor, this.blockId)) {
-        logger$2X.warn(`block (${this.blockId}) not found, deleted by others?`);
+        logger$2Y.warn(`block (${this.blockId}) not found, deleted by others?`);
         return false;
       }
       const container = editor.getContainerById(this.containerId);
@@ -28633,11 +28627,11 @@ ${codeText}
     }
     redo(editor) {
       if (!this.hasDocContainerId(editor, this.containerId)) {
-        logger$2X.warn(`container (${this.containerId}) not found, deleted by others?`);
+        logger$2Y.warn(`container (${this.containerId}) not found, deleted by others?`);
         return false;
       }
       if (!this.findDocBlockById(editor, this.blockId)) {
-        logger$2X.warn(`block (${this.blockId}) not found, deleted by others?`);
+        logger$2Y.warn(`block (${this.blockId}) not found, deleted by others?`);
         return false;
       }
       const container = editor.getContainerById(this.containerId);
@@ -28676,13 +28670,13 @@ ${codeText}
       return true;
     }
     combine(other) {
-      assert(logger$2X, other instanceof UpdateBlockTextAction, "invalid action type");
+      assert(logger$2Y, other instanceof UpdateBlockTextAction, "invalid action type");
       const last = other;
       this.afterRichTextData = last.afterRichTextData;
       this.afterRange = other.afterRange;
     }
   }
-  const logger$2W = getLogger("child-container-action");
+  const logger$2X = getLogger("child-container-action");
   class ChildContainerAction extends Action {
     constructor(editor, containerId, blocks) {
       super(editor, containerId, editor.selection.range.toDocRange());
@@ -28690,7 +28684,7 @@ ${codeText}
     }
     deleteChildContainer(editor) {
       if (!this.hasDocContainerId(editor, this.containerId)) {
-        logger$2W.warn(`container (${this.containerId}) not found, deleted by others?`);
+        logger$2X.warn(`container (${this.containerId}) not found, deleted by others?`);
         return false;
       }
       editor.doc.localDeleteChildContainers([this.containerId]);
@@ -28698,7 +28692,7 @@ ${codeText}
     }
     insertChildContainer(editor) {
       if (this.hasDocContainerId(editor, this.containerId)) {
-        logger$2W.warn(`container (${this.containerId}) already exists`);
+        logger$2X.warn(`container (${this.containerId}) already exists`);
         return false;
       }
       editor.doc.localInsertChildContainers([{ containerId: this.containerId, blocks: cloneDeep__default.default(this.blocks) }]);
@@ -28721,7 +28715,7 @@ ${codeText}
       return this.deleteChildContainer(editor);
     }
   }
-  const logger$2V = getLogger("undo");
+  const logger$2W = getLogger("undo");
   class UndoManager {
     constructor(editor) {
       __publicField(this, "editor");
@@ -28768,21 +28762,21 @@ ${codeText}
     }
     beginGroup() {
       if (this.groupCounter === 0) {
-        assert(logger$2V, !this.currentGroup, "current group already exists");
+        assert(logger$2W, !this.currentGroup, "current group already exists");
         this.currentGroup = new GroupAction(this.editor);
         this.groupCounter = 1;
       } else {
-        assert(logger$2V, this.currentGroup, "current group not exists");
+        assert(logger$2W, this.currentGroup, "current group not exists");
         this.groupCounter += 1;
       }
     }
     endGroup() {
-      assert(logger$2V, this.currentGroup, "current group not exists");
-      assert(logger$2V, this.groupCounter > 0, "group counter === 0");
+      assert(logger$2W, this.currentGroup, "current group not exists");
+      assert(logger$2W, this.groupCounter > 0, "group counter === 0");
       this.groupCounter -= 1;
       if (this.groupCounter === 0) {
         if (this.currentGroup.actions.length === 0) {
-          logger$2V.warn("empty undo group, skip it");
+          logger$2W.warn("empty undo group, skip it");
         } else {
           this.actions.push(this.currentGroup);
           this.editor.input.handleChanged(this.currentGroup);
@@ -28800,7 +28794,7 @@ ${codeText}
         setTimeout(() => this.editor.selection.caret.update());
         return ret;
       } catch (err) {
-        logger$2V.error(`failed to run action: ${err.message}`);
+        logger$2W.error(`failed to run action: ${err.message}`);
         throw err;
       } finally {
         this.endGroup();
@@ -28811,14 +28805,14 @@ ${codeText}
       if (pos.isSimple()) {
         const ok = pos.offset >= 0 && pos.offset <= getBlockTextLength$6(this.editor, block);
         if (!ok) {
-          assert(logger$2V, false, "invalid block position, out of range");
+          assert(logger$2W, false, "invalid block position, out of range");
         }
       } else {
         const childContainerId = pos.childContainerId;
         const container = this.editor.getContainerById(childContainerId);
         const ok = !!container;
         if (!ok) {
-          assert(logger$2V, false, "invalid complex block position, no container found");
+          assert(logger$2W, false, "invalid complex block position, no container found");
         }
       }
     }
@@ -28828,7 +28822,7 @@ ${codeText}
         this.verifyPos(start);
         this.verifyPos(end);
       } catch (err) {
-        logger$2V.error(`undo: failed to restore caret pos: ${err.message}`);
+        logger$2W.error(`undo: failed to restore caret pos: ${err.message}`);
         const firstBlock = this.editor.getFirstBlock();
         this.editor.selection.setRange(createBlockSimpleRange(this.editor, firstBlock, 0), { noScroll: true });
       }
@@ -28846,7 +28840,7 @@ ${codeText}
             try {
               this.editor.selection.setRange(fromDocRange(this.editor, action.beforeRange));
             } catch (err) {
-              logger$2V.error(`undo: failed to restore caret pos: ${err.message}`);
+              logger$2W.error(`undo: failed to restore caret pos: ${err.message}`);
             }
             this.editor.input.handleChanged(action);
             return true;
@@ -28854,7 +28848,7 @@ ${codeText}
         }
         return false;
       } catch (error2) {
-        logger$2V.error(`failed to undo: ${error2.message}`);
+        logger$2W.error(`failed to undo: ${error2.message}`);
         return false;
       } finally {
         this.undoRedoing = false;
@@ -28876,10 +28870,10 @@ ${codeText}
               if (afterRange) {
                 this.editor.selection.setRange(fromDocRange(this.editor, afterRange));
               } else {
-                logger$2V.warn("no after range");
+                logger$2W.warn("no after range");
               }
             } catch (err) {
-              logger$2V.error(`redo: failed to set caret pos after redo: ${err.message}`);
+              logger$2W.error(`redo: failed to set caret pos after redo: ${err.message}`);
             }
             this.editor.input.handleChanged(action);
             return true;
@@ -28954,8 +28948,8 @@ ${codeText}
         return;
       }
       this.prepareSaveUndoState();
-      assert(logger$2V, blockIndex >= 0, "invalid block index");
-      assert(logger$2V, blockData, "no block data");
+      assert(logger$2W, blockIndex >= 0, "invalid block index");
+      assert(logger$2W, blockData, "no block data");
       this.addAction(new InsertBlockAction(this.editor, containerId, blockIndex, blockData, newRange));
     }
     onBeforeDeleteBlock(containerId, blockIndex, blockData, newRange) {
@@ -29060,7 +29054,7 @@ ${codeText}
       components.textRenders.forEach((r) => editor.editorBlockRenders.registerRender(r));
     }
   }
-  const logger$2U = getLogger("range-commands");
+  const logger$2V = getLogger("range-commands");
   function addItemSource(items, source) {
     items.forEach((item) => {
       item.source = source;
@@ -29079,8 +29073,8 @@ ${codeText}
   }
   function getBlockCommands(editor, block, range, source) {
     const blockId = getBlockId(block);
-    assert(logger$2U, blockId === range.start.blockId, "invalid start range");
-    assert(logger$2U, blockId === range.end.blockId, "invalid end range");
+    assert(logger$2V, blockId === range.start.blockId, "invalid start range");
+    assert(logger$2V, blockId === range.end.blockId, "invalid end range");
     const providers = editor.editorCommandProviders.getCommandProviders();
     let allCommands = [];
     providers.forEach((provider) => {
@@ -29101,8 +29095,8 @@ ${codeText}
       if (!isComplexBlockPosition(range.start)) {
         return allCommands;
       }
-      assert(logger$2U, !range.start.isSimple(), "invalid start pos");
-      assert(logger$2U, !range.end.isSimple(), "invalid end pos");
+      assert(logger$2V, !range.start.isSimple(), "invalid start pos");
+      assert(logger$2V, !range.end.isSimple(), "invalid end pos");
       const focusedContainerId = range.start.childContainerId;
       const focusedContainer = getContainerById(editor, focusedContainerId);
       const blocks = getChildBlocks(focusedContainer);
@@ -29181,7 +29175,7 @@ ${codeText}
     editor.focus();
     return rangeResult;
   }
-  const logger$2T = getLogger("command-providers");
+  const logger$2U = getLogger("command-providers");
   class EditorCommandProviders {
     constructor(editor) {
       __publicField(this, "providers", []);
@@ -29195,7 +29189,7 @@ ${codeText}
     }
     getCommandProvider(id) {
       const ret = this.providers.find((provider) => provider.id === id);
-      assert(logger$2T, ret, `no command provider, id=${id}`);
+      assert(logger$2U, ret, `no command provider, id=${id}`);
       return ret;
     }
     getCommands(range, source) {
@@ -29229,12 +29223,12 @@ ${codeText}
     const blockIndex = getBlockIndex(block);
     onBlockDataChanged(editor, containerId, blockIndex);
   }
-  const logger$2S = getLogger("update-block-text");
+  const logger$2T = getLogger("update-block-text");
   function editorUpdateBoxData(editor, boxData, options) {
     const boxElem = editor.getBoxById(boxData.id);
     const block = getParentBlock(boxElem);
-    assert(logger$2S, block, "no parent block");
-    assert(logger$2S, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$2T, block, "no parent block");
+    assert(logger$2T, isTextKindBlock(editor, block), "not a text block");
     const text2 = editor.getBlockText(block);
     const newText = updateOpAttributes(text2, "id", boxData.id, boxData);
     editorSetBlockText(editor, block, newText, options);
@@ -29301,7 +29295,7 @@ ${codeText}
       return void 0;
     }
   }
-  const logger$2R = getLogger("editor");
+  const logger$2S = getLogger("editor");
   class Editor extends tinyTypedEmitter.TypedEmitter {
     constructor(parent, doc2, optionalOptions) {
       var _a, _b, _c, _d, _e, _f, _g, _h, _i;
@@ -29343,7 +29337,7 @@ ${codeText}
         }
         return colors[index2 % colors.length];
       });
-      logger$2R.debug("create editor");
+      logger$2S.debug("create editor");
       this.setMaxListeners(100);
       this.options = {
         colors: (_a = optionalOptions == null ? void 0 : optionalOptions.colors) != null ? _a : ["#0064FF", "#EB3723", "#F59300", "#00A865", "#F25A0A", "#70A310", "#009CAD", "#0990D9", "#8851ED", "#D62069"],
@@ -29411,7 +29405,7 @@ ${codeText}
     }
     getCustom(name) {
       const exists = this.customs.get(name);
-      assert(logger$2R, exists, `${name} does not exists`);
+      assert(logger$2S, exists, `${name} does not exists`);
       return exists;
     }
     replaceCustom(name, newCustom) {
@@ -29462,7 +29456,7 @@ ${codeText}
       return this.editorInsertions.createInsertion(blockContent, insertion);
     }
     destroy() {
-      logger$2R.debug("destroy editor");
+      logger$2S.debug("destroy editor");
       this.emit("destroy", this);
       this.input.destroy();
       this.rootContainerObject.destroy();
@@ -29490,8 +29484,8 @@ ${codeText}
     getChildContainerData(childContainerId) {
       const blocks = this.doc.getContainerBlocks(childContainerId);
       if (!blocks || !Array.isArray(blocks)) {
-        assert(logger$2R, blocks, `no child container data: ${childContainerId}, ${JSON.stringify(this.doc)}`);
-        assert(logger$2R, Array.isArray(blocks), `container data is not an array: ${JSON.stringify(blocks)}`);
+        assert(logger$2S, blocks, `no child container data: ${childContainerId}, ${JSON.stringify(this.doc)}`);
+        assert(logger$2S, Array.isArray(blocks), `container data is not an array: ${JSON.stringify(blocks)}`);
       }
       return blocks;
     }
@@ -29512,25 +29506,25 @@ ${codeText}
     findBlockById(id) {
       const block = this.rootContainer.querySelector(`#${id}`);
       if (block) {
-        assert(logger$2R, isBlock(block), "not an valid block element");
+        assert(logger$2S, isBlock(block), "not an valid block element");
       }
       return block != null ? block : null;
     }
     findBoxById(id) {
       const box = this.rootContainer.querySelector(`#${id}`);
       if (box) {
-        assert(logger$2R, isBox(box), "not an valid box element");
+        assert(logger$2S, isBox(box), "not an valid box element");
       }
       return box != null ? box : null;
     }
     getBlockById(id) {
       const block = this.findBlockById(id);
-      assert(logger$2R, block, `no block, id=${id}`);
+      assert(logger$2S, block, `no block, id=${id}`);
       return block;
     }
     getBoxById(id) {
       const box = this.findBoxById(id);
-      assert(logger$2R, box, `no box, id=${id}`);
+      assert(logger$2S, box, `no box, id=${id}`);
       return box;
     }
     getBlockByIndex(containerId, blockIndex) {
@@ -29851,7 +29845,7 @@ ${codeText}
       this.removeAllListeners();
     }
   }
-  const logger$2Q = getLogger("local-doc");
+  const logger$2R = getLogger("local-doc");
   class LocalDoc extends EventCallbacks {
     constructor(doc2, options) {
       super();
@@ -29891,17 +29885,17 @@ ${codeText}
     }
     getBlockData(containerId, blockIndex) {
       const blocks = this.getContainerBlocks(containerId);
-      assert(logger$2Q, blocks, `no container data: ${containerId}`);
+      assert(logger$2R, blocks, `no container data: ${containerId}`);
       const blockData = blocks[blockIndex];
-      assert(logger$2Q, blockData, `no block data: ${blockIndex}`);
+      assert(logger$2R, blockData, `no block data: ${blockIndex}`);
       return blockData;
     }
     localUpdateBlockText(containerId, blockIndex, actions2) {
       const blockData = this.getBlockData(containerId, blockIndex);
-      assert(logger$2Q, blockData.text, "no text for data");
+      assert(logger$2R, blockData.text, "no text for data");
       const newText = RichText.apply(blockData.text, actions2);
       blockData.text = newText;
-      assert(logger$2Q, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2R, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onUpdateBlockText) == null ? void 0 : _a.call(cb, containerId, blockIndex, actions2, true);
@@ -29914,7 +29908,7 @@ ${codeText}
       Object.entries(delta.insert).forEach(([key, value]) => {
         blockData[key] = value;
       });
-      assert(logger$2Q, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2R, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onUpdateBlockData) == null ? void 0 : _a.call(cb, containerId, blockIndex, delta, true);
@@ -29923,10 +29917,10 @@ ${codeText}
     }
     localInsertBlock(containerId, blockIndex, data2) {
       const blocks = this.getContainerBlocks(containerId);
-      assert(logger$2Q, blocks, `no container data: ${containerId}`);
-      assert(logger$2Q, blockIndex >= 0 && blockIndex <= blocks.length, `invalid block index: ${blockIndex}, ${blocks.length}`);
+      assert(logger$2R, blocks, `no container data: ${containerId}`);
+      assert(logger$2R, blockIndex >= 0 && blockIndex <= blocks.length, `invalid block index: ${blockIndex}, ${blocks.length}`);
       blocks.splice(blockIndex, 0, data2);
-      assert(logger$2Q, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2R, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onInsertBlock) == null ? void 0 : _a.call(cb, containerId, blockIndex, data2, true);
@@ -29935,11 +29929,11 @@ ${codeText}
     }
     localDeleteBlock(containerId, blockIndex) {
       const blocks = this.getContainerBlocks(containerId);
-      assert(logger$2Q, blocks, `no container data: ${containerId}`);
-      assert(logger$2Q, blockIndex >= 0 && blockIndex <= blocks.length, `invalid block index: ${blockIndex}, ${blocks.length}`);
+      assert(logger$2R, blocks, `no container data: ${containerId}`);
+      assert(logger$2R, blockIndex >= 0 && blockIndex <= blocks.length, `invalid block index: ${blockIndex}, ${blocks.length}`);
       const data2 = blocks[blockIndex];
       blocks.splice(blockIndex, 1);
-      assert(logger$2Q, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2R, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onDeleteBlock) == null ? void 0 : _a.call(cb, containerId, blockIndex, true);
@@ -29949,7 +29943,7 @@ ${codeText}
     localInsertChildContainers(containers) {
       containers.forEach(({ containerId, blocks }) => {
         this.doc.blocks[containerId] = blocks;
-        assert(logger$2Q, this.callbacks.length > 0, "no callbacks");
+        assert(logger$2R, this.callbacks.length > 0, "no callbacks");
         this.callbacks.forEach((cb) => {
           var _a;
           return (_a = cb.onInsertChildContainer) == null ? void 0 : _a.call(cb, containerId, blocks, true);
@@ -29957,13 +29951,13 @@ ${codeText}
       });
     }
     localDeleteChildContainers(containerIds) {
-      logger$2Q.debug(`delete child containers: ${containerIds}`);
+      logger$2R.debug(`delete child containers: ${containerIds}`);
       containerIds.forEach((id) => {
-        assert(logger$2Q, this.doc.blocks[id], `no child container: ${id}`);
+        assert(logger$2R, this.doc.blocks[id], `no child container: ${id}`);
         delete this.doc.blocks[id];
       });
       containerIds.forEach((id) => {
-        assert(logger$2Q, this.callbacks.length > 0, "no callbacks");
+        assert(logger$2R, this.callbacks.length > 0, "no callbacks");
         this.callbacks.forEach((cb) => {
           var _a;
           return (_a = cb.onDeleteChildContainer) == null ? void 0 : _a.call(cb, id, true);
@@ -29971,7 +29965,7 @@ ${codeText}
       });
     }
     uploadResource(file2, options) {
-      assert(logger$2Q, false, "not implemented");
+      assert(logger$2R, false, "not implemented");
     }
     async addResources(resourceIds) {
       return resourceIds;
@@ -29980,7 +29974,7 @@ ${codeText}
       return src;
     }
     request(url, opt) {
-      assert(logger$2Q, false, "not implemented");
+      assert(logger$2R, false, "not implemented");
     }
     broadcastMessage(data2) {
     }
@@ -30031,7 +30025,7 @@ ${codeText}
       return custom;
     });
   }
-  const logger$2P = getLogger("find-block");
+  const logger$2Q = getLogger("find-block");
   function findPrevVisibleSimpleBlock(editor, block) {
     const prevVisibleBlock = getPrevVisibleBlock(block);
     if (!prevVisibleBlock) {
@@ -30039,7 +30033,7 @@ ${codeText}
         return null;
       }
       const parent = getParentBlockExcludeSelf(block);
-      assert(logger$2P, parent, "no parent block");
+      assert(logger$2Q, parent, "no parent block");
       return findPrevVisibleSimpleBlock(editor, parent);
     }
     if (!isComplexKindBlock(editor, prevVisibleBlock)) {
@@ -30054,7 +30048,7 @@ ${codeText}
         return null;
       }
       const parent = getParentBlockExcludeSelf(block);
-      assert(logger$2P, parent, "no parent block");
+      assert(logger$2Q, parent, "no parent block");
       return findNextVisibleSimpleBlock(editor, parent);
     }
     if (!isComplexKindBlock(editor, nextVisibleBlock)) {
@@ -30062,7 +30056,7 @@ ${codeText}
     }
     return complexBlockGetFirstSimpleChild(editor, nextVisibleBlock, { visibleOnly: true });
   }
-  const logger$2O = getLogger("remote-cursor");
+  const logger$2P = getLogger("remote-cursor");
   class RemoteCaretsHandler {
     constructor() {
       __publicField(this, "remoteUsers", new RemoteUsers());
@@ -30075,7 +30069,7 @@ ${codeText}
       } else if (message.type === "caret") {
         this.handleUpdateCaret(message);
       } else {
-        logger$2O.debug(`unknown remote message received: ${msg}`);
+        logger$2P.debug(`unknown remote message received: ${msg}`);
       }
     }
     handleUpdateUsers(users) {
@@ -30202,7 +30196,7 @@ ${codeText}
     });
     this.setMethods(defaultMethods);
   }
-  var logger$2N = Logger$1;
+  var logger$2O = Logger$1;
   Logger$1.prototype.setMethods = function(overrides) {
     overrides = overrides || {};
     var logger2 = this;
@@ -30212,9 +30206,9 @@ ${codeText}
       }
     });
   };
-  var Logger = logger$2N;
-  var logger$2M = new Logger();
-  var logger_1 = logger$2M;
+  var Logger = logger$2O;
+  var logger$2N = new Logger();
+  var logger_1 = logger$2N;
   function ShareDBError$3(code, message) {
     this.code = code;
     this.message = message || "";
@@ -31133,7 +31127,7 @@ ${codeText}
     presenceRequest: "pr"
   };
   var emitter$5 = emitter$6;
-  var logger$2L = logger_1;
+  var logger$2M = logger_1;
   var ShareDBError$2 = error;
   var types$2 = types$3;
   var util$9 = util$a;
@@ -31735,7 +31729,7 @@ ${codeText}
     if (this.inflightOp.create) {
       this.version = message.v;
     } else if (message.v !== this.version) {
-      logger$2L.warn("Invalid version from server. Expected: " + this.version + " Received: " + message.v, message);
+      logger$2M.warn("Invalid version from server. Expected: " + this.version + " Received: " + message.v, message);
       return this.fetch();
     }
     if (message[ACTIONS$6.fixup]) {
@@ -34827,7 +34821,7 @@ ${codeText}
   var ACTIONS = messageActions.ACTIONS;
   var types$1 = types$3;
   var util = util$a;
-  var logger$2K = logger_1;
+  var logger$2L = logger_1;
   var DocPresenceEmitter = docPresenceEmitter;
   var ERROR_CODE = ShareDBError.CODES;
   function connectionState(socket) {
@@ -34871,11 +34865,11 @@ ${codeText}
       try {
         var data2 = typeof event.data === "string" ? JSON.parse(event.data) : event.data;
       } catch (err) {
-        logger$2K.warn("Failed to parse message", event);
+        logger$2L.warn("Failed to parse message", event);
         return;
       }
       if (connection2.debug)
-        logger$2K.info("RECV", JSON.stringify(data2));
+        logger$2L.info("RECV", JSON.stringify(data2));
       var request = { data: data2 };
       connection2.emit("receive", request);
       if (!request.data)
@@ -34977,7 +34971,7 @@ ${codeText}
       case ACTIONS.pingPong:
         return this._handlePingPong(err);
       default:
-        logger$2K.warn("Ignoring unrecognized message", message);
+        logger$2L.warn("Ignoring unrecognized message", message);
     }
   };
   function wrapErrorData(errorData, fullMessage) {
@@ -35017,7 +35011,7 @@ ${codeText}
           doc2[method](err);
       }
     } else {
-      logger$2K.error("Invalid bulk message", message);
+      logger$2L.error("Invalid bulk message", message);
     }
   };
   Connection$1.prototype._reset = function() {
@@ -35150,7 +35144,7 @@ ${codeText}
   };
   Connection$1.prototype.send = function(message) {
     if (this.debug)
-      logger$2K.info("SEND", JSON.stringify(message));
+      logger$2L.info("SEND", JSON.stringify(message));
     this.emit("send", message);
     this.socket.send(JSON.stringify(message));
   };
@@ -35427,12 +35421,12 @@ ${codeText}
   };
   const AuthHeader = "x-live-editor-token";
   const BaseURLHeader = "x-live-editor-base-url";
-  const logger$2J = getLogger("auth-connection");
+  const logger$2K = getLogger("auth-connection");
   function silentTry(fn) {
     try {
       fn();
     } catch (e2) {
-      logger$2J.error(e2);
+      logger$2K.error(e2);
     }
   }
   class AuthConnection {
@@ -35472,7 +35466,7 @@ ${codeText}
       return toBase64URL(this.getBaseURL());
     }
     async auth(auth) {
-      assert(logger$2J, auth.token, "no auth token");
+      assert(logger$2K, auth.token, "no auth token");
       const authURL = `${this.getBaseURL()}/auth`;
       const ret = await window.fetch(authURL, {
         method: "GET",
@@ -35517,7 +35511,7 @@ ${codeText}
         minReconnectionDelay: 1e3
       });
       this.connection = Object.create(Connection.prototype);
-      assert(logger$2J, this.connection, "no this.connection");
+      assert(logger$2K, this.connection, "no this.connection");
       const thatWs = this.ws;
       const pingOptions = this.pingOptions;
       this.connection._initializeHandshake = function handshake() {
@@ -35554,7 +35548,7 @@ ${codeText}
               if (!recoverFlag) {
                 recoverFlag = true;
               } else {
-                logger$2J.info("retrying re-auth success");
+                logger$2K.info("retrying re-auth success");
                 recoverFlag = false;
                 this.emitAuthRecover();
               }
@@ -35598,13 +35592,13 @@ ${codeText}
     }
     async _autoReAuth() {
       this.retryCount += 1;
-      logger$2J.info(`retrying re-auth attempt no. ${this.retryCount}`);
+      logger$2K.info(`retrying re-auth attempt no. ${this.retryCount}`);
       try {
         await this.reAuth();
       } catch (err) {
-        logger$2J.error(err);
+        logger$2K.error(err);
         if (this.retryCount >= 5) {
-          logger$2J.warn("retry auth times exceed 5, broadcast auth error");
+          logger$2K.warn("retry auth times exceed 5, broadcast auth error");
           this.emitAuthError();
         }
         const maxInterval = 30 * 1e3;
@@ -35618,13 +35612,13 @@ ${codeText}
     async autoReAuth() {
       var _a, _b;
       if (!this.enabled || this.retryCount > 0) {
-        logger$2J.debug("autoReAuth: not enabled or retryCount > 0");
+        logger$2K.debug("autoReAuth: not enabled or retryCount > 0");
         return;
       }
-      logger$2J.log("autoReAuth begin!");
+      logger$2K.log("autoReAuth begin!");
       (_a = this.ws) == null ? void 0 : _a.close();
       await this._autoReAuth();
-      logger$2J.log("autoReAuth end!");
+      logger$2K.log("autoReAuth end!");
       (_b = this.ws) == null ? void 0 : _b.reconnect();
     }
     async handleAuthError() {
@@ -35663,36 +35657,36 @@ ${codeText}
       }
       const err = msg.err;
       if (err === AuthError.err) {
-        logger$2J.warn("auth error");
+        logger$2K.warn("auth error");
         this.handleAuthError();
       } else if (err === MaxUserError.err) {
-        logger$2J.warn(MaxUserError.msg);
+        logger$2K.warn(MaxUserError.msg);
         this.emitMaxUsersError();
       } else if (err === RequestReloadError.err) {
-        logger$2J.warn(RequestReloadError.msg);
+        logger$2K.warn(RequestReloadError.msg);
         try {
           this.emitRequestReloadError();
         } catch (errTemp) {
-          logger$2J.error(`error occurred while process reload error: ${JSON.stringify(errTemp)}`);
+          logger$2K.error(`error occurred while process reload error: ${JSON.stringify(errTemp)}`);
         } finally {
           this.end(false);
         }
       } else if (err === PermissionError.err) {
         this.emitPermissionError();
       } else {
-        logger$2J.error(`unknown message received: ${JSON.stringify(msg)}`);
+        logger$2K.error(`unknown message received: ${JSON.stringify(msg)}`);
         this.emitAuthError();
       }
     }
     get(collectionName, documentID) {
-      assert(logger$2J, this.connection, "no this.connection");
+      assert(logger$2K, this.connection, "no this.connection");
       return this.connection.get(collectionName, documentID);
     }
     addEventListener(event, callback) {
       if (event === "error") {
         this.events.addListener(event, callback);
       } else {
-        assert(logger$2J, this.ws, "no this.ws");
+        assert(logger$2K, this.ws, "no this.ws");
         this.ws.addEventListener(event, callback);
       }
     }
@@ -35706,11 +35700,11 @@ ${codeText}
       this.events.addListener("writeConflictError", callback);
     }
     onMaxUsersError(callback) {
-      assert(logger$2J, this.events.listenerCount("maxUsersError") === 0, "too many maxUserError listener");
+      assert(logger$2K, this.events.listenerCount("maxUsersError") === 0, "too many maxUserError listener");
       this.events.addListener("maxUsersError", callback);
     }
     onRequestReloadError(callback) {
-      assert(logger$2J, this.events.listenerCount("requestReloadError") === 0, "to many requestReloadError listener");
+      assert(logger$2K, this.events.listenerCount("requestReloadError") === 0, "to many requestReloadError listener");
       this.events.addListener("requestReloadError", callback);
     }
     end(logout) {
@@ -35765,7 +35759,7 @@ ${codeText}
     const result = hasher.digest();
     return toBase64URL(result);
   }
-  const logger$2I = getLogger("sharedb-doc/client");
+  const logger$2J = getLogger("sharedb-doc/client");
   const axiosInstance$1 = axios__default.default.create();
   class ShareDBClient {
     constructor(auth, serverUrl, reauthFunc) {
@@ -35783,12 +35777,12 @@ ${codeText}
               resolve();
           });
         });
-        assert(logger$2I, !this.doc, "This websocket has opened a doc.");
+        assert(logger$2J, !this.doc, "This websocket has opened a doc.");
         await this.connection.init(this.auth);
         const doc2 = this.connection.get(this.auth.appId, this.auth.docId);
         this.doc = doc2;
         await fetchDoc(doc2);
-        logger$2I.debug(doc2);
+        logger$2J.debug(doc2);
         return doc2;
       });
       this.auth = auth;
@@ -35797,10 +35791,19 @@ ${codeText}
       this.connection = new AuthConnection(url, reauthFunc);
       this.reauthFunc = reauthFunc;
     }
+    token() {
+      return this.connection.token;
+    }
+    resourceToken() {
+      return this.connection.resourceToken || this.token();
+    }
+    docId() {
+      return this.auth.docId;
+    }
     editorServer() {
       const apiServer = this.apiServer();
       const last = `/${this.auth.appId}/${this.auth.docId}`;
-      assert(logger$2I, apiServer.endsWith(last), `invalid api server: ${apiServer}, ${last}`);
+      assert(logger$2J, apiServer.endsWith(last), `invalid api server: ${apiServer}, ${last}`);
       return apiServer.substr(0, apiServer.length - last.length);
     }
     close(logout) {
@@ -35898,7 +35901,7 @@ ${codeText}
       }
       max += 500;
       const handleUploadProgress = (event) => {
-        logger$2I.info(`on progress: ${event.loaded}`);
+        logger$2J.info(`on progress: ${event.loaded}`);
         let value = event.loaded * 100 / max;
         if (value > 100)
           value = 100;
@@ -35927,7 +35930,7 @@ ${codeText}
         },
         onUploadProgress: handleUploadProgress
       });
-      logger$2I.info(result);
+      logger$2J.info(result);
       onProgress(100);
       return Array.isArray(result.data) ? result.data[0] : result.data;
     }
@@ -35935,11 +35938,11 @@ ${codeText}
     }, options) {
       const server = this.apiServer();
       const api = `${server}/resources`;
-      assert(logger$2I, this.connection.token, "no connection token");
+      assert(logger$2J, this.connection.token, "no connection token");
       const ret = await this.uploadFile(api, file2, {
         [AuthHeader]: this.connection.token
       }, onProgress, options);
-      assert(logger$2I, ret, "no result");
+      assert(logger$2J, ret, "no result");
       return ret;
     }
     async request(url, opt) {
@@ -35952,7 +35955,7 @@ ${codeText}
         if (!options.headers) {
           options.headers = {};
         }
-        assert(logger$2I, token, "no token");
+        assert(logger$2J, token, "no token");
         options.headers = {
           ...options.headers,
           [AuthHeader]: token,
@@ -35981,7 +35984,7 @@ ${codeText}
           throw err;
         }
       }
-      assert(logger$2I, lastErr, "no error");
+      assert(logger$2J, lastErr, "no error");
       throw lastErr;
     }
     async getVersions() {
@@ -36024,7 +36027,7 @@ ${codeText}
       }
       let doc2;
       if (createdDoc) {
-        assert(logger$2I, createdDoc.create, "no createDoc.create");
+        assert(logger$2J, createdDoc.create, "no createDoc.create");
         doc2 = createdDoc.create.data;
       } else {
         doc2 = JSON.parse(ret.data.data);
@@ -36145,7 +36148,7 @@ ${codeText}
     const id = genId();
     return { blocks: [{ id, type: "text", text: [] }], comments: {}, meta: {} };
   }
-  const logger$2H = getLogger("block-ids");
+  const logger$2I = getLogger("block-ids");
   class BlockIds {
     constructor() {
       __publicField(this, "ids", /* @__PURE__ */ new Map());
@@ -36156,7 +36159,7 @@ ${codeText}
         const index2 = indexes[i];
         if (index2 >= blockIndex) {
           const oldId = this.ids.get(index2);
-          assert(logger$2H, oldId !== void 0, "old id is not exists");
+          assert(logger$2I, oldId !== void 0, "old id is not exists");
           this.ids.delete(index2);
           this.ids.set(index2 + 1, oldId);
         }
@@ -36171,7 +36174,7 @@ ${codeText}
         const index2 = indexes[i];
         if (index2 > blockIndex) {
           const oldId = this.ids.get(index2);
-          assert(logger$2H, oldId !== void 0, "old id is not exists");
+          assert(logger$2I, oldId !== void 0, "old id is not exists");
           this.ids.delete(index2);
           this.ids.set(index2 - 1, oldId);
         }
@@ -36222,7 +36225,7 @@ ${codeText}
           };
         }
       }
-      assert(logger$2H, false, "fault error: failed to get block index");
+      assert(logger$2I, false, "fault error: failed to get block index");
       return { containerId: "error", blockIndex: -1 };
     }
   }
@@ -36248,7 +36251,7 @@ ${codeText}
       };
     }
   }
-  const logger$2G = getLogger("op-parse-handler");
+  const logger$2H = getLogger("op-parse-handler");
   class ParseHandler {
     constructor(outerHandler, local) {
       __publicField(this, "actions", []);
@@ -36356,7 +36359,7 @@ ${codeText}
           blockIds.onDeleteBlock(a.containerId, a.blockIndex);
           const ignoreObjectData = updatingBlockDataDeltaMap.get(blockId);
           if (ignoreObjectData) {
-            logger$2G.debug(`ignore update object data before delete block: ${JSON.stringify(ignoreObjectData)}`);
+            logger$2H.debug(`ignore update object data before delete block: ${JSON.stringify(ignoreObjectData)}`);
             updatingBlockDataDeltaMap.delete(blockId);
           }
           const deletesBlockKey = `${a.containerId}-${a.blockIndex}`;
@@ -36366,7 +36369,7 @@ ${codeText}
           const a = action;
           const deletesBlockKey = `${a.containerId}-${a.blockIndex}`;
           if (deletedBlocks.has(deletesBlockKey)) {
-            logger$2G.warn("delete block data after delete block, ignore it");
+            logger$2H.warn("delete block data after delete block, ignore it");
             continue;
           }
           const blockId = blockIds.getBlockId(a.containerId, a.blockIndex);
@@ -36377,7 +36380,7 @@ ${codeText}
           }
           delta.delete(a.key);
         } else {
-          assert(logger$2G, false, `invalid action type, ${action.type}`);
+          assert(logger$2H, false, `invalid action type, ${action.type}`);
         }
       }
       this.actions.forEach((action) => {
@@ -36425,7 +36428,7 @@ ${codeText}
       });
     }
   }
-  const logger$2F = getLogger("op-parser");
+  const logger$2G = getLogger("op-parser");
   class DeleteBlockAction {
   }
   class DeleteBlockDataAction {
@@ -36472,8 +36475,8 @@ ${codeText}
       }
     }
     const blockData = firstOp.i;
-    assert(logger$2F, blockData.id, "block id is required");
-    assert(logger$2F, blockData.type, "block type is required");
+    assert(logger$2G, blockData.id, "block id is required");
+    assert(logger$2G, blockData.type, "block type is required");
     for (let i = 1; i < ops.length; i++) {
       const nextOp = ops[i];
       const key = nextOp[0];
@@ -36487,7 +36490,7 @@ ${codeText}
     if (processType === "upsert" && parseInsertBlockOnlyOp(containerId, orgOps, processor)) {
       return;
     }
-    assert(logger$2F, Array.isArray(orgOps), `invalid block op: ${containerId}, ${JSON.stringify(orgOps)}`);
+    assert(logger$2G, Array.isArray(orgOps), `invalid block op: ${containerId}, ${JSON.stringify(orgOps)}`);
     const ops = orgOps.concat();
     const blockIndex = ops[0];
     ops.shift();
@@ -36496,22 +36499,22 @@ ${codeText}
       const data2 = ops[0];
       if (data2 === "text") {
         const opData = ops[1];
-        assert(logger$2F, typeof opData === "object", `invalid block op: ${containerId}, ${JSON.stringify(orgOps)}`);
-        assert(logger$2F, opData.et === "rich-text", `invalid block op: ${containerId}, ${JSON.stringify(orgOps)}`);
+        assert(logger$2G, typeof opData === "object", `invalid block op: ${containerId}, ${JSON.stringify(orgOps)}`);
+        assert(logger$2G, opData.et === "rich-text", `invalid block op: ${containerId}, ${JSON.stringify(orgOps)}`);
         ops.splice(0, 2);
         if (processType === "upsert") {
           const deltaOps = opData.e;
           const richTextData = deltaOps;
           processor.onUpdateBlockText(containerId, blockIndex, richTextData);
         }
-        assert(logger$2F, ops.length === 0, `invalid block ops.length !== 0, ${JSON.stringify(ops)}`);
+        assert(logger$2G, ops.length === 0, `invalid block ops.length !== 0, ${JSON.stringify(ops)}`);
       } else if (Array.isArray(data2)) {
-        assert(logger$2F, data2.length === 2, `invalid block op: data.length !== 2, ${JSON.stringify(data2)}`);
+        assert(logger$2G, data2.length === 2, `invalid block op: data.length !== 2, ${JSON.stringify(data2)}`);
         const key = data2[0];
-        assert(logger$2F, typeof key === "string", `invalid block op: key ${JSON.stringify(key)}`);
+        assert(logger$2G, typeof key === "string", `invalid block op: key ${JSON.stringify(key)}`);
         const opData = data2[1];
         if (key === "text") {
-          assert(logger$2F, typeof opData === "object", `invalid opData type, ${JSON.stringify(opData)}`);
+          assert(logger$2G, typeof opData === "object", `invalid opData type, ${JSON.stringify(opData)}`);
           if (opData.i) {
             if (processType === "upsert") {
               processor.onInsertBlockData(containerId, blockIndex, key, opData.i);
@@ -36556,9 +36559,9 @@ ${codeText}
         }
         ops.shift();
       } else {
-        assert(logger$2F, typeof data2 === "string", "data is not string");
-        assert(logger$2F, data2 !== "text", "data !== 'text'");
-        assert(logger$2F, ops.length === 2, `invalid block op: ops.length !== 2, ${JSON.stringify(ops)}`);
+        assert(logger$2G, typeof data2 === "string", "data is not string");
+        assert(logger$2G, data2 !== "text", "data !== 'text'");
+        assert(logger$2G, ops.length === 2, `invalid block op: ops.length !== 2, ${JSON.stringify(ops)}`);
         const key = data2;
         const opData = ops[1];
         if (processType === "remove") {
@@ -36581,20 +36584,20 @@ ${codeText}
       } else if (a instanceof DeleteBlockDataAction) {
         processor.onDeleteBlockData(containerId, blockIndex, a.key);
       } else {
-        assert(logger$2F, false, `invalid action type: ${typeof a}, ${JSON.stringify(a)}`);
+        assert(logger$2G, false, `invalid action type: ${typeof a}, ${JSON.stringify(a)}`);
       }
     });
   }
   function parseMetaOp(ops, parseType, handler) {
-    logger$2F.warn(`unsupported meta op, ${JSON.stringify(ops)}`);
+    logger$2G.warn(`unsupported meta op, ${JSON.stringify(ops)}`);
   }
   function parseCommentsOp(ops, parseType, handler) {
     const commentId = ops[1];
     const actions2 = ops[2];
-    assert(logger$2F, commentId, `invalid comment op, no commentId: ${JSON.stringify(ops)}`);
-    assert(logger$2F, actions2, `invalid comment op, no actions: ${JSON.stringify(ops)}`);
+    assert(logger$2G, commentId, `invalid comment op, no commentId: ${JSON.stringify(ops)}`);
+    assert(logger$2G, actions2, `invalid comment op, no actions: ${JSON.stringify(ops)}`);
     if (typeof actions2 === "string") {
-      logger$2F.error(`unknown comment op, ${JSON.stringify(ops)}`);
+      logger$2G.error(`unknown comment op, ${JSON.stringify(ops)}`);
     } else {
       if (actions2.i && actions2.r) {
         if (parseType === "upsert") {
@@ -36609,7 +36612,7 @@ ${codeText}
           handler.onDeleteComment(commentId);
         }
       } else {
-        logger$2F.error(`unknown comment op, ${JSON.stringify(ops)}`);
+        logger$2G.error(`unknown comment op, ${JSON.stringify(ops)}`);
       }
     }
   }
@@ -36622,7 +36625,7 @@ ${codeText}
       return;
     }
     const rootKey = firstOp;
-    assert(logger$2F, typeof rootKey === "string", `invalid container id: ${JSON.stringify(ops)}`);
+    assert(logger$2G, typeof rootKey === "string", `invalid container id: ${JSON.stringify(ops)}`);
     if (rootKey === "meta") {
       parseMetaOp(ops);
       return;
@@ -36656,7 +36659,7 @@ ${codeText}
           }
         }
       } else {
-        assert(logger$2F, typeof ops[1] === "number", `invalid ops[1], not a number: ${JSON.stringify(ops)}`);
+        assert(logger$2G, typeof ops[1] === "number", `invalid ops[1], not a number: ${JSON.stringify(ops)}`);
         parseBlockOp(containerId, ops.slice(1), parseType, handler);
       }
     }
@@ -36677,10 +36680,10 @@ ${codeText}
     }
     innerHandler.end();
   }
-  const logger$2E = getLogger("sharedb-comments");
+  const logger$2F = getLogger("sharedb-comments");
   function shareDBCommentToDocObject(comment) {
     const root2 = comment.blocks;
-    assert(logger$2E, root2, "no comment blocks");
+    assert(logger$2F, root2, "no comment blocks");
     const doc2 = {
       blocks: {
         root: root2
@@ -36729,7 +36732,7 @@ ${codeText}
     delete ret.children;
     return ret;
   }
-  const logger$2D = getLogger("sharedb-doc/doc-container");
+  const logger$2E = getLogger("sharedb-doc/doc-container");
   const JSON1_TYPE_NAME = "ot-json1";
   json1__namespace.type.registerSubtype(richText.type);
   json1__namespace.type.name = JSON1_TYPE_NAME;
@@ -36833,22 +36836,22 @@ ${codeText}
       __publicField(this, "data", () => this.doc.data);
       __publicField(this, "submitOp", async (ops) => new Promise((resolve, reject) => {
         if (this.destroyed) {
-          logger$2D.warn("submit op after destroyed");
+          logger$2E.warn("submit op after destroyed");
           return;
         }
         this.setStatus("dirty");
         this.doc.submitOp(ops, {}, (err) => {
           if (err) {
-            logger$2D.error(`invalid op, ${err.message}, ${JSON.stringify(ops)}`);
+            logger$2E.error(`invalid op, ${err.message}, ${JSON.stringify(ops)}`);
             reject(err);
-            logger$2D.error("Transform detected write conflict, reload editor");
+            logger$2E.error("Transform detected write conflict, reload editor");
             this.handleReset("write conflict");
           } else {
             resolve();
           }
         });
         if (!this.doc.data) {
-          logger$2D.error("no data after submit op, may be the submitted op is invalid");
+          logger$2E.error("no data after submit op, may be the submitted op is invalid");
           this.handleReset(`invalid op, ${JSON.stringify(ops)}`);
         }
       }));
@@ -36912,18 +36915,18 @@ ${codeText}
       });
       __publicField(this, "handleOp", (ops, source, clientId) => {
         if (!ops) {
-          logger$2D.warn("handleOp: no ops");
+          logger$2E.warn("handleOp: no ops");
           return;
         }
         if (this.destroyed) {
-          logger$2D.warn("handleOp: destroyed");
+          logger$2E.warn("handleOp: destroyed");
           return;
         }
         try {
           const local = !!source;
           parseOps(ops, this, local);
         } catch (err) {
-          logger$2D.error(err);
+          logger$2E.error(err);
           throw err;
         }
       });
@@ -36940,7 +36943,7 @@ ${codeText}
     }
     endBatchUpdate() {
       this.batching--;
-      assert(logger$2D, this.batching >= 0, "invalid call beginBatchUpdate/endBatchUpdate");
+      assert(logger$2E, this.batching >= 0, "invalid call beginBatchUpdate/endBatchUpdate");
       if (this.batching === 0) {
         this.doc.preventCompose = true;
       }
@@ -36968,8 +36971,8 @@ ${codeText}
         shareDBDoc.initEvents();
         return shareDBDoc;
       } catch (err) {
-        logger$2D.error(err);
-        logger$2D.error(`failed to load doc: ${JSON.stringify(err)}`);
+        logger$2E.error(err);
+        logger$2E.error(`failed to load doc: ${JSON.stringify(err)}`);
         throw err;
       }
     }
@@ -37043,24 +37046,24 @@ ${codeText}
     }
     getContainerBlocks(containerId) {
       const doc2 = this.data();
-      assert(logger$2D, doc2, "no doc data");
+      assert(logger$2E, doc2, "no doc data");
       const blocks = doc2[docObjectContainerId2EditorDocContainerId(containerId)];
-      assert(logger$2D, blocks, `no container data: ${containerId}`);
+      assert(logger$2E, blocks, `no container data: ${containerId}`);
       return cloneDeep__default.default(blocks);
     }
     findContainerBlocks(containerId) {
       const doc2 = this.data();
-      assert(logger$2D, doc2, "no doc data");
+      assert(logger$2E, doc2, "no doc data");
       const blocks = doc2[docObjectContainerId2EditorDocContainerId(containerId)];
       return blocks != null ? blocks : null;
     }
     getBlockData(containerId, blockIndex) {
       const doc2 = this.data();
-      assert(logger$2D, doc2, "no doc data");
+      assert(logger$2E, doc2, "no doc data");
       const blocks = doc2[docObjectContainerId2EditorDocContainerId(containerId)];
-      assert(logger$2D, blocks, `no container data: ${containerId}`);
+      assert(logger$2E, blocks, `no container data: ${containerId}`);
       const blockData = blocks[blockIndex];
-      assert(logger$2D, blockData, `no block data: ${blockIndex}`);
+      assert(logger$2E, blockData, `no block data: ${blockIndex}`);
       return cloneDeep__default.default(blockData);
     }
     localInsertBlock(containerId, blockIndex, data2) {
@@ -37074,11 +37077,11 @@ ${codeText}
     }
     localUpdateBlockText(containerId, blockIndex, actions2) {
       const oldBlockData = this.getBlockData(containerId, blockIndex);
-      assert(logger$2D, oldBlockData.text, "no block text");
+      assert(logger$2E, oldBlockData.text, "no block text");
       const oldText = cloneDeep__default.default(oldBlockData.text);
       this.submitUpdateRichText(containerId, blockIndex, actions2);
       const newText = RichText.apply(oldText, actions2);
-      assert(logger$2D, newText, "no block text");
+      assert(logger$2E, newText, "no block text");
       return newText;
     }
     localUpdateBlockData(containerId, blockIndex, delta) {
@@ -37135,65 +37138,65 @@ ${codeText}
       this.remoteCaretHandler.destroy();
     }
     onDeleteBlock(containerId, blockIndex, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onDeleteBlock) == null ? void 0 : _a.call(cb, editorDpcContainerId2DocObjectContainerId(containerId), blockIndex, local);
       });
     }
     onInsertBlock(containerId, blockIndex, data2, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onInsertBlock) == null ? void 0 : _a.call(cb, editorDpcContainerId2DocObjectContainerId(containerId), blockIndex, data2, local);
       });
     }
     onUpdateBlockData(containerId, blockIndex, delta, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onUpdateBlockData) == null ? void 0 : _a.call(cb, editorDpcContainerId2DocObjectContainerId(containerId), blockIndex, delta, local);
       });
     }
     onUpdateBlockText(containerId, blockIndex, actions2, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onUpdateBlockText) == null ? void 0 : _a.call(cb, editorDpcContainerId2DocObjectContainerId(containerId), blockIndex, actions2, local);
       });
     }
     onDeleteContainer(containerId, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
-      assert(logger$2D, containerId !== "root", "should not delete root container in doc");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, containerId !== "root", "should not delete root container in doc");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onDeleteChildContainer) == null ? void 0 : _a.call(cb, editorDpcContainerId2DocObjectContainerId(containerId), local);
       });
     }
     onCreateContainer(containerId, blocks, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
-      assert(logger$2D, containerId !== "root", "should not create root container in doc");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, containerId !== "root", "should not create root container in doc");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onInsertChildContainer) == null ? void 0 : _a.call(cb, editorDpcContainerId2DocObjectContainerId(containerId), blocks, local);
       });
     }
     onDeleteComment(commentId, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onDeleteComment) == null ? void 0 : _a.call(cb, commentId, local);
       });
     }
     onCreateComment(commentId, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onCreateComment) == null ? void 0 : _a.call(cb, commentId, local);
       });
     }
     onUpdateComment(commentId, local) {
-      assert(logger$2D, this.callbacks.length > 0, "no callbacks");
+      assert(logger$2E, this.callbacks.length > 0, "no callbacks");
       this.callbacks.forEach((cb) => {
         var _a;
         return (_a = cb.onUpdateComment) == null ? void 0 : _a.call(cb, commentId, local);
@@ -37361,7 +37364,7 @@ ${codeText}
       this.editor.doc.getRemoteUsers().removeListener("remote-carets-change", this.handleRemoteCaretsChanged);
     }
   }
-  const logger$2C = getLogger("remote-cursor-decorator");
+  const logger$2D = getLogger("remote-cursor-decorator");
   class RemoteCaretsDecorator {
     decorateText(editor, path, blockText) {
       const remoteUsers = editor.doc.getRemoteUsers();
@@ -37370,8 +37373,8 @@ ${codeText}
       }
       const insertions = /* @__PURE__ */ new Map();
       const { containerId, blockIndex } = path[path.length - 1];
-      assert(logger$2C, typeof containerId === "string", "invalid path containerId");
-      assert(logger$2C, typeof blockIndex === "number", "invalid path blockIndex");
+      assert(logger$2D, typeof containerId === "string", "invalid path containerId");
+      assert(logger$2D, typeof blockIndex === "number", "invalid path blockIndex");
       const blockData = editor.doc.getBlockData(containerId, blockIndex);
       const length = getTextLength(blockText);
       const cursorMessages = remoteUsers.getSimpleCursors(blockData.id);
@@ -37401,6 +37404,221 @@ ${codeText}
       };
     }
   }
+  const logger$2C = getLogger("sharedb-server");
+  class ShareDBClientBase {
+    async getFileUrlByHash(uploadFileUrl, hash, name, size, headers) {
+      try {
+        const url = `${uploadFileUrl}/${hash}`;
+        const ret = await this.request(url, {
+          method: "post",
+          headers: {
+            ...headers
+          },
+          data: {
+            name,
+            size
+          }
+        });
+        if (ret.data && Array.isArray(ret.data) && ret.data.length === 1) {
+          return ret.data[0];
+        }
+        return "";
+      } catch (err) {
+        return "";
+      }
+    }
+    async getFileUrlsByHashes(resourceHashes) {
+      const server = this.apiServer();
+      const api = `${server}/resources`;
+      try {
+        const url = `${api}/hash`;
+        const ret = await this.request(url, {
+          method: "post",
+          headers: {
+            [AuthHeader]: this.token()
+          },
+          data: {
+            resources: resourceHashes
+          }
+        });
+        if (ret.data && Array.isArray(ret.data)) {
+          return ret.data;
+        }
+        return [];
+      } catch (err) {
+        return [];
+      }
+    }
+    async uploadFile(url, file2, headers, onProgress, options) {
+      let max = file2.size;
+      if (max === 0) {
+        throw new Error("file is empty");
+      }
+      max += 500;
+      const handleUploadProgress = (event) => {
+        logger$2C.info(`on progress: ${event.loaded}`);
+        let value = event.loaded * 100 / max;
+        if (value > 100)
+          value = 100;
+        onProgress(value);
+      };
+      const hash = await hashFile(file2);
+      const existsUrl = await this.getFileUrlByHash(url, hash, file2.name, file2.size, headers);
+      if (existsUrl) {
+        onProgress(-1);
+        return existsUrl;
+      }
+      let newUrl = url;
+      if (options == null ? void 0 : options.thumbnail) {
+        newUrl += "/thumbnail";
+      }
+      const data2 = new FormData();
+      data2.append("file-size", `${file2.size}`);
+      data2.append("file-hash", hash);
+      data2.append("file", file2, file2.name);
+      const result = await this.request(newUrl, {
+        method: "post",
+        data: data2,
+        withCredentials: true,
+        headers: {
+          ...headers
+        },
+        onUploadProgress: handleUploadProgress
+      });
+      logger$2C.info(result);
+      onProgress(100);
+      return Array.isArray(result.data) ? result.data[0] : result.data;
+    }
+    async uploadResource(file2, onProgress = () => {
+    }, options) {
+      const server = this.apiServer();
+      const api = `${server}/resources`;
+      const token = this.token();
+      assert(logger$2C, token, "no connection token");
+      const ret = await this.uploadFile(api, file2, {
+        [AuthHeader]: token
+      }, onProgress, options);
+      assert(logger$2C, ret, "no result");
+      return ret;
+    }
+    getResourceId(url) {
+      const regex = /\/resources\/([^?]+)/;
+      const matchResult = url.match(regex);
+      if (matchResult && matchResult.length >= 2) {
+        const resourceId = matchResult[1];
+        return resourceId;
+      }
+      return "";
+    }
+    buildResourceUrl(resourceId, options) {
+      var _a, _b;
+      if (!resourceId) {
+        return "";
+      }
+      if (resourceId.startsWith("file:") || resourceId.startsWith("data:") || resourceId.startsWith("blob:")) {
+        return resourceId;
+      }
+      const apiServer = this.apiServer();
+      if (resourceId.startsWith("http:") || resourceId.startsWith("https:")) {
+        const connectionUrlWithoutDocId = apiServer.replace(/\/[^/]*$/, "");
+        if (connectionUrlWithoutDocId && resourceId.includes(connectionUrlWithoutDocId)) {
+          const currentDocId = this.docId();
+          const startMarker = `${connectionUrlWithoutDocId}/`;
+          const endMarker = "/resources";
+          const startIndex = resourceId.indexOf(startMarker);
+          const endIndex = resourceId.indexOf(endMarker, startIndex + startMarker.length);
+          if (startIndex !== -1 && endIndex !== -1) {
+            const resourceDocId = resourceId.substring(startIndex + startMarker.length, endIndex);
+            if (resourceDocId !== currentDocId) {
+              let newResourceUrl = resourceId.replace(resourceDocId, currentDocId);
+              const url = new URL(newResourceUrl);
+              const paramNameToRemove = "token";
+              (_a = url.searchParams) == null ? void 0 : _a.delete(paramNameToRemove);
+              newResourceUrl = url.toString();
+              const syncResourceId = this.getResourceId(newResourceUrl);
+              if (options == null ? void 0 : options.syncNewResources) {
+                (_b = options == null ? void 0 : options.syncNewResources) == null ? void 0 : _b.call(options, syncResourceId, newResourceUrl);
+              }
+              return newResourceUrl;
+            }
+            return resourceId;
+          }
+          return resourceId;
+        }
+        return resourceId;
+      }
+      let ret = `${apiServer}/resources/${encodeURIComponent(resourceId)}`;
+      const params = [];
+      if (options == null ? void 0 : options.withToken) {
+        params.push(`token=${this.resourceToken()}`);
+      }
+      if (options == null ? void 0 : options.downloadFileName) {
+        params.push(`&fileName=${encodeURIComponent(options.downloadFileName)}`);
+      }
+      if (params.length > 0) {
+        const query2 = params.join("&");
+        ret += `?${query2}`;
+      }
+      return ret;
+    }
+  }
+  class ShareDBLocalClient extends ShareDBClientBase {
+    constructor(_options) {
+      super();
+      this._options = _options;
+    }
+    token() {
+      return this._options.token;
+    }
+    apiServer() {
+      return this._options.serverUrl;
+    }
+    resourceToken() {
+      return this._options.resourceToken || this._options.token;
+    }
+    docId() {
+      return this._options.docId;
+    }
+    request(url, opt) {
+      return axios__default.default(url, {
+        ...opt,
+        headers: {
+          "x-live-editor-token": this.token()
+        }
+      });
+    }
+  }
+  class ShareDBLocalDoc extends LocalDoc {
+    constructor(docObject, _options) {
+      super(docObject, {
+        serverUrl: _options.serverUrl
+      });
+      __publicField(this, "_client");
+      this._options = _options;
+      this._client = new ShareDBLocalClient(_options);
+    }
+    buildResourceUrl(src) {
+      return this._client.buildResourceUrl(src);
+    }
+    getUser() {
+      const localUser = {
+        ...this._options.user,
+        permission: "r"
+      };
+      return localUser;
+    }
+    request(url, opt) {
+      return this._client.request(url, opt);
+    }
+    async uploadResource(file2, options) {
+      var _a;
+      const ret = await this._client.uploadResource(file2, (_a = options == null ? void 0 : options.onProgress) != null ? _a : () => {
+      });
+      return {
+        resourceId: ret
+      };
+    }
+  }
   const logger$2B = getLogger("sharedb-doc/share-db-server");
   const axiosInstance = axios__default.default.create();
   class ShareDBSimpleClient {
@@ -48004,7 +48222,7 @@ ${codeText}
     }
   }
   const logger$1S = getLogger("toolbar-handler");
-  const SEP$1 = {
+  const SEP = {
     id: "",
     name: "",
     type: "separator"
@@ -48279,7 +48497,7 @@ ${codeText}
         });
         toolbarCommands.push(...sortCommands);
         if (index2 !== toolbarCommandsChunk.length - 1) {
-          toolbarCommands.push(SEP$1);
+          toolbarCommands.push(SEP);
         }
       });
       if (toolbarCommands.length === 0) {
@@ -55931,11 +56149,6 @@ $$${mathData.mathjaxText}$$
     "ja-JP": jaJP$s
   });
   const logger$1K = getLogger("readonly-toolbar");
-  const SEP = {
-    id: "",
-    name: "",
-    type: "separator"
-  };
   class ReadonlyToolbar {
     constructor(editor) {
       __publicField(this, "toolbar");
@@ -56033,35 +56246,6 @@ $$${mathData.mathjaxText}$$
         }
         this.showObjectToolbar(event);
       });
-      __publicField(this, "groupCommands", (allCommands) => {
-        var _a, _b;
-        const allCommandsMap = /* @__PURE__ */ new Map([["common", []]]);
-        for (let i = 0; i < allCommands.length; i++) {
-          const group = allCommands[i].group;
-          if (!group) {
-            (_a = allCommandsMap.get("common")) == null ? void 0 : _a.push(allCommands[i]);
-            continue;
-          }
-          if (allCommandsMap.has(group)) {
-            (_b = allCommandsMap.get(group)) == null ? void 0 : _b.push(allCommands[i]);
-          } else {
-            allCommandsMap.set(group, [allCommands[i]]);
-          }
-        }
-        const commandsChunk = [];
-        allCommandsMap.forEach((value) => {
-          commandsChunk.push(value.sort((item1, item2) => {
-            var _a2, _b2;
-            return ((_a2 = item1.order) != null ? _a2 : 0) - ((_b2 = item2.order) != null ? _b2 : 0);
-          }));
-        });
-        if (commandsChunk.length === 0) {
-          return [];
-        }
-        const commands = commandsChunk.reduce((prev, curr) => prev.concat([SEP, ...curr]), []);
-        commands.shift();
-        return commands;
-      });
       this.editor = editor;
       const popover = editor.options.componentsOptions.popover;
       this.toolbar = new ManualToolbar([], void 0, {
@@ -56110,7 +56294,7 @@ $$${mathData.mathjaxText}$$
     }
     showTextToolbar(reason) {
       var _a, _b;
-      let commands = [];
+      const commands = [];
       const range = this.editor.selection.range;
       this.providers.forEach((provider) => {
         if (provider.getTextCommands) {
@@ -56124,7 +56308,6 @@ $$${mathData.mathjaxText}$$
           commands.push(...textCommands);
         }
       });
-      commands = this.groupCommands(commands);
       if (commands.length === 0) {
         this.toolbar.close("cancelBar");
         return;
@@ -63353,8 +63536,8 @@ ${codeText}
     createItem() {
       var _a, _b;
       const { comment, commentsProvider, mainEditor: editor, groupItem } = this.options;
-      const canShowReply = !((_a = this.commentOptions) == null ? void 0 : _a.disableReply) && !editor.readonly;
-      const canShowEdit = !((_b = this.commentOptions) == null ? void 0 : _b.disableEdit) && !editor.readonly && commentsProvider.allowEdit(comment);
+      const canShowReply = !((_a = this.commentOptions) == null ? void 0 : _a.disableReply);
+      const canShowEdit = !((_b = this.commentOptions) == null ? void 0 : _b.disableEdit) && commentsProvider.allowEdit(comment);
       const canShowMore = canShowEdit && canShowReply;
       const head = createElement("div", ["item-head"], this.root);
       this.createAvatar(head, comment);
@@ -65460,31 +65643,6 @@ ${codeText}
       comments.commentProvider.addListener(this);
       editor.blockHooks.push(this);
     }
-    getTextCommands(editor, range) {
-      return [{
-        id: "add-comment-to-old-doc/text",
-        name: "Add Comment"
-      }];
-    }
-    executeCommand(editor, command, options) {
-      if (command.id === "add-comment-to-old-doc/text") {
-        const comments = editor.getCustom("editor-comments");
-        if (!comments) {
-          return;
-        }
-        const range = editor.selection.range;
-        if (!range.isSimple()) {
-          return;
-        }
-        comments.showCommentList();
-        editor.readonly = false;
-        addCommentToTextBlocks(editor, range, comments.commentProvider);
-        setTimeout(() => {
-          editor.readonly = true;
-        }, 100);
-      }
-      options.bar.close("clickItem");
-    }
     async onCreateComment(commentId, local) {
       if (local) {
         const comments = this.editor.getCustom("editor-comments");
@@ -65550,7 +65708,8 @@ ${codeText}
             group: "hovering-toolbar",
             commands: [{
               id: "add-comment-to-old-doc/child",
-              name: "Add Comment"
+              name: i18n$1.t("comment.quickMenuCommand"),
+              icon: CommentIcon$1
             }],
             executeCommand: (editor2, block, item, child2) => {
               if (!child2) {
@@ -65584,7 +65743,8 @@ ${codeText}
         group: "hovering-toolbar",
         commands: [{
           id: "add-comment-to-old-doc",
-          name: "Add Comment"
+          name: i18n$1.t("comment.quickMenuCommand"),
+          icon: CommentIcon$1
         }],
         executeCommand: (editor2, block, item) => {
           if (item.id === "add-comment-to-old-doc") {
@@ -65602,6 +65762,32 @@ ${codeText}
         }
       };
     }
+    getTextCommands(editor, range) {
+      return [{
+        id: "add-comment-to-old-doc/text",
+        name: i18n$1.t("comment.quickMenuCommand"),
+        icon: CommentIcon$1
+      }];
+    }
+    executeCommand(editor, command, options) {
+      if (command.id === "add-comment-to-old-doc/text") {
+        const comments = editor.getCustom("editor-comments");
+        if (!comments) {
+          return;
+        }
+        const range = editor.selection.range;
+        if (!range.isSimple()) {
+          return;
+        }
+        comments.showCommentList();
+        editor.readonly = false;
+        addCommentToTextBlocks(editor, range, comments.commentProvider);
+        setTimeout(() => {
+          editor.readonly = true;
+        }, 100);
+      }
+      options.bar.close("clickItem");
+    }
   }
   const index$8 = "";
   function createTextButton(parent, ...args) {
@@ -82900,7 +83086,7 @@ ${data2.flowchartText}
         }
       }
     });
-    editor.version = "2.1.0-beta.4";
+    editor.version = "2.1.1-beta.1";
     if (Logger$2.level === LogLevel.DEBUG) {
       window.setReauthFail = (fail) => {
         window.isReauthError = fail;
@@ -82995,7 +83181,7 @@ ${data2.flowchartText}
     if (!clientType.isMobile) {
       OnesEditorToolbar.register(editor);
     }
-    editor.version = "2.1.0-beta.4";
+    editor.version = "2.1.1-beta.1";
     return editor;
   }
   async function showDocVersions(editor, options, serverUrl) {
@@ -128806,8 +128992,10 @@ ${data2.flowchartText}
   exports2.RemoteUsers = RemoteUsers;
   exports2.RequestReloadError = RequestReloadError;
   exports2.RichText = RichText;
+  exports2.ShareDBClientBase = ShareDBClientBase;
   exports2.ShareDBDoc = ShareDBDoc;
   exports2.ShareDBDocVersionsProvider = ShareDBDocVersionsProvider;
+  exports2.ShareDBLocalDoc = ShareDBLocalDoc;
   exports2.ShareDBServer = ShareDBServer;
   exports2.SimpleCache = SimpleCache;
   exports2.StandardEmbedBlockCommands = StandardEmbedBlockCommands;