@ones-editor/editor 1.1.7-beta.15 → 1.1.7-beta.16

package/dist/index.js

@@ -6088,7 +6088,7 @@ var __publicField = (obj, key, value) => {
       imageExportFailed: "\u753B\u50CF\u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F"
     }
   };
-  const logger$4b = getLogger("i18n");
+  const logger$4c = getLogger("i18n");
   const langs$2 = {
     "en-US": enUS$u,
     "zh-CN": zhCN$u,
@@ -6108,7 +6108,7 @@ var __publicField = (obj, key, value) => {
   function t$8(key, args) {
     const ret = i18n.get(key, args);
     if (ret === key) {
-      logger$4b.warn(`no locale value for key ${key}`);
+      logger$4c.warn(`no locale value for key ${key}`);
     }
     return ret;
   }
@@ -6721,7 +6721,7 @@ var __publicField = (obj, key, value) => {
       this._callbacks.clear();
     }
   }
-  const logger$4a = getLogger("await-locker");
+  const logger$4b = getLogger("await-locker");
   class AwaitLock {
     constructor() {
       __publicField(this, "_acquired", false);
@@ -6763,7 +6763,7 @@ var __publicField = (obj, key, value) => {
       }
       if (this._waitingResolvers.length > 0) {
         const resolve = this._waitingResolvers.shift();
-        assert(logger$4a, resolve, "Resolver missing");
+        assert(logger$4b, resolve, "Resolver missing");
         resolve(void 0);
       } else {
         this._acquired = false;
@@ -6815,7 +6815,7 @@ var __publicField = (obj, key, value) => {
     }
   }
   const lockers = new Lockers();
-  const logger$49 = getLogger("dom-utils");
+  const logger$4a = getLogger("dom-utils");
   function addClass(dom, ...className) {
     if (dom && dom.nodeType === Node.ELEMENT_NODE) {
       dom.classList.add(...className);
@@ -6869,7 +6869,7 @@ var __publicField = (obj, key, value) => {
       range.setStart(node, offset);
       return range;
     } catch (err) {
-      assert(logger$49, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
+      assert(logger$4a, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
     }
   }
   function createExpandedRange(startNode, startOffset, endNode, endOffset) {
@@ -6879,17 +6879,17 @@ var __publicField = (obj, key, value) => {
       range.setEnd(endNode, endOffset);
       return range;
     } catch (err) {
-      assert(logger$49, false, `failed to create expanded range: ${startNode.childNodes.length}, ${startOffset}, ${endNode.childNodes.length}, ${endOffset}, ${err.message}`);
+      assert(logger$4a, 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$49, rects.length >= 1, "getFirstClientRect: no rects");
+    assert(logger$4a, rects.length >= 1, "getFirstClientRect: no rects");
     return rects[0];
   }
   function getLastClientRect(elem) {
     const rects = elem.getClientRects();
-    assert(logger$49, rects.length >= 1, "getLastClientRect: no rects");
+    assert(logger$4a, rects.length >= 1, "getLastClientRect: no rects");
     return rects[rects.length - 1];
   }
   function getDistanceSquare(rect, x, y) {
@@ -6929,7 +6929,7 @@ var __publicField = (obj, key, value) => {
       return 0;
     }
     if (!elem1.parentElement || !elem2.parentElement) {
-      assert(logger$49, false, "invalid dom node to compare");
+      assert(logger$4a, false, "invalid dom node to compare");
     }
     if (elem1.parentElement === elem2.parentElement) {
       const children = Array.from(elem1.parentElement.children);
@@ -6946,7 +6946,7 @@ var __publicField = (obj, key, value) => {
     const parents1 = getParents(elem1);
     const parents2 = getParents(elem2);
     if (parents1[0] !== parents2[0]) {
-      assert(logger$49, false, "invalid dom node to compare, different tree");
+      assert(logger$4a, false, "invalid dom node to compare, different tree");
     }
     for (let i = 1; ; i++) {
       const parent1 = parents1[i];
@@ -7445,7 +7445,7 @@ var __publicField = (obj, key, value) => {
     }
   }
   const MIN_DISTANCE_THRESHOLD = 3;
-  const logger$48 = getLogger("drag-drop");
+  const logger$49 = getLogger("drag-drop");
   class DragDrop {
     constructor(options) {
       __publicField(this, "dragStarted", false);
@@ -7465,7 +7465,7 @@ var __publicField = (obj, key, value) => {
         var _a;
         event.preventDefault();
         event.stopPropagation();
-        assert(logger$48, this.mouseDownEvent, "no mouse down event");
+        assert(logger$49, this.mouseDownEvent, "no mouse down event");
         const deltaX = event.x - this.mouseDownEvent.x;
         const deltaY = event.y - this.mouseDownEvent.y;
         if (this.dragStarted) {
@@ -7479,7 +7479,7 @@ var __publicField = (obj, key, value) => {
       });
       __publicField(this, "handleMouseUp", (event) => {
         if (event.button === 0) {
-          assert(logger$48, this.mouseDownEvent, "no mouse down event");
+          assert(logger$49, 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);
@@ -7552,7 +7552,7 @@ var __publicField = (obj, key, value) => {
     const dragDrop = new DragDrop(options);
     return dragDrop;
   }
-  const logger$47 = getLogger("character");
+  const logger$48 = getLogger("character");
   function checkChar(charCode, rangeList) {
     for (let i = 0; i < rangeList.length; i++) {
       const start = rangeList[i][0];
@@ -7599,7 +7599,7 @@ var __publicField = (obj, key, value) => {
   }
   function trimChar(s, char) {
     let c = char;
-    assert(logger$47, c.length === 1, "invalid char length");
+    assert(logger$48, c.length === 1, "invalid char length");
     if (c === "]")
       c = "\\]";
     if (c === "\\")
@@ -7953,7 +7953,7 @@ var __publicField = (obj, key, value) => {
     const metrics = context.measureText(text2);
     return metrics.width + 4;
   }
-  const logger$46 = getLogger("editor-clipboard");
+  const logger$47 = getLogger("editor-clipboard");
   async function setClipboardDataByEvent(items, event) {
     if (event.clipboardData) {
       const data = event.clipboardData;
@@ -7974,7 +7974,7 @@ var __publicField = (obj, key, value) => {
       await navigator.clipboard.write([clipboardItems]);
       return true;
     } catch (err) {
-      logger$46.error(err);
+      logger$47.error(err);
       return false;
     }
   }
@@ -8024,7 +8024,7 @@ var __publicField = (obj, key, value) => {
     a.click();
     a.remove();
   }
-  const logger$45 = getLogger("auto-scroll");
+  const logger$46 = getLogger("auto-scroll");
   function scrollable(scrollElement, direction) {
     if (scrollElement.scrollHeight === scrollElement.clientHeight) {
       return false;
@@ -8048,7 +8048,7 @@ var __publicField = (obj, key, value) => {
     const isHorizontal = direction === "left" || direction === "right";
     const scroll = () => {
       if (!scrollable(scrollElement, direction)) {
-        logger$45.debug("No need for scroll");
+        logger$46.debug("No need for scroll");
         return null;
       }
       if (isHorizontal) {
@@ -8106,7 +8106,7 @@ var __publicField = (obj, key, value) => {
           if (this.scrolling) {
             return;
           }
-          logger$45.debug(`scroll direction: ${direction}`);
+          logger$46.debug(`scroll direction: ${direction}`);
           this.cancelScroll = continuousScroll(scrollElement, {
             direction,
             step
@@ -8357,7 +8357,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$44 = getLogger("element");
+  const logger$45 = getLogger("element");
   function createContainerElement(parent, type, containerId) {
     const container = createElement("div", [type], parent);
     container.setAttribute("data-type", "editor-container");
@@ -8367,7 +8367,7 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerById(editor, containerId) {
     const container = editor.rootElement.querySelector(`[data-container-id=${containerId}]`);
-    assert(logger$44, container, `no container: ${containerId}`);
+    assert(logger$45, container, `no container: ${containerId}`);
     return container;
   }
   function getExistsContainerById(editor, containerId) {
@@ -8376,7 +8376,7 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerBlocksElement(container) {
     const blocks = container.querySelector(":scope > .container-blocks");
-    assert(logger$44, blocks, "no container blocks element");
+    assert(logger$45, blocks, "no container blocks element");
     return blocks;
   }
   function getContainerToolsElement(container) {
@@ -8386,16 +8386,16 @@ var __publicField = (obj, key, value) => {
     }
     return tools;
   }
-  const logger$43 = getLogger("container-children");
+  const logger$44 = getLogger("container-children");
   function getChildBlocks(container) {
     const content = getContainerBlocksElement(container);
     const blocks = Array.from(content.children);
-    assert(logger$43, blocks.length > 0, "container have not any child block");
+    assert(logger$44, blocks.length > 0, "container have not any child block");
     return blocks;
   }
   function getFirstChildBlock(container) {
     const block = container.querySelector(":scope > .container-blocks > div[data-type=editor-block]");
-    assert(logger$43, block, "container have not any child block");
+    assert(logger$44, block, "container have not any child block");
     return block;
   }
   function getLastChildBlock(container) {
@@ -8407,7 +8407,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockByIndex(container, blockIndex) {
     const block = getChildBlocks(container)[blockIndex];
-    assert(logger$43, block, `container have not block at index ${blockIndex}`);
+    assert(logger$44, block, `container have not block at index ${blockIndex}`);
     return block;
   }
   function findBlockByIndex(container, blockIndex) {
@@ -8513,18 +8513,18 @@ var __publicField = (obj, key, value) => {
       });
     }
   }
-  const logger$42 = getLogger("block-class");
+  const logger$43 = 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$42, text2.blockKind === "text", `is not a text block, ${text2.blockType}`);
+    assert(logger$43, 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$42, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
+    assert(logger$43, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
     return complex;
   }
   function getBlockClassByType(editor, type) {
@@ -8722,7 +8722,7 @@ var __publicField = (obj, key, value) => {
       return { classes, attributes: newAttributes, styles: newStyles };
     }
   }
-  const logger$41 = getLogger("block-dom");
+  const logger$42 = getLogger("block-dom");
   function isBlock(node) {
     if (!(node instanceof HTMLDivElement)) {
       return false;
@@ -8743,12 +8743,12 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockId(block) {
     const { id } = block;
-    assert(logger$41, id, "no block id");
+    assert(logger$42, id, "no block id");
     return id;
   }
   function getBlockType(block) {
     const type = block.getAttribute("data-block-type");
-    assert(logger$41, type, "invalid block dom, no data-type");
+    assert(logger$42, type, "invalid block dom, no data-type");
     return type;
   }
   function getParentBlock(node) {
@@ -8771,12 +8771,12 @@ var __publicField = (obj, key, value) => {
   }
   function getParentContainer(block) {
     const container = block.closest("div[data-type=editor-container]");
-    assert(logger$41, container, "failed to get block container");
+    assert(logger$42, container, "failed to get block container");
     return container;
   }
   function getBlockContent(block) {
     const content = block.querySelector(":scope >div[data-type=block-content]");
-    assert(logger$41, content, "no block content");
+    assert(logger$42, content, "no block content");
     return content;
   }
   function getBlockTools(block) {
@@ -8785,7 +8785,7 @@ var __publicField = (obj, key, value) => {
       tools = createElement("div", [], block);
       tools.setAttribute("data-type", "block-tools");
     }
-    assert(logger$41, tools, "no block tools");
+    assert(logger$42, tools, "no block tools");
     return tools;
   }
   function getExistsBlockTools(block) {
@@ -8806,7 +8806,7 @@ var __publicField = (obj, key, value) => {
   function createBlockElement(editor, path, data) {
     const blockData = editor.editorDecorators.decorateBlock(path, data);
     const { id, type } = blockData;
-    assert(logger$41, id, "no block id");
+    assert(logger$42, id, "no block id");
     const elem = createElement("div", [`${type}-block`], null);
     elem.id = id;
     elem.setAttribute("data-type", "editor-block");
@@ -8844,7 +8844,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxTypeFromElement(box) {
     const type = box.getAttribute("data-box-type");
-    assert(logger$41, type, "not a valid box element, no type");
+    assert(logger$42, type, "not a valid box element, no type");
     return type;
   }
   function isBox(node) {
@@ -8855,7 +8855,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxId(box) {
     const { id } = box;
-    assert(logger$41, id, "no box id");
+    assert(logger$42, id, "no box id");
     return id;
   }
   function getParentBox(node) {
@@ -8877,7 +8877,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxContent(box) {
     const content = box.querySelector("span[data-type=box-content]");
-    assert(logger$41, content, "invalid box dom, no content");
+    assert(logger$42, content, "invalid box dom, no content");
     return content;
   }
   function createInsertionElement(type, id, attributes) {
@@ -8909,7 +8909,7 @@ var __publicField = (obj, key, value) => {
   }
   function getInsertionContent(insertion) {
     const content = insertion.querySelector("span[data-type=insertion-content]");
-    assert(logger$41, content, "invalid insertion-child dom, no content");
+    assert(logger$42, content, "invalid insertion-child dom, no content");
     return content;
   }
   function getPrevBlock(block) {
@@ -8956,7 +8956,7 @@ var __publicField = (obj, key, value) => {
     const container = getParentContainer(block);
     const children = getChildBlocks(container);
     const index2 = children.indexOf(block);
-    assert(logger$41, index2 !== -1, "invalid block & container dom, failed to get block index");
+    assert(logger$42, index2 !== -1, "invalid block & container dom, failed to get block index");
     return index2;
   }
   function isInBlock(target) {
@@ -8985,7 +8985,7 @@ var __publicField = (obj, key, value) => {
     const blockClass = getBlockClass(editor, block);
     return blockClass.getCaretRect(block, pos);
   }
-  const logger$40 = getLogger("container");
+  const logger$41 = getLogger("container");
   function isContainer(elem) {
     return elem.getAttribute("data-type") === "editor-container";
   }
@@ -8997,9 +8997,9 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerId(container) {
     const id = container.getAttribute("data-container-id");
-    assert(logger$40, id, "no id for container");
+    assert(logger$41, id, "no id for container");
     if (isRootContainer(container)) {
-      assert(logger$40, id === "root", `invalid root container id, : ${id}`);
+      assert(logger$41, id === "root", `invalid root container id, : ${id}`);
     }
     return id;
   }
@@ -9007,7 +9007,7 @@ var __publicField = (obj, key, value) => {
     const containerId = getContainerId(container);
     return doc2.getContainerBlocks(containerId);
   }
-  const logger$3$ = getLogger("block");
+  const logger$40 = getLogger("block");
   function getBlockTextLength$4(editor, block) {
     return getBlockClass(editor, block).getBlockTextLength(block);
   }
@@ -9026,7 +9026,7 @@ var __publicField = (obj, key, value) => {
         return block;
       }
       const parent = getParentBlock(container);
-      assert(logger$3$, parent, "no parent block exists for child container");
+      assert(logger$40, parent, "no parent block exists for child container");
       block = parent;
     }
   }
@@ -9050,7 +9050,7 @@ var __publicField = (obj, key, value) => {
       }
       return fun(editor, block, options);
     } catch (err) {
-      logger$3$.debug(`unsupported block type: ${type}`);
+      logger$40.debug(`unsupported block type: ${type}`);
       return null;
     }
   }
@@ -9070,7 +9070,7 @@ var __publicField = (obj, key, value) => {
     const styles = Object.fromEntries(Object.entries(data).filter(([key]) => key.startsWith("style-")));
     Object.entries(styles).forEach(([, value]) => {
       const type = typeof value;
-      assert(logger$3$, type === "string" || type === "number" || type === "boolean", "invalid style value");
+      assert(logger$40, type === "string" || type === "number" || type === "boolean", "invalid style value");
     });
     return styles;
   }
@@ -9080,7 +9080,7 @@ var __publicField = (obj, key, value) => {
     }
     return false;
   }
-  const logger$3_ = getLogger("block-path");
+  const logger$3$ = getLogger("block-path");
   function getBlockPath(block) {
     const ret = [];
     let current = block;
@@ -9094,10 +9094,10 @@ var __publicField = (obj, key, value) => {
         return ret;
       }
       const parentBlock = getParentBlock(container);
-      assert(logger$3_, parentBlock, "no parent block");
+      assert(logger$3$, parentBlock, "no parent block");
       current = parentBlock;
     }
-    assert(logger$3_, false, "no parent block");
+    assert(logger$3$, false, "no parent block");
     return [];
   }
   function getBlockOptions(editor, block) {
@@ -9165,14 +9165,14 @@ var __publicField = (obj, key, value) => {
     }
     return { element: null, commands: [] };
   }
-  const logger$3Z = getLogger("embed-block-common");
+  const logger$3_ = getLogger("embed-block-common");
   function isEmbedBlock(block) {
     return getBlockType(block) === "embed";
   }
   function getEmbedType(block) {
-    assert(logger$3Z, isEmbedBlock(block), "not an embed block");
+    assert(logger$3_, isEmbedBlock(block), "not an embed block");
     const type = block.getAttribute("data-embed-type");
-    assert(logger$3Z, type, "no embed data type");
+    assert(logger$3_, type, "no embed data type");
     return type;
   }
   function getEmbedClassFromBlock(editor, block) {
@@ -9224,10 +9224,10 @@ var __publicField = (obj, key, value) => {
       data
     });
   }
-  const logger$3Y = getLogger("execute-block-command");
+  const logger$3Z = getLogger("execute-block-command");
   function executeEmbedBlockCommand(editor, block, commandGroup, item) {
     var _a;
-    assert(logger$3Y, isEmbedBlock(block), "not a embed block");
+    assert(logger$3Z, isEmbedBlock(block), "not a embed block");
     const embedType = getEmbedType(block);
     const embed = getEmbedClassByType(editor, embedType);
     if (!embed.getOptions) {
@@ -9259,7 +9259,7 @@ var __publicField = (obj, key, value) => {
     }
     return void 0;
   }
-  const logger$3X = getLogger("text-block-child");
+  const logger$3Y = getLogger("text-block-child");
   function isTextBlockContentChild(elem) {
     if (elem.tagName !== "SPAN") {
       return false;
@@ -9267,14 +9267,14 @@ var __publicField = (obj, key, value) => {
     return true;
   }
   function isTextBlockContentBoxChild(elem) {
-    assert(logger$3X, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$3Y, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-box") {
       return true;
     }
     return false;
   }
   function isTextBlockContentInsertionChild(elem) {
-    assert(logger$3X, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$3Y, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-insertion") {
       return true;
     }
@@ -9284,7 +9284,7 @@ var __publicField = (obj, key, value) => {
     return !isTextBlockContentBoxChild(elem) && !isTextBlockContentInsertionChild(elem);
   }
   function getTextBlockContentChildType(child) {
-    assert(logger$3X, isTextBlockContentChild(child), "not a valid text child");
+    assert(logger$3Y, isTextBlockContentChild(child), "not a valid text child");
     if (isTextBlockContentBoxChild(child)) {
       return "box";
     }
@@ -9299,15 +9299,15 @@ var __publicField = (obj, key, value) => {
       return 0;
     if (type === "box")
       return 1;
-    assert(logger$3X, child.textContent !== null, "text block content is undefined");
-    assert(logger$3X, child.textContent.length >= 0, "text block content length is negative");
+    assert(logger$3Y, child.textContent !== null, "text block content is undefined");
+    assert(logger$3Y, 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$3X, isTextBlockContentChild(child), "not a valid text child");
+      assert(logger$3Y, isTextBlockContentChild(child), "not a valid text child");
     });
     return children;
   }
@@ -9336,30 +9336,30 @@ var __publicField = (obj, key, value) => {
         };
       }
       const offset = blockOffset - start;
-      assert(logger$3X, offset > 0, "invalid offset value");
-      assert(logger$3X, !isTextBlockContentBoxChild(child), "invalid box child");
+      assert(logger$3Y, offset > 0, "invalid offset value");
+      assert(logger$3Y, !isTextBlockContentBoxChild(child), "invalid box child");
       return {
         prev: child,
         next: child,
         offset
       };
     }
-    assert(logger$3X, false, `invalid block child at position: ${blockOffset}`);
+    assert(logger$3Y, false, `invalid block child at position: ${blockOffset}`);
   }
-  const logger$3W = getLogger("child-container-path");
+  const logger$3X = getLogger("child-container-path");
   function getContainerBlockPath(container) {
     if (isRootContainer(container)) {
       return [];
     }
     const parentBlock = getParentBlock(container);
-    assert(logger$3W, parentBlock, "no parent block");
+    assert(logger$3X, parentBlock, "no parent block");
     return getBlockPath(parentBlock);
   }
-  const logger$3V = getLogger("load-blocks");
+  const logger$3W = getLogger("load-blocks");
   function loadBlocks(editor, container, path) {
     const containerId = getContainerId(container);
     const blocks = getContainerBlocks$1(container, editor.doc);
-    assert(logger$3V, blocks.length > 0, "no blocks in container");
+    assert(logger$3W, 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);
@@ -9375,7 +9375,7 @@ var __publicField = (obj, key, value) => {
       return block;
     }
     const blocks = getChildBlocks(container);
-    assert(logger$3V, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
+    assert(logger$3W, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
     if (blockIndex === blocks.length) {
       containerBlocksElement.appendChild(block);
     } else {
@@ -9393,7 +9393,7 @@ var __publicField = (obj, key, value) => {
     insertBlockAt(container, blockIndex, block);
     return block;
   }
-  const logger$3U = getLogger("root-container");
+  const logger$3V = getLogger("root-container");
   class RootContainer {
     constructor(editor, rootContainer) {
       __publicField(this, "resizeObserver");
@@ -9411,7 +9411,7 @@ var __publicField = (obj, key, value) => {
           this.editor.selection.updateSelection(null);
           this.editor.emit("resize", this.editor);
         } catch (err) {
-          logger$3U.warn(`failed to update selection while container resizing: ${err.message}`);
+          logger$3V.warn(`failed to update selection while container resizing: ${err.message}`);
         }
       });
       __publicField(this, "handleClick", (event) => {
@@ -9444,7 +9444,7 @@ var __publicField = (obj, key, value) => {
         const box = getParentBox(elem);
         if (box) {
           const block2 = getParentBlock(box);
-          assert(logger$3U, block2, "no parent block");
+          assert(logger$3V, 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;
         }
@@ -9606,7 +9606,7 @@ var __publicField = (obj, key, value) => {
     }
     return isEmptyTextBlock(editor, blocks[0]);
   }
-  const logger$3T = getLogger("complex-block-position");
+  const logger$3U = getLogger("complex-block-position");
   class EditorComplexBlockPosition {
     constructor(block, childContainerId, custom) {
       __publicField(this, "blockId");
@@ -9615,7 +9615,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$3T, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$3U, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.childContainerId = childContainerId;
@@ -9627,7 +9627,7 @@ var __publicField = (obj, key, value) => {
       return false;
     }
   }
-  const logger$3S = getLogger("simple-block-position");
+  const logger$3T = getLogger("simple-block-position");
   class EditorSimpleBlockPosition {
     constructor(block, offset, type) {
       __publicField(this, "blockId");
@@ -9636,7 +9636,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$3S, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$3T, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.offset = offset;
@@ -9646,7 +9646,7 @@ var __publicField = (obj, key, value) => {
       return true;
     }
   }
-  const logger$3R = getLogger("editor-position");
+  const logger$3S = getLogger("editor-position");
   function createSimpleBlockPosition(block, offset, type) {
     return new EditorSimpleBlockPosition(block, offset, type);
   }
@@ -9668,7 +9668,7 @@ var __publicField = (obj, key, value) => {
       }
       const block1 = editor.getBlockById(pos1.blockId);
       const block2 = editor.getBlockById(pos2.blockId);
-      assert(logger$3R, block1 !== block2, "comparePosition: blocks are the same");
+      assert(logger$3S, block1 !== block2, "comparePosition: blocks are the same");
       return compareElement(block1, block2);
     }
     if (isComplexBlockPosition(pos1) && isComplexBlockPosition(pos2)) {
@@ -9679,13 +9679,13 @@ var __publicField = (obj, key, value) => {
       }
       const container1 = editor.getContainerById(p1.childContainerId);
       const container2 = editor.getContainerById(p2.childContainerId);
-      assert(logger$3R, container1 !== container2, "comparePosition: containers are the same");
+      assert(logger$3S, container1 !== container2, "comparePosition: containers are the same");
       return compareElement(container1, container2);
     }
-    assert(logger$3R, false, "invalid ");
+    assert(logger$3S, false, "invalid ");
     return 0;
   }
-  const logger$3Q = getLogger("simple-range");
+  const logger$3R = getLogger("simple-range");
   class EditorSimpleSelectionRange {
     constructor(editor, options) {
       __publicField(this, "editor");
@@ -9734,11 +9734,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$3Q, startBlock, "no start block");
-      assert(logger$3Q, endBlock, "no end block");
+      assert(logger$3R, startBlock, "no start block");
+      assert(logger$3R, endBlock, "no end block");
       const startContainer = getParentContainer(startBlock);
       const endContainer = getParentContainer(endBlock);
-      assert(logger$3Q, startContainer === endContainer, "invalid range");
+      assert(logger$3R, startContainer === endContainer, "invalid range");
       const ret = [];
       if (startBlock === endBlock) {
         ret.push({
@@ -9749,7 +9749,7 @@ var __publicField = (obj, key, value) => {
       } else {
         const startIndex = getBlockIndex(startBlock);
         const endIndex = getBlockIndex(endBlock);
-        assert(logger$3Q, startIndex < endIndex, "invalid range, start > index");
+        assert(logger$3R, startIndex < endIndex, "invalid range, start > index");
         ret.push({
           block: startBlock,
           start: this.start,
@@ -9848,7 +9848,7 @@ var __publicField = (obj, key, value) => {
     clearSelection: clearSelection$4,
     convertTo: convertTo$k
   };
-  const logger$3P = getLogger("editor-blocks");
+  const logger$3Q = getLogger("editor-blocks");
   class EditorBlocks {
     constructor(editor) {
       __publicField(this, "blocks", /* @__PURE__ */ new Map());
@@ -9857,12 +9857,12 @@ var __publicField = (obj, key, value) => {
     registerBlockClass(blockClass) {
       const type = blockClass.blockType;
       const exists = this.blocks.get(type);
-      assert(logger$3P, !exists, `duplicated block type: ${type}`);
+      assert(logger$3Q, !exists, `duplicated block type: ${type}`);
       this.blocks.set(type, blockClass);
     }
     getBlockClass(type) {
       const exists = this.blocks.get(type);
-      assert(logger$3P, exists, `unknown block type: ${type}`);
+      assert(logger$3Q, exists, `unknown block type: ${type}`);
       return exists;
     }
     hasBlock(type) {
@@ -9878,7 +9878,7 @@ var __publicField = (obj, key, value) => {
       }
       const content = blockClass.createBlockContent(this.editor, path, container, blockElement, block);
       if (content.parentElement !== blockElement) {
-        logger$3P.warn("content parent is not block");
+        logger$3Q.warn("content parent is not block");
         blockElement.appendChild(content);
       }
       this.editor.blockHooks.forEach((hook) => {
@@ -9899,7 +9899,7 @@ var __publicField = (obj, key, value) => {
       return newBlock;
     }
   }
-  const logger$3O = getLogger("editor-embeds");
+  const logger$3P = getLogger("editor-embeds");
   class EditorEmbeds {
     constructor(editor) {
       __publicField(this, "objects", /* @__PURE__ */ new Map());
@@ -9908,12 +9908,12 @@ var __publicField = (obj, key, value) => {
     registerEmbedClass(embedClass) {
       const type = embedClass.embedType;
       const exists = this.objects.get(type);
-      assert(logger$3O, !exists, `duplicated embed object type: ${type}`);
+      assert(logger$3P, !exists, `duplicated embed object type: ${type}`);
       this.objects.set(type, embedClass);
     }
     getEmbedClass(type) {
       const exists = this.objects.get(type);
-      assert(logger$3O, exists, `unknown embed type: ${type}`);
+      assert(logger$3P, exists, `unknown embed type: ${type}`);
       return exists;
     }
     getEmbedClassFromBlock(block) {
@@ -9923,12 +9923,12 @@ var __publicField = (obj, key, value) => {
       this.objects.forEach(callback);
     }
   }
-  const logger$3N = getLogger("embed-block");
+  const logger$3O = getLogger("embed-block");
   function createBlockContent$4(editor, path, container, blockElement, blockData) {
     const content = createBlockContentElement(blockElement, "div");
-    assert(logger$3N, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
+    assert(logger$3O, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
     const embedBlockData = blockData;
-    assert(logger$3N, embedBlockData.embedType && embedBlockData.embedData, `not an embed data: ${JSON.stringify(embedBlockData)}`);
+    assert(logger$3O, 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);
@@ -10092,18 +10092,18 @@ var __publicField = (obj, key, value) => {
     toStandardDoc: toStandardDoc$1,
     getResources: getResources$2
   };
-  const logger$3M = getLogger("complex-block-helper");
+  const logger$3N = 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$3M, end.isSimple(), "invalid start and end position");
+      assert(logger$3N, end.isSimple(), "invalid start and end position");
       return complexBlockGetAllChildContainers(editor, block);
     }
-    assert(logger$3M, !start.isSimple(), "invalid start pos");
-    assert(logger$3M, !end.isSimple(), "invalid end pos");
+    assert(logger$3N, !start.isSimple(), "invalid start pos");
+    assert(logger$3N, !end.isSimple(), "invalid end pos");
     const blockClass = getComplexBlockClass(editor, block);
     return blockClass.getSelectedContainers(editor, block, start, end);
   }
@@ -10114,11 +10114,11 @@ var __publicField = (obj, key, value) => {
     const parentComplexBlock = getParentBlock(getParentContainer(childBlock));
     if (!parentComplexBlock)
       return false;
-    assert(logger$3M, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$3N, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainer = getParentContainer(childBlock);
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock);
     const index2 = childContainers.indexOf(childContainer);
-    assert(logger$3M, index2 >= 0, "not valid child container");
+    assert(logger$3N, index2 >= 0, "not valid child container");
     return index2 === 0;
   }
   function complexBlockGeFirstSimpleChild(editor, complexBlock, options) {
@@ -10152,13 +10152,13 @@ var __publicField = (obj, key, value) => {
     return lastBlock2;
   }
   function findPrevSimpleBlockBeforeChildContainer(editor, childContainer) {
-    assert(logger$3M, isChildContainer(childContainer), "not a child container");
+    assert(logger$3N, isChildContainer(childContainer), "not a child container");
     const parentComplexBlock = getParentBlock(childContainer);
-    assert(logger$3M, parentComplexBlock, "no parent block");
-    assert(logger$3M, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$3N, parentComplexBlock, "no parent block");
+    assert(logger$3N, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock);
     const containerIndex = childContainers.indexOf(childContainer);
-    assert(logger$3M, containerIndex !== -1, "child container not found");
+    assert(logger$3N, containerIndex !== -1, "child container not found");
     if (containerIndex === 0) {
       const prevBlock = getPrevBlock(parentComplexBlock);
       if (!prevBlock)
@@ -10176,9 +10176,9 @@ var __publicField = (obj, key, value) => {
     return lastBlock2;
   }
   function complexBlockGetTopChildContainers(editor, complexBlock) {
-    assert(logger$3M, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$3N, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$3M, childContainers.length > 0, "no child container");
+    assert(logger$3N, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -10203,9 +10203,9 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function complexBlockGetBottomChildContainers(editor, complexBlock) {
-    assert(logger$3M, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$3N, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$3M, childContainers.length > 0, "no child container");
+    assert(logger$3N, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -10248,8 +10248,8 @@ var __publicField = (obj, key, value) => {
   }
   function complexBlockAdjustSelectionPos(editor, complexBlock, anchor2, focus) {
     const blockId = getBlockId(complexBlock);
-    assert(logger$3M, blockId === anchor2.blockId, "invalid start pos");
-    assert(logger$3M, blockId === focus.blockId, "invalid end pos");
+    assert(logger$3N, blockId === anchor2.blockId, "invalid start pos");
+    assert(logger$3N, blockId === focus.blockId, "invalid end pos");
     const blockClass = getComplexBlockClass(editor, complexBlock);
     if (blockClass.adjustSelectionPos) {
       return blockClass.adjustSelectionPos(editor, complexBlock, anchor2, focus);
@@ -10332,13 +10332,13 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$3L = getLogger("selection-range");
+  const logger$3M = 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$3L, anchor2 instanceof EditorComplexBlockPosition && focus instanceof EditorComplexBlockPosition, "start position type does not math end type");
+    assert(logger$3M, 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) {
@@ -10360,7 +10360,7 @@ var __publicField = (obj, key, value) => {
     const focus = createSimpleBlockPosition(range.focus.blockId, range.focus.offset, "normal");
     return createEditorSelectionRange(editor, { anchor: anchor2, focus });
   }
-  const logger$3K = getLogger("range-from-point");
+  const logger$3L = getLogger("range-from-point");
   function getBlockRangeFromPoint(editor, pointX, pointY) {
     const yOffsets = [0, -12, 12];
     let x = pointX;
@@ -10391,7 +10391,7 @@ var __publicField = (obj, key, value) => {
       const rect = elem.getBoundingClientRect();
       if (elem.clientWidth && elem.clientHeight && i === 0) {
         if (rect.left + elem.clientWidth < x || rect.top + elem.clientHeight < y) {
-          logger$3K.debug("click on scrollbar, out of element rect");
+          logger$3L.debug("click on scrollbar, out of element rect");
           return null;
         }
       }
@@ -10443,7 +10443,7 @@ var __publicField = (obj, key, value) => {
       if (range instanceof EditorSimpleSelectionRange) {
         return range;
       }
-      assert(logger$3K, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
+      assert(logger$3L, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
       const complexRange = range;
       const container2 = editor.getContainerById(complexRange.start.childContainerId);
       return getRangeInContainer(editor, container2, x, y);
@@ -10511,11 +10511,11 @@ var __publicField = (obj, key, value) => {
     return result;
   }
   const anchor = "";
-  const logger$3J = getLogger("text-range");
+  const logger$3K = getLogger("text-range");
   function getBlockRangeInfo(block, blockOffset) {
     const getChildRange = (child, offset) => {
       if (isTextBlockContentInsertionChild(child)) {
-        assert(logger$3J, offset === 0, `invalid offset for insertion child: ${offset}`);
+        assert(logger$3K, offset === 0, `invalid offset for insertion child: ${offset}`);
         const childOffset = 2;
         return {
           child,
@@ -10524,7 +10524,7 @@ var __publicField = (obj, key, value) => {
         };
       }
       if (isTextBlockContentBoxChild(child)) {
-        assert(logger$3J, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
+        assert(logger$3K, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
         const childOffset = offset === 0 ? 1 : 2;
         return {
           child,
@@ -10533,17 +10533,17 @@ var __publicField = (obj, key, value) => {
         };
       }
       const textNode = child.firstChild;
-      assert(logger$3J, textNode, "no child node for text child");
-      assert(logger$3J, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
+      assert(logger$3K, textNode, "no child node for text child");
+      assert(logger$3K, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
       if (textNode instanceof HTMLBRElement) {
-        assert(logger$3J, offset >= 0 && offset <= 0, "invalid offset for text child");
+        assert(logger$3K, offset >= 0 && offset <= 0, "invalid offset for text child");
         return {
           child,
           container: textNode,
           offset
         };
       }
-      assert(logger$3J, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
+      assert(logger$3K, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
       return {
         child,
         container: textNode,
@@ -10572,38 +10572,38 @@ var __publicField = (obj, key, value) => {
       }
       start += childLength;
     }
-    assert(logger$3J, false, "failed to get range info");
+    assert(logger$3K, false, "failed to get range info");
   }
   function createChildRange(child, start, end) {
     if (start === end) {
-      assert(logger$3J, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
+      assert(logger$3K, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
     } else {
-      assert(logger$3J, start < end, `invalid start & end: ${start}, ${end}`);
+      assert(logger$3K, start < end, `invalid start & end: ${start}, ${end}`);
     }
     if (isTextBlockContentInsertionChild(child)) {
-      assert(logger$3J, start === end, `invalid insertion child range offset: ${start}, ${end}`);
-      assert(logger$3J, start === 0, `invalid insertion child range start: ${start}`);
+      assert(logger$3K, start === end, `invalid insertion child range offset: ${start}, ${end}`);
+      assert(logger$3K, start === 0, `invalid insertion child range start: ${start}`);
       const insertionElem = child;
-      assert(logger$3J, insertionElem.children.length === 3, `invalid insertion dom, children.length = ${insertionElem.children.length}`);
+      assert(logger$3K, 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$3J, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
-      assert(logger$3J, start === 0, `invalid box child range start: ${start}`);
+      assert(logger$3K, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
+      assert(logger$3K, start === 0, `invalid box child range start: ${start}`);
       const box = child;
-      assert(logger$3J, box.children.length === 3, `invalid box dom, children.length = ${box.children.length}`);
+      assert(logger$3K, 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$3J, end <= length, `invalid child end: ${end}, ${length}`);
+    assert(logger$3K, end <= length, `invalid child end: ${end}, ${length}`);
     const textNode = child.firstChild;
-    assert(logger$3J, textNode instanceof Text, "invalid block text child");
-    assert(logger$3J, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
+    assert(logger$3K, textNode instanceof Text, "invalid block text child");
+    assert(logger$3K, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
     return createExpandedRange(textNode, start, textNode, end);
   }
-  const logger$3I = getLogger("caret-rect");
+  const logger$3J = getLogger("caret-rect");
   function getChildClientRects(block, child) {
     if (isBox(child)) {
       const box = child;
@@ -10612,7 +10612,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$3I, rects.length > 0, "no box client rects");
+        assert(logger$3J, 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);
@@ -10632,22 +10632,22 @@ var __publicField = (obj, key, value) => {
         const rect2 = getLastClientRect(ranges[0].child);
         return new DOMRect(rect2.right, rect2.top, 1, rect2.height);
       }
-      assert(logger$3I, ranges[1], "invalid ranges");
+      assert(logger$3J, 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$3I, ranges.length >= 1, "failed to get block range");
+    assert(logger$3J, ranges.length >= 1, "failed to get block range");
     if (ranges.length === 1) {
       rangeInfo = ranges[0];
     } else {
-      assert(logger$3I, ranges.length >= 2, `invalid range info length: ${ranges.length}`);
+      assert(logger$3J, 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$3I, rects2.length >= 1, "no client rects for box content");
+        assert(logger$3J, 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);
       }
@@ -10664,9 +10664,9 @@ var __publicField = (obj, key, value) => {
       }
     }
     if (rangeInfo.container instanceof HTMLBRElement) {
-      assert(logger$3I, pos.offset === 0, "invalid offset for empty block text");
+      assert(logger$3J, pos.offset === 0, "invalid offset for empty block text");
       const parent = rangeInfo.container.parentElement;
-      assert(logger$3I, parent, "invalid br parent");
+      assert(logger$3J, parent, "invalid br parent");
       const rect = parent.getBoundingClientRect();
       const ret = new DOMRect(rect.left, rect.top, 1, rect.height);
       return ret;
@@ -10674,11 +10674,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$3I, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
-      assert(logger$3I, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
+      assert(logger$3J, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
+      assert(logger$3J, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
       const child = rangeInfo.child;
       const rects2 = getChildClientRects(block, child);
-      assert(logger$3I, rects2.length >= 1, "no client rects for box content");
+      assert(logger$3J, 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);
@@ -10724,13 +10724,13 @@ var __publicField = (obj, key, value) => {
         });
       }
     }
-    assert(logger$3I, rects.length > 0, "no client rects for range");
+    assert(logger$3J, rects.length > 0, "no client rects for range");
     if (pos.type === "home") {
       return rects[rects.length - 1];
     }
     return rects[0];
   }
-  const logger$3H = getLogger("core");
+  const logger$3I = getLogger("core");
   function createBlockAnchor(editor, block, id, refClientRect) {
     const tools = getBlockTools(block);
     let elem = tools.querySelector(`.block-anchor[data-id=${id}]`);
@@ -10748,7 +10748,7 @@ var __publicField = (obj, key, value) => {
     return elem;
   }
   function createBlockCaretAnchor(editor, block, offset, id) {
-    assert(logger$3H, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3I, isTextKindBlock(editor, block), "not a text kind block");
     const caretRect = getTextCaretRect(block, createSimpleBlockPosition(block, offset, "normal"));
     const blockRect = block.getBoundingClientRect();
     const tools = getBlockTools(block);
@@ -11617,19 +11617,19 @@ var __publicField = (obj, key, value) => {
     return object == null ? {} : basePick(object, paths);
   });
   const pick$1 = pick;
-  const logger$3G = getLogger("box");
+  const logger$3H = getLogger("box");
   function isBoxOp(op) {
     if (!op.attributes)
       return false;
     if (!op.attributes.box)
       return false;
-    assert(logger$3G, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
-    assert(logger$3G, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
+    assert(logger$3H, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
+    assert(logger$3H, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
     return true;
   }
-  const logger$3F = getLogger("text-op");
+  const logger$3G = getLogger("text-op");
   function getOpLength(op) {
-    assert(logger$3F, typeof op.insert === "string", "invalid op, no insert");
+    assert(logger$3G, typeof op.insert === "string", "invalid op, no insert");
     return op.insert.length;
   }
   function getOpAt(text2, offset) {
@@ -11637,7 +11637,7 @@ var __publicField = (obj, key, value) => {
     let pos = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$3F, typeof op.insert === "string", "invalid text op, no insert");
+      assert(logger$3G, typeof op.insert === "string", "invalid text op, no insert");
       const end = pos + getOpLength(op);
       if (end > offset) {
         return [op];
@@ -11653,22 +11653,22 @@ var __publicField = (obj, key, value) => {
     }
     return [];
   }
-  const logger$3E = getLogger("rich-text-length");
+  const logger$3F = getLogger("rich-text-length");
   function getTextOpLength(op) {
-    assert(logger$3E, typeof op.insert === "string", "op.insert is not string");
+    assert(logger$3F, 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$3E, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$3F, typeof op.insert === "string", "op.insert is not string");
         count += getTextOpLength(op);
       }
     });
     return count;
   }
-  const logger$3D = getLogger("split-text");
+  const logger$3E = getLogger("split-text");
   function splitText(ops, offset, splitResult) {
     ops = cloneDeep__default.default(ops);
     if (offset === 0) {
@@ -11686,8 +11686,8 @@ var __publicField = (obj, key, value) => {
     let counted = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$3D, typeof op === "object", `invalid op type, ${typeof op}`);
-      assert(logger$3D, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
+      assert(logger$3E, typeof op === "object", `invalid op type, ${typeof op}`);
+      assert(logger$3E, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
       const subLen = getTextOpLength(op);
       if (counted + subLen < offset) {
         counted += subLen;
@@ -11697,18 +11697,18 @@ var __publicField = (obj, key, value) => {
           right: ops.slice(i + 1)
         };
       } else {
-        assert(logger$3D, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
+        assert(logger$3E, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
         const splitIndex = offset - counted;
         const copied = cloneDeep__default.default(op);
-        assert(logger$3D, copied.insert, "no copied.insert");
-        assert(logger$3D, typeof copied.insert === "string", "invalid copied.insert type");
+        assert(logger$3E, copied.insert, "no copied.insert");
+        assert(logger$3E, 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$3D, false, "invalid copied.insert, is empty string");
+          assert(logger$3E, false, "invalid copied.insert, is empty string");
         }
         if (op.insert === "") {
-          assert(logger$3D, false, "invalid op.insert, is empty string");
+          assert(logger$3E, false, "invalid op.insert, is empty string");
         }
         const right = [
           op,
@@ -11727,9 +11727,9 @@ var __publicField = (obj, key, value) => {
     throw new Error(`invalid split offset: ${offset}, ${JSON.stringify(ops)}`);
   }
   function splitToThree(text2, offset, length) {
-    assert(logger$3D, offset >= 0, "invalid offset, < 0");
-    assert(logger$3D, length > 0, "invalid length, <= 0");
-    assert(logger$3D, offset + length <= getTextLength(text2), "invalid offset + length < text length");
+    assert(logger$3E, offset >= 0, "invalid offset, < 0");
+    assert(logger$3E, length > 0, "invalid length, <= 0");
+    assert(logger$3E, 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 };
@@ -11950,9 +11950,9 @@ var __publicField = (obj, key, value) => {
     }
     return [color, backgroundColor];
   }
-  const logger$3C = getLogger("text-block-content");
+  const logger$3D = getLogger("text-block-content");
   function updateBlockContentCore(editor, blockPath, content, blockText, insertions) {
-    assert(logger$3C, blockText, "no text for block");
+    assert(logger$3D, blockText, "no text for block");
     if (blockText.length === 0 && (!insertions || insertions.size === 0)) {
       content.innerHTML = "<span><br></span>";
       return;
@@ -11984,9 +11984,9 @@ var __publicField = (obj, key, value) => {
       for (let i2 = 0; i2 < text2.length; i2++) {
         const op = text2[i2];
         if (isBoxOp(op)) {
-          assert(logger$3C, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
+          assert(logger$3D, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
           const span2 = editor.editorBoxes.createBox(content, op.attributes);
-          assert(logger$3C, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
+          assert(logger$3D, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
           const ret = editor.editorBlockRenders.renderBox(blockPath, op.attributes);
           if (ret.classes) {
             addClass(span2, ...ret.classes);
@@ -12004,7 +12004,7 @@ var __publicField = (obj, key, value) => {
           fragment.appendChild(span2);
           continue;
         }
-        assert(logger$3C, op.insert, `no insert in op: ${JSON.stringify(op)}`);
+        assert(logger$3D, 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);
@@ -12034,7 +12034,7 @@ var __publicField = (obj, key, value) => {
     const compositionText = editor.compositingText;
     if (compositionText) {
       const pos = editor.selection.range.start;
-      assert(logger$3C, pos.isSimple(), "not an simple position while compositing");
+      assert(logger$3D, pos.isSimple(), "not an simple position while compositing");
       if (pos.blockId === blockId) {
         const attributes = getAttributesAt(text2, 0);
         insertions.set(pos.offset, [{
@@ -12050,11 +12050,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$3C.debug(`remove ${children.length} temp composition span`);
+      logger$3D.debug(`remove ${children.length} temp composition span`);
     }
     Array.from(children).forEach((c) => c.remove());
   }
-  const logger$3B = getLogger("client-rects");
+  const logger$3C = getLogger("client-rects");
   function getChildrenOffsets(block) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -12072,15 +12072,15 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function getChildrenInRange(editor, block, from, to) {
-    assert(logger$3B, from < to, `invalid from & to: ${from}, ${to}`);
+    assert(logger$3C, from < to, `invalid from & to: ${from}, ${to}`);
     const blockLength = getBlockTextLength$4(editor, block);
-    assert(logger$3B, from >= 0 && to >= 0 && from <= blockLength && to <= blockLength, `invalid offset: ${from}, ${to}, length: ${blockLength}`);
+    assert(logger$3C, 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$3B, startIndex !== -1, "failed to find start child");
-    assert(logger$3B, endIndex !== -1, "failed to find end child");
-    assert(logger$3B, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
+    assert(logger$3C, startIndex !== -1, "failed to find start child");
+    assert(logger$3C, endIndex !== -1, "failed to find end child");
+    assert(logger$3C, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
     if (startIndex === endIndex) {
       const child = offsets[startIndex];
       return [{
@@ -12155,20 +12155,20 @@ var __publicField = (obj, key, value) => {
     return rects;
   }
   function getRangeClientRects(editor, block, range) {
-    assert(logger$3B, range instanceof EditorSimpleSelectionRange, "invalid range");
+    assert(logger$3C, range instanceof EditorSimpleSelectionRange, "invalid range");
     const start = range.start;
     const end = range.end;
-    assert(logger$3B, start.isSimple(), "text block only allow simple position");
-    assert(logger$3B, end.isSimple(), "text block only allow simple position");
-    assert(logger$3B, start.blockId === end.blockId, "only allow update one text block selection");
-    assert(logger$3B, start.blockId === getBlockId(block), "only allow update one text block selection");
+    assert(logger$3C, start.isSimple(), "text block only allow simple position");
+    assert(logger$3C, end.isSimple(), "text block only allow simple position");
+    assert(logger$3C, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$3C, start.blockId === getBlockId(block), "only allow update one text block selection");
     return getClientRects$2(editor, block, start, end);
   }
-  const logger$3A = getLogger("selection-background");
+  const logger$3B = getLogger("selection-background");
   function updateSelection$2(editor, block, start, end) {
-    assert(logger$3A, start.isSimple(), "text block only allow simple position");
-    assert(logger$3A, end.isSimple(), "text block only allow simple position");
-    assert(logger$3A, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$3B, start.isSimple(), "text block only allow simple position");
+    assert(logger$3B, end.isSimple(), "text block only allow simple position");
+    assert(logger$3B, start.blockId === end.blockId, "only allow update one text block selection");
     const from = start.offset;
     const to = end.offset;
     if (from === to) {
@@ -12212,7 +12212,7 @@ var __publicField = (obj, key, value) => {
       }
     });
   }
-  const logger$3z = getLogger("line-breaker");
+  const logger$3A = getLogger("line-breaker");
   function mergeTextRects(rects) {
     const result = [];
     let lastRect = null;
@@ -12336,7 +12336,7 @@ var __publicField = (obj, key, value) => {
       }
       const textChild = child;
       const rects = mergeTextRects(textChild.getClientRects());
-      assert(logger$3z, rects.length > 0, "invalid text child dom");
+      assert(logger$3A, rects.length > 0, "invalid text child dom");
       if (rects.length === 1) {
         const nextChild = children[i + 1];
         if (!nextChild) {
@@ -12361,10 +12361,10 @@ var __publicField = (obj, key, value) => {
         continue;
       }
       const textNode = textChild.firstChild;
-      assert(logger$3z, textNode, "invalid text child, no text node");
-      assert(logger$3z, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
+      assert(logger$3A, textNode, "invalid text child, no text node");
+      assert(logger$3A, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
       const textChildLength = getTextBlockContentChildTextLength(textChild);
-      assert(logger$3z, textNode.data.length === textChildLength, "text node data length not equal child text length");
+      assert(logger$3A, 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];
@@ -12406,7 +12406,7 @@ var __publicField = (obj, key, value) => {
         }
       }
     }
-    assert(logger$3z, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
+    assert(logger$3A, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
     return {
       lineIndex: lineBreaks.length,
       lineBreaks
@@ -21179,7 +21179,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$3y = getLogger("text-offset");
+  const logger$3z = getLogger("text-offset");
   function getChildOffset(block, child) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -21195,26 +21195,26 @@ var __publicField = (obj, key, value) => {
       }
       start += testLength;
     }
-    assert(logger$3y, false, "can not find child in children");
+    assert(logger$3z, false, "can not find child in children");
   }
   function isValidOffset(block, blockOffset) {
-    assert(logger$3y, blockOffset >= 0, `invalid offset: ${blockOffset}`);
+    assert(logger$3z, blockOffset >= 0, `invalid offset: ${blockOffset}`);
     const childInfo = getTextBlockChild(block, blockOffset);
     const { prev, next, offset } = childInfo;
     if (!prev && !next) {
-      assert(logger$3y, false, "invalid offset, no prev & next child at offset");
+      assert(logger$3z, false, "invalid offset, no prev & next child at offset");
     }
     if (prev !== next) {
       return true;
     }
     const child = prev;
-    assert(logger$3y, child, "no child");
+    assert(logger$3z, child, "no child");
     if (isTextBlockContentBoxChild(child)) {
-      assert(logger$3y, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
+      assert(logger$3z, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
       return true;
     }
     const text2 = child.textContent;
-    assert(logger$3y, text2, "no content for text child");
+    assert(logger$3z, text2, "no content for text child");
     const chars = splitter.splitGraphemes(text2);
     const validOffsets = /* @__PURE__ */ new Set();
     let start = 0;
@@ -21244,7 +21244,7 @@ var __publicField = (obj, key, value) => {
   }
   function getNextValidOffset(block, blockOffset) {
     const length = getTextBlockLength(block);
-    assert(logger$3y, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
+    assert(logger$3z, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
     if (blockOffset === length) {
       return length;
     }
@@ -21258,7 +21258,7 @@ var __publicField = (obj, key, value) => {
     }
     return ret;
   }
-  const logger$3x = getLogger("line-offset");
+  const logger$3y = getLogger("line-offset");
   function getLineOffsets(block) {
     const lineBreaks = getLineBreaks(block);
     const ret = [];
@@ -21279,7 +21279,7 @@ var __publicField = (obj, key, value) => {
   }
   function getLineOffset(block, lineIndex) {
     const lines = getLineOffsets(block);
-    assert(logger$3x, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
+    assert(logger$3y, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
     return lines[lineIndex];
   }
   function getLineOffsetByPos(block, pos) {
@@ -21333,7 +21333,7 @@ var __publicField = (obj, key, value) => {
   function getLineCount(block) {
     return getLineOffsets(block).length;
   }
-  const logger$3w = getLogger("find-text-position");
+  const logger$3x = getLogger("find-text-position");
   function isWrappedLine(block, lineIndex) {
     const { start, end } = getLineOffset(block, lineIndex);
     const blockId = getBlockId(block);
@@ -21344,13 +21344,13 @@ var __publicField = (obj, key, value) => {
       return false;
     }
     const childInfo = getTextBlockChild(block, start);
-    assert(logger$3w, childInfo.next, "no next child at offset");
-    assert(logger$3w, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
+    assert(logger$3x, childInfo.next, "no next child at offset");
+    assert(logger$3x, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
     return true;
   }
   function getWrappedLineOffsets(block, lineIndex) {
     const blockId = getBlockId(block);
-    assert(logger$3w, isWrappedLine(block, lineIndex), "line is not wrapped");
+    assert(logger$3x, 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) {
@@ -21365,11 +21365,11 @@ var __publicField = (obj, key, value) => {
         return offset - 1;
       }
     }
-    assert(logger$3w, false, "failed to find wrapped offset");
+    assert(logger$3x, false, "failed to find wrapped offset");
     return 0;
   }
   function findTextPositionInLine(editor, block, lineIndex, sourceBlock, pos, findDirection, suggestedX) {
-    assert(logger$3w, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
+    assert(logger$3x, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
     const { start, end } = getLineOffset(block, lineIndex);
     let from = start;
     const blockId = getBlockId(block);
@@ -21411,11 +21411,11 @@ var __publicField = (obj, key, value) => {
     return retPos;
   }
   function findPrevTextBlockPosition(editor, block, sourceBlock, pos, suggestedX) {
-    assert(logger$3w, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$3x, 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$3w, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$3x, isTextKindBlock(editor, block), "not a text block");
     return findTextPositionInLine(editor, block, 0, sourceBlock, pos, "down", suggestedX);
   }
   function moveDown(editor, block, position, suggestedX) {
@@ -21523,7 +21523,7 @@ var __publicField = (obj, key, value) => {
     }
     return pos;
   }
-  const logger$3v = getLogger("move-caret");
+  const logger$3w = getLogger("move-caret");
   function moveTextCaret(editor, block, position, direction) {
     if (direction === "ArrowLeft") {
       const ret = moveLeft(block, position);
@@ -21553,9 +21553,9 @@ var __publicField = (obj, key, value) => {
       }
       return createSimpleBlockPosition(getBlockId(block), ret.offset, ret.type);
     }
-    assert(logger$3v, false, `invalid navigation direction: ${direction}`);
+    assert(logger$3w, false, `invalid navigation direction: ${direction}`);
   }
-  const logger$3u = getLogger("text-range");
+  const logger$3v = getLogger("text-range");
   function getBlockRects(block) {
     const ret = [];
     const children = getTextBlockContentChildren(block);
@@ -21631,9 +21631,9 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const children = getTextBlockContentChildren(block);
-    assert(logger$3u, children.indexOf(child) !== -1, "failed to find child in children");
+    assert(logger$3v, children.indexOf(child) !== -1, "failed to find child in children");
     const offsetInfo = getChildOffset(block, child);
-    assert(logger$3u, offsetInfo, "failed to get child offset");
+    assert(logger$3v, offsetInfo, "failed to get child offset");
     const { start } = offsetInfo;
     let offset;
     let length;
@@ -21644,7 +21644,7 @@ var __publicField = (obj, key, value) => {
       offset = start;
       length = 0;
     } else {
-      assert(logger$3u, child.firstChild instanceof Text, "child is not text");
+      assert(logger$3v, child.firstChild instanceof Text, "child is not text");
       offset = start + textNodeOffsetFromPoint(child.firstChild, x, y);
       length = 0;
     }
@@ -21668,9 +21668,9 @@ var __publicField = (obj, key, value) => {
     }
     return new EditorSimpleSelectionRange(editor, { anchor: startPos, focus: endPos != null ? endPos : startPos });
   }
-  const logger$3t = getLogger("create-text-op");
+  const logger$3u = getLogger("create-text-op");
   function createTextOp(text2, attributes) {
-    assert(logger$3t, text2, "text is empty");
+    assert(logger$3u, text2, "text is empty");
     const ret = {
       insert: text2
     };
@@ -21693,7 +21693,7 @@ var __publicField = (obj, key, value) => {
     }
     return result;
   }
-  const logger$3s = getLogger("merge-ops");
+  const logger$3t = getLogger("merge-ops");
   function mergeOps(text2) {
     if (text2.length <= 1) {
       return text2;
@@ -21715,10 +21715,10 @@ var __publicField = (obj, key, value) => {
         return false;
       }
       if (op1.attributes === void 0) {
-        assert(logger$3s, op2.attributes === void 0, "op2.attributes is not undefined");
+        assert(logger$3t, op2.attributes === void 0, "op2.attributes is not undefined");
         return true;
       }
-      assert(logger$3s, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
+      assert(logger$3t, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
       return isEqual__default.default(op1.attributes, op2.attributes);
     };
     const newOps = [];
@@ -21727,8 +21727,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$3s, typeof before.insert === "string", "before.insert is not string");
-        assert(logger$3s, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$3t, typeof before.insert === "string", "before.insert is not string");
+        assert(logger$3t, typeof op.insert === "string", "op.insert is not string");
         before.insert += op.insert;
       } else {
         newOps.push(op);
@@ -21756,15 +21756,15 @@ var __publicField = (obj, key, value) => {
     }
     return text2.slice(0, i + 1);
   }
-  const logger$3r = getLogger("delete-text");
+  const logger$3s = 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$3r, offset >= 0, `invalid offset: ${offset}`);
-    assert(logger$3r, count >= 1, `invalid delete count: ${count}`);
+    assert(logger$3s, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$3s, count >= 1, `invalid delete count: ${count}`);
     const ops = [];
     if (offset !== 0) {
       ops.push({
@@ -21776,7 +21776,7 @@ var __publicField = (obj, key, value) => {
     });
     return ops;
   }
-  const logger$3q = getLogger("delta");
+  const logger$3r = getLogger("delta");
   function diffRichText(oldText, newText) {
     const delta1D = new Delta__default.default(oldText);
     const delta2D = new Delta__default.default(newText);
@@ -21786,7 +21786,7 @@ var __publicField = (obj, key, value) => {
     return new Delta__default.default(ops).transformPosition(cursor, !isLocalOp);
   }
   function isValidDocText(text2) {
-    assert(logger$3q, text2, "ops is null or undefined");
+    assert(logger$3r, 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) {
@@ -21806,7 +21806,7 @@ var __publicField = (obj, key, value) => {
   }
   class RichText {
     static ensureValidText(text2) {
-      assert(logger$3q, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
+      assert(logger$3r, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
     }
     static diff(oldText, newText) {
       this.ensureValidText(oldText);
@@ -21828,9 +21828,9 @@ var __publicField = (obj, key, value) => {
       return resultText;
     }
   }
-  const logger$3p = getLogger("insert-text");
+  const logger$3q = getLogger("insert-text");
   function insertText(richText2, offset, text2, attributes) {
-    assert(logger$3p, text2, `invalid text to insert: ${text2}`);
+    assert(logger$3q, 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];
@@ -21843,7 +21843,7 @@ var __publicField = (obj, key, value) => {
     };
   }
   function createInsertOps(offset, text2, attributes) {
-    assert(logger$3p, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$3q, offset >= 0, `invalid offset: ${offset}`);
     if (text2.length === 0) {
       return [];
     }
@@ -21873,7 +21873,7 @@ var __publicField = (obj, key, value) => {
   function cloneText(text2) {
     return cloneDeep__default.default(text2);
   }
-  const logger$3o = getLogger("update-op-attribute");
+  const logger$3p = getLogger("update-op-attribute");
   function updateOpAttributes(orgOps, key, value, newAttributes) {
     const ops = cloneText(orgOps);
     const index2 = ops.findIndex((op2) => {
@@ -21881,7 +21881,7 @@ var __publicField = (obj, key, value) => {
         return false;
       return op2.attributes[key] === value;
     });
-    assert(logger$3o, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
+    assert(logger$3p, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
     const op = ops[index2];
     op.attributes = {
       ...op.attributes,
@@ -21957,11 +21957,11 @@ var __publicField = (obj, key, value) => {
     ]);
   }
   const FILL_CHAR = "\u200B";
-  const logger$3n = getLogger("to-plain-text");
+  const logger$3o = getLogger("to-plain-text");
   function toPlainText(ops, options) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3n, typeof op.insert === "string", "invalid op");
+      assert(logger$3o, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         if (options == null ? void 0 : options.boxReplacement) {
           text2 += options.boxReplacement;
@@ -22016,11 +22016,11 @@ var __publicField = (obj, key, value) => {
       focus: pos
     };
   }
-  const logger$3m = getLogger("block-to-text");
+  const logger$3n = getLogger("block-to-text");
   function textBlockToText$1(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3m, typeof op.insert === "string", "invalid op");
+      assert(logger$3n, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -22038,11 +22038,11 @@ var __publicField = (obj, key, value) => {
     });
     return text2;
   }
-  const logger$3l = getLogger("block-to-text");
+  const logger$3m = getLogger("block-to-text");
   function textToMarkdownText(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3l, typeof op.insert === "string", "invalid op");
+      assert(logger$3m, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -22165,11 +22165,11 @@ var __publicField = (obj, key, value) => {
         return void 0;
     }
   }
-  const logger$3k = getLogger("block-to-text");
+  const logger$3l = getLogger("block-to-text");
   function textBlockToHtml(editor, ops, doc2) {
     let html = "";
     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) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -22238,16 +22238,16 @@ var __publicField = (obj, key, value) => {
     }
     return `<p>${html}</p>`;
   }
-  const logger$3j = getLogger("text-block");
+  const logger$3k = getLogger("text-block");
   function createBlockContent$3(editor, path, container, blockElement, blockData) {
     const { text: text2 } = blockData;
-    assert(logger$3j, text2, "no text for text block");
+    assert(logger$3k, 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$3j, text2, "no text to update");
+    assert(logger$3k, text2, "no text to update");
     const newContent = createBlockContentElement(null, "div");
     updateBlockContent$1(editor, getBlockPath(block), getBlockId(block), newContent, text2);
     const oldContent = getBlockContent(block);
@@ -22274,7 +22274,7 @@ var __publicField = (obj, key, value) => {
     return res.trim();
   }
   function getBlockProperties$b(editor, block) {
-    assert(logger$3j, isTextKindBlock(editor, block), "block in not textBlock");
+    assert(logger$3k, isTextKindBlock(editor, block), "block in not textBlock");
     const range = editor.selection.range;
     let abstract = "";
     if (range.isCollapsed()) {
@@ -22284,7 +22284,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$3j, selectedBlock.block === block, "block not match");
+        assert(logger$3k, selectedBlock.block === block, "block not match");
         const blockOps = editor.getBlockText(block);
         const { start, end } = selectedBlock;
         const offset = start.offset;
@@ -22300,7 +22300,7 @@ var __publicField = (obj, key, value) => {
     };
   }
   function convertTo$i(editor, blockData, doc2, type) {
-    assert(logger$3j, blockData.text, "no text for text block");
+    assert(logger$3k, blockData.text, "no text for text block");
     if (type === "text") {
       return textBlockToText$1(editor, blockData.text, doc2);
     }
@@ -22325,7 +22325,7 @@ var __publicField = (obj, key, value) => {
     convertTo: convertTo$i
   };
   const updateTextBlockContent = updateBlockContent$1;
-  const logger$3i = getLogger("action-helper");
+  const logger$3j = getLogger("action-helper");
   function editorGetBlockData(editor, block) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -22333,10 +22333,10 @@ var __publicField = (obj, key, value) => {
     return editor.doc.getBlockData(containerId, blockIndex);
   }
   function editorGetBlockText(editor, block) {
-    assert(logger$3i, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3j, isTextKindBlock(editor, block), "not a text kind block");
     const data = editorGetBlockData(editor, block);
     const text2 = data.text;
-    assert(logger$3i, text2, "no text in block");
+    assert(logger$3j, text2, "no text in block");
     return text2;
   }
   function editorGetBlockTextEx(editor, block, length) {
@@ -22344,7 +22344,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetBoxData(editor, box) {
     const block = getParentBlock(box);
-    assert(logger$3i, block, "no parent block");
+    assert(logger$3j, block, "no parent block");
     const text2 = editorGetBlockText(editor, block);
     const id = getBoxId(box);
     const op = text2.find((op2) => {
@@ -22354,60 +22354,60 @@ var __publicField = (obj, key, value) => {
       }
       return false;
     });
-    assert(logger$3i, op, "failed to find box");
+    assert(logger$3j, op, "failed to find box");
     return op.attributes;
   }
-  const logger$3h = getLogger("block-text");
+  const logger$3i = getLogger("block-text");
   function getTextAfterOffset(editor, block, offset) {
-    assert(logger$3h, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3h, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3h, offset >= 0 && offset < getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3i, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3i, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3i, offset >= 0 && offset < getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3h, false, `no text after offset: ${offset}`);
+      assert(logger$3i, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3h, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3i, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3h, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3i, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getTextBeforeOffset(editor, block, offset) {
-    assert(logger$3h, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3h, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3h, offset > 0 && offset <= getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3i, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3i, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3i, offset > 0 && offset <= getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3h, false, `no text before offset: ${offset}`);
+      assert(logger$3i, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3h, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3i, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3h, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3i, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getOffsetInfoBefore(editor, block, offset) {
-    assert(logger$3h, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3h, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3h, offset > 0 && offset <= getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3i, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3i, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3i, offset > 0 && offset <= getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3h, false, `no text before offset: ${offset}`);
+      assert(logger$3i, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3h, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3i, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -22425,17 +22425,17 @@ var __publicField = (obj, key, value) => {
     };
   }
   function getOffsetInfoAfter(editor, block, offset) {
-    assert(logger$3h, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3h, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3h, offset >= 0 && offset < getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3i, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3i, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3i, offset >= 0 && offset < getBlockTextLength$4(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3h, false, `no text after offset: ${offset}`);
+      assert(logger$3i, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3h, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3i, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -22499,7 +22499,7 @@ var __publicField = (obj, key, value) => {
     return null;
   }
   function findWordLeft(editor, block, offset) {
-    assert(logger$3h, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3i, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -22527,7 +22527,7 @@ var __publicField = (obj, key, value) => {
     return startInfo.offset + startInfo.length;
   }
   function findWordEnd(editor, block, offset) {
-    assert(logger$3h, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3i, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -22554,10 +22554,10 @@ var __publicField = (obj, key, value) => {
       return getBlockTextLength$4(editor, block);
     return startInfo.offset;
   }
-  const logger$3g = getLogger("text-box");
+  const logger$3h = getLogger("text-box");
   function updateBoxContent$7(editor, boxElement, boxContent, boxData) {
-    assert(logger$3g, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
-    assert(logger$3g, typeof boxData.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3h, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3h, typeof boxData.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
     createElement("span", [], boxContent, boxData.text);
   }
   function convertTo$h(editor, boxData, doc2, type) {
@@ -22591,7 +22591,7 @@ var __publicField = (obj, key, value) => {
     updateBoxContent: updateBoxContent$6,
     convertTo: convertTo$g
   };
-  const logger$3f = getLogger("editor-boxes");
+  const logger$3g = getLogger("editor-boxes");
   class EditorBoxes {
     constructor(editor) {
       __publicField(this, "boxes", /* @__PURE__ */ new Map());
@@ -22600,12 +22600,12 @@ var __publicField = (obj, key, value) => {
     registerBoxClass(boxClass) {
       const type = boxClass.boxType;
       const exists = this.boxes.get(type);
-      assert(logger$3f, !exists, `duplicated box type: ${type}`);
+      assert(logger$3g, !exists, `duplicated box type: ${type}`);
       this.boxes.set(type, boxClass);
     }
     getBoxClass(type) {
       const exists = this.boxes.get(type);
-      assert(logger$3f, exists, `unknown box type: ${type}`);
+      assert(logger$3g, exists, `unknown box type: ${type}`);
       return exists;
     }
     createBox(blockContent, box) {
@@ -22656,7 +22656,7 @@ var __publicField = (obj, key, value) => {
     insertionType: "inputting",
     updateInsertionContent: updateInsertionContent$1
   };
-  const logger$3e = getLogger("editor-insertion");
+  const logger$3f = getLogger("editor-insertion");
   class EditorInsertions {
     constructor(editor) {
       __publicField(this, "insertions", /* @__PURE__ */ new Map());
@@ -22665,12 +22665,12 @@ var __publicField = (obj, key, value) => {
     registerInsertionClass(insertionClass) {
       const type = insertionClass.insertionType;
       const exists = this.insertions.get(type);
-      assert(logger$3e, !exists, `duplicated insertion type: ${type}`);
+      assert(logger$3f, !exists, `duplicated insertion type: ${type}`);
       this.insertions.set(type, insertionClass);
     }
     getInsertionClass(type) {
       const exists = this.insertions.get(type);
-      assert(logger$3e, exists, `unknown insertion type: ${type}`);
+      assert(logger$3f, exists, `unknown insertion type: ${type}`);
       return exists;
     }
     createInsertion(blockContent, insertion) {
@@ -22776,7 +22776,7 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$3d = getLogger("editor-input");
+  const logger$3e = getLogger("editor-input");
   class EditorInput {
     constructor(editor, callbacks) {
       __publicField(this, "editor");
@@ -22883,7 +22883,7 @@ var __publicField = (obj, key, value) => {
           return;
         }
         this.callbacks.onCut(event);
-        logger$3d.debug("on cut");
+        logger$3e.debug("on cut");
       });
       __publicField(this, "handlePaste", (event) => {
         if (event.isTrusted) {
@@ -22969,11 +22969,11 @@ var __publicField = (obj, key, value) => {
       this.callbacks.removeHandler(handler);
     }
     defaultInsertText(editor, containerId, blockIndex, offset, text2) {
-      assert(logger$3d, editor === this.editor, "invalid editor");
+      assert(logger$3e, editor === this.editor, "invalid editor");
       this.callbacks.defaultInsertText(editor, containerId, blockIndex, offset, text2);
     }
     defaultHandleKeydown(editor, event) {
-      assert(logger$3d, editor === this.editor, "invalid editor");
+      assert(logger$3e, editor === this.editor, "invalid editor");
       return this.callbacks.defaultHandleKeydown(editor, event);
     }
     forEach(callback) {
@@ -22998,7 +22998,7 @@ var __publicField = (obj, key, value) => {
     input2.style.left = `${x / scale}px`;
     input2.style.top = `${y / scale}px`;
   }
-  const logger$3c = getLogger("editor-caret");
+  const logger$3d = getLogger("editor-caret");
   function getFirefoxVersion() {
     const userAgent = window.navigator.userAgent;
     const match = userAgent.match(/Firefox\/(\d+)\./);
@@ -23061,11 +23061,11 @@ var __publicField = (obj, key, value) => {
         return;
       }
       const { range } = this.editor.selection;
-      assert(logger$3c, range.isCollapsed, "range is not collapsed");
+      assert(logger$3d, range.isCollapsed, "range is not collapsed");
       const pos = range.start;
-      assert(logger$3c, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
+      assert(logger$3d, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
       const block = this.editor.getBlockById(pos.blockId);
-      assert(logger$3c, isTextKindBlock(this.editor, block), "only text kind block can has caret");
+      assert(logger$3d, isTextKindBlock(this.editor, block), "only text kind block can has caret");
       let rect;
       const compositionSpan = block.querySelector("span.inputting-insertion");
       if (compositionSpan) {
@@ -23103,12 +23103,117 @@ var __publicField = (obj, key, value) => {
     clearAllSelection(editor);
     editor.selection.range.getSelectedBlocks().forEach((s) => updateBlockSelection(editor, s.block, s.start, s.end));
   }
-  getLogger("editor-dom");
+  const logger$3c = getLogger("editor-dom");
   function editorGetClientHeight(editor) {
     const scrollContainer = getScrollContainer$1(editor.rootContainer);
     return scrollContainer.clientHeight;
   }
+  function editorGetVisibleRect(editor) {
+    const elem = getScrollContainer$1(editor.rootContainer);
+    const rect = elem.getBoundingClientRect();
+    const x1 = rect.x < 0 ? 0 : rect.x;
+    const y1 = rect.y < 0 ? 0 : rect.y;
+    const x2 = rect.right > window.innerWidth ? window.innerWidth : rect.right;
+    const y2 = rect.bottom > window.innerHeight ? window.innerHeight : rect.bottom;
+    return new DOMRect(x1, y1, x2 - x1, y2 - y1);
+  }
+  function isBlockPositionVisible(editor, pos) {
+    const visibleRect = editorGetVisibleRect(editor);
+    const block = editor.getBlockById(pos.blockId);
+    const caretRect = getBlockCaretRect(editor, block, pos);
+    const rect = caretRect;
+    return pointInRect(visibleRect, rect.x, rect.y) && pointInRect(visibleRect, rect.right, rect.bottom);
+  }
+  function isBlockPartialVisible(editor, block) {
+    const visibleRect = editorGetVisibleRect(editor);
+    const rect = block.getBoundingClientRect();
+    if (rect.top >= visibleRect.top && rect.top <= visibleRect.bottom) {
+      return true;
+    }
+    if (rect.bottom <= visibleRect.bottom && rect.bottom >= visibleRect.top) {
+      return true;
+    }
+    return false;
+  }
+  function getBlockPartialVisiblePercent(editor, block) {
+    const visibleRect = editorGetVisibleRect(editor);
+    const rect = block.getBoundingClientRect();
+    if (rect.top >= visibleRect.top && rect.top <= visibleRect.bottom && rect.bottom <= visibleRect.bottom && rect.bottom >= visibleRect.top) {
+      return 100;
+    }
+    const intersectionX = Math.max(0, Math.min(rect.right, visibleRect.right) - Math.max(rect.left, visibleRect.left));
+    const intersectionY = Math.max(0, Math.min(rect.bottom, visibleRect.bottom) - Math.max(rect.top, visibleRect.top));
+    const intersectionArea = intersectionX * intersectionY;
+    const elementAArea = rect.width * rect.height;
+    return intersectionArea / elementAArea * 100;
+  }
+  function isChildContainerVisible(editor, container) {
+    const visibleRect = editorGetVisibleRect(editor);
+    const rect = container.getBoundingClientRect();
+    return pointInRect(visibleRect, rect.x, rect.y) || pointInRect(visibleRect, rect.right, rect.bottom);
+  }
   function editorScrollIntoView(editor) {
+    if (!isElementVisible(editor.rootContainer)) {
+      logger$3c.warn("editorScrollIntoView: editor is not visible");
+      return;
+    }
+    const rootClientRect = editor.rootContainer.getBoundingClientRect();
+    if (rootClientRect.height < 1 && rootClientRect.width < 1) {
+      return;
+    }
+    const selection = editor.selection;
+    const pos = selection.range.focus;
+    if (!pos.isSimple()) {
+      const complexPos = pos;
+      const childContainer = editor.getContainerById(complexPos.childContainerId);
+      if (!isChildContainerVisible(editor, childContainer)) {
+        childContainer.scrollIntoView();
+      }
+      return;
+    }
+    if (selection.range.start.blockId === selection.range.end.blockId) {
+      const block2 = editor.getBlockById(selection.range.start.blockId);
+      if (isEmbedBlock(block2) && isBlockPartialVisible(editor, block2) && getBlockPartialVisiblePercent(editor, block2) >= 95) {
+        return;
+      }
+      if (isComplexKindBlock(editor, block2) && isBlockPartialVisible(editor, block2)) {
+        return;
+      }
+    }
+    const simplePos = pos;
+    const block = editor.getBlockById(simplePos.blockId);
+    if (isBlockPositionVisible(editor, simplePos)) {
+      return;
+    }
+    if (isEmbedBlock(block)) {
+      const next = getNextBlock(block);
+      if (next) {
+        const delayEmbedBlockTypes = ["image"];
+        if (delayEmbedBlockTypes.includes(getEmbedType(block))) {
+          setTimeout(() => {
+            animateScrollTo(next, {
+              elementToScroll: getScrollContainer$1(editor.rootContainer)
+            });
+          }, 500);
+        } else {
+          animateScrollTo(next, {
+            elementToScroll: getScrollContainer$1(editor.rootContainer)
+          });
+        }
+        return;
+      }
+    }
+    const rect = getBlockCaretRect(editor, block, simplePos);
+    const blockRect = block.getBoundingClientRect();
+    const tools = getBlockTools(block);
+    const anchorElem = createElement("div", ["editor-block-anchor"], tools);
+    const scale = getElementScale(block);
+    anchorElem.style.top = `${(rect.top - blockRect.top) / scale}px`;
+    animateScrollTo(anchorElem, {
+      elementToScroll: getScrollContainer$1(editor.rootContainer)
+    });
+    setTimeout(() => {
+    }, 200);
   }
   function allSelected(editor, range) {
     if (range.isCollapsed()) {