npm - @ones-editor/editor - Versions diffs - 2.6.1-beta.4 → 2.7.1-beta.2 - Mend

@ones-editor/editor 2.6.1-beta.4 → 2.7.1-beta.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/index.js CHANGED Viewed

@@ -334,12 +334,12 @@ div.editor-root div.editor-content div[data-type=editor-container] div[data-type
 div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.hover .embed-hover-content {
   outline: 1px solid #0064ff;
 }
-div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected > div[data-type=block-content],
-div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected .embed-selected-content {
+div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected:not(.no-mask) > div[data-type=block-content],
+div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected:not(.no-mask) .embed-selected-content {
   position: relative;
 }
-div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected > div[data-type=block-content]::before,
-div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected .embed-selected-content::before {
+div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected:not(.no-mask) > div[data-type=block-content]::before,
+div.editor-root div.editor-content div[data-type=editor-container] div[data-type=editor-block].embed-block.selected:not(.no-mask) .embed-selected-content::before {
   content: " ";
   position: absolute;
   left: 0;
@@ -8900,7 +8900,7 @@ var __publicField = (obj, key, value) => {
       imageExportFailed: "\u753B\u50CF\u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F"
     }
   };
-  const logger$4S = getLogger("i18n");
+  const logger$4R = getLogger("i18n");
   const langs$3 = {
     "en-US": enUS$x,
     "zh-CN": zhCN$x,
@@ -8920,7 +8920,7 @@ var __publicField = (obj, key, value) => {
   function t$8(key, args) {
     const ret = i18n.get(key, args);
     if (ret === key) {
-      logger$4S.warn(`no locale value for key ${key}`);
+      logger$4R.warn(`no locale value for key ${key}`);
     }
     return ret;
   }
@@ -9533,7 +9533,7 @@ var __publicField = (obj, key, value) => {
       this._callbacks.clear();
     }
   }
-  const logger$4R = getLogger("await-locker");
+  const logger$4Q = getLogger("await-locker");
   class AwaitLock {
     constructor() {
       __publicField(this, "_acquired", false);
@@ -9575,7 +9575,7 @@ var __publicField = (obj, key, value) => {
       }
       if (this._waitingResolvers.length > 0) {
         const resolve = this._waitingResolvers.shift();
-        assert(logger$4R, resolve, "Resolver missing");
+        assert(logger$4Q, resolve, "Resolver missing");
         resolve(void 0);
       } else {
         this._acquired = false;
@@ -9658,7 +9658,7 @@ var __publicField = (obj, key, value) => {
     isMobileSafari: false
   };
   clientType.isMobileSafari = clientType.isMobile && clientType.isSafari;
-  const logger$4Q = getLogger("dom-utils");
+  const logger$4P = getLogger("dom-utils");
   function addClass(dom, ...className) {
     if (dom && dom.nodeType === Node.ELEMENT_NODE) {
       dom.classList.add(...className);
@@ -9712,7 +9712,7 @@ var __publicField = (obj, key, value) => {
       range.setStart(node, offset);
       return range;
     } catch (err) {
-      assert(logger$4Q, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
+      assert(logger$4P, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
     }
   }
   function createExpandedRange(startNode, startOffset, endNode, endOffset) {
@@ -9722,17 +9722,17 @@ var __publicField = (obj, key, value) => {
       range.setEnd(endNode, endOffset);
       return range;
     } catch (err) {
-      assert(logger$4Q, false, `failed to create expanded range: ${startNode.childNodes.length}, ${startOffset}, ${endNode.childNodes.length}, ${endOffset}, ${err.message}`);
+      assert(logger$4P, 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$4Q, rects.length >= 1, "getFirstClientRect: no rects");
+    assert(logger$4P, rects.length >= 1, "getFirstClientRect: no rects");
     return rects[0];
   }
   function getLastClientRect(elem) {
     const rects = elem.getClientRects();
-    assert(logger$4Q, rects.length >= 1, "getLastClientRect: no rects");
+    assert(logger$4P, rects.length >= 1, "getLastClientRect: no rects");
     return rects[rects.length - 1];
   }
   function getDistanceSquare(rect, x, y) {
@@ -9779,7 +9779,7 @@ var __publicField = (obj, key, value) => {
       return 0;
     }
     if (!elem1.parentElement || !elem2.parentElement) {
-      assert(logger$4Q, false, "invalid dom node to compare");
+      assert(logger$4P, false, "invalid dom node to compare");
     }
     if (elem1.parentElement === elem2.parentElement) {
       const children = Array.from(elem1.parentElement.children);
@@ -9796,7 +9796,7 @@ var __publicField = (obj, key, value) => {
     const parents1 = getParents(elem1);
     const parents2 = getParents(elem2);
     if (parents1[0] !== parents2[0]) {
-      assert(logger$4Q, false, "invalid dom node to compare, different tree");
+      assert(logger$4P, false, "invalid dom node to compare, different tree");
     }
     for (let i = 1; ; i++) {
       const parent1 = parents1[i];
@@ -10396,7 +10396,7 @@ var __publicField = (obj, key, value) => {
     }
   }
   const MIN_DISTANCE_THRESHOLD$3 = 3;
-  const logger$4P = getLogger("drag-drop");
+  const logger$4O = getLogger("drag-drop");
   class DragDrop {
     constructor(options) {
       __publicField(this, "dragStarted", false);
@@ -10417,7 +10417,7 @@ var __publicField = (obj, key, value) => {
         var _a;
         event.preventDefault();
         event.stopPropagation();
-        assert(logger$4P, this.mouseDownEvent, "no mouse down event");
+        assert(logger$4O, this.mouseDownEvent, "no mouse down event");
         const oldPos = DragDrop.getEventPosition(this.mouseDownEvent);
         const newPos = DragDrop.getEventPosition(event);
         const deltaX = newPos.x - oldPos.x;
@@ -10433,7 +10433,7 @@ var __publicField = (obj, key, value) => {
       });
       __publicField(this, "handleMouseUp", (event) => {
         if (event instanceof MouseEvent && event.button === 0 || event instanceof TouchEvent) {
-          assert(logger$4P, this.mouseDownEvent, "no mouse down event");
+          assert(logger$4O, this.mouseDownEvent, "no mouse down event");
           const oldPos = DragDrop.getEventPosition(this.mouseDownEvent);
           const newPos = DragDrop.getEventPosition(event);
           const deltaX = newPos.x - oldPos.x;
@@ -10542,7 +10542,7 @@ var __publicField = (obj, key, value) => {
     const dragDrop = new DragDrop(options);
     return dragDrop;
   }
-  const logger$4O = getLogger("character");
+  const logger$4N = getLogger("character");
   function checkChar(charCode, rangeList) {
     for (let i = 0; i < rangeList.length; i++) {
       const start = rangeList[i][0];
@@ -10587,13 +10587,9 @@ var __publicField = (obj, key, value) => {
     ];
     return checkChar(str.charCodeAt(0), CJKRange);
   }
-  function isCJKPunctuation(char) {
-    const reg = /[\u3000-\u303F\uFF00-\uFFEF\u2000-\u206F\u2E00-\u2E7F]/;
-    return reg.test(char);
-  }
   function trimChar(s, char) {
     let c = char;
-    assert(logger$4O, c.length === 1, "invalid char length");
+    assert(logger$4N, c.length === 1, "invalid char length");
     if (c === "]")
       c = "\\]";
     if (c === "\\")
@@ -10927,7 +10923,7 @@ var __publicField = (obj, key, value) => {
     const metrics = context.measureText(text2);
     return metrics.width + 4;
   }
-  const logger$4N = getLogger("editor-clipboard");
+  const logger$4M = getLogger("editor-clipboard");
   async function setClipboardDataByEvent(items, event) {
     if (event.clipboardData) {
       const data2 = event.clipboardData;
@@ -10985,7 +10981,7 @@ var __publicField = (obj, key, value) => {
       document.body.removeChild(textarea2);
       return true;
     } catch (ex) {
-      logger$4N.error(ex);
+      logger$4M.error(ex);
       document.body.removeChild(textarea2);
       return false;
     }
@@ -11006,7 +11002,7 @@ var __publicField = (obj, key, value) => {
       document.body.removeChild(div);
       return true;
     } catch (ex) {
-      logger$4N.error(ex);
+      logger$4M.error(ex);
       document.body.removeChild(div);
       return false;
     }
@@ -11033,7 +11029,7 @@ var __publicField = (obj, key, value) => {
       await navigator.clipboard.write([clipboardItems]);
       return true;
     } catch (err) {
-      logger$4N.error(err);
+      logger$4M.error(err);
       return await execCommandCopy(items);
     }
   }
@@ -11089,7 +11085,7 @@ var __publicField = (obj, key, value) => {
     a.click();
     a.remove();
   }
-  const logger$4M = getLogger("auto-scroll");
+  const logger$4L = getLogger("auto-scroll");
   function scrollable(scrollElement, direction) {
     if (scrollElement.scrollHeight === scrollElement.clientHeight) {
       return false;
@@ -11113,7 +11109,7 @@ var __publicField = (obj, key, value) => {
     const isHorizontal = direction === "left" || direction === "right";
     const scroll = () => {
       if (!scrollable(scrollElement, direction)) {
-        logger$4M.debug("No need for scroll");
+        logger$4L.debug("No need for scroll");
         return null;
       }
       if (isHorizontal) {
@@ -11170,7 +11166,7 @@ var __publicField = (obj, key, value) => {
           if (this.scrolling) {
             return;
           }
-          logger$4M.debug(`scroll direction: ${direction}`);
+          logger$4L.debug(`scroll direction: ${direction}`);
           this.cancelScroll = continuousScroll(scrollElement, {
             direction,
             step
@@ -11420,7 +11416,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$4L = getLogger("container");
+  const logger$4K = getLogger("container");
   function isContainer(elem) {
     return elem.getAttribute("data-type") === "editor-container";
   }
@@ -11432,9 +11428,9 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerId(container) {
     const id = container.getAttribute("data-container-id");
-    assert(logger$4L, id, "no id for container");
+    assert(logger$4K, id, "no id for container");
     if (isRootContainer(container)) {
-      assert(logger$4L, id === "root", `invalid root container id, : ${id}`);
+      assert(logger$4K, id === "root", `invalid root container id, : ${id}`);
     }
     return id;
   }
@@ -11445,7 +11441,7 @@ var __publicField = (obj, key, value) => {
   function generateEditorContainerId(containerId) {
     return `ones-editor-container-${containerId}`;
   }
-  const logger$4K = getLogger("element");
+  const logger$4J = getLogger("element");
   function createContainerElement(parent, type, containerId) {
     const container = createElement("div", [type], parent);
     container.setAttribute("data-type", "editor-container");
@@ -11456,7 +11452,7 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerById(editor, containerId) {
     const container = editor.rootElement.querySelector(`[data-container-id=${containerId}]`);
-    assert(logger$4K, container, `no container: ${containerId}`);
+    assert(logger$4J, container, `no container: ${containerId}`);
     return container;
   }
   function getExistsContainerById(editor, containerId) {
@@ -11465,7 +11461,7 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerBlocksElement(container) {
     const blocks = container.querySelector(":scope > .container-blocks");
-    assert(logger$4K, blocks, "no container blocks element");
+    assert(logger$4J, blocks, "no container blocks element");
     return blocks;
   }
   function getContainerToolsElement(container) {
@@ -11478,11 +11474,11 @@ var __publicField = (obj, key, value) => {
   function isContainerBlocksElement(element) {
     return element.classList.contains("container-blocks");
   }
-  const logger$4J = getLogger("container-children");
+  const logger$4I = getLogger("container-children");
   function getChildBlocks(container, traverseChild) {
     const content = getContainerBlocksElement(container);
     const blocks = Array.from(content.children);
-    assert(logger$4J, blocks.length > 0, "container have not any child block");
+    assert(logger$4I, blocks.length > 0, "container have not any child block");
     if (traverseChild) {
       const { condition, editor } = traverseChild;
       return blocks.reduce((result, block) => {
@@ -11505,7 +11501,7 @@ var __publicField = (obj, key, value) => {
   }
   function getFirstChildBlock(container) {
     const block = container.querySelector(":scope > .container-blocks > div[data-type=editor-block]");
-    assert(logger$4J, block, "container have not any child block");
+    assert(logger$4I, block, "container have not any child block");
     return block;
   }
   function getLastChildBlock(container) {
@@ -11517,14 +11513,14 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockByIndex(container, blockIndex) {
     const block = getChildBlocks(container)[blockIndex];
-    assert(logger$4J, block, `container have not block at index ${blockIndex}`);
+    assert(logger$4I, block, `container have not block at index ${blockIndex}`);
     return block;
   }
   function findBlockByIndex(container, blockIndex) {
     var _a;
     return (_a = getChildBlocks(container)[blockIndex]) != null ? _a : null;
   }
-  const logger$4I = getLogger("block-dom");
+  const logger$4H = getLogger("block-dom");
   function isBlock$1(node) {
     if (!(node instanceof HTMLDivElement)) {
       return false;
@@ -11545,12 +11541,12 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockId(block) {
     const { id } = block;
-    assert(logger$4I, id, "no block id");
+    assert(logger$4H, id, "no block id");
     return id;
   }
   function getBlockType(block) {
     const type = block.getAttribute("data-block-type");
-    assert(logger$4I, type, "invalid block dom, no data-type");
+    assert(logger$4H, type, "invalid block dom, no data-type");
     return type;
   }
   function getParentBlock(node) {
@@ -11573,12 +11569,12 @@ var __publicField = (obj, key, value) => {
   }
   function getParentContainer(block) {
     const container = block.closest("div[data-type=editor-container]");
-    assert(logger$4I, container, "failed to get block container");
+    assert(logger$4H, container, "failed to get block container");
     return container;
   }
   function getBlockContent(block) {
     const content = block.querySelector(":scope >div[data-type=block-content]");
-    assert(logger$4I, content, "no block content");
+    assert(logger$4H, content, "no block content");
     return content;
   }
   function getBlockTools(block) {
@@ -11587,7 +11583,7 @@ var __publicField = (obj, key, value) => {
       tools = createElement("div", [], block);
       tools.setAttribute("data-type", "block-tools");
     }
-    assert(logger$4I, tools, "no block tools");
+    assert(logger$4H, tools, "no block tools");
     return tools;
   }
   function getExistsBlockTools(block) {
@@ -11608,7 +11604,7 @@ var __publicField = (obj, key, value) => {
   function createBlockElement(editor, path, data2) {
     const blockData = editor.editorDecorators.decorateBlock(path, data2);
     const { id, type } = blockData;
-    assert(logger$4I, id, "no block id");
+    assert(logger$4H, id, "no block id");
     const elem = createElement("div", [`${type}-block`], null);
     elem.id = id;
     elem.setAttribute("data-type", "editor-block");
@@ -11646,7 +11642,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxTypeFromElement(box) {
     const type = box.getAttribute("data-box-type");
-    assert(logger$4I, type, "not a valid box element, no type");
+    assert(logger$4H, type, "not a valid box element, no type");
     return type;
   }
   function isBox(node) {
@@ -11657,7 +11653,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxId(box) {
     const { id } = box;
-    assert(logger$4I, id, "no box id");
+    assert(logger$4H, id, "no box id");
     return id;
   }
   function getParentBox(node) {
@@ -11679,7 +11675,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxContent(box) {
     const content = box.querySelector("span[data-type=box-content]");
-    assert(logger$4I, content, "invalid box dom, no content");
+    assert(logger$4H, content, "invalid box dom, no content");
     return content;
   }
   function createInsertionElement(type, id, attributes) {
@@ -11701,7 +11697,7 @@ var __publicField = (obj, key, value) => {
   }
   function getInsertionContent(insertion) {
     const content = insertion.querySelector("span[data-type=insertion-content]");
-    assert(logger$4I, content, "invalid insertion-child dom, no content");
+    assert(logger$4H, content, "invalid insertion-child dom, no content");
     return content;
   }
   function getPrevBlock(block) {
@@ -11724,44 +11720,31 @@ var __publicField = (obj, key, value) => {
     }
     return null;
   }
-  function getPrevVisibleBlock(block, matcher) {
-    const mergedMatcher = matcher || (() => true);
+  function getPrevVisibleBlock(block) {
     let prev = block.previousElementSibling;
     while (prev) {
-      if (isBlock$1(prev) && isVisibleBlock(prev) && mergedMatcher(prev)) {
+      if (isBlock$1(prev) && isVisibleBlock(prev)) {
         return prev;
       }
       prev = prev.previousElementSibling;
     }
     return null;
   }
-  function getNextVisibleBlock(block, matcher) {
-    const mergedMatcher = matcher || (() => true);
+  function getNextVisibleBlock(block) {
     let next2 = block.nextElementSibling;
     while (next2) {
-      if (isBlock$1(next2) && isVisibleBlock(next2) && mergedMatcher(next2)) {
+      if (isBlock$1(next2) && isVisibleBlock(next2)) {
         return next2;
       }
       next2 = next2.nextElementSibling;
     }
     return null;
   }
-  function getBlocksBetween(start, end, matcher) {
-    const blocks = [];
-    let cur = start;
-    while (cur !== end) {
-      if (isBlock$1(cur) && matcher(cur)) {
-        blocks.push(cur);
-      }
-      cur = cur.nextElementSibling;
-    }
-    return blocks;
-  }
   function getBlockIndex(block) {
     const container = getParentContainer(block);
     const children = getChildBlocks(container);
     const index2 = children.indexOf(block);
-    assert(logger$4I, index2 !== -1, "invalid block & container dom, failed to get block index");
+    assert(logger$4H, index2 !== -1, "invalid block & container dom, failed to get block index");
     return index2;
   }
   function isInBlock(target) {
@@ -11786,18 +11769,18 @@ var __publicField = (obj, key, value) => {
   function isTitleBlock$2(block) {
     return block.hasAttribute("data-document-title");
   }
-  const logger$4H = getLogger("block-class");
+  const logger$4G = 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$4H, text2.blockKind === "text", `is not a text block, ${text2.blockType}`);
+    assert(logger$4G, 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$4H, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
+    assert(logger$4G, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
     return complex;
   }
   function getBlockClassByType(editor, type) {
@@ -11818,7 +11801,7 @@ var __publicField = (obj, key, value) => {
   function getBlockKind(editor, block) {
     return getBlockClass(editor, block).blockKind;
   }
-  const logger$4G = getLogger("text-block-child");
+  const logger$4F = getLogger("text-block-child");
   function isTextBlockContentChild(elem) {
     if (elem.tagName !== "SPAN") {
       return false;
@@ -11826,14 +11809,14 @@ var __publicField = (obj, key, value) => {
     return true;
   }
   function isTextBlockContentBoxChild(elem) {
-    assert(logger$4G, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$4F, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-box") {
       return true;
     }
     return false;
   }
   function isTextBlockContentInsertionChild(elem) {
-    assert(logger$4G, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$4F, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-insertion") {
       return true;
     }
@@ -11843,7 +11826,7 @@ var __publicField = (obj, key, value) => {
     return !isTextBlockContentBoxChild(elem) && !isTextBlockContentInsertionChild(elem);
   }
   function getTextBlockContentChildType(child) {
-    assert(logger$4G, isTextBlockContentChild(child), "not a valid text child");
+    assert(logger$4F, isTextBlockContentChild(child), "not a valid text child");
     if (isTextBlockContentBoxChild(child)) {
       return "box";
     }
@@ -11858,15 +11841,15 @@ var __publicField = (obj, key, value) => {
       return 0;
     if (type === "box")
       return 1;
-    assert(logger$4G, child.textContent !== null, "text block content is undefined");
-    assert(logger$4G, child.textContent.length >= 0, "text block content length is negative");
+    assert(logger$4F, child.textContent !== null, "text block content is undefined");
+    assert(logger$4F, 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$4G, isTextBlockContentChild(child), "not a valid text child");
+      assert(logger$4F, isTextBlockContentChild(child), "not a valid text child");
     });
     return children;
   }
@@ -11895,17 +11878,17 @@ var __publicField = (obj, key, value) => {
         };
       }
       const offset = blockOffset - start;
-      assert(logger$4G, offset > 0, "invalid offset value");
-      assert(logger$4G, !isTextBlockContentBoxChild(child), "invalid box child");
+      assert(logger$4F, offset > 0, "invalid offset value");
+      assert(logger$4F, !isTextBlockContentBoxChild(child), "invalid box child");
       return {
         prev: child,
         next: child,
         offset
       };
     }
-    assert(logger$4G, false, `invalid block child at position: ${blockOffset}`);
+    assert(logger$4F, false, `invalid block child at position: ${blockOffset}`);
   }
-  const logger$4F = getLogger("block-path");
+  const logger$4E = getLogger("block-path");
   function getBlockPath(block) {
     const ret = [];
     let current = block;
@@ -11919,26 +11902,26 @@ var __publicField = (obj, key, value) => {
         return ret;
       }
       const parentBlock = getParentBlock(container);
-      assert(logger$4F, parentBlock, "no parent block");
+      assert(logger$4E, parentBlock, "no parent block");
       current = parentBlock;
     }
-    assert(logger$4F, false, "no parent block");
+    assert(logger$4E, false, "no parent block");
     return [];
   }
-  const logger$4E = getLogger("child-container-path");
+  const logger$4D = getLogger("child-container-path");
   function getContainerBlockPath(container) {
     if (isRootContainer(container)) {
       return [];
     }
     const parentBlock = getParentBlock(container);
-    assert(logger$4E, parentBlock, "no parent block");
+    assert(logger$4D, parentBlock, "no parent block");
     return getBlockPath(parentBlock);
   }
-  const logger$4D = getLogger("load-blocks");
+  const logger$4C = getLogger("load-blocks");
   function loadBlocks(editor, container, path) {
     const containerId = getContainerId(container);
     const blocks = getContainerBlocks$1(container, editor.doc);
-    assert(logger$4D, blocks.length > 0, "no blocks in container");
+    assert(logger$4C, 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);
@@ -11954,7 +11937,7 @@ var __publicField = (obj, key, value) => {
       return block;
     }
     const blocks = getChildBlocks(container);
-    assert(logger$4D, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
+    assert(logger$4C, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
     if (blockIndex === blocks.length) {
       containerBlocksElement.appendChild(block);
     } else {
@@ -11972,7 +11955,7 @@ var __publicField = (obj, key, value) => {
     insertBlockAt(container, blockIndex, block);
     return block;
   }
-  const logger$4C = getLogger("root-container");
+  const logger$4B = getLogger("root-container");
   const MIN_DISTANCE_THRESHOLD$2 = 3;
   class RootContainer {
     constructor(editor, rootContainer) {
@@ -12000,7 +11983,7 @@ var __publicField = (obj, key, value) => {
           this.editor.selection.updateSelection(null);
           this.editor.emit("resize", this.editor);
         } catch (err) {
-          logger$4C.warn(`failed to update selection while container resizing: ${err.message}`);
+          logger$4B.warn(`failed to update selection while container resizing: ${err.message}`);
         }
       });
       __publicField(this, "handleClick", (event) => {
@@ -12033,7 +12016,7 @@ var __publicField = (obj, key, value) => {
         const box = getParentBox(elem);
         if (box) {
           const block2 = getParentBlock(box);
-          assert(logger$4C, block2, "no parent block");
+          assert(logger$4B, 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;
         }
@@ -12088,7 +12071,7 @@ var __publicField = (obj, key, value) => {
         this.editor.input.focus({ preventScroll: true });
       });
       __publicField(this, "handleMouseMove", (event) => {
-        assert(logger$4C, this.mouseDownEvent, "no mouse down event");
+        assert(logger$4B, this.mouseDownEvent, "no mouse down event");
         if (ensureIsMobileEvent(this.mouseDownEvent))
           return;
         const deltaX = event.x - this.mouseDownEvent.x;
@@ -12204,7 +12187,7 @@ var __publicField = (obj, key, value) => {
     loadBlocks(editor, container, path);
     return container;
   }
-  const logger$4B = getLogger("block");
+  const logger$4A = getLogger("block");
   function getBlockTextLength$6(editor, block) {
     return getBlockClass(editor, block).getBlockTextLength(block);
   }
@@ -12223,7 +12206,7 @@ var __publicField = (obj, key, value) => {
         return block;
       }
       const parent = getParentBlock(container);
-      assert(logger$4B, parent, "no parent block exists for child container");
+      assert(logger$4A, parent, "no parent block exists for child container");
       block = parent;
     }
   }
@@ -12259,7 +12242,7 @@ var __publicField = (obj, key, value) => {
       }
       return fun(editor, block, options);
     } catch (err) {
-      logger$4B.debug(`unsupported block type: ${type}`);
+      logger$4A.debug(`unsupported block type: ${type}`);
       return null;
     }
   }
@@ -12279,7 +12262,7 @@ var __publicField = (obj, key, value) => {
     const styles = Object.fromEntries(Object.entries(data2).filter(([key]) => key.startsWith("style-")));
     Object.entries(styles).forEach(([, value]) => {
       const type = typeof value;
-      assert(logger$4B, type === "string" || type === "number" || type === "boolean", "invalid style value");
+      assert(logger$4A, type === "string" || type === "number" || type === "boolean", "invalid style value");
     });
     return styles;
   }
@@ -12404,7 +12387,7 @@ var __publicField = (obj, key, value) => {
     }
     return { element: null, blockCommands: [], boxCommands: [] };
   }
-  const logger$4A = getLogger("embed-block-common");
+  const logger$4z = getLogger("embed-block-common");
   function isColumnsBlock(block) {
     return getBlockType(block) === "layout";
   }
@@ -12412,9 +12395,9 @@ var __publicField = (obj, key, value) => {
     return getBlockType(block) === "embed";
   }
   function getEmbedType(block) {
-    assert(logger$4A, isEmbedBlock(block), "not an embed block");
+    assert(logger$4z, isEmbedBlock(block), "not an embed block");
     const type = block.getAttribute("data-embed-type");
-    assert(logger$4A, type, "no embed data type");
+    assert(logger$4z, type, "no embed data type");
     return type;
   }
   function getEmbedClassFromBlock(editor, block) {
@@ -12480,10 +12463,10 @@ var __publicField = (obj, key, value) => {
       data: (_c = overrideOptions == null ? void 0 : overrideOptions.data) != null ? _c : data2
     });
   }
-  const logger$4z = getLogger("execute-block-command");
+  const logger$4y = getLogger("execute-block-command");
   function executeEmbedBlockCommand(editor, block, commandGroup, item) {
     var _a;
-    assert(logger$4z, isEmbedBlock(block), "not a embed block");
+    assert(logger$4y, isEmbedBlock(block), "not a embed block");
     const embedType = getEmbedType(block);
     const embed = getEmbedClassByType(editor, embedType);
     if (!embed.getOptions) {
@@ -12516,14 +12499,14 @@ var __publicField = (obj, key, value) => {
     }
     return void 0;
   }
-  const logger$4y = getLogger("block-class");
+  const logger$4x = getLogger("block-class");
   function isHeadingBlock$1(block) {
     return !!block.getAttribute("data-style-heading");
   }
   function getBlockHeading(block) {
     var _a;
     const heading = Number.parseInt((_a = block.getAttribute("data-style-heading")) != null ? _a : "", 10);
-    assert(logger$4y, heading, "not a heading block");
+    assert(logger$4x, heading, "not a heading block");
     return heading;
   }
   function isExpandedHeadingBlock(block) {
@@ -12534,7 +12517,7 @@ var __publicField = (obj, key, value) => {
   }
   function getHeadingBlockChildren(block, oldHeading) {
     if (!oldHeading) {
-      assert(logger$4y, isHeadingBlock$1(block), "not a heading block");
+      assert(logger$4x, isHeadingBlock$1(block), "not a heading block");
     }
     const children = [];
     const heading = oldHeading != null ? oldHeading : getBlockHeading(block);
@@ -12564,7 +12547,7 @@ var __publicField = (obj, key, value) => {
     }
     return children;
   }
-  const logger$4x = getLogger("complex-block-position");
+  const logger$4w = getLogger("complex-block-position");
   class EditorComplexBlockPosition {
     constructor(block, childContainerId, custom) {
       __publicField(this, "blockId");
@@ -12573,7 +12556,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$4x, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$4w, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.childContainerId = childContainerId;
@@ -12585,7 +12568,7 @@ var __publicField = (obj, key, value) => {
       return false;
     }
   }
-  const logger$4w = getLogger("simple-block-position");
+  const logger$4v = getLogger("simple-block-position");
   class EditorSimpleBlockPosition {
     constructor(block, offset, type) {
       __publicField(this, "blockId");
@@ -12594,7 +12577,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$4w, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$4v, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.offset = offset;
@@ -12604,7 +12587,7 @@ var __publicField = (obj, key, value) => {
       return true;
     }
   }
-  const logger$4v = getLogger("editor-position");
+  const logger$4u = getLogger("editor-position");
   function createSimpleBlockPosition(block, offset, type) {
     return new EditorSimpleBlockPosition(block, offset, type);
   }
@@ -12626,7 +12609,7 @@ var __publicField = (obj, key, value) => {
       }
       const block1 = editor.getBlockById(pos1.blockId);
       const block2 = editor.getBlockById(pos2.blockId);
-      assert(logger$4v, block1 !== block2, "comparePosition: blocks are the same");
+      assert(logger$4u, block1 !== block2, "comparePosition: blocks are the same");
       return compareElement(block1, block2);
     }
     if (isComplexBlockPosition(pos1) && isComplexBlockPosition(pos2)) {
@@ -12637,13 +12620,13 @@ var __publicField = (obj, key, value) => {
       }
       const container1 = editor.getContainerById(p1.childContainerId);
       const container2 = editor.getContainerById(p2.childContainerId);
-      assert(logger$4v, container1 !== container2, "comparePosition: containers are the same");
+      assert(logger$4u, container1 !== container2, "comparePosition: containers are the same");
       return compareElement(container1, container2);
     }
-    assert(logger$4v, false, "invalid ");
+    assert(logger$4u, false, "invalid ");
     return 0;
   }
-  const logger$4u = getLogger("simple-range");
+  const logger$4t = getLogger("simple-range");
   class EditorSimpleSelectionRange {
     constructor(editor, options) {
       __publicField(this, "editor");
@@ -12692,11 +12675,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$4u, startBlock, "no start block");
-      assert(logger$4u, endBlock, "no end block");
+      assert(logger$4t, startBlock, "no start block");
+      assert(logger$4t, endBlock, "no end block");
       const startContainer = getParentContainer(startBlock);
       const endContainer = getParentContainer(endBlock);
-      assert(logger$4u, startContainer === endContainer, "invalid range");
+      assert(logger$4t, startContainer === endContainer, "invalid range");
       const ret = [];
       if (startBlock === endBlock) {
         ret.push({
@@ -12707,7 +12690,7 @@ var __publicField = (obj, key, value) => {
       } else {
         const startIndex = getBlockIndex(startBlock);
         const endIndex = getBlockIndex(endBlock);
-        assert(logger$4u, startIndex < endIndex, "invalid range, start > index");
+        assert(logger$4t, startIndex < endIndex, "invalid range, start > index");
         ret.push({
           block: startBlock,
           start: this.start,
@@ -12807,7 +12790,7 @@ var __publicField = (obj, key, value) => {
     clearSelection: clearSelection$6,
     convertTo: convertTo$m
   };
-  const logger$4t = getLogger("editor-blocks");
+  const logger$4s = getLogger("editor-blocks");
   class EditorBlocks {
     constructor(editor) {
       __publicField(this, "blocks", /* @__PURE__ */ new Map());
@@ -12816,12 +12799,12 @@ var __publicField = (obj, key, value) => {
     registerBlockClass(blockClass) {
       const type = blockClass.blockType;
       const exists = this.blocks.get(type);
-      assert(logger$4t, !exists, `duplicated block type: ${type}`);
+      assert(logger$4s, !exists, `duplicated block type: ${type}`);
       this.blocks.set(type, blockClass);
     }
     getBlockClass(type) {
       const exists = this.blocks.get(type);
-      assert(logger$4t, exists, `unknown block type: ${type}`);
+      assert(logger$4s, exists, `unknown block type: ${type}`);
       return exists;
     }
     hasBlock(type) {
@@ -12837,7 +12820,7 @@ var __publicField = (obj, key, value) => {
       }
       const content = blockClass.createBlockContent(this.editor, path, container, blockElement, block);
       if (content.parentElement !== blockElement) {
-        logger$4t.warn("content parent is not block");
+        logger$4s.warn("content parent is not block");
         blockElement.appendChild(content);
       }
       this.editor.blockHooks.forEach((hook) => {
@@ -12858,7 +12841,7 @@ var __publicField = (obj, key, value) => {
       return newBlock;
     }
   }
-  const logger$4s = getLogger("editor-embeds");
+  const logger$4r = getLogger("editor-embeds");
   class EditorEmbeds {
     constructor(editor) {
       __publicField(this, "objects", /* @__PURE__ */ new Map());
@@ -12867,12 +12850,12 @@ var __publicField = (obj, key, value) => {
     registerEmbedClass(embedClass) {
       const type = embedClass.embedType;
       const exists = this.objects.get(type);
-      assert(logger$4s, !exists, `duplicated embed object type: ${type}`);
+      assert(logger$4r, !exists, `duplicated embed object type: ${type}`);
       this.objects.set(type, embedClass);
     }
     getEmbedClass(type) {
       const exists = this.objects.get(type);
-      assert(logger$4s, exists, `unknown embed type: ${type}`);
+      assert(logger$4r, exists, `unknown embed type: ${type}`);
       return exists;
     }
     getEmbedClassFromBlock(block) {
@@ -12882,12 +12865,12 @@ var __publicField = (obj, key, value) => {
       this.objects.forEach(callback);
     }
   }
-  const logger$4r = getLogger("embed-block");
+  const logger$4q = getLogger("embed-block");
   function createBlockContent$6(editor, path, container, blockElement, blockData) {
     const content = createBlockContentElement(blockElement, "div");
-    assert(logger$4r, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
+    assert(logger$4q, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
     const embedBlockData = blockData;
-    assert(logger$4r, embedBlockData.embedType && embedBlockData.embedData, `not an embed data: ${JSON.stringify(embedBlockData)}`);
+    assert(logger$4q, 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);
@@ -12915,7 +12898,7 @@ var __publicField = (obj, key, value) => {
   function getCaretRect$4(block, pos) {
     const content = getBlockContent(block);
     const rect = content.getBoundingClientRect();
-    assert(logger$4r, pos.offset === 0 || pos.offset === 1, `invalid offset: ${pos.offset}`);
+    assert(logger$4q, pos.offset === 0 || pos.offset === 1, `invalid offset: ${pos.offset}`);
     if (pos.offset === 1) {
       return new DOMRect(rect.right, rect.top, 0, rect.height);
     }
@@ -13055,18 +13038,18 @@ var __publicField = (obj, key, value) => {
     toStandardDoc: toStandardDoc$2,
     getResources: getResources$2
   };
-  const logger$4q = getLogger("complex-block-helper");
+  const logger$4p = 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$4q, end.isSimple(), "invalid start and end position");
+      assert(logger$4p, end.isSimple(), "invalid start and end position");
       return complexBlockGetAllChildContainers(editor, block);
     }
-    assert(logger$4q, !start.isSimple(), "invalid start pos");
-    assert(logger$4q, !end.isSimple(), "invalid end pos");
+    assert(logger$4p, !start.isSimple(), "invalid start pos");
+    assert(logger$4p, !end.isSimple(), "invalid end pos");
     const blockClass = getComplexBlockClass(editor, block);
     return blockClass.getSelectedContainers(editor, block, start, end);
   }
@@ -13077,11 +13060,11 @@ var __publicField = (obj, key, value) => {
     const parentComplexBlock = getParentBlock(getParentContainer(childBlock));
     if (!parentComplexBlock)
       return false;
-    assert(logger$4q, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$4p, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainer = getParentContainer(childBlock);
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock);
     const index2 = childContainers.indexOf(childContainer);
-    assert(logger$4q, index2 >= 0, "not valid child container");
+    assert(logger$4p, index2 >= 0, "not valid child container");
     return index2 === 0;
   }
   function complexBlockGetFirstSimpleChild(editor, complexBlock, options) {
@@ -13134,13 +13117,13 @@ var __publicField = (obj, key, value) => {
     return block;
   }
   function findPrevSimpleBlockBeforeChildContainer(editor, childContainer, options) {
-    assert(logger$4q, isChildContainer(childContainer), "not a child container");
+    assert(logger$4p, isChildContainer(childContainer), "not a child container");
     const parentComplexBlock = getParentBlock(childContainer);
-    assert(logger$4q, parentComplexBlock, "no parent block");
-    assert(logger$4q, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$4p, parentComplexBlock, "no parent block");
+    assert(logger$4p, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock, options);
     const containerIndex = childContainers.indexOf(childContainer);
-    assert(logger$4q, containerIndex !== -1, "child container not found");
+    assert(logger$4p, containerIndex !== -1, "child container not found");
     if (containerIndex === 0) {
       const prevBlock = getPrevBlock(parentComplexBlock);
       if (!prevBlock)
@@ -13158,9 +13141,9 @@ var __publicField = (obj, key, value) => {
     return lastBlock2;
   }
   function complexBlockGetTopChildContainers(editor, complexBlock) {
-    assert(logger$4q, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$4p, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$4q, childContainers.length > 0, "no child container");
+    assert(logger$4p, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -13185,9 +13168,9 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function complexBlockGetBottomChildContainers(editor, complexBlock) {
-    assert(logger$4q, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$4p, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$4q, childContainers.length > 0, "no child container");
+    assert(logger$4p, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -13292,11 +13275,11 @@ var __publicField = (obj, key, value) => {
     return result;
   }
   const anchor = "";
-  const logger$4p = getLogger("text-range");
+  const logger$4o = getLogger("text-range");
   function getBlockRangeInfo(block, blockOffset) {
     const getChildRange = (child, offset) => {
       if (isTextBlockContentInsertionChild(child)) {
-        assert(logger$4p, offset === 0, `invalid offset for insertion child: ${offset}`);
+        assert(logger$4o, offset === 0, `invalid offset for insertion child: ${offset}`);
         const childOffset = 2;
         return {
           child,
@@ -13305,7 +13288,7 @@ var __publicField = (obj, key, value) => {
         };
       }
       if (isTextBlockContentBoxChild(child)) {
-        assert(logger$4p, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
+        assert(logger$4o, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
         const childOffset = offset === 0 ? 1 : 2;
         return {
           child,
@@ -13314,17 +13297,17 @@ var __publicField = (obj, key, value) => {
         };
       }
       const textNode = child.firstChild;
-      assert(logger$4p, textNode, "no child node for text child");
-      assert(logger$4p, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
+      assert(logger$4o, textNode, "no child node for text child");
+      assert(logger$4o, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
       if (textNode instanceof HTMLBRElement) {
-        assert(logger$4p, offset >= 0 && offset <= 0, "invalid offset for text child");
+        assert(logger$4o, offset >= 0 && offset <= 0, "invalid offset for text child");
         return {
           child,
           container: textNode,
           offset
         };
       }
-      assert(logger$4p, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
+      assert(logger$4o, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
       return {
         child,
         container: textNode,
@@ -13353,38 +13336,38 @@ var __publicField = (obj, key, value) => {
       }
       start += childLength;
     }
-    assert(logger$4p, false, "failed to get range info");
+    assert(logger$4o, false, "failed to get range info");
   }
   function createChildRange(child, start, end) {
     if (start === end) {
-      assert(logger$4p, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
+      assert(logger$4o, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
     } else {
-      assert(logger$4p, start < end, `invalid start & end: ${start}, ${end}`);
+      assert(logger$4o, start < end, `invalid start & end: ${start}, ${end}`);
     }
     if (isTextBlockContentInsertionChild(child)) {
-      assert(logger$4p, start === end, `invalid insertion child range offset: ${start}, ${end}`);
-      assert(logger$4p, start === 0, `invalid insertion child range start: ${start}`);
+      assert(logger$4o, start === end, `invalid insertion child range offset: ${start}, ${end}`);
+      assert(logger$4o, start === 0, `invalid insertion child range start: ${start}`);
       const insertionElem = child;
-      assert(logger$4p, insertionElem.children.length === 3, `invalid insertion dom, children.length = ${insertionElem.children.length}`);
+      assert(logger$4o, 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$4p, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
-      assert(logger$4p, start === 0, `invalid box child range start: ${start}`);
+      assert(logger$4o, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
+      assert(logger$4o, start === 0, `invalid box child range start: ${start}`);
       const box = child;
-      assert(logger$4p, box.children.length === 3, `invalid box dom, children.length = ${box.children.length}`);
+      assert(logger$4o, 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$4p, end <= length, `invalid child end: ${end}, ${length}`);
+    assert(logger$4o, end <= length, `invalid child end: ${end}, ${length}`);
     const textNode = child.firstChild;
-    assert(logger$4p, textNode instanceof Text, "invalid block text child");
-    assert(logger$4p, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
+    assert(logger$4o, textNode instanceof Text, "invalid block text child");
+    assert(logger$4o, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
     return createExpandedRange(textNode, start, textNode, end);
   }
-  const logger$4o = getLogger("caret-rect");
+  const logger$4n = getLogger("caret-rect");
   function getChildClientRects(block, child) {
     if (isBox(child)) {
       const box = child;
@@ -13393,7 +13376,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$4o, rects.length > 0, "no box client rects");
+        assert(logger$4n, 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);
@@ -13413,22 +13396,22 @@ var __publicField = (obj, key, value) => {
         const rect2 = getLastClientRect(ranges[0].child);
         return new DOMRect(rect2.right, rect2.top, 1, rect2.height);
       }
-      assert(logger$4o, ranges[1], "invalid ranges");
+      assert(logger$4n, 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$4o, ranges.length >= 1, "failed to get block range");
+    assert(logger$4n, ranges.length >= 1, "failed to get block range");
     if (ranges.length === 1) {
       rangeInfo = ranges[0];
     } else {
-      assert(logger$4o, ranges.length >= 2, `invalid range info length: ${ranges.length}`);
+      assert(logger$4n, 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$4o, rects2.length >= 1, "no client rects for box content");
+        assert(logger$4n, 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);
       }
@@ -13445,9 +13428,9 @@ var __publicField = (obj, key, value) => {
       }
     }
     if (rangeInfo.container instanceof HTMLBRElement) {
-      assert(logger$4o, pos.offset === 0, "invalid offset for empty block text");
+      assert(logger$4n, pos.offset === 0, "invalid offset for empty block text");
       const parent = rangeInfo.container.parentElement;
-      assert(logger$4o, parent, "invalid br parent");
+      assert(logger$4n, parent, "invalid br parent");
       const rect = parent.getBoundingClientRect();
       const ret = new DOMRect(rect.left, rect.top, 1, rect.height);
       return ret;
@@ -13455,11 +13438,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$4o, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
-      assert(logger$4o, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
+      assert(logger$4n, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
+      assert(logger$4n, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
       const child = rangeInfo.child;
       const rects2 = getChildClientRects(block, child);
-      assert(logger$4o, rects2.length >= 1, "no client rects for box content");
+      assert(logger$4n, 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);
@@ -13505,7 +13488,7 @@ var __publicField = (obj, key, value) => {
         });
       }
     }
-    assert(logger$4o, rects.length > 0, "no client rects for range");
+    assert(logger$4n, rects.length > 0, "no client rects for range");
     if (pos.type === "home") {
       return rects[rects.length - 1];
     }
@@ -13585,13 +13568,13 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$4n = getLogger("selection-range");
+  const logger$4m = 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$4n, anchor2 instanceof EditorComplexBlockPosition && focus instanceof EditorComplexBlockPosition, "start position type does not math end type");
+    assert(logger$4m, 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) {
@@ -13613,7 +13596,7 @@ var __publicField = (obj, key, value) => {
     const focus = createSimpleBlockPosition(range.focus.blockId, range.focus.offset, "normal");
     return createEditorSelectionRange(editor, { anchor: anchor2, focus });
   }
-  const logger$4m = getLogger("range-from-point");
+  const logger$4l = getLogger("range-from-point");
   function getBlockRangeFromPoint(editor, pointX, pointY, dragging) {
     const yOffsets = [0, -12, 12];
     let x = pointX;
@@ -13645,7 +13628,7 @@ var __publicField = (obj, key, value) => {
       const rect = elem.getBoundingClientRect();
       if (rect.width && rect.top && i === 0) {
         if (rect.left + rect.width < x || rect.top + rect.height < y) {
-          logger$4m.debug("click on scrollbar, out of element rect");
+          logger$4l.debug("click on scrollbar, out of element rect");
           return null;
         }
       }
@@ -13683,7 +13666,7 @@ var __publicField = (obj, key, value) => {
     let block = getLastChildBlock(container);
     if (!isVisibleBlock(block)) {
       const preBlock = getPrevVisibleBlock(block);
-      assert(logger$4m, preBlock, "container must have visible block");
+      assert(logger$4l, preBlock, "container must have visible block");
       block = preBlock;
     }
     const range = getBlockClass(editor, block).getRangeFromPoint(editor, block, x, block.getBoundingClientRect().bottom - 4);
@@ -13702,7 +13685,7 @@ var __publicField = (obj, key, value) => {
       if (range instanceof EditorSimpleSelectionRange) {
         return range;
       }
-      assert(logger$4m, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
+      assert(logger$4l, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
       const complexRange = range;
       const container2 = editor.getContainerById(complexRange.start.childContainerId);
       return getRangeInContainer(editor, container2, x, y);
@@ -13725,7 +13708,7 @@ var __publicField = (obj, key, value) => {
     });
     return getRangeInContainer(editor, container, x, y);
   }
-  const logger$4l = getLogger("adjust-selection-pos");
+  const logger$4k = getLogger("adjust-selection-pos");
   function getParentContainers(block) {
     const containers = [];
     while (block) {
@@ -13735,10 +13718,10 @@ var __publicField = (obj, key, value) => {
         return containers;
       }
       const newBlock = getParentBlock(container);
-      assert(logger$4l, newBlock, "child container has not parent container");
+      assert(logger$4k, newBlock, "child container has not parent container");
       block = newBlock;
     }
-    assert(logger$4l, false, "should not come here: getParentContainers");
+    assert(logger$4k, false, "should not come here: getParentContainers");
   }
   function getParentBlockInContainer(container, block) {
     while (block) {
@@ -13747,16 +13730,16 @@ var __publicField = (obj, key, value) => {
         return block;
       }
       const newBlock = getParentBlock(parent);
-      assert(logger$4l, newBlock, "could not find parent block for a child container");
+      assert(logger$4k, newBlock, "could not find parent block for a child container");
       block = newBlock;
     }
-    assert(logger$4l, false, "no parent block in specified container");
+    assert(logger$4k, false, "no parent block in specified container");
   }
   function getClosestParentBlock(block1, block2) {
     const containers1 = getParentContainers(block1);
     const containers2 = getParentContainers(block2);
-    assert(logger$4l, containers1.length > 0 && containers2.length > 0, "block has not parent container");
-    assert(logger$4l, containers1[0] === containers2[0], "root container does not equal");
+    assert(logger$4k, containers1.length > 0 && containers2.length > 0, "block has not parent container");
+    assert(logger$4k, containers1[0] === containers2[0], "root container does not equal");
     let parentContainer = containers1[0];
     for (let i = 1; i < containers1.length || containers2.length; i++) {
       if (containers1[i] === containers2[i]) {
@@ -13775,23 +13758,23 @@ var __publicField = (obj, key, value) => {
   }
   function getParentContainerInComplexBlock(parentComplexBlock, element) {
     let block = getParentBlock(element);
-    assert(logger$4l, block, "element is not in a block");
+    assert(logger$4k, block, "element is not in a block");
     while (block) {
       const container = getParentContainer(block);
-      assert(logger$4l, isChildContainer(container), "not a child container");
+      assert(logger$4k, isChildContainer(container), "not a child container");
       const parentBlock = getParentBlock(container);
-      assert(logger$4l, parentBlock, "child container has not parent block");
+      assert(logger$4k, parentBlock, "child container has not parent block");
       if (parentBlock === parentComplexBlock) {
         return container;
       }
       block = parentBlock;
     }
-    assert(logger$4l, false, "failed to find parent container in complex block");
+    assert(logger$4k, false, "failed to find parent container in complex block");
   }
   function complexBlockAdjustSelectionPos(editor, complexBlock, anchor2, focus) {
     const blockId = getBlockId(complexBlock);
-    assert(logger$4l, blockId === anchor2.blockId, "invalid start pos");
-    assert(logger$4l, blockId === focus.blockId, "invalid end pos");
+    assert(logger$4k, blockId === anchor2.blockId, "invalid start pos");
+    assert(logger$4k, blockId === focus.blockId, "invalid end pos");
     const blockClass = getComplexBlockClass(editor, complexBlock);
     if (blockClass.adjustSelectionPos) {
       return blockClass.adjustSelectionPos(editor, complexBlock, anchor2, focus);
@@ -13825,8 +13808,8 @@ var __publicField = (obj, key, value) => {
       if (focus instanceof EditorComplexBlockPosition) {
         focus = createSimpleBlockPosition(focusBlock, getBlockTextLength$6(editor, focusBlock), "end");
       }
-      assert(logger$4l, anchor2 instanceof EditorSimpleBlockPosition, "not valid position type");
-      assert(logger$4l, focus instanceof EditorSimpleBlockPosition, "not valid position type");
+      assert(logger$4k, anchor2 instanceof EditorSimpleBlockPosition, "not valid position type");
+      assert(logger$4k, focus instanceof EditorSimpleBlockPosition, "not valid position type");
       return {
         anchor: anchor2,
         focus
@@ -13880,7 +13863,7 @@ var __publicField = (obj, key, value) => {
       focus
     };
   }
-  const logger$4k = getLogger("core");
+  const logger$4j = getLogger("core");
   function createBlockAnchor(editor, block, id, refClientRect) {
     const tools = getBlockTools(block);
     let elem = tools.querySelector(`.block-anchor[data-id=${id}]`);
@@ -13898,7 +13881,7 @@ var __publicField = (obj, key, value) => {
     return elem;
   }
   function createBlockCaretAnchor(editor, block, offset, id) {
-    assert(logger$4k, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$4j, isTextKindBlock(editor, block), "not a text kind block");
     const caretRect = getTextCaretRect(block, createSimpleBlockPosition(block, offset, "normal"));
     const blockRect = block.getBoundingClientRect();
     const tools = getBlockTools(block);
@@ -14257,19 +14240,19 @@ var __publicField = (obj, key, value) => {
     return result + (index2 ? "-" : "") + word.toLowerCase();
   });
   const kebabCase$1 = kebabCase;
-  const logger$4j = getLogger("box");
+  const logger$4i = getLogger("box");
   function isBoxOp(op) {
     if (!op.attributes)
       return false;
     if (!op.attributes.box)
       return false;
-    assert(logger$4j, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
-    assert(logger$4j, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
+    assert(logger$4i, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
+    assert(logger$4i, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
     return true;
   }
-  const logger$4i = getLogger("text-op");
+  const logger$4h = getLogger("text-op");
   function getOpLength(op) {
-    assert(logger$4i, typeof op.insert === "string", "invalid op, no insert");
+    assert(logger$4h, typeof op.insert === "string", "invalid op, no insert");
     return op.insert.length;
   }
   function getOpAt(text2, offset) {
@@ -14277,7 +14260,7 @@ var __publicField = (obj, key, value) => {
     let pos = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$4i, typeof op.insert === "string", "invalid text op, no insert");
+      assert(logger$4h, typeof op.insert === "string", "invalid text op, no insert");
       const end = pos + getOpLength(op);
       if (end > offset) {
         return [op];
@@ -14293,22 +14276,22 @@ var __publicField = (obj, key, value) => {
     }
     return [];
   }
-  const logger$4h = getLogger("rich-text-length");
+  const logger$4g = getLogger("rich-text-length");
   function getTextOpLength(op) {
-    assert(logger$4h, typeof op.insert === "string", "op.insert is not string");
+    assert(logger$4g, 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$4h, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$4g, typeof op.insert === "string", "op.insert is not string");
         count += getTextOpLength(op);
       }
     });
     return count;
   }
-  const logger$4g = getLogger("split-text");
+  const logger$4f = getLogger("split-text");
   function splitText(ops, offset, splitResult) {
     ops = cloneDeep__default.default(ops);
     if (offset === 0) {
@@ -14326,8 +14309,8 @@ var __publicField = (obj, key, value) => {
     let counted = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$4g, typeof op === "object", `invalid op type, ${typeof op}`);
-      assert(logger$4g, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
+      assert(logger$4f, typeof op === "object", `invalid op type, ${typeof op}`);
+      assert(logger$4f, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
       const subLen = getTextOpLength(op);
       if (counted + subLen < offset) {
         counted += subLen;
@@ -14337,18 +14320,18 @@ var __publicField = (obj, key, value) => {
           right: ops.slice(i + 1)
         };
       } else {
-        assert(logger$4g, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
+        assert(logger$4f, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
         const splitIndex = offset - counted;
         const copied = cloneDeep__default.default(op);
-        assert(logger$4g, copied.insert, "no copied.insert");
-        assert(logger$4g, typeof copied.insert === "string", "invalid copied.insert type");
+        assert(logger$4f, copied.insert, "no copied.insert");
+        assert(logger$4f, 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$4g, false, "invalid copied.insert, is empty string");
+          assert(logger$4f, false, "invalid copied.insert, is empty string");
         }
         if (op.insert === "") {
-          assert(logger$4g, false, "invalid op.insert, is empty string");
+          assert(logger$4f, false, "invalid op.insert, is empty string");
         }
         const right = [
           op,
@@ -14367,9 +14350,9 @@ var __publicField = (obj, key, value) => {
     throw new Error(`invalid split offset: ${offset}, ${JSON.stringify(ops)}`);
   }
   function splitToThree(text2, offset, length) {
-    assert(logger$4g, offset >= 0, "invalid offset, < 0");
-    assert(logger$4g, length > 0, "invalid length, <= 0");
-    assert(logger$4g, offset + length <= getTextLength(text2), "invalid offset + length < text length");
+    assert(logger$4f, offset >= 0, "invalid offset, < 0");
+    assert(logger$4f, length > 0, "invalid length, <= 0");
+    assert(logger$4f, 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 };
@@ -14592,9 +14575,9 @@ var __publicField = (obj, key, value) => {
     }
     return [color, backgroundColor];
   }
-  const logger$4f = getLogger("text-block-content");
+  const logger$4e = getLogger("text-block-content");
   function updateBlockContentCore(editor, blockPath, content, blockText, insertions) {
-    assert(logger$4f, blockText, "no text for block");
+    assert(logger$4e, blockText, "no text for block");
     if (blockText.length === 0 && (!insertions || insertions.size === 0)) {
       content.innerHTML = "<span><br></span>";
       return;
@@ -14626,9 +14609,9 @@ var __publicField = (obj, key, value) => {
       for (let i2 = 0; i2 < text2.length; i2++) {
         const op = text2[i2];
         if (isBoxOp(op)) {
-          assert(logger$4f, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
+          assert(logger$4e, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
           const span2 = editor.editorBoxes.createBox(content, op.attributes);
-          assert(logger$4f, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
+          assert(logger$4e, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
           const ret = editor.editorBlockRenders.renderBox(blockPath, op.attributes);
           if (ret.classes) {
             addClass(span2, ...ret.classes);
@@ -14646,7 +14629,7 @@ var __publicField = (obj, key, value) => {
           fragment.appendChild(span2);
           continue;
         }
-        assert(logger$4f, op.insert, `no insert in op: ${JSON.stringify(op)}`);
+        assert(logger$4e, 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);
@@ -14677,7 +14660,7 @@ var __publicField = (obj, key, value) => {
     const compositionText = editor.compositingText;
     if (compositionText) {
       const pos = editor.selection.range.start;
-      assert(logger$4f, pos.isSimple(), "not an simple position while compositing");
+      assert(logger$4e, pos.isSimple(), "not an simple position while compositing");
       if (pos.blockId === blockId) {
         const attributes = getAttributesAt(text2, 0);
         insertions.set(pos.offset, [{
@@ -14693,11 +14676,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$4f.debug(`remove ${children.length} temp composition span`);
+      logger$4e.debug(`remove ${children.length} temp composition span`);
     }
     Array.from(children).forEach((c) => c.remove());
   }
-  const logger$4e = getLogger("client-rects");
+  const logger$4d = getLogger("client-rects");
   function getChildrenOffsets(block) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -14715,15 +14698,15 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function getChildrenInRange(editor, block, from, to) {
-    assert(logger$4e, from < to, `invalid from & to: ${from}, ${to}`);
+    assert(logger$4d, from < to, `invalid from & to: ${from}, ${to}`);
     const blockLength = getBlockTextLength$6(editor, block);
-    assert(logger$4e, from >= 0 && to >= 0 && from <= blockLength && to <= blockLength, `invalid offset: ${from}, ${to}, length: ${blockLength}`);
+    assert(logger$4d, 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$4e, startIndex !== -1, "failed to find start child");
-    assert(logger$4e, endIndex !== -1, "failed to find end child");
-    assert(logger$4e, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
+    assert(logger$4d, startIndex !== -1, "failed to find start child");
+    assert(logger$4d, endIndex !== -1, "failed to find end child");
+    assert(logger$4d, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
     if (startIndex === endIndex) {
       const child = offsets[startIndex];
       return [{
@@ -14805,16 +14788,16 @@ var __publicField = (obj, key, value) => {
     return rects;
   }
   function getRangeClientRects(editor, block, range) {
-    assert(logger$4e, range instanceof EditorSimpleSelectionRange, "invalid range");
+    assert(logger$4d, range instanceof EditorSimpleSelectionRange, "invalid range");
     const start = range.start;
     const end = range.end;
-    assert(logger$4e, start.isSimple(), "text block only allow simple position");
-    assert(logger$4e, end.isSimple(), "text block only allow simple position");
-    assert(logger$4e, start.blockId === end.blockId, "only allow update one text block selection");
-    assert(logger$4e, start.blockId === getBlockId(block), "only allow update one text block selection");
+    assert(logger$4d, start.isSimple(), "text block only allow simple position");
+    assert(logger$4d, end.isSimple(), "text block only allow simple position");
+    assert(logger$4d, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$4d, start.blockId === getBlockId(block), "only allow update one text block selection");
     return getClientRects$2(editor, block, start, end);
   }
-  const logger$4d = getLogger("selection-background");
+  const logger$4c = getLogger("selection-background");
   function getLineHeight(elem) {
     const style2 = window.getComputedStyle(elem);
     const lineHeightStyle = style2.getPropertyValue("line-height");
@@ -14834,9 +14817,9 @@ var __publicField = (obj, key, value) => {
     return lineHeight;
   }
   function updateSelection$4(editor, block, start, end) {
-    assert(logger$4d, start.isSimple(), "text block only allow simple position");
-    assert(logger$4d, end.isSimple(), "text block only allow simple position");
-    assert(logger$4d, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$4c, start.isSimple(), "text block only allow simple position");
+    assert(logger$4c, end.isSimple(), "text block only allow simple position");
+    assert(logger$4c, start.blockId === end.blockId, "only allow update one text block selection");
     const from = start.offset;
     const to = end.offset;
     if (from === to) {
@@ -14895,7 +14878,7 @@ var __publicField = (obj, key, value) => {
       }
     });
   }
-  const logger$4c = getLogger("line-breaker");
+  const logger$4b = getLogger("line-breaker");
   function mergeTextRects(rects) {
     const result = [];
     let lastRect = null;
@@ -15022,7 +15005,7 @@ var __publicField = (obj, key, value) => {
       }
       const textChild = child;
       const rects = mergeTextRects(textChild.getClientRects());
-      assert(logger$4c, rects.length > 0, "invalid text child dom");
+      assert(logger$4b, rects.length > 0, "invalid text child dom");
       if (rects.length === 1) {
         const nextChild = children[i + 1];
         if (!nextChild) {
@@ -15047,10 +15030,10 @@ var __publicField = (obj, key, value) => {
         continue;
       }
       const textNode = textChild.firstChild;
-      assert(logger$4c, textNode, "invalid text child, no text node");
-      assert(logger$4c, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
+      assert(logger$4b, textNode, "invalid text child, no text node");
+      assert(logger$4b, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
       const textChildLength = getTextBlockContentChildTextLength(textChild);
-      assert(logger$4c, textNode.data.length === textChildLength, "text node data length not equal child text length");
+      assert(logger$4b, 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];
@@ -15092,7 +15075,7 @@ var __publicField = (obj, key, value) => {
         }
       }
     }
-    assert(logger$4c, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
+    assert(logger$4b, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
     return {
       lineIndex: lineBreaks.length,
       lineBreaks
@@ -23865,7 +23848,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$4b = getLogger("text-offset");
+  const logger$4a = getLogger("text-offset");
   function getChildOffset(block, child) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -23881,26 +23864,26 @@ var __publicField = (obj, key, value) => {
       }
       start += testLength;
     }
-    assert(logger$4b, false, "can not find child in children");
+    assert(logger$4a, false, "can not find child in children");
   }
   function isValidOffset(block, blockOffset) {
-    assert(logger$4b, blockOffset >= 0, `invalid offset: ${blockOffset}`);
+    assert(logger$4a, blockOffset >= 0, `invalid offset: ${blockOffset}`);
     const childInfo = getTextBlockChild(block, blockOffset);
     const { prev, next: next2, offset } = childInfo;
     if (!prev && !next2) {
-      assert(logger$4b, false, "invalid offset, no prev & next child at offset");
+      assert(logger$4a, false, "invalid offset, no prev & next child at offset");
     }
     if (prev !== next2) {
       return true;
     }
     const child = prev;
-    assert(logger$4b, child, "no child");
+    assert(logger$4a, child, "no child");
     if (isTextBlockContentBoxChild(child)) {
-      assert(logger$4b, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
+      assert(logger$4a, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
       return true;
     }
     const text2 = child.textContent;
-    assert(logger$4b, text2, "no content for text child");
+    assert(logger$4a, text2, "no content for text child");
     const chars = splitter.splitGraphemes(text2);
     const validOffsets = /* @__PURE__ */ new Set();
     let start = 0;
@@ -23930,7 +23913,7 @@ var __publicField = (obj, key, value) => {
   }
   function getNextValidOffset(block, blockOffset) {
     const length = getTextBlockLength(block);
-    assert(logger$4b, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
+    assert(logger$4a, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
     if (blockOffset === length) {
       return length;
     }
@@ -23944,7 +23927,7 @@ var __publicField = (obj, key, value) => {
     }
     return ret;
   }
-  const logger$4a = getLogger("line-offset");
+  const logger$49 = getLogger("line-offset");
   function getLineOffsets(block) {
     const lineBreaks = getLineBreaks(block);
     const ret = [];
@@ -23965,7 +23948,7 @@ var __publicField = (obj, key, value) => {
   }
   function getLineOffset(block, lineIndex) {
     const lines = getLineOffsets(block);
-    assert(logger$4a, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
+    assert(logger$49, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
     return lines[lineIndex];
   }
   function getLineOffsetByPos(block, pos) {
@@ -24022,7 +24005,7 @@ var __publicField = (obj, key, value) => {
   function getLineCount(block) {
     return getLineOffsets(block).length;
   }
-  const logger$49 = getLogger("find-text-position");
+  const logger$48 = getLogger("find-text-position");
   function isWrappedLine(block, lineIndex) {
     const { start, end } = getLineOffset(block, lineIndex);
     const blockId = getBlockId(block);
@@ -24033,13 +24016,13 @@ var __publicField = (obj, key, value) => {
       return false;
     }
     const childInfo = getTextBlockChild(block, start);
-    assert(logger$49, childInfo.next, "no next child at offset");
-    assert(logger$49, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
+    assert(logger$48, childInfo.next, "no next child at offset");
+    assert(logger$48, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
     return true;
   }
   function getWrappedLineOffsets(block, lineIndex) {
     const blockId = getBlockId(block);
-    assert(logger$49, isWrappedLine(block, lineIndex), "line is not wrapped");
+    assert(logger$48, 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) {
@@ -24054,11 +24037,11 @@ var __publicField = (obj, key, value) => {
         return offset - 1;
       }
     }
-    assert(logger$49, false, "failed to find wrapped offset");
+    assert(logger$48, false, "failed to find wrapped offset");
     return 0;
   }
   function findTextPositionInLine(editor, block, lineIndex, sourceBlock, pos, findDirection, suggestedX) {
-    assert(logger$49, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
+    assert(logger$48, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
     const { start, end } = getLineOffset(block, lineIndex);
     let from = start;
     const blockId = getBlockId(block);
@@ -24100,11 +24083,11 @@ var __publicField = (obj, key, value) => {
     return retPos;
   }
   function findPrevTextBlockPosition(editor, block, sourceBlock, pos, suggestedX) {
-    assert(logger$49, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$48, 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$49, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$48, isTextKindBlock(editor, block), "not a text block");
     return findTextPositionInLine(editor, block, 0, sourceBlock, pos, "down", suggestedX);
   }
   function moveDown(editor, block, position, suggestedX) {
@@ -24212,7 +24195,7 @@ var __publicField = (obj, key, value) => {
     }
     return pos;
   }
-  const logger$48 = getLogger("move-caret");
+  const logger$47 = getLogger("move-caret");
   function moveTextCaret(editor, block, position, direction) {
     if (direction === "ArrowLeft") {
       const ret = moveLeft(block, position);
@@ -24242,9 +24225,9 @@ var __publicField = (obj, key, value) => {
       }
       return createSimpleBlockPosition(getBlockId(block), ret.offset, ret.type);
     }
-    assert(logger$48, false, `invalid navigation direction: ${direction}`);
+    assert(logger$47, false, `invalid navigation direction: ${direction}`);
   }
-  const logger$47 = getLogger("text-range");
+  const logger$46 = getLogger("text-range");
   function getBlockRects(block) {
     const ret = [];
     const children = getTextBlockContentChildren(block);
@@ -24302,9 +24285,9 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const children = getTextBlockContentChildren(block);
-    assert(logger$47, children.indexOf(child) !== -1, "failed to find child in children");
+    assert(logger$46, children.indexOf(child) !== -1, "failed to find child in children");
     const offsetInfo = getChildOffset(block, child);
-    assert(logger$47, offsetInfo, "failed to get child offset");
+    assert(logger$46, offsetInfo, "failed to get child offset");
     const { start } = offsetInfo;
     let offset;
     let length;
@@ -24320,7 +24303,7 @@ var __publicField = (obj, key, value) => {
       }
       length = 0;
     } else {
-      assert(logger$47, child.firstChild instanceof Text, "child is not text");
+      assert(logger$46, child.firstChild instanceof Text, "child is not text");
       offset = start + textNodeOffsetFromPoint(child.firstChild, x, y);
       length = 0;
     }
@@ -24344,9 +24327,9 @@ var __publicField = (obj, key, value) => {
     }
     return new EditorSimpleSelectionRange(editor, { anchor: startPos, focus: endPos != null ? endPos : startPos });
   }
-  const logger$46 = getLogger("create-text-op");
+  const logger$45 = getLogger("create-text-op");
   function createTextOp(text2, attributes) {
-    assert(logger$46, text2, "text is empty");
+    assert(logger$45, text2, "text is empty");
     const ret = {
       insert: text2
     };
@@ -24369,7 +24352,7 @@ var __publicField = (obj, key, value) => {
     }
     return result;
   }
-  const logger$45 = getLogger("merge-ops");
+  const logger$44 = getLogger("merge-ops");
   function mergeOps(text2) {
     if (text2.length <= 1) {
       return text2;
@@ -24391,10 +24374,10 @@ var __publicField = (obj, key, value) => {
         return false;
       }
       if (op1.attributes === void 0) {
-        assert(logger$45, op2.attributes === void 0, "op2.attributes is not undefined");
+        assert(logger$44, op2.attributes === void 0, "op2.attributes is not undefined");
         return true;
       }
-      assert(logger$45, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
+      assert(logger$44, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
       return isEqual__default.default(op1.attributes, op2.attributes);
     };
     const newOps = [];
@@ -24403,8 +24386,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$45, typeof before.insert === "string", "before.insert is not string");
-        assert(logger$45, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$44, typeof before.insert === "string", "before.insert is not string");
+        assert(logger$44, typeof op.insert === "string", "op.insert is not string");
         before.insert += op.insert;
       } else {
         newOps.push(op);
@@ -24432,15 +24415,15 @@ var __publicField = (obj, key, value) => {
     }
     return text2.slice(0, i + 1);
   }
-  const logger$44 = getLogger("delete-text");
+  const logger$43 = 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$44, offset >= 0, `invalid offset: ${offset}`);
-    assert(logger$44, count >= 1, `invalid delete count: ${count}`);
+    assert(logger$43, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$43, count >= 1, `invalid delete count: ${count}`);
     const ops = [];
     if (offset !== 0) {
       ops.push({
@@ -24452,7 +24435,7 @@ var __publicField = (obj, key, value) => {
     });
     return ops;
   }
-  const logger$43 = getLogger("delta");
+  const logger$42 = getLogger("delta");
   function diffRichText(oldText, newText) {
     const delta1D = new Delta__default.default(oldText);
     const delta2D = new Delta__default.default(newText);
@@ -24462,7 +24445,7 @@ var __publicField = (obj, key, value) => {
     return new Delta__default.default(ops).transformPosition(cursor, !isLocalOp);
   }
   function isValidDocText(text2) {
-    assert(logger$43, text2, "ops is null or undefined");
+    assert(logger$42, 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) {
@@ -24482,7 +24465,7 @@ var __publicField = (obj, key, value) => {
   }
   class RichText {
     static ensureValidText(text2) {
-      assert(logger$43, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
+      assert(logger$42, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
     }
     static diff(oldText, newText) {
       this.ensureValidText(oldText);
@@ -24504,9 +24487,9 @@ var __publicField = (obj, key, value) => {
       return resultText;
     }
   }
-  const logger$42 = getLogger("insert-text");
+  const logger$41 = getLogger("insert-text");
   function insertText(richText2, offset, text2, attributes) {
-    assert(logger$42, text2, `invalid text to insert: ${text2}`);
+    assert(logger$41, 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];
@@ -24519,7 +24502,7 @@ var __publicField = (obj, key, value) => {
     };
   }
   function createInsertOps(offset, text2, attributes) {
-    assert(logger$42, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$41, offset >= 0, `invalid offset: ${offset}`);
     if (text2.length === 0) {
       return [];
     }
@@ -24549,7 +24532,7 @@ var __publicField = (obj, key, value) => {
   function cloneText(text2) {
     return cloneDeep__default.default(text2);
   }
-  const logger$41 = getLogger("update-op-attribute");
+  const logger$40 = getLogger("update-op-attribute");
   function updateOpAttributes(orgOps, key, value, newAttributes) {
     const ops = cloneText(orgOps);
     const index2 = ops.findIndex((op2) => {
@@ -24557,7 +24540,7 @@ var __publicField = (obj, key, value) => {
         return false;
       return op2.attributes[key] === value;
     });
-    assert(logger$41, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
+    assert(logger$40, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
     const op = ops[index2];
     op.attributes = {
       ...op.attributes,
@@ -24639,11 +24622,11 @@ var __publicField = (obj, key, value) => {
     ]);
   }
   const FILL_CHAR = "\u200B";
-  const logger$40 = getLogger("to-plain-text");
+  const logger$3$ = getLogger("to-plain-text");
   function toPlainText(ops, options) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$40, typeof op.insert === "string", "invalid op");
+      assert(logger$3$, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         if (options == null ? void 0 : options.boxReplacement) {
           text2 += options.boxReplacement;
@@ -24698,11 +24681,11 @@ var __publicField = (obj, key, value) => {
       focus: pos
     };
   }
-  const logger$3$ = getLogger("block-to-text");
+  const logger$3_ = getLogger("block-to-text");
   function textBlockToText$1(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3$, typeof op.insert === "string", "invalid op");
+      assert(logger$3_, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -24720,11 +24703,11 @@ var __publicField = (obj, key, value) => {
     });
     return text2;
   }
-  const logger$3_ = getLogger("block-to-text");
+  const logger$3Z = getLogger("block-to-text");
   function textToMarkdownText(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3_, typeof op.insert === "string", "invalid op");
+      assert(logger$3Z, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -24847,12 +24830,12 @@ var __publicField = (obj, key, value) => {
         return void 0;
     }
   }
-  const logger$3Z = getLogger("block-to-text");
+  const logger$3Y = getLogger("block-to-text");
   function textBlockToHtml(editor, blockData, doc2) {
     let html = "";
     const ops = blockData.text || [];
     ops.forEach((op) => {
-      assert(logger$3Z, typeof op.insert === "string", "invalid op");
+      assert(logger$3Y, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -24928,16 +24911,16 @@ var __publicField = (obj, key, value) => {
     }
     return `<p>${html}</p>`;
   }
-  const logger$3Y = getLogger("text-block");
+  const logger$3X = getLogger("text-block");
   function createBlockContent$5(editor, path, container, blockElement, blockData) {
     const { text: text2 } = blockData;
-    assert(logger$3Y, text2, "no text for text block");
+    assert(logger$3X, 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$3Y, text2, "no text to update");
+    assert(logger$3X, text2, "no text to update");
     const newContent = createBlockContentElement(null, "div");
     updateBlockContent$1(editor, getBlockPath(block), getBlockId(block), newContent, text2);
     const oldContent = getBlockContent(block);
@@ -24947,7 +24930,7 @@ var __publicField = (obj, key, value) => {
     return getRangeClientRects(editor, block, range);
   }
   function convertTo$k(editor, blockData, doc2, type) {
-    assert(logger$3Y, blockData.text, "no text for text block");
+    assert(logger$3X, blockData.text, "no text for text block");
     if (type === "text") {
       return textBlockToText$1(editor, blockData.text, doc2);
     }
@@ -24961,7 +24944,7 @@ var __publicField = (obj, key, value) => {
     blockData.id = genId();
     info == null ? void 0 : info.blockIdMap.set(srcBlockData.id, blockData.id);
     const { text: text2 } = blockData;
-    assert(logger$3Y, text2, "no text for text block");
+    assert(logger$3X, text2, "no text for text block");
     text2.forEach((op) => {
       if (op.insert && op.attributes && op.attributes.box === true) {
         const boxId = genId();
@@ -24993,7 +24976,7 @@ var __publicField = (obj, key, value) => {
     blockToDoc: blockToDoc$1
   };
   const updateTextBlockContent = updateBlockContent$1;
-  const logger$3X = getLogger("action-helper");
+  const logger$3W = getLogger("action-helper");
   function editorGetBlockData(editor, block) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -25001,10 +24984,10 @@ var __publicField = (obj, key, value) => {
     return editor.doc.getBlockData(containerId, blockIndex);
   }
   function editorGetBlockText(editor, block) {
-    assert(logger$3X, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3W, isTextKindBlock(editor, block), "not a text kind block");
     const data2 = editorGetBlockData(editor, block);
     const text2 = data2.text;
-    assert(logger$3X, text2, "no text in block");
+    assert(logger$3W, text2, "no text in block");
     return text2;
   }
   function editorGetBlockTextEx(editor, block, length) {
@@ -25012,7 +24995,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetBoxData(editor, box) {
     const block = getParentBlock(box);
-    assert(logger$3X, block, "no parent block");
+    assert(logger$3W, block, "no parent block");
     const text2 = editorGetBlockText(editor, block);
     const id = getBoxId(box);
     const op = text2.find((op2) => {
@@ -25022,60 +25005,60 @@ var __publicField = (obj, key, value) => {
       }
       return false;
     });
-    assert(logger$3X, op, "failed to find box");
+    assert(logger$3W, op, "failed to find box");
     return op.attributes;
   }
-  const logger$3W = getLogger("block-text");
+  const logger$3V = getLogger("block-text");
   function getTextAfterOffset(editor, block, offset) {
-    assert(logger$3W, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3W, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3W, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3V, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3V, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3V, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3W, false, `no text after offset: ${offset}`);
+      assert(logger$3V, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3W, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3V, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3W, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3V, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getTextBeforeOffset(editor, block, offset) {
-    assert(logger$3W, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3W, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3W, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3V, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3V, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3V, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3W, false, `no text before offset: ${offset}`);
+      assert(logger$3V, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3W, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3V, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3W, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3V, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getOffsetInfoBefore(editor, block, offset) {
-    assert(logger$3W, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3W, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3W, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3V, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3V, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3V, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3W, false, `no text before offset: ${offset}`);
+      assert(logger$3V, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3W, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3V, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -25085,33 +25068,25 @@ var __publicField = (obj, key, value) => {
         length: 1
       };
     }
-    let charType = "text";
-    if (isSpace(op.insert)) {
-      charType = "space";
-    } else if (isCJKPunctuation(op.insert)) {
-      charType = "cjk_punctuation";
-    } else if (isCJK(op.insert)) {
-      charType = "cjk";
-    }
     return {
       op,
-      charType,
+      charType: isSpace(op.insert) ? "space" : "text",
       offset: newOffset,
       length: op.insert.length
     };
   }
   function getOffsetInfoAfter(editor, block, offset) {
-    assert(logger$3W, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3W, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3W, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3V, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3V, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3V, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3W, false, `no text after offset: ${offset}`);
+      assert(logger$3V, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3W, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3V, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -25121,17 +25096,9 @@ var __publicField = (obj, key, value) => {
         length: 1
       };
     }
-    let charType = "text";
-    if (isSpace(op.insert)) {
-      charType = "space";
-    } else if (isCJKPunctuation(op.insert)) {
-      charType = "cjk_punctuation";
-    } else if (isCJK(op.insert)) {
-      charType = "cjk";
-    }
     return {
       op,
-      charType,
+      charType: isSpace(op.insert) ? "space" : "text",
       offset,
       length: op.insert.length
     };
@@ -25183,7 +25150,7 @@ var __publicField = (obj, key, value) => {
     return null;
   }
   function findWordLeft(editor, block, offset) {
-    assert(logger$3W, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3V, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -25192,7 +25159,6 @@ var __publicField = (obj, key, value) => {
       return offset - 1;
     }
     let start = offset;
-    let find = offsetInfo.charType;
     if (offsetInfo.charType === "space") {
       const startInfo2 = findPrevOffsetNotType(editor, block, start, "space");
       if (!startInfo2) {
@@ -25205,15 +25171,14 @@ var __publicField = (obj, key, value) => {
         return startInfo2.offset;
       }
       start = startInfo2.offset;
-      find = getOffsetInfoBefore(editor, block, start).charType;
     }
-    const startInfo = findPrevOffsetNotType(editor, block, start, find);
+    const startInfo = findPrevOffsetNotType(editor, block, start, "text");
     if (!startInfo)
       return 0;
     return startInfo.offset + startInfo.length;
   }
   function findWordEnd(editor, block, offset) {
-    assert(logger$3W, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3V, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -25222,7 +25187,6 @@ var __publicField = (obj, key, value) => {
       return offset + 1;
     }
     let start = offset;
-    let find = offsetInfo.charType;
     if (offsetInfo.charType === "space") {
       const startInfo2 = findAfterOffsetNotType(editor, block, start, "space");
       if (!startInfo2) {
@@ -25235,17 +25199,16 @@ var __publicField = (obj, key, value) => {
         return startInfo2.offset;
       }
       start = startInfo2.offset;
-      find = getOffsetInfoAfter(editor, block, start).charType;
     }
-    const startInfo = findAfterOffsetNotType(editor, block, start, find);
+    const startInfo = findAfterOffsetNotType(editor, block, start, "text");
     if (!startInfo)
       return getBlockTextLength$6(editor, block);
     return startInfo.offset;
   }
-  const logger$3V = getLogger("text-box");
+  const logger$3U = getLogger("text-box");
   function updateBoxContent$8(editor, boxElement, boxContent, boxData) {
-    assert(logger$3V, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
-    assert(logger$3V, typeof boxData.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3U, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3U, typeof boxData.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
     createElement("span", [], boxContent, boxData.text);
   }
   function convertTo$j(editor, boxData, doc2, type) {
@@ -25279,7 +25242,7 @@ var __publicField = (obj, key, value) => {
     updateBoxContent: updateBoxContent$7,
     convertTo: convertTo$i
   };
-  const logger$3U = getLogger("editor-boxes");
+  const logger$3T = getLogger("editor-boxes");
   class EditorBoxes {
     constructor(editor) {
       __publicField(this, "boxes", /* @__PURE__ */ new Map());
@@ -25288,12 +25251,12 @@ var __publicField = (obj, key, value) => {
     registerBoxClass(boxClass) {
       const type = boxClass.boxType;
       const exists = this.boxes.get(type);
-      assert(logger$3U, !exists, `duplicated box type: ${type}`);
+      assert(logger$3T, !exists, `duplicated box type: ${type}`);
       this.boxes.set(type, boxClass);
     }
     getBoxClass(type) {
       const exists = this.boxes.get(type);
-      assert(logger$3U, exists, `unknown box type: ${type}`);
+      assert(logger$3T, exists, `unknown box type: ${type}`);
       return exists;
     }
     createBox(blockContent, box) {
@@ -25658,7 +25621,7 @@ var __publicField = (obj, key, value) => {
       return { classes, attributes: newAttributes, styles: newStyles };
     }
   }
-  const logger$3T = getLogger("editor-insertion");
+  const logger$3S = getLogger("editor-insertion");
   class EditorInsertions {
     constructor(editor) {
       __publicField(this, "insertions", /* @__PURE__ */ new Map());
@@ -25667,12 +25630,12 @@ var __publicField = (obj, key, value) => {
     registerInsertionClass(insertionClass) {
       const type = insertionClass.insertionType;
       const exists = this.insertions.get(type);
-      assert(logger$3T, !exists, `duplicated insertion type: ${type}`);
+      assert(logger$3S, !exists, `duplicated insertion type: ${type}`);
       this.insertions.set(type, insertionClass);
     }
     getInsertionClass(type) {
       const exists = this.insertions.get(type);
-      assert(logger$3T, exists, `unknown insertion type: ${type}`);
+      assert(logger$3S, exists, `unknown insertion type: ${type}`);
       return exists;
     }
     createInsertionElement(type, id, attributes) {
@@ -25792,7 +25755,7 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$3S = getLogger("editor-input");
+  const logger$3R = getLogger("editor-input");
   class EditorInput$1 {
     constructor(editor, callbacks) {
       __publicField(this, "editor");
@@ -25914,7 +25877,7 @@ var __publicField = (obj, key, value) => {
           return;
         }
         this.callbacks.onCut(event);
-        logger$3S.debug("on cut");
+        logger$3R.debug("on cut");
       });
       __publicField(this, "handlePaste", (event) => {
         if (event.isTrusted) {
@@ -26029,11 +25992,11 @@ var __publicField = (obj, key, value) => {
       this.callbacks.removeHandler(handler);
     }
     defaultInsertText(editor, containerId, blockIndex, offset, text2) {
-      assert(logger$3S, editor === this.editor, "invalid editor");
+      assert(logger$3R, editor === this.editor, "invalid editor");
       this.callbacks.defaultInsertText(editor, containerId, blockIndex, offset, text2);
     }
     defaultHandleKeydown(editor, event) {
-      assert(logger$3S, editor === this.editor, "invalid editor");
+      assert(logger$3R, editor === this.editor, "invalid editor");
       return this.callbacks.defaultHandleKeydown(editor, event);
     }
     forEach(callback) {
@@ -26058,7 +26021,7 @@ var __publicField = (obj, key, value) => {
     input2.style.left = `${x / scale}px`;
     input2.style.top = `${y / scale}px`;
   }
-  const logger$3R = getLogger("editor-caret");
+  const logger$3Q = getLogger("editor-caret");
   function getFirefoxVersion() {
     const userAgent = window.navigator.userAgent;
     const match = userAgent.match(/Firefox\/(\d+)\./);
@@ -26121,11 +26084,11 @@ var __publicField = (obj, key, value) => {
         return;
       }
       const { range } = this.editor.selection;
-      assert(logger$3R, range.isCollapsed, "range is not collapsed");
+      assert(logger$3Q, range.isCollapsed, "range is not collapsed");
       const pos = range.start;
-      assert(logger$3R, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
+      assert(logger$3Q, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
       const block = this.editor.getBlockById(pos.blockId);
-      assert(logger$3R, isTextKindBlock(this.editor, block), "only text kind block can has caret");
+      assert(logger$3Q, isTextKindBlock(this.editor, block), "only text kind block can has caret");
       let rect;
       const compositionSpan = block.querySelector("span.inputting-insertion");
       if (compositionSpan) {
@@ -26163,7 +26126,7 @@ var __publicField = (obj, key, value) => {
     clearAllSelection(editor);
     editor.selection.range.getSelectedBlocks().forEach((s) => updateBlockSelection(editor, s.block, s.start, s.end));
   }
-  const logger$3Q = getLogger("editor-dom");
+  const logger$3P = getLogger("editor-dom");
   function editorGetClientHeight(editor) {
     const scrollContainer = getScrollContainer$1(editor.rootContainer);
     return scrollContainer.clientHeight;
@@ -26251,7 +26214,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorScrollIntoView(editor) {
     if (!isElementVisible(editor.rootContainer)) {
-      logger$3Q.warn("editorScrollIntoView: editor is not visible");
+      logger$3P.warn("editorScrollIntoView: editor is not visible");
       return;
     }
     const rootClientRect = editor.rootContainer.getBoundingClientRect();
@@ -26316,7 +26279,7 @@ var __publicField = (obj, key, value) => {
     const { start, end } = range;
     return start.blockId === getBlockId(firstChildBlock) && start.offset === 0 && end.blockId === getBlockId(lastChildBlock) && end.offset === getBlockTextLength$6(editor, lastChildBlock);
   }
-  const logger$3P = getLogger("range-in-block");
+  const logger$3O = getLogger("range-in-block");
   function rangeInBlock(block, range) {
     const editor = range.getEditor();
     const start = editor.getBlockById(range.start.blockId);
@@ -26337,16 +26300,16 @@ var __publicField = (obj, key, value) => {
       while (prevBlock && !blocks.has(getBlockId(prevBlock))) {
         prevBlock = getPrevVisibleBlock(prevBlock);
       }
-      assert(logger$3P, prevBlock, "no prev block while deleting a block");
+      assert(logger$3O, prevBlock, "no prev block while deleting a block");
       newRange = createBlockSimpleRange(editor, prevBlock, getBlockTextLength$6(editor, prevBlock));
     } else {
       const nextBlock = getNextVisibleBlock(block);
-      assert(logger$3P, nextBlock, "no prev and next block while deleting a block");
+      assert(logger$3O, nextBlock, "no prev and next block while deleting a block");
       newRange = createBlockSimpleRange(editor, nextBlock, 0);
     }
     return newRange;
   }
-  const logger$3O = getLogger("block-to-html");
+  const logger$3N = getLogger("block-to-html");
   function blockToHtml(editor, blockData, doc2, path) {
     const blockClass = getBlockClassByType(editor, blockData.type);
     if (blockClass.convertTo) {
@@ -26355,15 +26318,15 @@ var __publicField = (obj, key, value) => {
     if (blockClass.blockKind !== "text") {
       return `[${blockData.type}]`;
     }
-    assert(logger$3O, blockData.text, "no text");
+    assert(logger$3N, blockData.text, "no text");
     const plainText = toPlainText(blockData.text);
     return `<div>${escapeHtmlText(plainText)}</div>`;
   }
-  const logger$3N = getLogger("block-to-text");
+  const logger$3M = getLogger("block-to-text");
   function textBlockToText(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3N, 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);
@@ -26389,7 +26352,7 @@ var __publicField = (obj, key, value) => {
     if (blockClass.blockKind !== "text") {
       return `[${blockData.type}]`;
     }
-    assert(logger$3N, blockData.text, "no text");
+    assert(logger$3M, blockData.text, "no text");
     const plainText = textBlockToText(editor, blockData.text, doc2);
     return plainText;
   }
@@ -26422,11 +26385,11 @@ var __publicField = (obj, key, value) => {
     const markdown = lines.join("\n");
     return markdown;
   }
-  const logger$3M = getLogger("get-text-position");
+  const logger$3L = getLogger("get-text-position");
   function editorGetTextPosition(editor, insertPos) {
     const pos = insertPos != null ? insertPos : editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3M, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3L, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
@@ -26514,14 +26477,14 @@ var __publicField = (obj, key, value) => {
       return attributes;
     }
   }
-  const logger$3L = getLogger("insert-text");
+  const logger$3K = getLogger("insert-text");
   function getTextAttributes(editor, containerId, blockIndex, offset) {
     var _a, _b;
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3L, blockData, "no block data");
-    assert(logger$3L, blockData.text, "no block text");
+    assert(logger$3K, blockData, "no block data");
+    assert(logger$3K, blockData.text, "no block text");
     if (getTextLength(blockData.text) === 0) {
-      assert(logger$3L, offset === 0, "invalid text offset");
+      assert(logger$3K, offset === 0, "invalid text offset");
       return BlockAttributesHandler.get(editor).getEmptyBlockTextAttributes(blockData.id);
     }
     if (offset === 0) {
@@ -26568,7 +26531,7 @@ var __publicField = (obj, key, value) => {
     }
     for (let i = 0; i < text2.length; i++) {
       const op = text2[i];
-      assert(logger$3L, typeof op.insert === "string", "invalid text op, no insert");
+      assert(logger$3K, typeof op.insert === "string", "invalid text op, no insert");
       const endPos = pos + getOpLength(op);
       if (endPos === start) {
         return false;
@@ -26582,8 +26545,8 @@ var __publicField = (obj, key, value) => {
   }
   function editorInsertTextToBlockEx(editor, text2, containerId, blockIndex, offset) {
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3L, blockData, "no block data");
-    assert(logger$3L, blockData.text, "no block text");
+    assert(logger$3K, blockData, "no block data");
+    assert(logger$3K, blockData.text, "no block text");
     const attributes = getTextAttributes(editor, containerId, blockIndex, offset);
     if (attributes && Object.keys(attributes).includes("link")) {
       const inOp = checkRangeInOp(blockData.text, offset);
@@ -26602,21 +26565,21 @@ var __publicField = (obj, key, value) => {
     const { containerId, blockIndex, offset } = editorGetTextPosition(editor);
     editorInsertTextToBlockEx(editor, text2, containerId, blockIndex, offset);
   }
-  const logger$3K = getLogger("update-composition-text");
+  const logger$3J = getLogger("update-composition-text");
   function editorUpdateCompositionText(editor) {
     const pos = editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3K, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3J, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
-    assert(logger$3K, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3J, isTextKindBlock(editor, block), "not a text kind block");
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3K, blockData, "no block data in doc");
-    assert(logger$3K, blockData.text, "no text data in text block");
+    assert(logger$3J, blockData, "no block data in doc");
+    assert(logger$3J, blockData.text, "no text data in text block");
     const blockContent = getBlockContent(block);
     updateBlockContent$1(editor, getBlockPath(block), blockId, blockContent, blockData.text);
   }
@@ -26628,25 +26591,25 @@ var __publicField = (obj, key, value) => {
     const block = editor.getBlockById(blockData.id);
     return block;
   }
-  const logger$3J = getLogger("delete-block-text");
+  const logger$3I = getLogger("delete-block-text");
   function editorDeleteBlockText(editor, block, offset, count, options) {
     if (!editor.isBlockWritable(block)) {
-      logger$3J.error("block is not writable");
+      logger$3I.error("block is not writable");
       return 0;
     }
-    assert(logger$3J, isTextKindBlock(editor, block), "block is not a text kind block");
+    assert(logger$3I, isTextKindBlock(editor, block), "block is not a text kind block");
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3J, blockData, "no block data in doc");
-    assert(logger$3J, blockData.text, "no text data in text block");
+    assert(logger$3I, blockData, "no block data in doc");
+    assert(logger$3I, blockData.text, "no text data in text block");
     let from = offset;
     if (!isValidOffset(block, offset)) {
       from = getPrevValidOffset(block, from);
     }
     let to = offset + count;
-    assert(logger$3J, to <= getBlockTextLength$6(editor, block), `invalid offset and count: ${offset}, ${count}`);
+    assert(logger$3I, to <= getBlockTextLength$6(editor, block), `invalid offset and count: ${offset}, ${count}`);
     if (!isValidOffset(block, to)) {
       to = getNextValidOffset(block, to);
     }
@@ -26655,7 +26618,7 @@ var __publicField = (obj, key, value) => {
     editor.doc.localUpdateBlockText(containerId, blockIndex, actions2, options);
     return deleteCount;
   }
-  const logger$3I = getLogger("break-text-block");
+  const logger$3H = getLogger("break-text-block");
   function copyBlockAttributes(editor, block) {
     const blockData = editor.getBlockData(block);
     const quoted = blockData.quoted;
@@ -26667,8 +26630,8 @@ var __publicField = (obj, key, value) => {
     return {};
   }
   function editorBreakTextBlock(editor, block, offset, options) {
-    assert(logger$3I, isTextKindBlock(editor, block), `block is not a text kind block: ${getBlockType(block)}`);
-    assert(logger$3I, offset >= 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3H, isTextKindBlock(editor, block), `block is not a text kind block: ${getBlockType(block)}`);
+    assert(logger$3H, offset >= 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
@@ -26698,7 +26661,7 @@ var __publicField = (obj, key, value) => {
         };
       }
     }
-    assert(logger$3I, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3H, isValidOffset(block, offset), "not a valid offset");
     const text2 = editorGetBlockText(editor, block);
     const { right } = splitText(text2, offset);
     const rightLength = getTextLength(right);
@@ -26724,12 +26687,12 @@ var __publicField = (obj, key, value) => {
       newBlock
     };
   }
-  const logger$3H = getLogger("prepare-insert-new-block");
+  const logger$3G = getLogger("prepare-insert-new-block");
   function editorPrepareInsertNewBlock(editor, containerId, blockIndex) {
     if (containerId && blockIndex !== void 0 && blockIndex !== null) {
       const container = editor.getContainerById(containerId);
       const blocks = getChildBlocks(container);
-      assert(logger$3H, blockIndex >= 0 && blockIndex <= blocks.length, `invalid blockIndex: ${blockIndex}`);
+      assert(logger$3G, blockIndex >= 0 && blockIndex <= blocks.length, `invalid blockIndex: ${blockIndex}`);
       return {
         containerId,
         blockIndex
@@ -26763,15 +26726,15 @@ var __publicField = (obj, key, value) => {
       blockIndex: getBlockIndex(newBlock)
     };
   }
-  const logger$3G = getLogger("auto-insert-block");
+  const logger$3F = getLogger("auto-insert-block");
   function editorAutoInsertBlock(editor, blockData, containerId, blockIndex, newRange, insertBlockOptions) {
     const result = editorPrepareInsertNewBlock(editor, containerId, blockIndex);
-    assert(logger$3G, result, `not an valid insert position: ${editor.selection.range}`);
+    assert(logger$3F, result, `not an valid insert position: ${editor.selection.range}`);
     const defaultPos = { blockId: blockData.id, offset: 0 };
     const defaultRange = { anchor: defaultPos, focus: defaultPos };
     return editorInsertBlock(editor, result.containerId, result.blockIndex, blockData, newRange != null ? newRange : defaultRange, insertBlockOptions);
   }
-  const logger$3F = getLogger("delete-block");
+  const logger$3E = getLogger("delete-block");
   function getAllChildContainers(editor, blockData, containerIds) {
     if (blockData.children) {
       containerIds.push(...blockData.children);
@@ -26788,7 +26751,7 @@ var __publicField = (obj, key, value) => {
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3F, blockData, "no block data in doc");
+    assert(logger$3E, blockData, "no block data in doc");
     editor.doc.localDeleteBlock(containerId, blockIndex, createEditorSelectionRange(editor, { anchor: newRange.start, focus: newRange.end }));
     return blockData;
   }
@@ -26834,15 +26797,15 @@ var __publicField = (obj, key, value) => {
     });
     editor.doc.localDeleteChildContainers(containerIds);
   }
-  const logger$3E = getLogger("merge-text-block");
+  const logger$3D = getLogger("merge-text-block");
   function editorMergeTextBlock(editor, block1, block2) {
-    assert(logger$3E, isTextKindBlock(editor, block1), "only text block can be merged");
-    assert(logger$3E, isTextKindBlock(editor, block2), "only text block can be merged");
+    assert(logger$3D, isTextKindBlock(editor, block1), "only text block can be merged");
+    assert(logger$3D, isTextKindBlock(editor, block2), "only text block can be merged");
     const data1 = editorGetBlockData(editor, block1);
     const data2 = editorGetBlockData(editor, block2);
     const text1 = data1.text;
     const text2 = data2.text;
-    assert(logger$3E, text1 && text2, "block data has no text");
+    assert(logger$3D, text1 && text2, "block data has no text");
     const container = getParentContainer(block1);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block1);
@@ -26852,15 +26815,15 @@ var __publicField = (obj, key, value) => {
     editorDeleteBlock(editor, block2, newRange);
     return block;
   }
-  const logger$3D = getLogger("clear-selected-contents");
+  const logger$3C = getLogger("clear-selected-contents");
   function deleteTextBlockSelection(editor, selectedBlock) {
-    assert(logger$3D, isTextKindBlock(editor, selectedBlock.block), "not a text kind block");
+    assert(logger$3C, isTextKindBlock(editor, selectedBlock.block), "not a text kind block");
     const { start, end } = selectedBlock;
-    assert(logger$3D, start.isSimple(), "not a simple block position");
-    assert(logger$3D, end.isSimple(), "not a simple block position");
+    assert(logger$3C, start.isSimple(), "not a simple block position");
+    assert(logger$3C, end.isSimple(), "not a simple block position");
     const startOffset = start.offset;
     const endOffset = end.offset;
-    assert(logger$3D, startOffset <= endOffset, `invalid delete text offset: ${startOffset}, ${endOffset}`);
+    assert(logger$3C, startOffset <= endOffset, `invalid delete text offset: ${startOffset}, ${endOffset}`);
     if (startOffset === endOffset) {
       return;
     }
@@ -26885,7 +26848,7 @@ var __publicField = (obj, key, value) => {
       return;
     }
     if (isEmbedBlock(block) || start.isSimple()) {
-      assert(logger$3D, end.isSimple(), "invalid range");
+      assert(logger$3C, end.isSimple(), "invalid range");
       const container = getParentContainer(block);
       const blockIndex = getBlockIndex(block);
       const newBlock = editor.insertTextBlock("", getContainerId(container), blockIndex);
@@ -26893,8 +26856,8 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
       return;
     }
-    assert(logger$3D, isComplexKindBlock(editor, block), "invalid block kind");
-    assert(logger$3D, !start.isSimple() && !end.isSimple(), "invalid range");
+    assert(logger$3C, isComplexKindBlock(editor, block), "invalid block kind");
+    assert(logger$3C, !start.isSimple() && !end.isSimple(), "invalid range");
     complexBlockGetSelectedContainers(editor, block, start, end);
     const containers = editor.selection.range.getSelectedContainers();
     containers.forEach((container, index2) => {
@@ -26911,7 +26874,7 @@ var __publicField = (obj, key, value) => {
       return;
     }
     const selectedBlocks = range.getSelectedBlocks();
-    assert(logger$3D, selectedBlocks.length > 0, "no selected block");
+    assert(logger$3C, selectedBlocks.length > 0, "no selected block");
     if (selectedBlocks.length === 1) {
       clearOneBlock(editor, selectedBlocks[0]);
       return;
@@ -26919,7 +26882,7 @@ var __publicField = (obj, key, value) => {
     const firstSelectedBlock = selectedBlocks[0];
     const firstBlock = firstSelectedBlock.block;
     const container = getParentContainer(firstBlock);
-    assert(logger$3D, selectedBlocks.length > 1, "no selected block");
+    assert(logger$3C, selectedBlocks.length > 1, "no selected block");
     const lastSelectedBlock = selectedBlocks[selectedBlocks.length - 1];
     const lastBlock2 = lastSelectedBlock.block;
     if (isTextKindBlock(editor, firstBlock)) {
@@ -26949,7 +26912,7 @@ var __publicField = (obj, key, value) => {
     }
     const prevBlock = getPrevBlock(firstBlock);
     const nextBlock = getNextBlock(lastBlock2);
-    assert(logger$3D, prevBlock || nextBlock, "no prev or next block");
+    assert(logger$3C, prevBlock || nextBlock, "no prev or next block");
     selectedBlocks.forEach((selectedBlock) => editor.deleteBlock(selectedBlock.block));
   }
   function editorClearSelectedContents(editor, selectionRange) {
@@ -26968,7 +26931,7 @@ var __publicField = (obj, key, value) => {
       editor.emit("afterClearSelection", editor);
     });
   }
-  const logger$3C = getLogger("core");
+  const logger$3B = getLogger("core");
   function editorUpdateBlockText(editor, block, ops, options) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -26981,7 +26944,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorSetBlockText(editor, block, newText, options) {
     if (!editor.isBlockWritable(block)) {
-      logger$3C.error("block is not writable");
+      logger$3B.error("block is not writable");
       return;
     }
     const oldText = editor.getBlockText(block);
@@ -26994,7 +26957,7 @@ var __publicField = (obj, key, value) => {
     const ops = RichText.diff(oldText, newText);
     return editorUpdateBlockText(editor, block, ops);
   }
-  const logger$3B = getLogger("update-block-data");
+  const logger$3A = getLogger("update-block-data");
   function editorUpdateBlockData(editor, block, data2, newRange, options) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -27011,17 +26974,17 @@ var __publicField = (obj, key, value) => {
         if (oldKey === "id" || oldKey === "type" || oldKey === "text") {
           return;
         }
-        logger$3B.debug(`delete key: ${oldKey}`);
+        logger$3A.debug(`delete key: ${oldKey}`);
         delta.delete.push(oldKey);
       }
     });
     const entries = Object.entries(data2);
     entries.forEach(([key, value]) => {
-      assert(logger$3B, key !== "id" && key !== "type", `invalid block data delta, ${key}`);
+      assert(logger$3A, key !== "id" && key !== "type", `invalid block data delta, ${key}`);
       const oldValue = oldData[key];
       if (value === null || value === void 0) {
         if (oldValue !== null && oldValue !== void 0) {
-          logger$3B.debug(`delete key: ${key}`);
+          logger$3A.debug(`delete key: ${key}`);
           delta.delete.push(key);
         }
         return;
@@ -27039,10 +27002,10 @@ var __publicField = (obj, key, value) => {
         }
       }
       if (oldKeys.has(key)) {
-        logger$3B.debug(`replace key: ${key}`);
+        logger$3A.debug(`replace key: ${key}`);
         delta.delete.push(key);
       } else {
-        logger$3B.debug(`insert key: ${key}`);
+        logger$3A.debug(`insert key: ${key}`);
       }
       delta.insert[key] = value;
     });
@@ -27087,13 +27050,13 @@ var __publicField = (obj, key, value) => {
       comments: {}
     };
   }
-  const logger$3A = getLogger("clone-block");
+  const logger$3z = getLogger("clone-block");
   function cloneBlock(editorBlocks, oldDoc, data2, info) {
     var _a;
     const blockClass = editorBlocks.getBlockClass(data2.type);
     if (blockClass.blockToDoc) {
       return blockClass.blockToDoc(oldDoc, data2, (oldDoc2, childBlock) => {
-        assert(logger$3A, data2 !== childBlock, "invalid child block");
+        assert(logger$3z, data2 !== childBlock, "invalid child block");
         return cloneBlock(editorBlocks, oldDoc2, data2, info);
       }, info);
     }
@@ -27106,7 +27069,7 @@ var __publicField = (obj, key, value) => {
       }
       const newChildContainerId = genId();
       const childBlocks = oldDoc.blocks[oldChildContainerId];
-      assert(logger$3A, Array.isArray(childBlocks), "invalid child blocks");
+      assert(logger$3z, Array.isArray(childBlocks), "invalid child blocks");
       const newDocs = childBlocks.map((c) => cloneBlock(editorBlocks, oldDoc, c, info));
       const newDoc = mergeDocs(newDocs);
       const { root: root2, ...childContainersData } = newDoc.blocks;
@@ -27135,7 +27098,7 @@ var __publicField = (obj, key, value) => {
           if (key.startsWith(prefix1)) {
             const keyContent = key.substring(prefix1.length);
             const newKey = `${newContainerId}/${keyContent}`;
-            logger$3A.debug(`replace key: ${key} -> ${newKey}`);
+            logger$3z.debug(`replace key: ${key} -> ${newKey}`);
             return newKey;
           }
         }
@@ -27144,7 +27107,7 @@ var __publicField = (obj, key, value) => {
           if (key.startsWith(prefix2)) {
             const keyContent = key.substring(prefix2.length);
             const newKey = `${newContainerId}_${keyContent}`;
-            logger$3A.debug(`replace key: ${key} -> ${newKey}`);
+            logger$3z.debug(`replace key: ${key} -> ${newKey}`);
             return newKey;
           }
         }
@@ -27174,7 +27137,7 @@ var __publicField = (obj, key, value) => {
   }
   function cloneChildContainer(editorBlocks, oldDoc, containerId, info) {
     const blocks = oldDoc.blocks[containerId];
-    assert(logger$3A, Array.isArray(blocks), "invalid child blocks");
+    assert(logger$3z, Array.isArray(blocks), "invalid child blocks");
     const newDocs = blocks.map((c) => cloneBlock(editorBlocks, oldDoc, c, info));
     const newDoc = mergeDocs(newDocs);
     return newDoc;
@@ -27183,10 +27146,10 @@ var __publicField = (obj, key, value) => {
     const docs = doc2.blocks.root.map((b) => cloneBlock(editor.editorBlocks, doc2, b, info));
     return cloneDeep__default.default(mergeDocs(docs));
   }
-  const logger$3z = getLogger("insert-doc");
+  const logger$3y = getLogger("insert-doc");
   function editorInsertDoc(editor, block, offset, insertedDoc, cloneDocResult) {
     if (isComplexKindBlock(editor, block)) {
-      logger$3z.warn("failed to insert doc into a complex block");
+      logger$3y.warn("failed to insert doc into a complex block");
       return;
     }
     const doc2 = cloneDoc(editor, insertedDoc, cloneDocResult);
@@ -27220,7 +27183,7 @@ var __publicField = (obj, key, value) => {
         }
         return;
       }
-      assert(logger$3z, isTextKindBlock(editor, block), "not a text block");
+      assert(logger$3y, isTextKindBlock(editor, block), "not a text block");
       if (isEmptyTextBlock(editor, block)) {
         const blockIndex2 = getBlockIndex(block);
         let lastBlock22;
@@ -27352,11 +27315,11 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
     }
   }
-  const logger$3y = getLogger("add-text-attribute");
+  const logger$3x = getLogger("add-text-attribute");
   function editorRemoveTextAttribute(editor, block, range, attributeName) {
     const { start, end } = range;
-    assert(logger$3y, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
-    assert(logger$3y, attributeName, "invalid attribute name");
+    assert(logger$3x, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3x, attributeName, "invalid attribute name");
     const oldText = editor.getBlockText(block);
     const newText = rangeRemoveAttribute(start.offset, end.offset - start.offset, oldText, attributeName, void 0, { ignoreValue: true });
     editor.setBlockText(block, newText);
@@ -27364,8 +27327,8 @@ var __publicField = (obj, key, value) => {
   }
   function editorAddTextAttribute(editor, block, range, attributeName, value) {
     const { start, end } = range;
-    assert(logger$3y, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
-    assert(logger$3y, attributeName, "invalid attribute name");
+    assert(logger$3x, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3x, attributeName, "invalid attribute name");
     const oldText = editor.getBlockText(block);
     const newText = rangeAddAttribute(start.offset, end.offset - start.offset, oldText, attributeName, value);
     editor.setBlockText(block, newText);
@@ -27373,7 +27336,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorSetTextColor(editor, block, range, type, value) {
     const { start, end } = range;
-    assert(logger$3y, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3x, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
     const oldText = editor.getBlockText(block);
     const newText = rangeSetTextColor(start.offset, end.offset - start.offset, oldText, type, value);
     editor.setBlockText(block, newText);
@@ -27462,10 +27425,10 @@ var __publicField = (obj, key, value) => {
     });
     return [color, backgroundColor];
   }
-  const logger$3x = getLogger("move-complex-block-position");
+  const logger$3w = getLogger("move-complex-block-position");
   function moveComplexBlockPosition(editor, old, type) {
     const block = editor.getBlockById(old.blockId);
-    assert(logger$3x, isComplexKindBlock(editor, block), "is not a complex block");
+    assert(logger$3w, isComplexKindBlock(editor, block), "is not a complex block");
     const blockClass = getComplexBlockClass(editor, block);
     const focusedContainer = editor.getContainerById(old.childContainerId);
     const nextContainer = blockClass.getNextContainer(editor, block, focusedContainer, type, { noWrap: true });
@@ -27474,24 +27437,24 @@ var __publicField = (obj, key, value) => {
     }
     return createComplexBlockPosition(block, getContainerId(nextContainer));
   }
-  const logger$3w = getLogger("move-simple-block-position");
+  const logger$3v = getLogger("move-simple-block-position");
   function getFirstChildBlockInComplexBlock(editor, complexBlock) {
     const containers = complexBlockGetAllChildContainers(editor, complexBlock, { visibleOnly: true });
     if (containers.length === 0) {
-      logger$3w.warn("complex block has not any child container, not loaded?");
+      logger$3v.warn("complex block has not any child container, not loaded?");
       return null;
     }
-    assert(logger$3w, containers.length > 0, "complex block has not any child container");
+    assert(logger$3v, containers.length > 0, "complex block has not any child container");
     const container = containers[0];
     return getFirstChildBlock(container);
   }
   function getLastChildBlockInComplexBlock(editor, complexBlock) {
     const containers = complexBlockGetAllChildContainers(editor, complexBlock, { visibleOnly: true });
     if (containers.length === 0) {
-      logger$3w.warn("complex block has not any child container, not loaded?");
+      logger$3v.warn("complex block has not any child container, not loaded?");
       return null;
     }
-    assert(logger$3w, containers.length > 0, "complex block has not any child container");
+    assert(logger$3v, containers.length > 0, "complex block has not any child container");
     const container = containers[containers.length - 1];
     return getLastChildBlock(container);
   }
@@ -27536,8 +27499,8 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const parentComplexBlock = getParentBlock(container);
-    assert(logger$3w, parentComplexBlock, "child container has not parent block");
-    assert(logger$3w, isComplexKindBlock(editor, parentComplexBlock), "is not a complex block");
+    assert(logger$3v, parentComplexBlock, "child container has not parent block");
+    assert(logger$3v, isComplexKindBlock(editor, parentComplexBlock), "is not a complex block");
     const nextContainer = getComplexBlockClass(editor, parentComplexBlock).getNextContainer(editor, parentComplexBlock, container, type);
     if (nextContainer) {
       if (isFindPrev(type)) {
@@ -27559,7 +27522,7 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const parentBlock = getParentBlock(container);
-    assert(logger$3w, parentBlock, "child container has not parent block");
+    assert(logger$3v, parentBlock, "child container has not parent block");
     if (isFindPrev(type)) {
       const prev = getPrevBlock(parentBlock);
       if (prev) {
@@ -27614,7 +27577,7 @@ var __publicField = (obj, key, value) => {
     }
     if (!targetBlock) {
       if (isComplexKindBlock(editor, block) && complexBlockGetAllChildContainers(editor, block).length === 0) {
-        logger$3w.warn("complex block has not any child container, not loaded?");
+        logger$3v.warn("complex block has not any child container, not loaded?");
         targetBlock = direction === "ArrowDown" || direction === "ArrowRight" ? getNextVisibleBlock(block) : getPrevVisibleBlock(block);
       }
     }
@@ -27761,10 +27724,10 @@ var __publicField = (obj, key, value) => {
     editorAdjustSelection(editor, "ArrowUp", "select");
     return true;
   }
-  const logger$3v = getLogger("word-offset");
+  const logger$3u = getLogger("word-offset");
   function editorGetWordLeftPos(editor, type) {
     const old = editor.selection.range.focus;
-    assert(logger$3v, old.isSimple(), "invalid range type");
+    assert(logger$3u, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (isEmptyTextBlock(editor, block)) {
       return createSimpleBlockPosition(block, 0, "home");
@@ -27789,7 +27752,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetWordRightPos(editor, type) {
     const old = editor.selection.range.focus;
-    assert(logger$3v, old.isSimple(), "invalid range type");
+    assert(logger$3u, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (isEmptyTextBlock(editor, block)) {
       return createSimpleBlockPosition(block, 0, "end");
@@ -27901,10 +27864,10 @@ var __publicField = (obj, key, value) => {
     editor.selection.setSelection(editor.selection.getAnchorPos(), pos);
     return true;
   }
-  const logger$3u = getLogger("line-offset");
+  const logger$3t = getLogger("line-offset");
   function editorGetLineHomePos(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3u, old.isSimple(), "invalid range type");
+    assert(logger$3t, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (old.offset === 0 || !isTextKindBlock(editor, block)) {
       const newPos2 = createSimpleBlockPosition(block, 0, "home");
@@ -27921,7 +27884,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetLineEndPos(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3u, old.isSimple(), "invalid range type");
+    assert(logger$3t, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (old.offset === getBlockTextLength$6(editor, block) || !isTextKindBlock(editor, block)) {
       const newPos2 = createSimpleBlockPosition(block, getBlockTextLength$6(editor, block), "end");
@@ -28021,7 +27984,7 @@ var __publicField = (obj, key, value) => {
     editorPageDownScroll(editor);
     return true;
   }
-  const logger$3t = getLogger("table-scroll");
+  const logger$3s = getLogger("table-scroll");
   class DomEventHandler {
     constructor(editor, dom, name, handler, data2, options) {
       __publicField(this, "handleEvent", (event) => {
@@ -28053,7 +28016,7 @@ var __publicField = (obj, key, value) => {
       const existsHandlers = this.handlers.get(element);
       if (existsHandlers) {
         if (existsHandlers.find((handler) => handler.handler === eventHandler && handler.name === eventName)) {
-          logger$3t.warn(`event has already registered: ${eventName}`);
+          logger$3s.warn(`event has already registered: ${eventName}`);
           return;
         }
         existsHandlers.push(new DomEventHandler(this.editor, element, eventName, eventHandler, data2, options));
@@ -28163,7 +28126,7 @@ var __publicField = (obj, key, value) => {
     });
     return true;
   }
-  const logger$3s = getLogger("select-all");
+  const logger$3r = getLogger("select-all");
   function isContainerSelectedAllChildBlocks(container, range) {
     const firstBlock = getFirstChildBlock(container);
     const lastBlock2 = getLastChildBlock(container);
@@ -28178,8 +28141,8 @@ var __publicField = (obj, key, value) => {
     return range.start.blockId === blockId && range.start.childContainerId === getContainerId(first) && range.end.blockId === blockId && range.end.childContainerId === getContainerId(last);
   }
   function selectComplexBlock(editor, block) {
-    assert(logger$3s, block, "no parent block");
-    assert(logger$3s, isComplexKindBlock(editor, block), "not a complex block");
+    assert(logger$3r, block, "no parent block");
+    assert(logger$3r, isComplexKindBlock(editor, block), "not a complex block");
     const containers = getComplexBlockClass(editor, block).getChildContainers(editor, block);
     const first = containers[0];
     const last = containers[containers.length - 1];
@@ -28215,13 +28178,13 @@ var __publicField = (obj, key, value) => {
       selectParentContainer(editor, getFirstChildBlock(editor.rootContainer));
       return false;
     }
-    assert(logger$3s, !range.isSimple(), "invalid range type");
+    assert(logger$3r, !range.isSimple(), "invalid range type");
     if (isComplexBlockSelectedAllChildContainer(focusedBlock, range)) {
       selectParentContainer(editor, focusedBlock);
       return false;
     }
-    assert(logger$3s, focusedBlock, "no parent block");
-    assert(logger$3s, isComplexKindBlock(editor, focusedBlock), "not a complex block");
+    assert(logger$3r, focusedBlock, "no parent block");
+    assert(logger$3r, isComplexKindBlock(editor, focusedBlock), "not a complex block");
     selectComplexBlock(editor, focusedBlock);
     return true;
   }
@@ -28257,30 +28220,6 @@ var __publicField = (obj, key, value) => {
     }
     editor.selection.setSelection(newStartPos, newEndPos);
   }
-  function editorMoveBlockStart(editor) {
-    const focus = editor.selection.range.focus;
-    const block = editor.getBlockById(focus.blockId);
-    if (!block)
-      return false;
-    if (!isSimpleBlock(editor, block))
-      return false;
-    const newPos = createSimpleBlockPosition(block, 0, "home");
-    editor.selection.setSelection(newPos);
-    editor.selection.updateLastCaretRect();
-    return true;
-  }
-  function editorMoveBlockEnd(editor) {
-    const focus = editor.selection.range.focus;
-    const block = editor.getBlockById(focus.blockId);
-    if (!block)
-      return false;
-    if (!isSimpleBlock(editor, block))
-      return false;
-    const newPos = createSimpleBlockPosition(block, getBlockTextLength$6(editor, block), "end");
-    editor.selection.setSelection(newPos);
-    editor.selection.updateLastCaretRect();
-    return true;
-  }
   function editorFocusToEnd(editor) {
     editorSelectEnd(editor);
     editor.focus();
@@ -28360,7 +28299,7 @@ var __publicField = (obj, key, value) => {
     }
     return cloned;
   }
-  const logger$3r = getLogger("selected-block-to-doc");
+  const logger$3q = getLogger("selected-block-to-doc");
   function appendBlockChildren(editor, data2, doc2) {
     if (!data2.children)
       return;
@@ -28381,7 +28320,7 @@ var __publicField = (obj, key, value) => {
     if (isTextKindBlock(editor, selectedBlock.block)) {
       const start = selectedBlock.start;
       const end = selectedBlock.end;
-      assert(logger$3r, data2.text, "no block text");
+      assert(logger$3q, data2.text, "no block text");
       if (start.offset === end.offset) {
         return {
           blocks: {
@@ -28415,8 +28354,8 @@ var __publicField = (obj, key, value) => {
         comments: {}
       };
     }
-    assert(logger$3r, isComplexKindBlock(editor, selectedBlock.block), "not complex block");
-    assert(logger$3r, data2.children, "no children");
+    assert(logger$3q, isComplexKindBlock(editor, selectedBlock.block), "not complex block");
+    assert(logger$3q, data2.children, "no children");
     const ret = {
       blocks: {
         root: [
@@ -28434,9 +28373,9 @@ var __publicField = (obj, key, value) => {
     const end = createSimpleBlockPosition(block, getBlockTextLength$6(editor, block), "end");
     return selectedBlockToDoc(editor, { block, start, end });
   }
-  const logger$3q = getLogger("block-to-doc");
+  const logger$3p = getLogger("block-to-doc");
   function blocksToDoc(editor, blocks) {
-    assert(logger$3q, blocks.length > 0, "invalid params, no blocks");
+    assert(logger$3p, blocks.length > 0, "invalid params, no blocks");
     const docs = blocks.map((b) => blockToDoc(editor, b));
     return mergeDocs(docs);
   }
@@ -28456,7 +28395,7 @@ var __publicField = (obj, key, value) => {
     const newDocs = selectedBlocks.map((s) => selectedBlockToDoc(editor, s));
     return mergeDocs(newDocs);
   }
-  const logger$3p = getLogger("ensure-block-visible");
+  const logger$3o = getLogger("ensure-block-visible");
   function ensureBlockVisible(editor, block) {
     var _a;
     while (block) {
@@ -28466,16 +28405,16 @@ var __publicField = (obj, key, value) => {
         return;
       }
       const parentComplexBlock = getParentBlock(container);
-      assert(logger$3p, parentComplexBlock, "no parent block");
+      assert(logger$3o, parentComplexBlock, "no parent block");
       const parentComplexBlockClass = getBlockClass(editor, parentComplexBlock);
       if (parentComplexBlockClass.isChildContainerVisible && !((_a = parentComplexBlockClass.isChildContainerVisible) == null ? void 0 : _a.call(parentComplexBlockClass, editor, parentComplexBlock, container))) {
-        assert(logger$3p, parentComplexBlockClass.showChildContainer, "no showChildContainer method");
+        assert(logger$3o, parentComplexBlockClass.showChildContainer, "no showChildContainer method");
         parentComplexBlockClass.showChildContainer(editor, parentComplexBlock, container);
       }
       block = parentComplexBlock;
     }
   }
-  const logger$3o = getLogger("editor-selection");
+  const logger$3n = getLogger("editor-selection");
   class EditorSelection {
     constructor(editor) {
       __publicField(this, "editor");
@@ -28488,7 +28427,7 @@ var __publicField = (obj, key, value) => {
         }
         const range = this.range;
         if (rangeInBlock(deletedBlock, range)) {
-          logger$3o.debug("adjust selection because remote deleted current block");
+          logger$3n.debug("adjust selection because remote deleted current block");
           const newRange = moveSelectionBeforeDeleteBlock(editor, deletedBlock);
           this.setRange(newRange, { noScroll: true });
         }
@@ -28613,14 +28552,14 @@ var __publicField = (obj, key, value) => {
       if (pos.isSimple()) {
         const ok = pos.offset >= 0 && pos.offset <= getBlockTextLength$6(this.editor, block);
         if (!ok) {
-          assert(logger$3o, false, "invalid block position, out of range");
+          assert(logger$3n, false, "invalid block position, out of range");
         }
       } else {
         const childContainerId = pos.childContainerId;
         const container = this.editor.getContainerById(childContainerId);
         const ok = !!container;
         if (!ok) {
-          assert(logger$3o, false, "invalid complex block position, no container found");
+          assert(logger$3n, false, "invalid complex block position, no container found");
         }
       }
     }
@@ -28681,7 +28620,7 @@ var __publicField = (obj, key, value) => {
       let container = getParentContainer(block);
       while (isChildContainer(container)) {
         const parentBlock = getParentBlock(container);
-        assert(logger$3o, parentBlock, "parent block not found");
+        assert(logger$3n, parentBlock, "parent block not found");
         addClass(parentBlock, "child-focused");
         container = getParentContainer(parentBlock);
       }
@@ -28791,15 +28730,15 @@ var __publicField = (obj, key, value) => {
     editor.undoManager.redo();
     return true;
   }
-  const logger$3n = getLogger("delete-text");
+  const logger$3m = getLogger("delete-text");
   function editorDeleteText(editor, type, count, insertPos) {
     const pos = insertPos != null ? insertPos : editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3n, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3m, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
-    assert(logger$3n, isTextKindBlock(editor, block), "block is not a text kind block");
+    assert(logger$3m, isTextKindBlock(editor, block), "block is not a text kind block");
     let { offset } = pos;
     if (type === "backward") {
       if (offset - count < 0) {
@@ -28829,7 +28768,7 @@ var __publicField = (obj, key, value) => {
     }
     return false;
   }
-  const logger$3m = getLogger("handle-backspace");
+  const logger$3l = getLogger("handle-backspace");
   function tryDeleteEmptyBlock(editor, block) {
     if (!isEmptyTextBlock(editor, block)) {
       return;
@@ -28869,7 +28808,7 @@ var __publicField = (obj, key, value) => {
             }
           } else {
             tryDeleteEmptyBlock(editor, block);
-            assert(logger$3m, isEmbedBlock(prevBlock), "prev block is not embed block");
+            assert(logger$3l, isEmbedBlock(prevBlock), "prev block is not embed block");
             editor.selection.selectBlock(prevBlock, 1);
           }
         } else {
@@ -28896,7 +28835,6 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
     }
   }
-  const logger$3l = getLogger("word-offset");
   function handleEditorDelete(editor, event) {
     if (!editor.selection.range.isCollapsed()) {
       editor.clearSelectedContents();
@@ -28931,130 +28869,6 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
     }
   }
-  function handleEditorDeleteLeftWord(editor, event) {
-    const old = editor.selection.range.focus;
-    assert(logger$3l, old.isSimple(), "invalid range type");
-    const block = editor.getBlockById(old.blockId);
-    if (!isTextKindBlock(editor, block)) {
-      editor.deleteBlock(block);
-      return true;
-    }
-    if (old.offset === 0) {
-      const matchNonEmptyTextBlockOrOtherBlock = (block2) => {
-        if (!isTextKindBlock(editor, block2))
-          return true;
-        return !isEmptyTextBlock(editor, block2);
-      };
-      const prevBlock = getPrevVisibleBlock(block, matchNonEmptyTextBlockOrOtherBlock);
-      if (!prevBlock)
-        return false;
-      const matchEmptyTextBlock = (block2) => isEmptyTextBlock(editor, block2);
-      const emptyTextBlocks = getBlocksBetween(prevBlock, block, matchEmptyTextBlock);
-      emptyTextBlocks.forEach((b) => {
-        editor.deleteBlock(b);
-      });
-      if (!isTextKindBlock(editor, prevBlock)) {
-        editor.deleteBlock(prevBlock);
-        return true;
-      }
-      const textBlockLen = getBlockTextLength$6(editor, prevBlock);
-      const newOffset2 = findWordLeft(editor, prevBlock, textBlockLen);
-      editor.deleteTextFromBlock(prevBlock, newOffset2, textBlockLen - newOffset2);
-      const currentBlockText = editor.getBlockText(block);
-      editor.insertTextToBlock(prevBlock, newOffset2, currentBlockText);
-      editor.deleteBlock(block);
-      const pos = createSimpleBlockPosition(prevBlock, newOffset2, "normal");
-      editor.selection.setSelection(pos);
-      editor.selection.updateLastCaretRect();
-      return true;
-    }
-    const newOffset = findWordLeft(editor, block, old.offset);
-    const deletedCount = old.offset - newOffset;
-    editor.deleteTextFromBlock(block, newOffset, deletedCount);
-    return true;
-  }
-  function handleEditorDeleteRightWord(editor, event) {
-    const old = editor.selection.range.focus;
-    assert(logger$3l, old.isSimple(), "invalid range type");
-    const block = editor.getBlockById(old.blockId);
-    if (!isTextKindBlock(editor, block)) {
-      editor.deleteBlock(block);
-      return true;
-    }
-    if (old.offset === getTextBlockLength(block)) {
-      const matchNonEmptyTextBlockOrOtherBlock = (block2) => {
-        if (!isTextKindBlock(editor, block2))
-          return true;
-        return !isEmptyTextBlock(editor, block2);
-      };
-      const nextBlock = getNextVisibleBlock(block, matchNonEmptyTextBlockOrOtherBlock);
-      if (!nextBlock)
-        return false;
-      const matchEmptyTextBlock = (block2) => isEmptyTextBlock(editor, block2);
-      const emptyTextBlocks = getBlocksBetween(block, nextBlock, matchEmptyTextBlock);
-      emptyTextBlocks.forEach((b) => {
-        editor.deleteBlock(b);
-      });
-      if (!isTextKindBlock(editor, nextBlock)) {
-        editor.deleteBlock(nextBlock);
-        return true;
-      }
-      const newOffset = findWordEnd(editor, nextBlock, 0);
-      editor.deleteTextFromBlock(nextBlock, 0, newOffset);
-      const nextBlockText = editor.getBlockText(nextBlock);
-      editor.insertTextToBlock(block, old.offset, nextBlockText);
-      editor.deleteBlock(nextBlock);
-      const pos = createSimpleBlockPosition(block, old.offset, "normal");
-      editor.selection.setSelection(pos);
-      editor.selection.updateLastCaretRect();
-      return true;
-    }
-    const endOffset = findWordEnd(editor, block, old.offset);
-    const deletedCount = endOffset - old.offset;
-    editor.deleteTextFromBlock(block, old.offset, deletedCount);
-    return true;
-  }
-  function handleEditorDeleteAfterWords(editor) {
-    const old = editor.selection.range.focus;
-    assert(logger$3l, old.isSimple(), "invalid range type");
-    const block = editor.getBlockById(old.blockId);
-    if (!isTextKindBlock(editor, block)) {
-      editor.deleteBlock(block);
-      return;
-    }
-    const needDeleteCount = getTextBlockLength(block) - old.offset;
-    if (needDeleteCount === 0)
-      return;
-    editor.deleteTextFromBlock(block, old.offset, needDeleteCount);
-  }
-  function handleEditorDeleteRightChar(editor) {
-    const old = editor.selection.range.focus;
-    assert(logger$3l, old.isSimple(), "invalid range type");
-    const block = editor.getBlockById(old.blockId);
-    if (!isTextKindBlock(editor, block)) {
-      editor.deleteBlock(block);
-      return;
-    }
-    if (old.offset === getBlockTextLength$6(editor, block)) {
-      const nextVisibleBlock = getNextVisibleBlock(block);
-      if (!nextVisibleBlock)
-        return;
-      if (!isTextKindBlock(editor, nextVisibleBlock))
-        return;
-      if (isEmptyTextBlock(editor, nextVisibleBlock)) {
-        editor.deleteBlock(nextVisibleBlock);
-        return;
-      }
-      const nextBlockText = editor.getBlockText(nextVisibleBlock);
-      editor.deleteBlock(nextVisibleBlock);
-      editor.insertTextToBlock(block, old.offset, nextBlockText);
-      const pos = createSimpleBlockPosition(block, old.offset, "normal");
-      editor.selection.setSelection(pos);
-      editor.selection.updateLastCaretRect();
-      return;
-    }
-    editorDeleteText(editor, "forward", 1, null);
-  }
   function handleEditorEnterEvent$1(editor, event) {
     if (isFullSelectedOneComplexBlock(editor)) {
       const focusedBlock2 = editor.getFocusedBlock();
@@ -29276,42 +29090,6 @@ var __publicField = (obj, key, value) => {
       return true;
     });
   }
-  function editorHandleDeleteLeftWord(editor, event) {
-    if (editor.readonly || !editor.isWritable()) {
-      return false;
-    }
-    return editor.undoManager.runInGroup(() => {
-      handleEditorDeleteLeftWord(editor);
-      return true;
-    });
-  }
-  function editorHandleDeleteRightWord(editor, event) {
-    if (editor.readonly || !editor.isWritable()) {
-      return false;
-    }
-    return editor.undoManager.runInGroup(() => {
-      handleEditorDeleteRightWord(editor);
-      return true;
-    });
-  }
-  function editorHandleDeleteAfterWords(editor, event) {
-    if (editor.readonly || !editor.isWritable()) {
-      return false;
-    }
-    return editor.undoManager.runInGroup(() => {
-      handleEditorDeleteAfterWords(editor);
-      return true;
-    });
-  }
-  function editorHandleDeleteRightChar(editor, event) {
-    if (editor.readonly || !editor.isWritable()) {
-      return false;
-    }
-    return editor.undoManager.runInGroup(() => {
-      handleEditorDeleteRightChar(editor);
-      return true;
-    });
-  }
   function editorHandleBackspace(editor, event) {
     if (editor.readonly || !editor.isWritable()) {
       return false;
@@ -29405,10 +29183,6 @@ ${codeText}
     __proto__: null,
     editorHandleEnter,
     editorHandleDelete,
-    editorHandleDeleteLeftWord,
-    editorHandleDeleteRightWord,
-    editorHandleDeleteAfterWords,
-    editorHandleDeleteRightChar,
     editorHandleBackspace,
     editorHandleInsertBr,
     editorHandlePastePlainText,
@@ -29416,41 +29190,6 @@ ${codeText}
     getSelectedCodeBlockMarkdown,
     editorHandleCopyMarkdown
   }, Symbol.toStringTag, { value: "Module" }));
-  const MacShortcuts = {
-    "Cmd+ArrowLeft": editorMoveLineHome,
-    "Cmd+ArrowRight": editorMoveLineEnd,
-    "Option+ArrowLeft": editorMoveWordLeft,
-    "Option+ArrowRight": editorMoveWordEnd,
-    "Option+Shift+ArrowLeft": editorSelectWordLeft,
-    "Option+Shift+ArrowRight": editorSelectWordEnd,
-    "Cmd+Shift+ArrowLeft": editorSelectLineHome,
-    "Cmd+Shift+ArrowRight": editorSelectLineEnd,
-    "Ctrl+A": editorMoveBlockStart,
-    "Ctrl+E": editorMoveBlockEnd,
-    "Option+Delete": editorHandleDeleteRightWord,
-    "Option+Backspace": editorHandleDeleteLeftWord,
-    "Ctrl+B": editorMoveLeft,
-    "Ctrl+F": editorMoveRight,
-    "Ctrl+N": editorMoveDown,
-    "Ctrl+P": editorMoveUp,
-    "Ctrl+K": editorHandleDeleteAfterWords,
-    "Ctrl+H": editorHandleBackspace,
-    "Ctrl+D": editorHandleDeleteRightChar
-  };
-  const WinLinuxShortcuts = {
-    "Home": editorMoveLineHome,
-    "End": editorMoveLineEnd,
-    "Shift+Home": editorSelectLineHome,
-    "Shift+End": editorSelectLineEnd,
-    "Ctrl+Delete": editorHandleDeleteRightWord,
-    "Ctrl+Backspace": editorHandleDeleteLeftWord,
-    "Ctrl+ArrowLeft": editorMoveWordLeft,
-    "Ctrl+ArrowRight": editorMoveWordEnd,
-    "Ctrl+Shift+ArrowLeft": editorSelectWordLeft,
-    "Ctrl+Shift+ArrowRight": editorSelectWordEnd
-  };
-  const isMac = clientType.isMac;
-  const CustomShortcuts = isMac ? MacShortcuts : WinLinuxShortcuts;
   const DefaultShortcuts = {
     "ArrowDown": editorMoveDown,
     "ArrowUp": editorMoveUp,
@@ -29460,11 +29199,19 @@ ${codeText}
     "Shift+ArrowUp": editorSelectUp,
     "Shift+ArrowLeft": editorSelectLeft,
     "Shift+ArrowRight": editorSelectRight,
+    "CtrlOrCmd+ArrowLeft": editorMoveWordLeft,
+    "CtrlOrCmd+ArrowRight": editorMoveWordEnd,
+    "CtrlOrCmd+Shift+ArrowLeft": editorSelectWordLeft,
+    "CtrlOrCmd+Shift+ArrowRight": editorSelectWordEnd,
     "CtrlOrCmd+ArrowUp": editorMoveHome,
     "CtrlOrCmd+ArrowDown": editorMoveEnd,
     "CtrlOrCmd+Shift+ArrowUp": editorSelectHome,
     "CtrlOrCmd+Shift+ArrowDown": editorSelectEnd,
     "CtrlOrCmd+A": editorSelectAll,
+    "Home": editorMoveLineHome,
+    "End": editorMoveLineEnd,
+    "Shift+Home": editorSelectLineHome,
+    "Shift+End": editorSelectLineEnd,
     "PageUp": editorMovePageUp,
     "PageDown": editorMovePageDown,
     "Shift+PageUp": editorSelectPageUp,
@@ -29476,8 +29223,7 @@ ${codeText}
     "Backspace": editorHandleBackspace,
     "Shift+Enter": editorHandleInsertBr,
     "CtrlOrCmd+Shift+V": editorHandlePastePlainText,
-    "CtrlOrCmd+Shift+C": editorHandleCopyMarkdown,
-    ...CustomShortcuts
+    "CtrlOrCmd+Shift+C": editorHandleCopyMarkdown
   };
   function editorHandleKeyboardEvent(editor, event) {
     const result = editor.shortcuts.handleKeyboardEvents(editor, event);
@@ -43255,21 +43001,8 @@ ${codeText}
   const textColorItem = "";
   const DEFAULT_BG_COLOR = 2;
   const NULLABLE_COLOR = -1;
-  const STORAGE_NAME = "color-item";
-  function getColorsFromLocalStorage(editor) {
-    const colors = [null, null];
-    const color = Number.parseInt(editor.settingsProvider.getItem(`${STORAGE_NAME}-color`) || "", 10);
-    const backgroundColor = Number.parseInt(editor.settingsProvider.getItem(`${STORAGE_NAME}-backgroundColor`) || `${DEFAULT_BG_COLOR}`, 10);
-    if (!Number.isNaN(color)) {
-      colors[0] = color;
-    }
-    if (!Number.isNaN(backgroundColor)) {
-      colors[1] = backgroundColor;
-    }
-    return colors;
-  }
   class TextColorItem extends tinyTypedEmitter.TypedEmitter {
-    constructor(editor, storageName = STORAGE_NAME) {
+    constructor(editor, storageName = "color-item") {
       super();
       __publicField(this, "id", "text-color-item");
       __publicField(this, "name", i18n$1.t("colorPalette.name"));
@@ -50964,7 +50697,7 @@ ${codeText}
     }
     return handleDragList(editor, draggedBlock, targetBlock, insertPos);
   }
-  function executeShortcut$3(editor, type) {
+  function executeShortcut$1(editor, type) {
     if (!editor.isWritable()) {
       return false;
     }
@@ -50978,8 +50711,8 @@ ${codeText}
     return true;
   }
   const ListBlockShortcuts = {
-    "Shift+CtrlOrCmd+L": (editor) => executeShortcut$3(editor, "ordered-list"),
-    "Shift+CtrlOrCmd+U": (editor) => executeShortcut$3(editor, "unordered-list")
+    "Shift+CtrlOrCmd+L": (editor) => executeShortcut$1(editor, "ordered-list"),
+    "Shift+CtrlOrCmd+U": (editor) => executeShortcut$1(editor, "unordered-list")
   };
   function getBlockPadding$1(block) {
     const padding = block.getAttribute("block-padding-level");
@@ -61489,31 +61222,6 @@ $$${mathData.mathjaxText}$$
       return editor.addCustom("overflow-tooltip-helper", () => new OverflowTooltipHelper(editor));
     }
   }
-  function executeShortcut$2(editor, style2) {
-    if (!editor.isWritable()) {
-      return false;
-    }
-    const range = editor.selection.range;
-    const allCommands = editor.editorCommandProviders.getCommands(range);
-    const alignCommands = allCommands.flatMap((command2) => {
-      if (command2.id === "align") {
-        return command2.children;
-      }
-      return [];
-    });
-    const command = alignCommands.find((c) => c.id === `align-${style2}`);
-    if (!command) {
-      return false;
-    }
-    editor.editorCommandProviders.executeCommand(range, command, {});
-    OnesEditorToolbar.get(editor).update("selectionChange");
-    return true;
-  }
-  const AlignShortcuts = {
-    "CtrlOrCmd+Shift+E": (editor) => executeShortcut$2(editor, "center"),
-    "CtrlOrCmd+Shift+O": (editor) => executeShortcut$2(editor, "left"),
-    "CtrlOrCmd+Shift+R": (editor) => executeShortcut$2(editor, "right")
-  };
   const TextCommands = {
     "text/style-bold": "bold",
     "text/style-italic": "italic",
@@ -61522,15 +61230,14 @@ $$${mathData.mathjaxText}$$
     "text/style-code": "code",
     "text/style-sub": "subscript",
     "text/style-super": "superscript",
-    link: "link",
-    "insert-link": "link"
+    link: "link"
   };
   function getTextCommands(editor, blockCommands) {
     const styleCommandsSet = new Set(Object.keys(TextCommands));
     const styleCommands = blockCommands.filter((command) => styleCommandsSet.has(command.id));
     return styleCommands;
   }
-  function executeShortcut$1(editor, style2) {
+  function executeShortcut(editor, style2) {
     if (!editor.isWritable()) {
       return false;
     }
@@ -61540,7 +61247,7 @@ $$${mathData.mathjaxText}$$
     const range = editor.selection.range;
     const allCommands = editor.editorCommandProviders.getCommands(range);
     const textCommands = getTextCommands(editor, allCommands);
-    const command = textCommands.find((c) => c.id === `text/${style2}` || c.id === "link" || c.id === "insert-link");
+    const command = textCommands.find((c) => c.id === `text/${style2}` || c.id === "link");
     if (!command) {
       return false;
     }
@@ -61575,37 +61282,13 @@ $$${mathData.mathjaxText}$$
     return shortcuts2;
   };
   const TextStyleShortcuts = {
-    "CtrlOrCmd+B": (editor) => executeShortcut$1(editor, "style-bold"),
-    "CtrlOrCmd+I": (editor) => executeShortcut$1(editor, "style-italic"),
-    "CtrlOrCmd+U": (editor) => executeShortcut$1(editor, "style-underline"),
-    "CtrlOrCmd+D": (editor) => executeShortcut$1(editor, "style-strikethrough"),
-    "CtrlOrCmd+K": (editor) => executeShortcut$1(editor, "insert-link"),
+    "CtrlOrCmd+B": (editor) => executeShortcut(editor, "style-bold"),
+    "CtrlOrCmd+I": (editor) => executeShortcut(editor, "style-italic"),
+    "CtrlOrCmd+U": (editor) => executeShortcut(editor, "style-underline"),
+    "CtrlOrCmd+D": (editor) => executeShortcut(editor, "style-strikethrough"),
+    "CtrlOrCmd+K": (editor) => executeShortcut(editor, "link"),
     ...headingShortcut()
   };
-  function executeShortcut(editor) {
-    if (!editor.isWritable()) {
-      return false;
-    }
-    const range = editor.selection.range;
-    if (range.isCollapsed()) {
-      return false;
-    }
-    editor.undoManager.runInGroup(() => {
-      const colors = getColorsFromLocalStorage(editor);
-      colors.forEach((color, idx) => {
-        if (color === null) {
-          return;
-        }
-        const type = idx === 0 ? "color" : "backgroundColor";
-        editorRangeSetColor(editor, type, color, () => {
-        });
-      });
-    });
-    return true;
-  }
-  const TextColorShortcuts = {
-    "CtrlOrCmd+Alt+KeyH": (editor) => executeShortcut(editor)
-  };
   const zhCN$p = {
     quickMenu: {
       basic: {
@@ -62364,7 +62047,7 @@ $$${mathData.mathjaxText}$$
       __publicField(this, "updateButtonColor", (range) => {
         const currentTextColor = editorRangeGetColor(this.editor, range, this.getEmptyTextBlockColor);
         this.colorItem.setCurrentTextColors(currentTextColor);
-        const lastButtonColor = getColorsFromLocalStorage(this.editor);
+        const lastButtonColor = this.colorItem.getColorsFromLocalStorage();
         this.colorItem.setCurrentButtonColor(lastButtonColor);
       });
       __publicField(this, "setActiveAttribute", (type, value) => {
@@ -92219,11 +91902,9 @@ ${data2.plantumlText}
         FindReplaceShortcuts,
         BlockPaddingShortcuts,
         TextStyleShortcuts,
-        AlignShortcuts,
         AutoLinkShortcuts,
         DefaultShortcuts,
         ListBlockShortcuts,
-        TextColorShortcuts,
         ...options.shortcuts || []
       ],
       colors: [
@@ -92432,7 +92113,7 @@ ${data2.plantumlText}
         }
       }
     });
-    editor.version = "2.6.1-beta.4";
+    editor.version = "2.7.1-beta.2";
     return editor;
   }
   function isDoc(doc2) {
@@ -92545,7 +92226,7 @@ ${data2.plantumlText}
       }
     });
     OnesEditorToolbar.register(editor);
-    editor.version = "2.6.1-beta.4";
+    editor.version = "2.7.1-beta.2";
     return editor;
   }
   async function showDocVersions(editor, options, serverUrl) {
@@ -138331,7 +138012,6 @@ ${data2.plantumlText}
   exports2.AlignProvider = AlignProvider;
   exports2.AlignRightIcon = AlignRightIcon;
   exports2.AlignRightItem = AlignRightItem;
-  exports2.AlignShortcuts = AlignShortcuts;
   exports2.AnchorBox = AnchorBox;
   exports2.ArrowDownIcon = ArrowDownIcon$1;
   exports2.ArrowLeftIcon = arrowLeft;
@@ -138588,7 +138268,6 @@ ${data2.plantumlText}
   exports2.TextBox = TextBox;
   exports2.TextColorIcon = TextColorIcon;
   exports2.TextColorItem = TextColorItem;
-  exports2.TextColorShortcuts = TextColorShortcuts;
   exports2.TextCommandProvider = TextCommandProvider;
   exports2.TextGroupIcon = TextGroupIcon;
   exports2.TextIcon = TextIcon;
@@ -138758,8 +138437,6 @@ ${data2.plantumlText}
   exports2.editorInsertTextToBlock = editorInsertTextToBlock;
   exports2.editorInsertTextToBlockEx = editorInsertTextToBlockEx;
   exports2.editorMergeTextBlock = editorMergeTextBlock;
-  exports2.editorMoveBlockEnd = editorMoveBlockEnd;
-  exports2.editorMoveBlockStart = editorMoveBlockStart;
   exports2.editorMoveDown = editorMoveDown;
   exports2.editorMoveEnd = editorMoveEnd;
   exports2.editorMoveHome = editorMoveHome;
@@ -138864,7 +138541,6 @@ ${data2.plantumlText}
   exports2.getBlockTextLength = getBlockTextLength$6;
   exports2.getBlockTools = getBlockTools;
   exports2.getBlockType = getBlockType;
-  exports2.getBlocksBetween = getBlocksBetween;
   exports2.getBlocksWidth = getBlocksWidth;
   exports2.getBoxContent = getBoxContent;
   exports2.getBoxId = getBoxId;
@@ -138877,7 +138553,6 @@ ${data2.plantumlText}
   exports2.getClosestContainerByCondition = getClosestContainerByCondition;
   exports2.getColorFromAttributes = getColorFromAttributes;
   exports2.getColorFromContent = getColorFromContent;
-  exports2.getColorsFromLocalStorage = getColorsFromLocalStorage;
   exports2.getComplexBlockClass = getComplexBlockClass;
   exports2.getContainerBlockOverrideOptions = getContainerBlockOverrideOptions;
   exports2.getContainerBlockPath = getContainerBlockPath;
@@ -138980,7 +138655,6 @@ ${data2.plantumlText}
   exports2.isBox = isBox;
   exports2.isBoxOp = isBoxOp;
   exports2.isCJK = isCJK;
-  exports2.isCJKPunctuation = isCJKPunctuation;
   exports2.isChildContainer = isChildContainer;
   exports2.isChildNode = isChildNode;
   exports2.isClipboardEmpty = isClipboardEmpty$1;
@@ -139053,7 +138727,7 @@ ${data2.plantumlText}
   exports2.loadJs = loadJs;
   exports2.loadJsPromise = loadJsPromise;
   exports2.lockers = lockers;
-  exports2.logger = logger$4q;
+  exports2.logger = logger$4p;
   exports2.markdownToDoc = markdownToDoc;
   exports2.mergeCommands = mergeCommands;
   exports2.mergeDocs = mergeDocs;