@ones-editor/editor 5.0.6-beta.DNP8216.3 → 5.0.6-beta.p8216.2

package/dist/index.js

@@ -9342,7 +9342,7 @@ var __publicField = (obj, key, value) => {
       imageExportFailed: "Bild konnte nicht geladen werden"
     }
   };
-  const logger$4Y = getLogger("i18n");
+  const logger$4X = getLogger("i18n");
   const langs$3 = {
     "en-US": enUS$y,
     "zh-CN": zhCN$y,
@@ -9364,7 +9364,7 @@ var __publicField = (obj, key, value) => {
   function t$8(key, args) {
     const ret = i18n.get(key, args);
     if (ret === key) {
-      logger$4Y.warn(`no locale value for key ${key}`);
+      logger$4X.warn(`no locale value for key ${key}`);
     }
     return ret;
   }
@@ -9982,7 +9982,7 @@ var __publicField = (obj, key, value) => {
       this._callbacks.clear();
     }
   }
-  const logger$4X = getLogger("await-locker");
+  const logger$4W = getLogger("await-locker");
   class AwaitLock {
     constructor() {
       __publicField(this, "_acquired", false);
@@ -10024,7 +10024,7 @@ var __publicField = (obj, key, value) => {
       }
       if (this._waitingResolvers.length > 0) {
         const resolve = this._waitingResolvers.shift();
-        assert(logger$4X, resolve, "Resolver missing");
+        assert(logger$4W, resolve, "Resolver missing");
         resolve(void 0);
       } else {
         this._acquired = false;
@@ -10107,7 +10107,7 @@ var __publicField = (obj, key, value) => {
     isMobileSafari: false
   };
   clientType.isMobileSafari = clientType.isMobile && clientType.isSafari;
-  const logger$4W = getLogger("dom-utils");
+  const logger$4V = getLogger("dom-utils");
   function addClass(dom, ...className) {
     if (dom && dom.nodeType === Node.ELEMENT_NODE) {
       dom.classList.add(...className);
@@ -10164,7 +10164,7 @@ var __publicField = (obj, key, value) => {
       range.setStart(node, offset);
       return range;
     } catch (err) {
-      assert(logger$4W, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
+      assert(logger$4V, false, `failed to create range: ${node.childNodes.length}, ${offset}, ${err.message}`);
     }
   }
   function createExpandedRange(startNode, startOffset, endNode, endOffset) {
@@ -10174,17 +10174,17 @@ var __publicField = (obj, key, value) => {
       range.setEnd(endNode, endOffset);
       return range;
     } catch (err) {
-      assert(logger$4W, false, `failed to create expanded range: ${startNode.childNodes.length}, ${startOffset}, ${endNode.childNodes.length}, ${endOffset}, ${err.message}`);
+      assert(logger$4V, 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$4W, rects.length >= 1, "getFirstClientRect: no rects");
+    assert(logger$4V, rects.length >= 1, "getFirstClientRect: no rects");
     return rects[0];
   }
   function getLastClientRect(elem) {
     const rects = elem.getClientRects();
-    assert(logger$4W, rects.length >= 1, "getLastClientRect: no rects");
+    assert(logger$4V, rects.length >= 1, "getLastClientRect: no rects");
     return rects[rects.length - 1];
   }
   function getDistanceSquare(rect, x, y) {
@@ -10231,7 +10231,7 @@ var __publicField = (obj, key, value) => {
       return 0;
     }
     if (!elem1.parentElement || !elem2.parentElement) {
-      assert(logger$4W, false, "invalid dom node to compare");
+      assert(logger$4V, false, "invalid dom node to compare");
     }
     if (elem1.parentElement === elem2.parentElement) {
       const children = Array.from(elem1.parentElement.children);
@@ -10248,7 +10248,7 @@ var __publicField = (obj, key, value) => {
     const parents1 = getParents(elem1);
     const parents2 = getParents(elem2);
     if (parents1[0] !== parents2[0]) {
-      assert(logger$4W, false, "invalid dom node to compare, different tree");
+      assert(logger$4V, false, "invalid dom node to compare, different tree");
     }
     for (let i = 1; ; i++) {
       const parent1 = parents1[i];
@@ -10848,7 +10848,7 @@ var __publicField = (obj, key, value) => {
     }
   }
   const MIN_DISTANCE_THRESHOLD$3 = 3;
-  const logger$4V = getLogger("drag-drop");
+  const logger$4U = getLogger("drag-drop");
   class DragDrop {
     constructor(options) {
       __publicField(this, "dragStarted", false);
@@ -10869,7 +10869,7 @@ var __publicField = (obj, key, value) => {
         var _a;
         event.preventDefault();
         event.stopPropagation();
-        assert(logger$4V, this.mouseDownEvent, "no mouse down event");
+        assert(logger$4U, this.mouseDownEvent, "no mouse down event");
         const oldPos = DragDrop.getEventPosition(this.mouseDownEvent);
         const newPos = DragDrop.getEventPosition(event);
         const deltaX = newPos.x - oldPos.x;
@@ -10885,7 +10885,7 @@ var __publicField = (obj, key, value) => {
       });
       __publicField(this, "handleMouseUp", (event) => {
         if (event instanceof MouseEvent && event.button === 0 || event instanceof TouchEvent) {
-          assert(logger$4V, this.mouseDownEvent, "no mouse down event");
+          assert(logger$4U, this.mouseDownEvent, "no mouse down event");
           const oldPos = DragDrop.getEventPosition(this.mouseDownEvent);
           const newPos = DragDrop.getEventPosition(event);
           const deltaX = newPos.x - oldPos.x;
@@ -10994,7 +10994,7 @@ var __publicField = (obj, key, value) => {
     const dragDrop = new DragDrop(options);
     return dragDrop;
   }
-  const logger$4U = getLogger("character");
+  const logger$4T = getLogger("character");
   function checkChar(charCode, rangeList) {
     for (let i = 0; i < rangeList.length; i++) {
       const start = rangeList[i][0];
@@ -11045,7 +11045,7 @@ var __publicField = (obj, key, value) => {
   }
   function trimChar(s, char) {
     let c = char;
-    assert(logger$4U, c.length === 1, "invalid char length");
+    assert(logger$4T, c.length === 1, "invalid char length");
     if (c === "]")
       c = "\\]";
     if (c === "\\")
@@ -11403,7 +11403,7 @@ var __publicField = (obj, key, value) => {
       return 200;
     }
   }
-  const logger$4T = getLogger("editor-clipboard");
+  const logger$4S = getLogger("editor-clipboard");
   async function setClipboardDataByEvent(items, event) {
     if (event.clipboardData) {
       const data2 = event.clipboardData;
@@ -11461,7 +11461,7 @@ var __publicField = (obj, key, value) => {
       document.body.removeChild(textarea2);
       return true;
     } catch (ex) {
-      logger$4T.error(ex);
+      logger$4S.error(ex);
       document.body.removeChild(textarea2);
       return false;
     }
@@ -11482,7 +11482,7 @@ var __publicField = (obj, key, value) => {
       document.body.removeChild(div);
       return true;
     } catch (ex) {
-      logger$4T.error(ex);
+      logger$4S.error(ex);
       document.body.removeChild(div);
       return false;
     }
@@ -11509,7 +11509,7 @@ var __publicField = (obj, key, value) => {
       await navigator.clipboard.write([clipboardItems]);
       return true;
     } catch (err) {
-      logger$4T.error(err);
+      logger$4S.error(err);
       return await execCommandCopy(items);
     }
   }
@@ -11565,7 +11565,7 @@ var __publicField = (obj, key, value) => {
     a.click();
     a.remove();
   }
-  const logger$4S = getLogger("auto-scroll");
+  const logger$4R = getLogger("auto-scroll");
   function scrollable(scrollElement, direction) {
     if (scrollElement.scrollHeight === scrollElement.clientHeight) {
       return false;
@@ -11589,7 +11589,7 @@ var __publicField = (obj, key, value) => {
     const isHorizontal = direction === "left" || direction === "right";
     const scroll = () => {
       if (!scrollable(scrollElement, direction)) {
-        logger$4S.debug("No need for scroll");
+        logger$4R.debug("No need for scroll");
         return null;
       }
       if (isHorizontal) {
@@ -11646,7 +11646,7 @@ var __publicField = (obj, key, value) => {
           if (this.scrolling) {
             return;
           }
-          logger$4S.debug(`scroll direction: ${direction}`);
+          logger$4R.debug(`scroll direction: ${direction}`);
           this.cancelScroll = continuousScroll(scrollElement, {
             direction,
             step
@@ -11984,7 +11984,7 @@ var __publicField = (obj, key, value) => {
     var _a;
     (_a = pendingEditors.get(editor)) == null ? void 0 : _a.renderId(id);
   }
-  const logger$4R = getLogger("container");
+  const logger$4Q = getLogger("container");
   function isContainer(elem) {
     return elem.getAttribute("data-type") === "editor-container";
   }
@@ -11996,9 +11996,9 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerId(container) {
     const id = container.getAttribute("data-container-id");
-    assert(logger$4R, id, "no id for container");
+    assert(logger$4Q, id, "no id for container");
     if (isRootContainer(container)) {
-      assert(logger$4R, id === "root", `invalid root container id, : ${id}`);
+      assert(logger$4Q, id === "root", `invalid root container id, : ${id}`);
     }
     return id;
   }
@@ -12009,7 +12009,7 @@ var __publicField = (obj, key, value) => {
   function generateEditorContainerId(containerId) {
     return `ones-editor-container-${containerId}`;
   }
-  const logger$4Q = getLogger("element");
+  const logger$4P = getLogger("element");
   function createContainerElement(parent, type, containerId) {
     const container = createElement("div", [type], parent);
     container.setAttribute("data-type", "editor-container");
@@ -12024,7 +12024,7 @@ var __publicField = (obj, key, value) => {
       renderDeferredId(editor, containerId);
       container = editor.rootElement.querySelector(`[data-container-id=${containerId}]`);
     }
-    assert(logger$4Q, container, `no container: ${containerId}`);
+    assert(logger$4P, container, `no container: ${containerId}`);
     return container;
   }
   function getExistsContainerById(editor, containerId) {
@@ -12033,7 +12033,7 @@ var __publicField = (obj, key, value) => {
   }
   function getContainerBlocksElement(container) {
     const blocks = container.querySelector(":scope > .container-blocks");
-    assert(logger$4Q, blocks, "no container blocks element");
+    assert(logger$4P, blocks, "no container blocks element");
     return blocks;
   }
   function getContainerToolsElement(container) {
@@ -12046,11 +12046,11 @@ var __publicField = (obj, key, value) => {
   function isContainerBlocksElement(element) {
     return element.classList.contains("container-blocks");
   }
-  const logger$4P = getLogger("container-children");
+  const logger$4O = getLogger("container-children");
   function getChildBlocks(container, traverseChild) {
     const content = getContainerBlocksElement(container);
     const blocks = Array.from(content.children);
-    assert(logger$4P, blocks.length > 0, "container have not any child block");
+    assert(logger$4O, blocks.length > 0, "container have not any child block");
     if (traverseChild) {
       const { condition, editor } = traverseChild;
       return blocks.reduce((result, block) => {
@@ -12073,7 +12073,7 @@ var __publicField = (obj, key, value) => {
   }
   function getFirstChildBlock(container) {
     const block = container.querySelector(":scope > .container-blocks > div[data-type=editor-block]");
-    assert(logger$4P, block, "container have not any child block");
+    assert(logger$4O, block, "container have not any child block");
     return block;
   }
   function getLastChildBlock(container) {
@@ -12085,14 +12085,14 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockByIndex(container, blockIndex) {
     const block = getChildBlocks(container)[blockIndex];
-    assert(logger$4P, block, `container have not block at index ${blockIndex}`);
+    assert(logger$4O, 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$4O = getLogger("block-dom");
+  const logger$4N = getLogger("block-dom");
   function isBlock$1(node) {
     if (!(node instanceof HTMLDivElement)) {
       return false;
@@ -12113,12 +12113,12 @@ var __publicField = (obj, key, value) => {
   }
   function getBlockId(block) {
     const { id } = block;
-    assert(logger$4O, id, "no block id");
+    assert(logger$4N, id, "no block id");
     return id;
   }
   function getBlockType(block) {
     const type = block.getAttribute("data-block-type");
-    assert(logger$4O, type, "invalid block dom, no data-type");
+    assert(logger$4N, type, "invalid block dom, no data-type");
     return type;
   }
   function getParentBlock(node) {
@@ -12141,12 +12141,12 @@ var __publicField = (obj, key, value) => {
   }
   function getParentContainer(block) {
     const container = block.closest("div[data-type=editor-container]");
-    assert(logger$4O, container, "failed to get block container");
+    assert(logger$4N, container, "failed to get block container");
     return container;
   }
   function getBlockContent(block) {
     const content = block.querySelector(":scope >div[data-type=block-content]");
-    assert(logger$4O, content, "no block content");
+    assert(logger$4N, content, "no block content");
     return content;
   }
   function getBlockTools(block) {
@@ -12155,7 +12155,7 @@ var __publicField = (obj, key, value) => {
       tools = createElement("div", [], block);
       tools.setAttribute("data-type", "block-tools");
     }
-    assert(logger$4O, tools, "no block tools");
+    assert(logger$4N, tools, "no block tools");
     return tools;
   }
   function getExistsBlockTools(block) {
@@ -12176,7 +12176,7 @@ var __publicField = (obj, key, value) => {
   function createBlockElement(editor, path, data2) {
     const blockData = editor.editorDecorators.decorateBlock(path, data2);
     const { id, type } = blockData;
-    assert(logger$4O, id, "no block id");
+    assert(logger$4N, id, "no block id");
     const elem = createElement("div", [`${type}-block`], null);
     elem.id = id;
     elem.setAttribute("data-type", "editor-block");
@@ -12214,7 +12214,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxTypeFromElement(box) {
     const type = box.getAttribute("data-box-type");
-    assert(logger$4O, type, "not a valid box element, no type");
+    assert(logger$4N, type, "not a valid box element, no type");
     return type;
   }
   function isBox(node) {
@@ -12225,7 +12225,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxId(box) {
     const { id } = box;
-    assert(logger$4O, id, "no box id");
+    assert(logger$4N, id, "no box id");
     return id;
   }
   function getParentBox(node) {
@@ -12247,7 +12247,7 @@ var __publicField = (obj, key, value) => {
   }
   function getBoxContent(box) {
     const content = box.querySelector("span[data-type=box-content]");
-    assert(logger$4O, content, "invalid box dom, no content");
+    assert(logger$4N, content, "invalid box dom, no content");
     return content;
   }
   function createInsertionElement(type, id, attributes) {
@@ -12269,7 +12269,7 @@ var __publicField = (obj, key, value) => {
   }
   function getInsertionContent(insertion) {
     const content = insertion.querySelector("span[data-type=insertion-content]");
-    assert(logger$4O, content, "invalid insertion-child dom, no content");
+    assert(logger$4N, content, "invalid insertion-child dom, no content");
     return content;
   }
   function getPrevBlock(block) {
@@ -12329,7 +12329,7 @@ var __publicField = (obj, key, value) => {
     const container = getParentContainer(block);
     const children = getChildBlocks(container);
     const index2 = children.indexOf(block);
-    assert(logger$4O, index2 !== -1, "invalid block & container dom, failed to get block index");
+    assert(logger$4N, index2 !== -1, "invalid block & container dom, failed to get block index");
     return index2;
   }
   function isInBlock(target) {
@@ -12354,18 +12354,18 @@ var __publicField = (obj, key, value) => {
   function isTitleBlock$2(block) {
     return block.hasAttribute("data-document-title");
   }
-  const logger$4N = getLogger("block-class");
+  const logger$4M = 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$4N, text2.blockKind === "text", `is not a text block, ${text2.blockType}`);
+    assert(logger$4M, 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$4N, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
+    assert(logger$4M, complex.blockKind === "complex", `is not a text block, ${complex.blockType}`);
     return complex;
   }
   function getBlockClassByType(editor, type) {
@@ -12386,7 +12386,7 @@ var __publicField = (obj, key, value) => {
   function getBlockKind(editor, block) {
     return getBlockClass(editor, block).blockKind;
   }
-  const logger$4M = getLogger("text-block-child");
+  const logger$4L = getLogger("text-block-child");
   function isTextBlockContentChild(elem) {
     if (elem.tagName !== "SPAN") {
       return false;
@@ -12394,14 +12394,14 @@ var __publicField = (obj, key, value) => {
     return true;
   }
   function isTextBlockContentBoxChild(elem) {
-    assert(logger$4M, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$4L, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-box") {
       return true;
     }
     return false;
   }
   function isTextBlockContentInsertionChild(elem) {
-    assert(logger$4M, isTextBlockContentChild(elem), "not a valid text child");
+    assert(logger$4L, isTextBlockContentChild(elem), "not a valid text child");
     if (elem.getAttribute("data-type") === "editor-insertion") {
       return true;
     }
@@ -12411,7 +12411,7 @@ var __publicField = (obj, key, value) => {
     return !isTextBlockContentBoxChild(elem) && !isTextBlockContentInsertionChild(elem);
   }
   function getTextBlockContentChildType(child) {
-    assert(logger$4M, isTextBlockContentChild(child), "not a valid text child");
+    assert(logger$4L, isTextBlockContentChild(child), "not a valid text child");
     if (isTextBlockContentBoxChild(child)) {
       return "box";
     }
@@ -12426,15 +12426,15 @@ var __publicField = (obj, key, value) => {
       return 0;
     if (type === "box")
       return 1;
-    assert(logger$4M, child.textContent !== null, "text block content is undefined");
-    assert(logger$4M, child.textContent.length >= 0, "text block content length is negative");
+    assert(logger$4L, child.textContent !== null, "text block content is undefined");
+    assert(logger$4L, 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$4M, isTextBlockContentChild(child), "not a valid text child");
+      assert(logger$4L, isTextBlockContentChild(child), "not a valid text child");
     });
     return children;
   }
@@ -12463,17 +12463,17 @@ var __publicField = (obj, key, value) => {
         };
       }
       const offset = blockOffset - start;
-      assert(logger$4M, offset > 0, "invalid offset value");
-      assert(logger$4M, !isTextBlockContentBoxChild(child), "invalid box child");
+      assert(logger$4L, offset > 0, "invalid offset value");
+      assert(logger$4L, !isTextBlockContentBoxChild(child), "invalid box child");
       return {
         prev: child,
         next: child,
         offset
       };
     }
-    assert(logger$4M, false, `invalid block child at position: ${blockOffset}`);
+    assert(logger$4L, false, `invalid block child at position: ${blockOffset}`);
   }
-  const logger$4L = getLogger("block-path");
+  const logger$4K = getLogger("block-path");
   function getBlockPath(block) {
     const ret = [];
     let current = block;
@@ -12487,26 +12487,26 @@ var __publicField = (obj, key, value) => {
         return ret;
       }
       const parentBlock = getParentBlock(container);
-      assert(logger$4L, parentBlock, "no parent block");
+      assert(logger$4K, parentBlock, "no parent block");
       current = parentBlock;
     }
-    assert(logger$4L, false, "no parent block");
+    assert(logger$4K, false, "no parent block");
     return [];
   }
-  const logger$4K = getLogger("child-container-path");
+  const logger$4J = getLogger("child-container-path");
   function getContainerBlockPath(container) {
     if (isRootContainer(container)) {
       return [];
     }
     const parentBlock = getParentBlock(container);
-    assert(logger$4K, parentBlock, "no parent block");
+    assert(logger$4J, parentBlock, "no parent block");
     return getBlockPath(parentBlock);
   }
-  const logger$4J = getLogger("load-blocks");
+  const logger$4I = getLogger("load-blocks");
   function loadBlocks(editor, container, path) {
     const containerId = getContainerId(container);
     const blocks = getContainerBlocks$1(container, editor.doc);
-    assert(logger$4J, blocks.length > 0, "no blocks in container");
+    assert(logger$4I, 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);
@@ -12522,7 +12522,7 @@ var __publicField = (obj, key, value) => {
       return block;
     }
     const blocks = getChildBlocks(container);
-    assert(logger$4J, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
+    assert(logger$4I, blockIndex >= 0 && blockIndex <= blocks.length, "invalid block index");
     if (blockIndex === blocks.length) {
       containerBlocksElement.appendChild(block);
     } else {
@@ -12540,7 +12540,7 @@ var __publicField = (obj, key, value) => {
     insertBlockAt(container, blockIndex, block);
     return block;
   }
-  const logger$4I = getLogger("root-container");
+  const logger$4H = getLogger("root-container");
   const MIN_DISTANCE_THRESHOLD$2 = 3;
   class RootContainer {
     constructor(editor, rootContainer) {
@@ -12568,7 +12568,7 @@ var __publicField = (obj, key, value) => {
           this.editor.selection.updateSelection(null);
           this.editor.emit("resize", this.editor);
         } catch (err) {
-          logger$4I.warn(`failed to update selection while container resizing: ${err.message}`);
+          logger$4H.warn(`failed to update selection while container resizing: ${err.message}`);
         }
       });
       __publicField(this, "handleClick", (event) => {
@@ -12602,7 +12602,7 @@ var __publicField = (obj, key, value) => {
         const box = getParentBox(elem);
         if (box && isChildNode(box, eTarget)) {
           const block2 = getParentBlock(box);
-          assert(logger$4I, block2, "no parent block");
+          assert(logger$4H, 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;
         }
@@ -12658,7 +12658,7 @@ var __publicField = (obj, key, value) => {
         this.editor.input.focus({ preventScroll: true });
       });
       __publicField(this, "handleMouseMove", (event) => {
-        assert(logger$4I, this.mouseDownEvent, "no mouse down event");
+        assert(logger$4H, this.mouseDownEvent, "no mouse down event");
         if (ensureIsMobileEvent(this.mouseDownEvent))
           return;
         const deltaX = event.x - this.mouseDownEvent.x;
@@ -12774,7 +12774,7 @@ var __publicField = (obj, key, value) => {
     loadBlocks(editor, container, path);
     return container;
   }
-  const logger$4H = getLogger("block");
+  const logger$4G = getLogger("block");
   function getBlockTextLength$6(editor, block) {
     return getBlockClass(editor, block).getBlockTextLength(block);
   }
@@ -12793,7 +12793,7 @@ var __publicField = (obj, key, value) => {
         return block;
       }
       const parent = getParentBlock(container);
-      assert(logger$4H, parent, "no parent block exists for child container");
+      assert(logger$4G, parent, "no parent block exists for child container");
       block = parent;
     }
   }
@@ -12829,7 +12829,7 @@ var __publicField = (obj, key, value) => {
       }
       return fun(editor, block, options);
     } catch (err) {
-      logger$4H.debug(`unsupported block type: ${type}`);
+      logger$4G.debug(`unsupported block type: ${type}`);
       return null;
     }
   }
@@ -12849,7 +12849,7 @@ var __publicField = (obj, key, value) => {
     const styles2 = Object.fromEntries(Object.entries(data2).filter(([key]) => key.startsWith("style-")));
     Object.entries(styles2).forEach(([, value]) => {
       const type = typeof value;
-      assert(logger$4H, type === "string" || type === "number" || type === "boolean", "invalid style value");
+      assert(logger$4G, type === "string" || type === "number" || type === "boolean", "invalid style value");
     });
     return styles2;
   }
@@ -12974,7 +12974,7 @@ var __publicField = (obj, key, value) => {
     }
     return { element: null, blockCommands: [], boxCommands: [] };
   }
-  const logger$4G = getLogger("embed-block-common");
+  const logger$4F = getLogger("embed-block-common");
   function isColumnsBlock(block) {
     return getBlockType(block) === "layout";
   }
@@ -12982,9 +12982,9 @@ var __publicField = (obj, key, value) => {
     return getBlockType(block) === "embed";
   }
   function getEmbedType(block) {
-    assert(logger$4G, isEmbedBlock(block), "not an embed block");
+    assert(logger$4F, isEmbedBlock(block), "not an embed block");
     const type = block.getAttribute("data-embed-type");
-    assert(logger$4G, type, "no embed data type");
+    assert(logger$4F, type, "no embed data type");
     return type;
   }
   function getEmbedClassFromBlock(editor, block) {
@@ -13050,10 +13050,10 @@ var __publicField = (obj, key, value) => {
       data: (_c = overrideOptions == null ? void 0 : overrideOptions.data) != null ? _c : data2
     });
   }
-  const logger$4F = getLogger("execute-block-command");
+  const logger$4E = getLogger("execute-block-command");
   function executeEmbedBlockCommand(editor, block, commandGroup, item) {
     var _a;
-    assert(logger$4F, isEmbedBlock(block), "not a embed block");
+    assert(logger$4E, isEmbedBlock(block), "not a embed block");
     const embedType = getEmbedType(block);
     const embed = getEmbedClassByType(editor, embedType);
     if (!embed.getOptions) {
@@ -13086,14 +13086,14 @@ var __publicField = (obj, key, value) => {
     }
     return void 0;
   }
-  const logger$4E = getLogger("block-class");
+  const logger$4D = 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$4E, heading, "not a heading block");
+    assert(logger$4D, heading, "not a heading block");
     return heading;
   }
   function isExpandedHeadingBlock(block) {
@@ -13104,7 +13104,7 @@ var __publicField = (obj, key, value) => {
   }
   function getHeadingBlockChildren(block, oldHeading) {
     if (!oldHeading) {
-      assert(logger$4E, isHeadingBlock$1(block), "not a heading block");
+      assert(logger$4D, isHeadingBlock$1(block), "not a heading block");
     }
     const children = [];
     const heading = oldHeading != null ? oldHeading : getBlockHeading(block);
@@ -13134,7 +13134,7 @@ var __publicField = (obj, key, value) => {
     }
     return children;
   }
-  const logger$4D = getLogger("complex-block-position");
+  const logger$4C = getLogger("complex-block-position");
   class EditorComplexBlockPosition {
     constructor(block, childContainerId, custom) {
       __publicField(this, "blockId");
@@ -13143,7 +13143,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$4D, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$4C, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.childContainerId = childContainerId;
@@ -13155,7 +13155,7 @@ var __publicField = (obj, key, value) => {
       return false;
     }
   }
-  const logger$4C = getLogger("simple-block-position");
+  const logger$4B = getLogger("simple-block-position");
   class EditorSimpleBlockPosition {
     constructor(block, offset, type) {
       __publicField(this, "blockId");
@@ -13164,7 +13164,7 @@ var __publicField = (obj, key, value) => {
       if (block instanceof HTMLElement) {
         this.blockId = getBlockId(block);
       } else {
-        assert(logger$4C, typeof block === "string", `not a valid block id: ${block}`);
+        assert(logger$4B, typeof block === "string", `not a valid block id: ${block}`);
         this.blockId = block;
       }
       this.offset = offset;
@@ -13174,7 +13174,7 @@ var __publicField = (obj, key, value) => {
       return true;
     }
   }
-  const logger$4B = getLogger("editor-position");
+  const logger$4A = getLogger("editor-position");
   function createSimpleBlockPosition(block, offset, type) {
     return new EditorSimpleBlockPosition(block, offset, type);
   }
@@ -13196,7 +13196,7 @@ var __publicField = (obj, key, value) => {
       }
       const block1 = editor.getBlockById(pos1.blockId);
       const block2 = editor.getBlockById(pos2.blockId);
-      assert(logger$4B, block1 !== block2, "comparePosition: blocks are the same");
+      assert(logger$4A, block1 !== block2, "comparePosition: blocks are the same");
       return compareElement(block1, block2);
     }
     if (isComplexBlockPosition(pos1) && isComplexBlockPosition(pos2)) {
@@ -13207,13 +13207,13 @@ var __publicField = (obj, key, value) => {
       }
       const container1 = editor.getContainerById(p1.childContainerId);
       const container2 = editor.getContainerById(p2.childContainerId);
-      assert(logger$4B, container1 !== container2, "comparePosition: containers are the same");
+      assert(logger$4A, container1 !== container2, "comparePosition: containers are the same");
       return compareElement(container1, container2);
     }
-    assert(logger$4B, false, "invalid ");
+    assert(logger$4A, false, "invalid ");
     return 0;
   }
-  const logger$4A = getLogger("simple-range");
+  const logger$4z = getLogger("simple-range");
   class EditorSimpleSelectionRange {
     constructor(editor, options) {
       __publicField(this, "editor");
@@ -13262,11 +13262,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$4A, startBlock, "no start block");
-      assert(logger$4A, endBlock, "no end block");
+      assert(logger$4z, startBlock, "no start block");
+      assert(logger$4z, endBlock, "no end block");
       const startContainer = getParentContainer(startBlock);
       const endContainer = getParentContainer(endBlock);
-      assert(logger$4A, startContainer === endContainer, "invalid range");
+      assert(logger$4z, startContainer === endContainer, "invalid range");
       const ret = [];
       if (startBlock === endBlock) {
         ret.push({
@@ -13277,7 +13277,7 @@ var __publicField = (obj, key, value) => {
       } else {
         const startIndex = getBlockIndex(startBlock);
         const endIndex = getBlockIndex(endBlock);
-        assert(logger$4A, startIndex < endIndex, "invalid range, start > index");
+        assert(logger$4z, startIndex < endIndex, "invalid range, start > index");
         ret.push({
           block: startBlock,
           start: this.start,
@@ -13377,7 +13377,7 @@ var __publicField = (obj, key, value) => {
     clearSelection: clearSelection$6,
     convertTo: convertTo$m
   };
-  const logger$4z = getLogger("editor-blocks");
+  const logger$4y = getLogger("editor-blocks");
   class EditorBlocks {
     constructor(editor) {
       __publicField(this, "blocks", /* @__PURE__ */ new Map());
@@ -13386,12 +13386,12 @@ var __publicField = (obj, key, value) => {
     registerBlockClass(blockClass) {
       const type = blockClass.blockType;
       const exists = this.blocks.get(type);
-      assert(logger$4z, !exists, `duplicated block type: ${type}`);
+      assert(logger$4y, !exists, `duplicated block type: ${type}`);
       this.blocks.set(type, blockClass);
     }
     getBlockClass(type) {
       const exists = this.blocks.get(type);
-      assert(logger$4z, exists, `unknown block type: ${type}`);
+      assert(logger$4y, exists, `unknown block type: ${type}`);
       return exists;
     }
     hasBlock(type) {
@@ -13407,7 +13407,7 @@ var __publicField = (obj, key, value) => {
       }
       const content = blockClass.createBlockContent(this.editor, path, container, blockElement, block);
       if (content.parentElement !== blockElement) {
-        logger$4z.warn("content parent is not block");
+        logger$4y.warn("content parent is not block");
         blockElement.appendChild(content);
       }
       this.editor.blockHooks.forEach((hook) => {
@@ -13428,7 +13428,7 @@ var __publicField = (obj, key, value) => {
       return newBlock;
     }
   }
-  const logger$4y = getLogger("editor-embeds");
+  const logger$4x = getLogger("editor-embeds");
   class EditorEmbeds {
     constructor(editor) {
       __publicField(this, "objects", /* @__PURE__ */ new Map());
@@ -13437,12 +13437,12 @@ var __publicField = (obj, key, value) => {
     registerEmbedClass(embedClass) {
       const type = embedClass.embedType;
       const exists = this.objects.get(type);
-      assert(logger$4y, !exists, `duplicated embed object type: ${type}`);
+      assert(logger$4x, !exists, `duplicated embed object type: ${type}`);
       this.objects.set(type, embedClass);
     }
     getEmbedClass(type) {
       const exists = this.objects.get(type);
-      assert(logger$4y, exists, `unknown embed type: ${type}`);
+      assert(logger$4x, exists, `unknown embed type: ${type}`);
       return exists;
     }
     getEmbedClassFromBlock(block) {
@@ -13452,12 +13452,12 @@ var __publicField = (obj, key, value) => {
       this.objects.forEach(callback);
     }
   }
-  const logger$4x = getLogger("embed-block");
+  const logger$4w = getLogger("embed-block");
   function createBlockContent$6(editor, path, container, blockElement, blockData) {
     const content = createBlockContentElement(blockElement, "div");
-    assert(logger$4x, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
+    assert(logger$4w, blockData.type === "embed", `not an embed data: ${JSON.stringify(blockData)}`);
     const embedBlockData = blockData;
-    assert(logger$4x, embedBlockData.embedType && embedBlockData.embedData, `not an embed data: ${JSON.stringify(embedBlockData)}`);
+    assert(logger$4w, 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);
@@ -13485,7 +13485,7 @@ var __publicField = (obj, key, value) => {
   function getCaretRect$4(block, pos) {
     const content = getBlockContent(block);
     const rect = content.getBoundingClientRect();
-    assert(logger$4x, pos.offset === 0 || pos.offset === 1, `invalid offset: ${pos.offset}`);
+    assert(logger$4w, pos.offset === 0 || pos.offset === 1, `invalid offset: ${pos.offset}`);
     if (pos.offset === 1) {
       return new DOMRect(rect.right, rect.top, 0, rect.height);
     }
@@ -13625,18 +13625,18 @@ var __publicField = (obj, key, value) => {
     toStandardDoc: toStandardDoc$2,
     getResources: getResources$2
   };
-  const logger$4w = getLogger("complex-block-helper");
+  const logger$4v = 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$4w, end.isSimple(), "invalid start and end position");
+      assert(logger$4v, end.isSimple(), "invalid start and end position");
       return complexBlockGetAllChildContainers(editor, block);
     }
-    assert(logger$4w, !start.isSimple(), "invalid start pos");
-    assert(logger$4w, !end.isSimple(), "invalid end pos");
+    assert(logger$4v, !start.isSimple(), "invalid start pos");
+    assert(logger$4v, !end.isSimple(), "invalid end pos");
     const blockClass = getComplexBlockClass(editor, block);
     return blockClass.getSelectedContainers(editor, block, start, end);
   }
@@ -13647,11 +13647,11 @@ var __publicField = (obj, key, value) => {
     const parentComplexBlock = getParentBlock(getParentContainer(childBlock));
     if (!parentComplexBlock)
       return false;
-    assert(logger$4w, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$4v, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainer = getParentContainer(childBlock);
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock);
     const index2 = childContainers.indexOf(childContainer);
-    assert(logger$4w, index2 >= 0, "not valid child container");
+    assert(logger$4v, index2 >= 0, "not valid child container");
     return index2 === 0;
   }
   function complexBlockGetFirstSimpleChild(editor, complexBlock, options) {
@@ -13704,13 +13704,13 @@ var __publicField = (obj, key, value) => {
     return block;
   }
   function findPrevSimpleBlockBeforeChildContainer(editor, childContainer, options) {
-    assert(logger$4w, isChildContainer(childContainer), "not a child container");
+    assert(logger$4v, isChildContainer(childContainer), "not a child container");
     const parentComplexBlock = getParentBlock(childContainer);
-    assert(logger$4w, parentComplexBlock, "no parent block");
-    assert(logger$4w, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
+    assert(logger$4v, parentComplexBlock, "no parent block");
+    assert(logger$4v, isComplexKindBlock(editor, parentComplexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, parentComplexBlock, options);
     const containerIndex = childContainers.indexOf(childContainer);
-    assert(logger$4w, containerIndex !== -1, "child container not found");
+    assert(logger$4v, containerIndex !== -1, "child container not found");
     if (containerIndex === 0) {
       const prevBlock = getPrevBlock(parentComplexBlock);
       if (!prevBlock)
@@ -13728,9 +13728,9 @@ var __publicField = (obj, key, value) => {
     return lastBlock2;
   }
   function complexBlockGetTopChildContainers(editor, complexBlock) {
-    assert(logger$4w, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$4v, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$4w, childContainers.length > 0, "no child container");
+    assert(logger$4v, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -13755,9 +13755,9 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function complexBlockGetBottomChildContainers(editor, complexBlock) {
-    assert(logger$4w, isComplexKindBlock(editor, complexBlock), "not a complex block");
+    assert(logger$4v, isComplexKindBlock(editor, complexBlock), "not a complex block");
     const childContainers = complexBlockGetAllChildContainers(editor, complexBlock);
-    assert(logger$4w, childContainers.length > 0, "no child container");
+    assert(logger$4v, childContainers.length > 0, "no child container");
     if (childContainers.length === 1) {
       return childContainers;
     }
@@ -13862,11 +13862,11 @@ var __publicField = (obj, key, value) => {
     return result;
   }
   const anchor = "";
-  const logger$4v = getLogger("text-range");
+  const logger$4u = getLogger("text-range");
   function getBlockRangeInfo(block, blockOffset) {
     const getChildRange = (child, offset) => {
       if (isTextBlockContentInsertionChild(child)) {
-        assert(logger$4v, offset === 0, `invalid offset for insertion child: ${offset}`);
+        assert(logger$4u, offset === 0, `invalid offset for insertion child: ${offset}`);
         const childOffset = 2;
         return {
           child,
@@ -13875,7 +13875,7 @@ var __publicField = (obj, key, value) => {
         };
       }
       if (isTextBlockContentBoxChild(child)) {
-        assert(logger$4v, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
+        assert(logger$4u, offset === 0 || offset === 1, `invalid offset for box: ${offset}`);
         const childOffset = offset === 0 ? 1 : 2;
         return {
           child,
@@ -13884,17 +13884,17 @@ var __publicField = (obj, key, value) => {
         };
       }
       const textNode = child.firstChild;
-      assert(logger$4v, textNode, "no child node for text child");
-      assert(logger$4v, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
+      assert(logger$4u, textNode, "no child node for text child");
+      assert(logger$4u, textNode instanceof Text || textNode instanceof HTMLBRElement, `invalid child for text child, ${textNode.nodeName}`);
       if (textNode instanceof HTMLBRElement) {
-        assert(logger$4v, offset >= 0 && offset <= 0, "invalid offset for text child");
+        assert(logger$4u, offset >= 0 && offset <= 0, "invalid offset for text child");
         return {
           child,
           container: textNode,
           offset
         };
       }
-      assert(logger$4v, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
+      assert(logger$4u, offset >= 0 && offset <= textNode.data.length, "invalid offset for text child");
       return {
         child,
         container: textNode,
@@ -13923,38 +13923,38 @@ var __publicField = (obj, key, value) => {
       }
       start += childLength;
     }
-    assert(logger$4v, false, "failed to get range info");
+    assert(logger$4u, false, "failed to get range info");
   }
   function createChildRange(child, start, end) {
     if (start === end) {
-      assert(logger$4v, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
+      assert(logger$4u, isTextBlockContentInsertionChild(child), "only insertion child can be zero offset");
     } else {
-      assert(logger$4v, start < end, `invalid start & end: ${start}, ${end}`);
+      assert(logger$4u, start < end, `invalid start & end: ${start}, ${end}`);
     }
     if (isTextBlockContentInsertionChild(child)) {
-      assert(logger$4v, start === end, `invalid insertion child range offset: ${start}, ${end}`);
-      assert(logger$4v, start === 0, `invalid insertion child range start: ${start}`);
+      assert(logger$4u, start === end, `invalid insertion child range offset: ${start}, ${end}`);
+      assert(logger$4u, start === 0, `invalid insertion child range start: ${start}`);
       const insertionElem = child;
-      assert(logger$4v, insertionElem.children.length === 3, `invalid insertion dom, children.length = ${insertionElem.children.length}`);
+      assert(logger$4u, 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$4v, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
-      assert(logger$4v, start === 0, `invalid box child range start: ${start}`);
+      assert(logger$4u, start + 1 === end, `invalid box child range offset: ${start}, ${end}`);
+      assert(logger$4u, start === 0, `invalid box child range start: ${start}`);
       const box = child;
-      assert(logger$4v, box.children.length === 3, `invalid box dom, children.length = ${box.children.length}`);
+      assert(logger$4u, 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$4v, end <= length, `invalid child end: ${end}, ${length}`);
+    assert(logger$4u, end <= length, `invalid child end: ${end}, ${length}`);
     const textNode = child.firstChild;
-    assert(logger$4v, textNode instanceof Text, "invalid block text child");
-    assert(logger$4v, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
+    assert(logger$4u, textNode instanceof Text, "invalid block text child");
+    assert(logger$4u, textNode.data.length >= end, `invalid range end: ${end}, ${textNode.data.length}`);
     return createExpandedRange(textNode, start, textNode, end);
   }
-  const logger$4u = getLogger("caret-rect");
+  const logger$4t = getLogger("caret-rect");
   function getChildClientRects(block, child) {
     if (isBox(child)) {
       const box = child;
@@ -13963,7 +13963,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$4u, rects.length > 0, "no box client rects");
+        assert(logger$4t, 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);
@@ -13983,22 +13983,22 @@ var __publicField = (obj, key, value) => {
         const rect2 = getLastClientRect(ranges[0].child);
         return new DOMRect(rect2.right, rect2.top, 1, rect2.height);
       }
-      assert(logger$4u, ranges[1], "invalid ranges");
+      assert(logger$4t, 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$4u, ranges.length >= 1, "failed to get block range");
+    assert(logger$4t, ranges.length >= 1, "failed to get block range");
     if (ranges.length === 1) {
       rangeInfo = ranges[0];
     } else {
-      assert(logger$4u, ranges.length >= 2, `invalid range info length: ${ranges.length}`);
+      assert(logger$4t, 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$4u, rects2.length >= 1, "no client rects for box content");
+        assert(logger$4t, 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);
       }
@@ -14015,9 +14015,9 @@ var __publicField = (obj, key, value) => {
       }
     }
     if (rangeInfo.container instanceof HTMLBRElement) {
-      assert(logger$4u, pos.offset === 0, "invalid offset for empty block text");
+      assert(logger$4t, pos.offset === 0, "invalid offset for empty block text");
       const parent = rangeInfo.container.parentElement;
-      assert(logger$4u, parent, "invalid br parent");
+      assert(logger$4t, parent, "invalid br parent");
       const rect = parent.getBoundingClientRect();
       const ret = new DOMRect(rect.left, rect.top, 1, rect.height);
       return ret;
@@ -14025,11 +14025,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$4u, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
-      assert(logger$4u, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
+      assert(logger$4t, !isTextBlockContentTextChild(rangeInfo.child), "only box or insertion child range has zero client rect");
+      assert(logger$4t, rangeInfo.offset === 1 || rangeInfo.offset === 2, "invalid offset for box or insertion child");
       const child = rangeInfo.child;
       const rects2 = getChildClientRects(block, child);
-      assert(logger$4u, rects2.length >= 1, "no client rects for box content");
+      assert(logger$4t, 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);
@@ -14075,7 +14075,7 @@ var __publicField = (obj, key, value) => {
         });
       }
     }
-    assert(logger$4u, rects.length > 0, "no client rects for range");
+    assert(logger$4t, rects.length > 0, "no client rects for range");
     if (pos.type === "home") {
       return rects[rects.length - 1];
     }
@@ -14155,13 +14155,13 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$4t = getLogger("selection-range");
+  const logger$4s = 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$4t, anchor2 instanceof EditorComplexBlockPosition && focus instanceof EditorComplexBlockPosition, "start position type does not math end type");
+    assert(logger$4s, 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) {
@@ -14183,7 +14183,7 @@ var __publicField = (obj, key, value) => {
     const focus = createSimpleBlockPosition(range.focus.blockId, range.focus.offset, "normal");
     return createEditorSelectionRange(editor, { anchor: anchor2, focus });
   }
-  const logger$4s = getLogger("range-from-point");
+  const logger$4r = getLogger("range-from-point");
   function getBlockRangeFromPoint(editor, pointX, pointY, dragging) {
     const yOffsets = [0, -12, 12];
     let x = pointX;
@@ -14215,7 +14215,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$4s.debug("click on scrollbar, out of element rect");
+          logger$4r.debug("click on scrollbar, out of element rect");
           return null;
         }
       }
@@ -14253,7 +14253,7 @@ var __publicField = (obj, key, value) => {
     let block = getLastChildBlock(container);
     if (!isVisibleBlock(block)) {
       const preBlock = getPrevVisibleBlock(block);
-      assert(logger$4s, preBlock, "container must have visible block");
+      assert(logger$4r, preBlock, "container must have visible block");
       block = preBlock;
     }
     const range = getBlockClass(editor, block).getRangeFromPoint(editor, block, x, block.getBoundingClientRect().bottom - 4);
@@ -14272,7 +14272,7 @@ var __publicField = (obj, key, value) => {
       if (range instanceof EditorSimpleSelectionRange) {
         return range;
       }
-      assert(logger$4s, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
+      assert(logger$4r, range instanceof EditorComplexSelectionRange, `invalid range type: ${typeof range}`);
       const complexRange = range;
       const container2 = editor.getContainerById(complexRange.start.childContainerId);
       return getRangeInContainer(editor, container2, x, y);
@@ -14295,7 +14295,7 @@ var __publicField = (obj, key, value) => {
     });
     return getRangeInContainer(editor, container, x, y);
   }
-  const logger$4r = getLogger("adjust-selection-pos");
+  const logger$4q = getLogger("adjust-selection-pos");
   function getParentContainers(block) {
     const containers = [];
     while (block) {
@@ -14305,10 +14305,10 @@ var __publicField = (obj, key, value) => {
         return containers;
       }
       const newBlock = getParentBlock(container);
-      assert(logger$4r, newBlock, "child container has not parent container");
+      assert(logger$4q, newBlock, "child container has not parent container");
       block = newBlock;
     }
-    assert(logger$4r, false, "should not come here: getParentContainers");
+    assert(logger$4q, false, "should not come here: getParentContainers");
   }
   function getParentBlockInContainer(container, block) {
     while (block) {
@@ -14317,16 +14317,16 @@ var __publicField = (obj, key, value) => {
         return block;
       }
       const newBlock = getParentBlock(parent);
-      assert(logger$4r, newBlock, "could not find parent block for a child container");
+      assert(logger$4q, newBlock, "could not find parent block for a child container");
       block = newBlock;
     }
-    assert(logger$4r, false, "no parent block in specified container");
+    assert(logger$4q, false, "no parent block in specified container");
   }
   function getClosestParentBlock(block1, block2) {
     const containers1 = getParentContainers(block1);
     const containers2 = getParentContainers(block2);
-    assert(logger$4r, containers1.length > 0 && containers2.length > 0, "block has not parent container");
-    assert(logger$4r, containers1[0] === containers2[0], "root container does not equal");
+    assert(logger$4q, containers1.length > 0 && containers2.length > 0, "block has not parent container");
+    assert(logger$4q, 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]) {
@@ -14345,23 +14345,23 @@ var __publicField = (obj, key, value) => {
   }
   function getParentContainerInComplexBlock(parentComplexBlock, element) {
     let block = getParentBlock(element);
-    assert(logger$4r, block, "element is not in a block");
+    assert(logger$4q, block, "element is not in a block");
     while (block) {
       const container = getParentContainer(block);
-      assert(logger$4r, isChildContainer(container), "not a child container");
+      assert(logger$4q, isChildContainer(container), "not a child container");
       const parentBlock = getParentBlock(container);
-      assert(logger$4r, parentBlock, "child container has not parent block");
+      assert(logger$4q, parentBlock, "child container has not parent block");
       if (parentBlock === parentComplexBlock) {
         return container;
       }
       block = parentBlock;
     }
-    assert(logger$4r, false, "failed to find parent container in complex block");
+    assert(logger$4q, false, "failed to find parent container in complex block");
   }
   function complexBlockAdjustSelectionPos(editor, complexBlock, anchor2, focus) {
     const blockId = getBlockId(complexBlock);
-    assert(logger$4r, blockId === anchor2.blockId, "invalid start pos");
-    assert(logger$4r, blockId === focus.blockId, "invalid end pos");
+    assert(logger$4q, blockId === anchor2.blockId, "invalid start pos");
+    assert(logger$4q, blockId === focus.blockId, "invalid end pos");
     const blockClass = getComplexBlockClass(editor, complexBlock);
     if (blockClass.adjustSelectionPos) {
       return blockClass.adjustSelectionPos(editor, complexBlock, anchor2, focus);
@@ -14395,8 +14395,8 @@ var __publicField = (obj, key, value) => {
       if (focus instanceof EditorComplexBlockPosition) {
         focus = createSimpleBlockPosition(focusBlock, getBlockTextLength$6(editor, focusBlock), "end");
       }
-      assert(logger$4r, anchor2 instanceof EditorSimpleBlockPosition, "not valid position type");
-      assert(logger$4r, focus instanceof EditorSimpleBlockPosition, "not valid position type");
+      assert(logger$4q, anchor2 instanceof EditorSimpleBlockPosition, "not valid position type");
+      assert(logger$4q, focus instanceof EditorSimpleBlockPosition, "not valid position type");
       return {
         anchor: anchor2,
         focus
@@ -14450,7 +14450,7 @@ var __publicField = (obj, key, value) => {
       focus
     };
   }
-  const logger$4q = getLogger("core");
+  const logger$4p = getLogger("core");
   function createBlockAnchor(editor, block, id, refClientRect) {
     const tools = getBlockTools(block);
     let elem = tools.querySelector(`.block-anchor[data-id=${id}]`);
@@ -14468,7 +14468,7 @@ var __publicField = (obj, key, value) => {
     return elem;
   }
   function createBlockCaretAnchor(editor, block, offset, id) {
-    assert(logger$4q, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$4p, isTextKindBlock(editor, block), "not a text kind block");
     const caretRect = getTextCaretRect(block, createSimpleBlockPosition(block, offset, "normal"));
     const blockRect = block.getBoundingClientRect();
     const tools = getBlockTools(block);
@@ -14827,19 +14827,19 @@ var __publicField = (obj, key, value) => {
     return result + (index2 ? "-" : "") + word.toLowerCase();
   });
   const kebabCase$1 = kebabCase;
-  const logger$4p = getLogger("box");
+  const logger$4o = getLogger("box");
   function isBoxOp(op) {
     if (!op.attributes)
       return false;
     if (!op.attributes.box)
       return false;
-    assert(logger$4p, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
-    assert(logger$4p, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
+    assert(logger$4o, typeof op.attributes.box === "string" && op.attributes.box === "true" || op.attributes.box === true, `invalid op attribute box property, ${op.attributes.box}`);
+    assert(logger$4o, op.attributes.type, `no box type: ${JSON.stringify(op)}`);
     return true;
   }
-  const logger$4o = getLogger("text-op");
+  const logger$4n = getLogger("text-op");
   function getOpLength(op) {
-    assert(logger$4o, typeof op.insert === "string", "invalid op, no insert");
+    assert(logger$4n, typeof op.insert === "string", "invalid op, no insert");
     return op.insert.length;
   }
   function getOpAt(text2, offset) {
@@ -14847,7 +14847,7 @@ var __publicField = (obj, key, value) => {
     let pos = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$4o, typeof op.insert === "string", "invalid text op, no insert");
+      assert(logger$4n, typeof op.insert === "string", "invalid text op, no insert");
       const end = pos + getOpLength(op);
       if (end > offset) {
         return [op];
@@ -14863,22 +14863,22 @@ var __publicField = (obj, key, value) => {
     }
     return [];
   }
-  const logger$4n = getLogger("rich-text-length");
+  const logger$4m = getLogger("rich-text-length");
   function getTextOpLength(op) {
-    assert(logger$4n, typeof op.insert === "string", "op.insert is not string");
+    assert(logger$4m, 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$4n, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$4m, typeof op.insert === "string", "op.insert is not string");
         count += getTextOpLength(op);
       }
     });
     return count;
   }
-  const logger$4m = getLogger("split-text");
+  const logger$4l = getLogger("split-text");
   function splitText(ops, offset, splitResult) {
     ops = cloneDeep__default.default(ops);
     if (offset === 0) {
@@ -14896,8 +14896,8 @@ var __publicField = (obj, key, value) => {
     let counted = 0;
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
-      assert(logger$4m, typeof op === "object", `invalid op type, ${typeof op}`);
-      assert(logger$4m, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
+      assert(logger$4l, typeof op === "object", `invalid op type, ${typeof op}`);
+      assert(logger$4l, typeof op.insert === "string", `invalid op.insert type, ${typeof op.insert}`);
       const subLen = getTextOpLength(op);
       if (counted + subLen < offset) {
         counted += subLen;
@@ -14907,18 +14907,18 @@ var __publicField = (obj, key, value) => {
           right: ops.slice(i + 1)
         };
       } else {
-        assert(logger$4m, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
+        assert(logger$4l, counted + subLen > offset, `invalid offset, ${counted}, ${subLen}, ${offset}`);
         const splitIndex = offset - counted;
         const copied = cloneDeep__default.default(op);
-        assert(logger$4m, copied.insert, "no copied.insert");
-        assert(logger$4m, typeof copied.insert === "string", "invalid copied.insert type");
+        assert(logger$4l, copied.insert, "no copied.insert");
+        assert(logger$4l, 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$4m, false, "invalid copied.insert, is empty string");
+          assert(logger$4l, false, "invalid copied.insert, is empty string");
         }
         if (op.insert === "") {
-          assert(logger$4m, false, "invalid op.insert, is empty string");
+          assert(logger$4l, false, "invalid op.insert, is empty string");
         }
         const right = [
           op,
@@ -14937,9 +14937,9 @@ var __publicField = (obj, key, value) => {
     throw new Error(`invalid split offset: ${offset}, ${JSON.stringify(ops)}`);
   }
   function splitToThree(text2, offset, length) {
-    assert(logger$4m, offset >= 0, "invalid offset, < 0");
-    assert(logger$4m, length > 0, "invalid length, <= 0");
-    assert(logger$4m, offset + length <= getTextLength(text2), "invalid offset + length < text length");
+    assert(logger$4l, offset >= 0, "invalid offset, < 0");
+    assert(logger$4l, length > 0, "invalid length, <= 0");
+    assert(logger$4l, 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 };
@@ -15162,9 +15162,9 @@ var __publicField = (obj, key, value) => {
     }
     return [color, backgroundColor];
   }
-  const logger$4l = getLogger("text-block-content");
+  const logger$4k = getLogger("text-block-content");
   function updateBlockContentCore(editor, blockPath, content, blockText, insertions) {
-    assert(logger$4l, blockText, "no text for block");
+    assert(logger$4k, blockText, "no text for block");
     if (blockText.length === 0 && (!insertions || insertions.size === 0)) {
       content.innerHTML = "<span><br></span>";
       return;
@@ -15196,9 +15196,9 @@ var __publicField = (obj, key, value) => {
       for (let i2 = 0; i2 < text2.length; i2++) {
         const op = text2[i2];
         if (isBoxOp(op)) {
-          assert(logger$4l, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
+          assert(logger$4k, op.attributes, `op is not an valid box: ${JSON.stringify(op)}`);
           const span2 = editor.editorBoxes.createBox(content, op.attributes);
-          assert(logger$4l, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
+          assert(logger$4k, span2 instanceof HTMLSpanElement, `invalid box element: ${span2.tagName}`);
           const ret = editor.editorBlockRenders.renderBox(blockPath, op.attributes);
           if (ret.classes) {
             addClass(span2, ...ret.classes);
@@ -15216,7 +15216,7 @@ var __publicField = (obj, key, value) => {
           fragment.appendChild(span2);
           continue;
         }
-        assert(logger$4l, op.insert, `no insert in op: ${JSON.stringify(op)}`);
+        assert(logger$4k, 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);
@@ -15247,7 +15247,7 @@ var __publicField = (obj, key, value) => {
     const compositionText = editor.compositingText;
     if (compositionText) {
       const pos = editor.selection.range.start;
-      assert(logger$4l, pos.isSimple(), "not an simple position while compositing");
+      assert(logger$4k, pos.isSimple(), "not an simple position while compositing");
       if (pos.blockId === blockId) {
         const attributes = getAttributesAt(text2, 0);
         insertions.set(pos.offset, [{
@@ -15263,11 +15263,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$4l.debug(`remove ${children.length} temp composition span`);
+      logger$4k.debug(`remove ${children.length} temp composition span`);
     }
     Array.from(children).forEach((c) => c.remove());
   }
-  const logger$4k = getLogger("client-rects");
+  const logger$4j = getLogger("client-rects");
   function getChildrenOffsets(block) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -15285,15 +15285,15 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function getChildrenInRange(editor, block, from, to) {
-    assert(logger$4k, from < to, `invalid from & to: ${from}, ${to}`);
+    assert(logger$4j, from < to, `invalid from & to: ${from}, ${to}`);
     const blockLength = getBlockTextLength$6(editor, block);
-    assert(logger$4k, from >= 0 && to >= 0 && from <= blockLength && to <= blockLength, `invalid offset: ${from}, ${to}, length: ${blockLength}`);
+    assert(logger$4j, 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$4k, startIndex !== -1, "failed to find start child");
-    assert(logger$4k, endIndex !== -1, "failed to find end child");
-    assert(logger$4k, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
+    assert(logger$4j, startIndex !== -1, "failed to find start child");
+    assert(logger$4j, endIndex !== -1, "failed to find end child");
+    assert(logger$4j, startIndex <= endIndex, `invalid start index & end index: ${startIndex}, ${endIndex}`);
     if (startIndex === endIndex) {
       const child = offsets[startIndex];
       return [{
@@ -15375,16 +15375,16 @@ var __publicField = (obj, key, value) => {
     return rects;
   }
   function getRangeClientRects(editor, block, range) {
-    assert(logger$4k, range instanceof EditorSimpleSelectionRange, "invalid range");
+    assert(logger$4j, range instanceof EditorSimpleSelectionRange, "invalid range");
     const start = range.start;
     const end = range.end;
-    assert(logger$4k, start.isSimple(), "text block only allow simple position");
-    assert(logger$4k, end.isSimple(), "text block only allow simple position");
-    assert(logger$4k, start.blockId === end.blockId, "only allow update one text block selection");
-    assert(logger$4k, start.blockId === getBlockId(block), "only allow update one text block selection");
+    assert(logger$4j, start.isSimple(), "text block only allow simple position");
+    assert(logger$4j, end.isSimple(), "text block only allow simple position");
+    assert(logger$4j, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$4j, start.blockId === getBlockId(block), "only allow update one text block selection");
     return getClientRects$2(editor, block, start, end);
   }
-  const logger$4j = getLogger("selection-background");
+  const logger$4i = getLogger("selection-background");
   function getLineHeight(elem) {
     const style2 = window.getComputedStyle(elem);
     const lineHeightStyle = style2.getPropertyValue("line-height");
@@ -15404,9 +15404,9 @@ var __publicField = (obj, key, value) => {
     return lineHeight;
   }
   function updateSelection$4(editor, block, start, end) {
-    assert(logger$4j, start.isSimple(), "text block only allow simple position");
-    assert(logger$4j, end.isSimple(), "text block only allow simple position");
-    assert(logger$4j, start.blockId === end.blockId, "only allow update one text block selection");
+    assert(logger$4i, start.isSimple(), "text block only allow simple position");
+    assert(logger$4i, end.isSimple(), "text block only allow simple position");
+    assert(logger$4i, start.blockId === end.blockId, "only allow update one text block selection");
     const from = start.offset;
     const to = end.offset;
     if (from === to) {
@@ -15465,7 +15465,7 @@ var __publicField = (obj, key, value) => {
       }
     });
   }
-  const logger$4i = getLogger("line-breaker");
+  const logger$4h = getLogger("line-breaker");
   function mergeTextRects(rects) {
     const result = [];
     let lastRect = null;
@@ -15592,7 +15592,7 @@ var __publicField = (obj, key, value) => {
       }
       const textChild = child;
       const rects = mergeTextRects(textChild.getClientRects());
-      assert(logger$4i, rects.length > 0, "invalid text child dom");
+      assert(logger$4h, rects.length > 0, "invalid text child dom");
       if (rects.length === 1) {
         const nextChild = children[i + 1];
         if (!nextChild) {
@@ -15617,10 +15617,10 @@ var __publicField = (obj, key, value) => {
         continue;
       }
       const textNode = textChild.firstChild;
-      assert(logger$4i, textNode, "invalid text child, no text node");
-      assert(logger$4i, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
+      assert(logger$4h, textNode, "invalid text child, no text node");
+      assert(logger$4h, textNode instanceof Text, `invalid text child, not a valid text node: ${typeof textNode}`);
       const textChildLength = getTextBlockContentChildTextLength(textChild);
-      assert(logger$4i, textNode.data.length === textChildLength, "text node data length not equal child text length");
+      assert(logger$4h, 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];
@@ -15662,7 +15662,7 @@ var __publicField = (obj, key, value) => {
         }
       }
     }
-    assert(logger$4i, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
+    assert(logger$4h, position.offset <= getTextBlockLength(block), "invalid position, offset > block length");
     return {
       lineIndex: lineBreaks.length,
       lineBreaks
@@ -24435,7 +24435,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$4h = getLogger("text-offset");
+  const logger$4g = getLogger("text-offset");
   function getChildOffset(block, child) {
     const children = getTextBlockContentChildren(block);
     let start = 0;
@@ -24451,26 +24451,26 @@ var __publicField = (obj, key, value) => {
       }
       start += testLength;
     }
-    assert(logger$4h, false, "can not find child in children");
+    assert(logger$4g, false, "can not find child in children");
   }
   function isValidOffset(block, blockOffset) {
-    assert(logger$4h, blockOffset >= 0, `invalid offset: ${blockOffset}`);
+    assert(logger$4g, blockOffset >= 0, `invalid offset: ${blockOffset}`);
     const childInfo = getTextBlockChild(block, blockOffset);
     const { prev, next: next2, offset } = childInfo;
     if (!prev && !next2) {
-      assert(logger$4h, false, "invalid offset, no prev & next child at offset");
+      assert(logger$4g, false, "invalid offset, no prev & next child at offset");
     }
     if (prev !== next2) {
       return true;
     }
     const child = prev;
-    assert(logger$4h, child, "no child");
+    assert(logger$4g, child, "no child");
     if (isTextBlockContentBoxChild(child)) {
-      assert(logger$4h, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
+      assert(logger$4g, offset === 0 || offset === 1, `invalid box child offset: ${offset}`);
       return true;
     }
     const text2 = child.textContent;
-    assert(logger$4h, text2, "no content for text child");
+    assert(logger$4g, text2, "no content for text child");
     const chars = splitter.splitGraphemes(text2);
     const validOffsets = /* @__PURE__ */ new Set();
     let start = 0;
@@ -24500,7 +24500,7 @@ var __publicField = (obj, key, value) => {
   }
   function getNextValidOffset(block, blockOffset) {
     const length = getTextBlockLength(block);
-    assert(logger$4h, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
+    assert(logger$4g, blockOffset >= 0 && blockOffset <= length, `invalid offset: ${blockOffset}, ${length}`);
     if (blockOffset === length) {
       return length;
     }
@@ -24514,7 +24514,7 @@ var __publicField = (obj, key, value) => {
     }
     return ret;
   }
-  const logger$4g = getLogger("line-offset");
+  const logger$4f = getLogger("line-offset");
   function getLineOffsets(block) {
     const lineBreaks = getLineBreaks(block);
     const ret = [];
@@ -24535,7 +24535,7 @@ var __publicField = (obj, key, value) => {
   }
   function getLineOffset(block, lineIndex) {
     const lines = getLineOffsets(block);
-    assert(logger$4g, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
+    assert(logger$4f, lineIndex >= 0 && lineIndex < lines.length, `invalid line index: ${lineIndex}, ${lines.length}`);
     return lines[lineIndex];
   }
   function getLineOffsetByPos(block, pos) {
@@ -24592,7 +24592,7 @@ var __publicField = (obj, key, value) => {
   function getLineCount(block) {
     return getLineOffsets(block).length;
   }
-  const logger$4f = getLogger("find-text-position");
+  const logger$4e = getLogger("find-text-position");
   function isWrappedLine(block, lineIndex) {
     const { start, end } = getLineOffset(block, lineIndex);
     const blockId = getBlockId(block);
@@ -24603,13 +24603,13 @@ var __publicField = (obj, key, value) => {
       return false;
     }
     const childInfo = getTextBlockChild(block, start);
-    assert(logger$4f, childInfo.next, "no next child at offset");
-    assert(logger$4f, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
+    assert(logger$4e, childInfo.next, "no next child at offset");
+    assert(logger$4e, !isTextBlockContentTextChild(childInfo.next), "next child is not text child");
     return true;
   }
   function getWrappedLineOffsets(block, lineIndex) {
     const blockId = getBlockId(block);
-    assert(logger$4f, isWrappedLine(block, lineIndex), "line is not wrapped");
+    assert(logger$4e, 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) {
@@ -24624,11 +24624,11 @@ var __publicField = (obj, key, value) => {
         return offset - 1;
       }
     }
-    assert(logger$4f, false, "failed to find wrapped offset");
+    assert(logger$4e, false, "failed to find wrapped offset");
     return 0;
   }
   function findTextPositionInLine(editor, block, lineIndex, sourceBlock, pos, findDirection, suggestedX) {
-    assert(logger$4f, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
+    assert(logger$4e, isTextKindBlock(editor, block), `not a text kind block: ${getBlockType(block)}`);
     const { start, end } = getLineOffset(block, lineIndex);
     let from = start;
     const blockId = getBlockId(block);
@@ -24670,11 +24670,11 @@ var __publicField = (obj, key, value) => {
     return retPos;
   }
   function findPrevTextBlockPosition(editor, block, sourceBlock, pos, suggestedX) {
-    assert(logger$4f, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$4e, 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$4f, isTextKindBlock(editor, block), "not a text block");
+    assert(logger$4e, isTextKindBlock(editor, block), "not a text block");
     return findTextPositionInLine(editor, block, 0, sourceBlock, pos, "down", suggestedX);
   }
   function moveDown(editor, block, position, suggestedX) {
@@ -24782,7 +24782,7 @@ var __publicField = (obj, key, value) => {
     }
     return pos;
   }
-  const logger$4e = getLogger("move-caret");
+  const logger$4d = getLogger("move-caret");
   function moveTextCaret(editor, block, position, direction) {
     if (direction === "ArrowLeft") {
       const ret = moveLeft(block, position);
@@ -24812,9 +24812,9 @@ var __publicField = (obj, key, value) => {
       }
       return createSimpleBlockPosition(getBlockId(block), ret.offset, ret.type);
     }
-    assert(logger$4e, false, `invalid navigation direction: ${direction}`);
+    assert(logger$4d, false, `invalid navigation direction: ${direction}`);
   }
-  const logger$4d = getLogger("text-range");
+  const logger$4c = getLogger("text-range");
   function getBlockRects(block) {
     const ret = [];
     const children = getTextBlockContentChildren(block);
@@ -24872,9 +24872,9 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const children = getTextBlockContentChildren(block);
-    assert(logger$4d, children.indexOf(child) !== -1, "failed to find child in children");
+    assert(logger$4c, children.indexOf(child) !== -1, "failed to find child in children");
     const offsetInfo = getChildOffset(block, child);
-    assert(logger$4d, offsetInfo, "failed to get child offset");
+    assert(logger$4c, offsetInfo, "failed to get child offset");
     const { start } = offsetInfo;
     let offset;
     let length;
@@ -24890,7 +24890,7 @@ var __publicField = (obj, key, value) => {
       }
       length = 0;
     } else {
-      assert(logger$4d, child.firstChild instanceof Text, "child is not text");
+      assert(logger$4c, child.firstChild instanceof Text, "child is not text");
       offset = start + textNodeOffsetFromPoint(child.firstChild, x, y);
       length = 0;
     }
@@ -24923,22 +24923,9 @@ var __publicField = (obj, key, value) => {
     }
     return versions;
   }
-  class WikiMacroError extends Error {
-    constructor(details, requestId) {
-      super(details.message || details.code);
-      __publicField(this, "code");
-      __publicField(this, "sizeBytes");
-      __publicField(this, "limitBytes");
-      this.requestId = requestId;
-      this.name = "WikiMacroError";
-      this.code = details.code;
-      this.sizeBytes = details.sizeBytes;
-      this.limitBytes = details.limitBytes;
-    }
-  }
-  const logger$4c = getLogger("create-text-op");
+  const logger$4b = getLogger("create-text-op");
   function createTextOp(text2, attributes) {
-    assert(logger$4c, text2, "text is empty");
+    assert(logger$4b, text2, "text is empty");
     const ret = {
       insert: text2
     };
@@ -24961,7 +24948,7 @@ var __publicField = (obj, key, value) => {
     }
     return result;
   }
-  const logger$4b = getLogger("merge-ops");
+  const logger$4a = getLogger("merge-ops");
   function mergeOps(text2) {
     if (text2.length <= 1) {
       return text2;
@@ -24983,10 +24970,10 @@ var __publicField = (obj, key, value) => {
         return false;
       }
       if (op1.attributes === void 0) {
-        assert(logger$4b, op2.attributes === void 0, "op2.attributes is not undefined");
+        assert(logger$4a, op2.attributes === void 0, "op2.attributes is not undefined");
         return true;
       }
-      assert(logger$4b, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
+      assert(logger$4a, op1.attributes && op2.attributes, "op1.attributes && op2.attributes is undefined");
       return isEqual__default.default(op1.attributes, op2.attributes);
     };
     const newOps = [];
@@ -24995,8 +24982,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$4b, typeof before.insert === "string", "before.insert is not string");
-        assert(logger$4b, typeof op.insert === "string", "op.insert is not string");
+        assert(logger$4a, typeof before.insert === "string", "before.insert is not string");
+        assert(logger$4a, typeof op.insert === "string", "op.insert is not string");
         before.insert += op.insert;
       } else {
         newOps.push(op);
@@ -25024,15 +25011,15 @@ var __publicField = (obj, key, value) => {
     }
     return text2.slice(0, i + 1);
   }
-  const logger$4a = getLogger("delete-text");
+  const logger$49 = 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$4a, offset >= 0, `invalid offset: ${offset}`);
-    assert(logger$4a, count >= 1, `invalid delete count: ${count}`);
+    assert(logger$49, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$49, count >= 1, `invalid delete count: ${count}`);
     const ops = [];
     if (offset !== 0) {
       ops.push({
@@ -25044,7 +25031,7 @@ var __publicField = (obj, key, value) => {
     });
     return ops;
   }
-  const logger$49 = getLogger("delta");
+  const logger$48 = getLogger("delta");
   function diffRichText(oldText, newText) {
     const delta1D = new Delta__default.default(oldText);
     const delta2D = new Delta__default.default(newText);
@@ -25054,7 +25041,7 @@ var __publicField = (obj, key, value) => {
     return new Delta__default.default(ops).transformPosition(cursor, !isLocalOp);
   }
   function isValidDocText(text2) {
-    assert(logger$49, text2, "ops is null or undefined");
+    assert(logger$48, 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) {
@@ -25074,7 +25061,7 @@ var __publicField = (obj, key, value) => {
   }
   class RichText {
     static ensureValidText(text2) {
-      assert(logger$49, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
+      assert(logger$48, isValidDocText(text2), `text is not a valid text, ${JSON.stringify(text2)}`);
     }
     static diff(oldText, newText) {
       this.ensureValidText(oldText);
@@ -25096,9 +25083,9 @@ var __publicField = (obj, key, value) => {
       return resultText;
     }
   }
-  const logger$48 = getLogger("insert-text");
+  const logger$47 = getLogger("insert-text");
   function insertText(richText2, offset, text2, attributes) {
-    assert(logger$48, text2, `invalid text to insert: ${text2}`);
+    assert(logger$47, 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];
@@ -25111,7 +25098,7 @@ var __publicField = (obj, key, value) => {
     };
   }
   function createInsertOps(offset, text2, attributes) {
-    assert(logger$48, offset >= 0, `invalid offset: ${offset}`);
+    assert(logger$47, offset >= 0, `invalid offset: ${offset}`);
     if (text2.length === 0) {
       return [];
     }
@@ -25141,7 +25128,7 @@ var __publicField = (obj, key, value) => {
   function cloneText(text2) {
     return cloneDeep__default.default(text2);
   }
-  const logger$47 = getLogger("update-op-attribute");
+  const logger$46 = getLogger("update-op-attribute");
   function updateOpAttributes(orgOps, key, value, newAttributes) {
     const ops = cloneText(orgOps);
     const index2 = ops.findIndex((op2) => {
@@ -25149,7 +25136,7 @@ var __publicField = (obj, key, value) => {
         return false;
       return op2.attributes[key] === value;
     });
-    assert(logger$47, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
+    assert(logger$46, index2 !== -1, `can not find op by key: ${key}, value: ${value}`);
     const op = ops[index2];
     op.attributes = {
       ...op.attributes,
@@ -25224,11 +25211,11 @@ var __publicField = (obj, key, value) => {
     ]);
   }
   const FILL_CHAR = "\u200B";
-  const logger$46 = getLogger("to-plain-text");
+  const logger$45 = getLogger("to-plain-text");
   function toPlainText(ops, options) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$46, typeof op.insert === "string", "invalid op");
+      assert(logger$45, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         if (options == null ? void 0 : options.boxReplacement) {
           text2 += options.boxReplacement;
@@ -25283,7 +25270,64 @@ var __publicField = (obj, key, value) => {
       focus: pos
     };
   }
-  const logger$45 = getLogger("repair-duplicated-block-ids");
+  const WIKI_MACRO_TYPE = "ones-open-wiki-macro";
+  function getWikiMacroExportSpec(data2) {
+    if (!data2 || data2.protocolVersion !== 2 || !Array.isArray(data2.exportSpec))
+      return [];
+    return data2.exportSpec.filter((spec) => {
+      if (!spec || typeof spec !== "object")
+        return false;
+      if (spec.type === "text")
+        return typeof spec.data === "string";
+      if (spec.type === "image")
+        return typeof spec.data === "string" && !!spec.data;
+      return spec.type === "link" && spec.data && typeof spec.data.title === "string" && typeof spec.data.url === "string" && /^(https?:\/\/|mailto:)/i.test(spec.data.url.trim());
+    });
+  }
+  function getWikiMacroResources(data2) {
+    if (!data2 || data2.protocolVersion !== 2)
+      return [];
+    const resources = /* @__PURE__ */ new Set();
+    if (Array.isArray(data2.resources)) {
+      data2.resources.forEach((resource) => {
+        if (typeof resource === "string" && resource)
+          resources.add(resource);
+      });
+    }
+    getWikiMacroExportSpec(data2).forEach((spec) => {
+      if (spec.type === "image" && typeof spec.data === "string" && spec.data)
+        resources.add(spec.data);
+    });
+    return Array.from(resources);
+  }
+  function replaceWikiMacroResources(data2, resources) {
+    if (!data2 || data2.protocolVersion !== 2)
+      return;
+    if (Array.isArray(data2.resources)) {
+      data2.resources = data2.resources.map((resource) => {
+        var _a;
+        return (_a = resources.get(resource)) != null ? _a : resource;
+      });
+    }
+    getWikiMacroExportSpec(data2).forEach((spec) => {
+      var _a;
+      if (spec.type === "image" && typeof spec.data === "string")
+        spec.data = (_a = resources.get(spec.data)) != null ? _a : spec.data;
+    });
+  }
+  function wikiMacroToText(data2) {
+    return getWikiMacroExportSpec(data2).map((spec) => {
+      if (spec.type === "text" && typeof spec.data === "string")
+        return spec.data;
+      if (spec.type === "link" && spec.data && typeof spec.data === "object") {
+        const link2 = spec.data;
+        if (typeof link2.title === "string" && typeof link2.url === "string")
+          return `${link2.title} ${link2.url}`;
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  const logger$44 = getLogger("repair-duplicated-block-ids");
   const ROOT_CONTAINER_ID = "root";
   function buildChildContainersDelta(doc2, block) {
     const children = block.children;
@@ -25335,10 +25379,10 @@ var __publicField = (obj, key, value) => {
         if (seenBlockIds.has(block.id)) {
           duplicatedIds.push(block.id);
           if (readonly) {
-            logger$45.warn(`duplicated block id ${block.id} at ${containerId}[${blockIndex}], readonly, skip repairing`);
+            logger$44.warn(`duplicated block id ${block.id} at ${containerId}[${blockIndex}], readonly, skip repairing`);
           } else {
             const newId = genId();
-            logger$45.warn(`repair duplicated block id ${block.id} -> ${newId} at ${containerId}[${blockIndex}]`);
+            logger$44.warn(`repair duplicated block id ${block.id} -> ${newId} at ${containerId}[${blockIndex}]`);
             const childDelta = buildChildContainersDelta(doc2, block);
             doc2.localUpdateBlockData(
               containerId,
@@ -25362,17 +25406,17 @@ var __publicField = (obj, key, value) => {
     };
     visitContainer(ROOT_CONTAINER_ID);
     if (duplicatedIds.length > 0) {
-      logger$45.error(
+      logger$44.error(
         `found ${duplicatedIds.length} duplicated block id(s): ${duplicatedIds.join(", ")}, repaired ${repaired}`
       );
     }
     return { repaired, duplicatedIds };
   }
-  const logger$44 = getLogger("block-to-text");
+  const logger$43 = getLogger("block-to-text");
   function textBlockToText$1(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$44, typeof op.insert === "string", "invalid op");
+      assert(logger$43, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -25390,11 +25434,11 @@ var __publicField = (obj, key, value) => {
     });
     return text2;
   }
-  const logger$43 = getLogger("block-to-text");
+  const logger$42 = getLogger("block-to-text");
   function textToMarkdownText(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$43, typeof op.insert === "string", "invalid op");
+      assert(logger$42, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -25517,12 +25561,12 @@ var __publicField = (obj, key, value) => {
         return void 0;
     }
   }
-  const logger$42 = getLogger("block-to-text");
+  const logger$41 = getLogger("block-to-text");
   function textBlockToHtml(editor, blockData, doc2) {
     let html = "";
     const ops = blockData.text || [];
     ops.forEach((op) => {
-      assert(logger$42, typeof op.insert === "string", "invalid op");
+      assert(logger$41, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -25598,16 +25642,16 @@ var __publicField = (obj, key, value) => {
     }
     return `<p>${html}</p>`;
   }
-  const logger$41 = getLogger("text-block");
+  const logger$40 = getLogger("text-block");
   function createBlockContent$5(editor, path, container, blockElement, blockData) {
     const { text: text2 } = blockData;
-    assert(logger$41, text2, "no text for text block");
+    assert(logger$40, 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$41, text2, "no text to update");
+    assert(logger$40, text2, "no text to update");
     const newContent = createBlockContentElement(null, "div");
     updateBlockContent$1(editor, getBlockPath(block), getBlockId(block), newContent, text2);
     const oldContent = getBlockContent(block);
@@ -25617,7 +25661,7 @@ var __publicField = (obj, key, value) => {
     return getRangeClientRects(editor, block, range);
   }
   function convertTo$k(editor, blockData, doc2, type) {
-    assert(logger$41, blockData.text, "no text for text block");
+    assert(logger$40, blockData.text, "no text for text block");
     if (type === "text") {
       return textBlockToText$1(editor, blockData.text, doc2);
     }
@@ -25631,7 +25675,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$41, text2, "no text for text block");
+    assert(logger$40, text2, "no text for text block");
     text2.forEach((op) => {
       if (op.insert && op.attributes && op.attributes.box === true) {
         const boxId = genId();
@@ -25664,7 +25708,7 @@ var __publicField = (obj, key, value) => {
     blockToDoc: blockToDoc$1
   };
   const updateTextBlockContent = updateBlockContent$1;
-  const logger$40 = getLogger("action-helper");
+  const logger$3$ = getLogger("action-helper");
   function editorGetBlockData(editor, block) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -25672,10 +25716,10 @@ var __publicField = (obj, key, value) => {
     return editor.doc.getBlockData(containerId, blockIndex);
   }
   function editorGetBlockText(editor, block) {
-    assert(logger$40, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3$, isTextKindBlock(editor, block), "not a text kind block");
     const data2 = editorGetBlockData(editor, block);
     const text2 = data2.text;
-    assert(logger$40, text2, "no text in block");
+    assert(logger$3$, text2, "no text in block");
     return text2;
   }
   function editorGetBlockTextEx(editor, block, length) {
@@ -25683,7 +25727,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetBoxData(editor, box) {
     const block = getParentBlock(box);
-    assert(logger$40, block, "no parent block");
+    assert(logger$3$, block, "no parent block");
     const text2 = editorGetBlockText(editor, block);
     const id = getBoxId(box);
     const op = text2.find((op2) => {
@@ -25693,60 +25737,60 @@ var __publicField = (obj, key, value) => {
       }
       return false;
     });
-    assert(logger$40, op, "failed to find box");
+    assert(logger$3$, op, "failed to find box");
     return op.attributes;
   }
-  const logger$3$ = getLogger("block-text");
+  const logger$3_ = getLogger("block-text");
   function getTextAfterOffset(editor, block, offset) {
-    assert(logger$3$, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3$, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3$, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3_, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3_, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3_, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3$, false, `no text after offset: ${offset}`);
+      assert(logger$3_, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3$, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3_, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3$, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3_, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getTextBeforeOffset(editor, block, offset) {
-    assert(logger$3$, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3$, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3$, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3_, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3_, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3_, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3$, false, `no text before offset: ${offset}`);
+      assert(logger$3_, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3$, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3_, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return " ";
     }
-    assert(logger$3$, op.insert.length === 1 || op.insert.length === 2, "invalid op");
+    assert(logger$3_, op.insert.length === 1 || op.insert.length === 2, "invalid op");
     return op.insert;
   }
   function getOffsetInfoBefore(editor, block, offset) {
-    assert(logger$3$, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3$, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3$, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3_, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3_, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3_, offset > 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getPrevValidOffset(block, offset);
     const length = offset - newOffset;
     if (length === 0) {
-      assert(logger$3$, false, `no text before offset: ${offset}`);
+      assert(logger$3_, false, `no text before offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, newOffset, length);
-    assert(logger$3$, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3_, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -25772,17 +25816,17 @@ var __publicField = (obj, key, value) => {
     };
   }
   function getOffsetInfoAfter(editor, block, offset) {
-    assert(logger$3$, isTextKindBlock(editor, block), "not a text kind block");
-    assert(logger$3$, isValidOffset(block, offset), "not a valid offset");
-    assert(logger$3$, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3_, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3_, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3_, offset >= 0 && offset < getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const newOffset = getNextValidOffset(block, offset);
     const length = newOffset - offset;
     if (length === 0) {
-      assert(logger$3$, false, `no text after offset: ${offset}`);
+      assert(logger$3_, false, `no text after offset: ${offset}`);
     }
     const text2 = editorGetBlockText(editor, block);
     const { middle } = splitToThree(text2, offset, length);
-    assert(logger$3$, middle.length === 1, "failed to split text to 3 parts");
+    assert(logger$3_, middle.length === 1, "failed to split text to 3 parts");
     const op = middle[0];
     if (isBoxOp(op)) {
       return {
@@ -25854,7 +25898,7 @@ var __publicField = (obj, key, value) => {
     return null;
   }
   function findWordLeft(editor, block, offset) {
-    assert(logger$3$, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3_, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -25884,7 +25928,7 @@ var __publicField = (obj, key, value) => {
     return startInfo.offset + startInfo.length;
   }
   function findWordEnd(editor, block, offset) {
-    assert(logger$3$, isTextKindBlock(editor, block), "invalid blok type");
+    assert(logger$3_, isTextKindBlock(editor, block), "invalid blok type");
     if (isEmptyTextBlock(editor, block)) {
       return 0;
     }
@@ -25913,10 +25957,10 @@ var __publicField = (obj, key, value) => {
       return getBlockTextLength$6(editor, block);
     return startInfo.offset;
   }
-  const logger$3_ = getLogger("text-box");
+  const logger$3Z = getLogger("text-box");
   function updateBoxContent$8(editor, boxElement, boxContent, boxData) {
-    assert(logger$3_, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
-    assert(logger$3_, typeof boxData.text === "string", `invalid text type for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3Z, boxData.text, `no text for text box data: ${JSON.stringify(boxData)}`);
+    assert(logger$3Z, 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) {
@@ -25950,7 +25994,7 @@ var __publicField = (obj, key, value) => {
     updateBoxContent: updateBoxContent$7,
     convertTo: convertTo$i
   };
-  const logger$3Z = getLogger("editor-boxes");
+  const logger$3Y = getLogger("editor-boxes");
   class EditorBoxes {
     constructor(editor) {
       __publicField(this, "boxes", /* @__PURE__ */ new Map());
@@ -25959,12 +26003,12 @@ var __publicField = (obj, key, value) => {
     registerBoxClass(boxClass) {
       const type = boxClass.boxType;
       const exists = this.boxes.get(type);
-      assert(logger$3Z, !exists, `duplicated box type: ${type}`);
+      assert(logger$3Y, !exists, `duplicated box type: ${type}`);
       this.boxes.set(type, boxClass);
     }
     getBoxClass(type) {
       const exists = this.boxes.get(type);
-      assert(logger$3Z, exists, `unknown box type: ${type}`);
+      assert(logger$3Y, exists, `unknown box type: ${type}`);
       return exists;
     }
     createBox(blockContent, box) {
@@ -26368,7 +26412,7 @@ var __publicField = (obj, key, value) => {
       return { classes, attributes: newAttributes, styles: newStyles };
     }
   }
-  const logger$3Y = getLogger("editor-insertion");
+  const logger$3X = getLogger("editor-insertion");
   class EditorInsertions {
     constructor(editor) {
       __publicField(this, "insertions", /* @__PURE__ */ new Map());
@@ -26377,12 +26421,12 @@ var __publicField = (obj, key, value) => {
     registerInsertionClass(insertionClass) {
       const type = insertionClass.insertionType;
       const exists = this.insertions.get(type);
-      assert(logger$3Y, !exists, `duplicated insertion type: ${type}`);
+      assert(logger$3X, !exists, `duplicated insertion type: ${type}`);
       this.insertions.set(type, insertionClass);
     }
     getInsertionClass(type) {
       const exists = this.insertions.get(type);
-      assert(logger$3Y, exists, `unknown insertion type: ${type}`);
+      assert(logger$3X, exists, `unknown insertion type: ${type}`);
       return exists;
     }
     createInsertionElement(type, id, attributes) {
@@ -26502,7 +26546,7 @@ var __publicField = (obj, key, value) => {
       };
     }
   }
-  const logger$3X = getLogger("editor-input");
+  const logger$3W = getLogger("editor-input");
   class EditorInput$1 {
     constructor(editor, callbacks) {
       __publicField(this, "editor");
@@ -26639,7 +26683,7 @@ var __publicField = (obj, key, value) => {
           return;
         }
         this.callbacks.onCut(event);
-        logger$3X.debug("on cut");
+        logger$3W.debug("on cut");
       });
       __publicField(this, "handlePaste", (event) => {
         if (event.isTrusted) {
@@ -26760,11 +26804,11 @@ var __publicField = (obj, key, value) => {
       this.callbacks.removeHandler(handler);
     }
     defaultInsertText(editor, containerId, blockIndex, offset, text2) {
-      assert(logger$3X, editor === this.editor, "invalid editor");
+      assert(logger$3W, editor === this.editor, "invalid editor");
       this.callbacks.defaultInsertText(editor, containerId, blockIndex, offset, text2);
     }
     defaultHandleKeydown(editor, event) {
-      assert(logger$3X, editor === this.editor, "invalid editor");
+      assert(logger$3W, editor === this.editor, "invalid editor");
       return this.callbacks.defaultHandleKeydown(editor, event);
     }
     forEach(callback) {
@@ -26790,7 +26834,7 @@ var __publicField = (obj, key, value) => {
     input2.style.left = `${x}px`;
     input2.style.top = `${y}px`;
   }
-  const logger$3W = getLogger("editor-caret");
+  const logger$3V = getLogger("editor-caret");
   function getFirefoxVersion() {
     const userAgent = window.navigator.userAgent;
     const match = userAgent.match(/Firefox\/(\d+)\./);
@@ -26858,11 +26902,11 @@ var __publicField = (obj, key, value) => {
       }
       try {
         const { range } = this.editor.selection;
-        assert(logger$3W, range.isCollapsed, "range is not collapsed");
+        assert(logger$3V, range.isCollapsed, "range is not collapsed");
         const pos = range.start;
-        assert(logger$3W, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
+        assert(logger$3V, pos instanceof EditorSimpleBlockPosition, "only simple block position can has caret");
         const block = this.editor.getBlockById(pos.blockId);
-        assert(logger$3W, isTextKindBlock(this.editor, block), "only text kind block can has caret");
+        assert(logger$3V, isTextKindBlock(this.editor, block), "only text kind block can has caret");
         let rect;
         const compositionSpan = block.querySelector("span.inputting-insertion");
         if (compositionSpan) {
@@ -26895,7 +26939,7 @@ var __publicField = (obj, key, value) => {
           cursor.style.display = "";
         }
       } catch (err) {
-        logger$3W.error(err);
+        logger$3V.error(err);
       }
     }
   }
@@ -26919,7 +26963,7 @@ var __publicField = (obj, key, value) => {
       updateBlockSelection(editor, s.block, s.start, s.end);
     });
   }
-  const logger$3V = getLogger("editor-dom");
+  const logger$3U = getLogger("editor-dom");
   function editorGetClientHeight(editor) {
     const scrollContainer = getScrollContainer$1(editor.rootContainer);
     return scrollContainer.clientHeight;
@@ -27010,7 +27054,7 @@ var __publicField = (obj, key, value) => {
       return;
     }
     if (!isElementVisible(editor.rootContainer)) {
-      logger$3V.warn("editorScrollIntoView: editor is not visible");
+      logger$3U.warn("editorScrollIntoView: editor is not visible");
       return;
     }
     const rootClientRect = editor.rootContainer.getBoundingClientRect();
@@ -27066,7 +27110,7 @@ var __publicField = (obj, key, value) => {
       anchorElem.remove();
     }, 200);
   }
-  const logger$3U = getLogger("range-in-block");
+  const logger$3T = getLogger("range-in-block");
   function rangeInBlock(block, range) {
     const editor = range.getEditor();
     const start = editor.getBlockById(range.start.blockId);
@@ -27093,11 +27137,11 @@ var __publicField = (obj, key, value) => {
       }
     }
     const nextBlock = getNextVisibleBlock(block);
-    assert(logger$3U, nextBlock, "no prev and next block while deleting a block");
+    assert(logger$3T, nextBlock, "no prev and next block while deleting a block");
     newRange = createBlockSimpleRange(editor, nextBlock, 0);
     return newRange;
   }
-  const logger$3T = getLogger("block-to-html");
+  const logger$3S = getLogger("block-to-html");
   function blockToHtml(editor, blockData, doc2, path) {
     const blockClass = getBlockClassByType(editor, blockData.type);
     if (blockClass.convertTo) {
@@ -27106,15 +27150,15 @@ var __publicField = (obj, key, value) => {
     if (blockClass.blockKind !== "text") {
       return `[${blockData.type}]`;
     }
-    assert(logger$3T, blockData.text, "no text");
+    assert(logger$3S, blockData.text, "no text");
     const plainText = toPlainText(blockData.text);
     return `<div>${escapeHtmlText(plainText)}</div>`;
   }
-  const logger$3S = getLogger("block-to-text");
+  const logger$3R = getLogger("block-to-text");
   function textBlockToText(editor, ops, doc2) {
     let text2 = "";
     ops.forEach((op) => {
-      assert(logger$3S, typeof op.insert === "string", "invalid op");
+      assert(logger$3R, typeof op.insert === "string", "invalid op");
       if (op.attributes && op.attributes.box === true) {
         const box = op.attributes;
         const boxClass = editor.editorBoxes.getBoxClass(box.type);
@@ -27140,7 +27184,7 @@ var __publicField = (obj, key, value) => {
     if (blockClass.blockKind !== "text") {
       return `[${blockData.type}]`;
     }
-    assert(logger$3S, blockData.text, "no text");
+    assert(logger$3R, blockData.text, "no text");
     const plainText = textBlockToText(editor, blockData.text, doc2);
     return plainText;
   }
@@ -27173,11 +27217,11 @@ var __publicField = (obj, key, value) => {
     const markdown2 = lines.join("\n");
     return markdown2;
   }
-  const logger$3R = getLogger("get-text-position");
+  const logger$3Q = getLogger("get-text-position");
   function editorGetTextPosition(editor, insertPos) {
     const pos = insertPos != null ? insertPos : editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3R, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3Q, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
@@ -27265,14 +27309,14 @@ var __publicField = (obj, key, value) => {
       return attributes;
     }
   }
-  const logger$3Q = getLogger("insert-text");
+  const logger$3P = getLogger("insert-text");
   function getTextAttributes(editor, containerId, blockIndex, offset) {
     var _a, _b;
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3Q, blockData, "no block data");
-    assert(logger$3Q, blockData.text, "no block text");
+    assert(logger$3P, blockData, "no block data");
+    assert(logger$3P, blockData.text, "no block text");
     if (getTextLength(blockData.text) === 0) {
-      assert(logger$3Q, offset === 0, "invalid text offset");
+      assert(logger$3P, offset === 0, "invalid text offset");
       return BlockAttributesHandler.get(editor).getEmptyBlockTextAttributes(blockData.id);
     }
     if (offset === 0) {
@@ -27319,7 +27363,7 @@ var __publicField = (obj, key, value) => {
     }
     for (let i = 0; i < text2.length; i++) {
       const op = text2[i];
-      assert(logger$3Q, typeof op.insert === "string", "invalid text op, no insert");
+      assert(logger$3P, typeof op.insert === "string", "invalid text op, no insert");
       const endPos = pos + getOpLength(op);
       if (endPos === start) {
         return false;
@@ -27333,8 +27377,8 @@ var __publicField = (obj, key, value) => {
   }
   function editorInsertTextToBlockEx(editor, text2, containerId, blockIndex, offset) {
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3Q, blockData, "no block data");
-    assert(logger$3Q, blockData.text, "no block text");
+    assert(logger$3P, blockData, "no block data");
+    assert(logger$3P, 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);
@@ -27353,21 +27397,21 @@ var __publicField = (obj, key, value) => {
     const { containerId, blockIndex, offset } = editorGetTextPosition(editor);
     editorInsertTextToBlockEx(editor, text2, containerId, blockIndex, offset);
   }
-  const logger$3P = getLogger("update-composition-text");
+  const logger$3O = getLogger("update-composition-text");
   function editorUpdateCompositionText(editor) {
     const pos = editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3P, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3O, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
-    assert(logger$3P, isTextKindBlock(editor, block), "not a text kind block");
+    assert(logger$3O, 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$3P, blockData, "no block data in doc");
-    assert(logger$3P, blockData.text, "no text data in text block");
+    assert(logger$3O, blockData, "no block data in doc");
+    assert(logger$3O, blockData.text, "no text data in text block");
     const blockContent = getBlockContent(block);
     updateBlockContent$1(editor, getBlockPath(block), blockId, blockContent, blockData.text);
   }
@@ -27379,25 +27423,25 @@ var __publicField = (obj, key, value) => {
     const block = editor.getBlockById(blockData.id);
     return block;
   }
-  const logger$3O = getLogger("delete-block-text");
+  const logger$3N = getLogger("delete-block-text");
   function editorDeleteBlockText(editor, block, offset, count, options) {
     if (!editor.isBlockWritable(block)) {
-      logger$3O.error("block is not writable");
+      logger$3N.error("block is not writable");
       return 0;
     }
-    assert(logger$3O, isTextKindBlock(editor, block), "block is not a text kind block");
+    assert(logger$3N, 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$3O, blockData, "no block data in doc");
-    assert(logger$3O, blockData.text, "no text data in text block");
+    assert(logger$3N, blockData, "no block data in doc");
+    assert(logger$3N, 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$3O, to <= getBlockTextLength$6(editor, block), `invalid offset and count: ${offset}, ${count}`);
+    assert(logger$3N, to <= getBlockTextLength$6(editor, block), `invalid offset and count: ${offset}, ${count}`);
     if (!isValidOffset(block, to)) {
       to = getNextValidOffset(block, to);
     }
@@ -27406,7 +27450,7 @@ var __publicField = (obj, key, value) => {
     editor.doc.localUpdateBlockText(containerId, blockIndex, actions2, options);
     return deleteCount;
   }
-  const logger$3N = getLogger("break-text-block");
+  const logger$3M = getLogger("break-text-block");
   function copyBlockAttributes(editor, block, options) {
     const blockData = editor.getBlockData(block);
     const quoted = blockData.quoted;
@@ -27423,8 +27467,8 @@ var __publicField = (obj, key, value) => {
     return ret;
   }
   function editorBreakTextBlock(editor, block, offset, options) {
-    assert(logger$3N, isTextKindBlock(editor, block), `block is not a text kind block: ${getBlockType(block)}`);
-    assert(logger$3N, offset >= 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
+    assert(logger$3M, isTextKindBlock(editor, block), `block is not a text kind block: ${getBlockType(block)}`);
+    assert(logger$3M, offset >= 0 && offset <= getBlockTextLength$6(editor, block), `invalid offset: ${offset}`);
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block);
@@ -27454,7 +27498,7 @@ var __publicField = (obj, key, value) => {
         };
       }
     }
-    assert(logger$3N, isValidOffset(block, offset), "not a valid offset");
+    assert(logger$3M, isValidOffset(block, offset), "not a valid offset");
     const text2 = editorGetBlockText(editor, block);
     const { right } = splitText(text2, offset);
     const rightLength = getTextLength(right);
@@ -27480,12 +27524,12 @@ var __publicField = (obj, key, value) => {
       newBlock
     };
   }
-  const logger$3M = getLogger("prepare-insert-new-block");
+  const logger$3L = 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$3M, blockIndex >= 0 && blockIndex <= blocks.length, `invalid blockIndex: ${blockIndex}`);
+      assert(logger$3L, blockIndex >= 0 && blockIndex <= blocks.length, `invalid blockIndex: ${blockIndex}`);
       return {
         containerId,
         blockIndex
@@ -27519,92 +27563,15 @@ var __publicField = (obj, key, value) => {
       blockIndex: getBlockIndex(newBlock)
     };
   }
-  const logger$3L = getLogger("auto-insert-block");
+  const logger$3K = getLogger("auto-insert-block");
   function editorAutoInsertBlock(editor, blockData, containerId, blockIndex, newRange, insertBlockOptions) {
     const result = editorPrepareInsertNewBlock(editor, containerId, blockIndex);
-    assert(logger$3L, result, `not an valid insert position: ${editor.selection.range}`);
+    assert(logger$3K, 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 editorLeases = /* @__PURE__ */ new WeakMap();
-  function getLeaseState(editor) {
-    let state = editorLeases.get(editor);
-    if (!state) {
-      state = { locks: /* @__PURE__ */ new Map(), activeSessions: /* @__PURE__ */ new Set(), known: true };
-      editorLeases.set(editor, state);
-    }
-    return state;
-  }
-  function initializeWikiMacroLocks(editor) {
-    getLeaseState(editor).known = false;
-  }
-  function updateWikiMacroLocks(editor, locks) {
-    const state = getLeaseState(editor);
-    state.known = true;
-    state.locks.clear();
-    locks.forEach((lock) => state.locks.set(lock.blockId, lock));
-  }
-  function setWikiMacroLockSession(editor, sessionId, active) {
-    const state = getLeaseState(editor);
-    if (active) {
-      state.activeSessions.add(sessionId);
-    } else {
-      state.activeSessions.delete(sessionId);
-    }
-  }
-  function isWikiMacroBlockLocked(editor, block, macroSessionId) {
-    var _a;
-    const state = editorLeases.get(editor);
-    if (!state || state.known && state.locks.size === 0)
-      return false;
-    const mayOwnLease = !!macroSessionId && state.activeSessions.has(macroSessionId);
-    if (!((_a = block.children) == null ? void 0 : _a.length)) {
-      if (block.type !== "embed" || block.embedType !== "ones-open-wiki-macro")
-        return false;
-      if (!state.known)
-        return true;
-      const lease = state.locks.get(block.id);
-      return !!lease && (!mayOwnLease || lease.sessionId !== macroSessionId);
-    }
-    const visited = /* @__PURE__ */ new Set();
-    const hasLockedDescendant = (data2) => {
-      if (visited.has(data2.id))
-        return false;
-      visited.add(data2.id);
-      if (data2.type === "embed" && data2.embedType === "ones-open-wiki-macro") {
-        if (!state.known)
-          return true;
-        const lease = state.locks.get(data2.id);
-        if (lease && (!mayOwnLease || lease.sessionId !== macroSessionId))
-          return true;
-      }
-      for (const containerId of data2.children || []) {
-        const children = editor.doc.findContainerBlocks(containerId) || [];
-        if (children.some(hasLockedDescendant))
-          return true;
-      }
-      return false;
-    };
-    return hasLockedDescendant(block);
-  }
-  function isWikiMacroElementLocked(editor, block, macroSessionId) {
-    const state = editorLeases.get(editor);
-    if (!state || state.known && state.locks.size === 0)
-      return false;
-    if (isWikiMacroBlockLocked(editor, editor.getBlockData(block), macroSessionId))
-      return true;
-    return isHeadingBlock$1(block) && isCollapsedHeadingBlock(block) && getHeadingBlockChildren(block).some(
-      (child) => isWikiMacroBlockLocked(editor, editor.getBlockData(child), macroSessionId)
-    );
-  }
-  function clearWikiMacroLocks(editor) {
-    const state = editorLeases.get(editor);
-    state == null ? void 0 : state.locks.clear();
-    state == null ? void 0 : state.activeSessions.clear();
-    editorLeases.delete(editor);
-  }
-  const logger$3K = getLogger("delete-block");
+  const logger$3J = getLogger("delete-block");
   function getAllChildContainers(editor, blockData, containerIds) {
     if (blockData.children) {
       blockData.children.forEach((childContainerId) => {
@@ -27613,7 +27580,7 @@ var __publicField = (obj, key, value) => {
         }
         const childBlocks = editor.doc.findContainerBlocks(childContainerId);
         if (!Array.isArray(childBlocks)) {
-          logger$3K.warn(`skip invalid child container while deleting: parentBlock=${blockData.id}, container=${childContainerId}`);
+          logger$3J.warn(`skip invalid child container while deleting: parentBlock=${blockData.id}, container=${childContainerId}`);
           return;
         }
         containerIds.add(childContainerId);
@@ -27628,13 +27595,11 @@ var __publicField = (obj, key, value) => {
     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$3J, blockData, "no block data in doc");
     editor.doc.localDeleteBlock(containerId, blockIndex, createEditorSelectionRange(editor, { anchor: newRange.start, focus: newRange.end }));
     return blockData;
   }
   function editorDeleteBlock(editor, block, newDocRange) {
-    if (isWikiMacroElementLocked(editor, block))
-      throw new WikiMacroError({ code: "LOCK_CONFLICT" });
     return editor.undoManager.runInGroup(() => {
       const container = getParentContainer(block);
       if (getChildBlockCount(container) === 1) {
@@ -27676,15 +27641,15 @@ var __publicField = (obj, key, value) => {
     });
     editor.doc.localDeleteChildContainers(Array.from(containerIds));
   }
-  const logger$3J = getLogger("merge-text-block");
+  const logger$3I = getLogger("merge-text-block");
   function editorMergeTextBlock(editor, block1, block2) {
-    assert(logger$3J, isTextKindBlock(editor, block1), "only text block can be merged");
-    assert(logger$3J, isTextKindBlock(editor, block2), "only text block can be merged");
+    assert(logger$3I, isTextKindBlock(editor, block1), "only text block can be merged");
+    assert(logger$3I, 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$3J, text1 && text2, "block data has no text");
+    assert(logger$3I, text1 && text2, "block data has no text");
     const container = getParentContainer(block1);
     const containerId = getContainerId(container);
     const blockIndex = getBlockIndex(block1);
@@ -27694,15 +27659,15 @@ var __publicField = (obj, key, value) => {
     editorDeleteBlock(editor, block2, newRange);
     return block;
   }
-  const logger$3I = getLogger("clear-selected-contents");
+  const logger$3H = getLogger("clear-selected-contents");
   function deleteTextBlockSelection(editor, selectedBlock) {
-    assert(logger$3I, isTextKindBlock(editor, selectedBlock.block), "not a text kind block");
+    assert(logger$3H, isTextKindBlock(editor, selectedBlock.block), "not a text kind block");
     const { start, end } = selectedBlock;
-    assert(logger$3I, start.isSimple(), "not a simple block position");
-    assert(logger$3I, end.isSimple(), "not a simple block position");
+    assert(logger$3H, start.isSimple(), "not a simple block position");
+    assert(logger$3H, end.isSimple(), "not a simple block position");
     const startOffset = start.offset;
     const endOffset = end.offset;
-    assert(logger$3I, startOffset <= endOffset, `invalid delete text offset: ${startOffset}, ${endOffset}`);
+    assert(logger$3H, startOffset <= endOffset, `invalid delete text offset: ${startOffset}, ${endOffset}`);
     if (startOffset === endOffset) {
       return;
     }
@@ -27727,7 +27692,7 @@ var __publicField = (obj, key, value) => {
       return;
     }
     if (isEmbedBlock(block) || start.isSimple()) {
-      assert(logger$3I, end.isSimple(), "invalid range");
+      assert(logger$3H, end.isSimple(), "invalid range");
       const container = getParentContainer(block);
       const blockIndex = getBlockIndex(block);
       const newBlock = editor.insertTextBlock("", getContainerId(container), blockIndex);
@@ -27735,8 +27700,8 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
       return;
     }
-    assert(logger$3I, isComplexKindBlock(editor, block), "invalid block kind");
-    assert(logger$3I, !start.isSimple() && !end.isSimple(), "invalid range");
+    assert(logger$3H, isComplexKindBlock(editor, block), "invalid block kind");
+    assert(logger$3H, !start.isSimple() && !end.isSimple(), "invalid range");
     complexBlockGetSelectedContainers(editor, block, start, end);
     const containers = editor.selection.range.getSelectedContainers();
     containers.forEach((container, index2) => {
@@ -27753,7 +27718,7 @@ var __publicField = (obj, key, value) => {
       return;
     }
     const selectedBlocks = range.getSelectedBlocks();
-    assert(logger$3I, selectedBlocks.length > 0, "no selected block");
+    assert(logger$3H, selectedBlocks.length > 0, "no selected block");
     if (selectedBlocks.length === 1) {
       clearOneBlock(editor, selectedBlocks[0]);
       return;
@@ -27761,7 +27726,7 @@ var __publicField = (obj, key, value) => {
     const firstSelectedBlock = selectedBlocks[0];
     const firstBlock = firstSelectedBlock.block;
     const container = getParentContainer(firstBlock);
-    assert(logger$3I, selectedBlocks.length > 1, "no selected block");
+    assert(logger$3H, selectedBlocks.length > 1, "no selected block");
     const lastSelectedBlock = selectedBlocks[selectedBlocks.length - 1];
     const lastBlock2 = lastSelectedBlock.block;
     if (isTextKindBlock(editor, firstBlock)) {
@@ -27791,7 +27756,7 @@ var __publicField = (obj, key, value) => {
     }
     const prevBlock = getPrevBlock(firstBlock);
     const nextBlock = getNextBlock(lastBlock2);
-    assert(logger$3I, prevBlock || nextBlock, "no prev or next block");
+    assert(logger$3H, prevBlock || nextBlock, "no prev or next block");
     selectedBlocks.forEach((selectedBlock) => editor.deleteBlock(selectedBlock.block));
   }
   function editorClearSelectedContents(editor, selectionRange) {
@@ -27810,7 +27775,7 @@ var __publicField = (obj, key, value) => {
       editor.emit("afterClearSelection", editor);
     });
   }
-  const logger$3H = getLogger("core");
+  const logger$3G = getLogger("core");
   function editorUpdateBlockText(editor, block, ops, options) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -27823,7 +27788,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorSetBlockText(editor, block, newText, options) {
     if (!editor.isBlockWritable(block)) {
-      logger$3H.error("block is not writable");
+      logger$3G.error("block is not writable");
       return;
     }
     const oldText = editor.getBlockText(block);
@@ -27836,7 +27801,7 @@ var __publicField = (obj, key, value) => {
     const ops = RichText.diff(oldText, newText);
     return editorUpdateBlockText(editor, block, ops);
   }
-  const logger$3G = getLogger("update-block-data");
+  const logger$3F = getLogger("update-block-data");
   function editorUpdateBlockData(editor, block, data2, newRange, options) {
     const container = getParentContainer(block);
     const containerId = getContainerId(container);
@@ -27853,17 +27818,17 @@ var __publicField = (obj, key, value) => {
         if (oldKey === "id" || oldKey === "type" || oldKey === "text") {
           return;
         }
-        logger$3G.debug(`delete key: ${oldKey}`);
+        logger$3F.debug(`delete key: ${oldKey}`);
         delta.delete.push(oldKey);
       }
     });
     const entries = Object.entries(data2);
     entries.forEach(([key, value]) => {
-      assert(logger$3G, key !== "id" && key !== "type", `invalid block data delta, ${key}`);
+      assert(logger$3F, 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$3G.debug(`delete key: ${key}`);
+          logger$3F.debug(`delete key: ${key}`);
           delta.delete.push(key);
         }
         return;
@@ -27881,10 +27846,10 @@ var __publicField = (obj, key, value) => {
         }
       }
       if (oldKeys.has(key)) {
-        logger$3G.debug(`replace key: ${key}`);
+        logger$3F.debug(`replace key: ${key}`);
         delta.delete.push(key);
       } else {
-        logger$3G.debug(`insert key: ${key}`);
+        logger$3F.debug(`insert key: ${key}`);
       }
       delta.insert[key] = value;
     });
@@ -27929,13 +27894,13 @@ var __publicField = (obj, key, value) => {
       comments: {}
     };
   }
-  const logger$3F = getLogger("clone-block");
+  const logger$3E = 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$3F, data2 !== childBlock, "invalid child block");
+        assert(logger$3E, data2 !== childBlock, "invalid child block");
         return cloneBlock(editorBlocks, oldDoc2, data2, info);
       }, info);
     }
@@ -27948,7 +27913,7 @@ var __publicField = (obj, key, value) => {
       }
       const newChildContainerId = genId();
       const childBlocks = oldDoc.blocks[oldChildContainerId];
-      assert(logger$3F, Array.isArray(childBlocks), "invalid child blocks");
+      assert(logger$3E, 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;
@@ -27977,7 +27942,7 @@ var __publicField = (obj, key, value) => {
           if (key.startsWith(prefix1)) {
             const keyContent = key.substring(prefix1.length);
             const newKey = `${newContainerId}/${keyContent}`;
-            logger$3F.debug(`replace key: ${key} -> ${newKey}`);
+            logger$3E.debug(`replace key: ${key} -> ${newKey}`);
             return newKey;
           }
         }
@@ -27986,7 +27951,7 @@ var __publicField = (obj, key, value) => {
           if (key.startsWith(prefix2)) {
             const keyContent = key.substring(prefix2.length);
             const newKey = `${newContainerId}_${keyContent}`;
-            logger$3F.debug(`replace key: ${key} -> ${newKey}`);
+            logger$3E.debug(`replace key: ${key} -> ${newKey}`);
             return newKey;
           }
         }
@@ -28001,9 +27966,6 @@ var __publicField = (obj, key, value) => {
       blockData[newKey] = value;
     });
     blockData.id = genId();
-    if (blockData.type === "embed" && blockData.embedType === "ones-open-wiki-macro") {
-      blockData.macroRevision = 1;
-    }
     if (info) {
       info.blockIdMap.set(data2.id, blockData.id);
       childContainerIdMap.forEach((newId, oldId) => info.containerIdMap.set(oldId, newId));
@@ -28019,7 +27981,7 @@ var __publicField = (obj, key, value) => {
   }
   function cloneChildContainer(editorBlocks, oldDoc, containerId, info) {
     const blocks = oldDoc.blocks[containerId];
-    assert(logger$3F, Array.isArray(blocks), "invalid child blocks");
+    assert(logger$3E, Array.isArray(blocks), "invalid child blocks");
     const newDocs = blocks.map((c) => cloneBlock(editorBlocks, oldDoc, c, info));
     const newDoc = mergeDocs(newDocs);
     return newDoc;
@@ -28028,11 +27990,11 @@ 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$3E = getLogger("insert-doc");
+  const logger$3D = getLogger("insert-doc");
   function editorInsertDoc(editor, block, offset, insertedDoc, cloneDocResult) {
     var _a;
     if (isComplexKindBlock(editor, block)) {
-      logger$3E.warn("failed to insert doc into a complex block");
+      logger$3D.warn("failed to insert doc into a complex block");
       return;
     }
     const doc2 = cloneDoc(editor, insertedDoc, cloneDocResult);
@@ -28070,7 +28032,7 @@ var __publicField = (obj, key, value) => {
         }
         return;
       }
-      assert(logger$3E, isTextKindBlock(editor, block), "not a text block");
+      assert(logger$3D, isTextKindBlock(editor, block), "not a text block");
       if (isEmptyTextBlock(editor, block)) {
         const blockIndex2 = getBlockIndex(block);
         let lastBlock22;
@@ -28202,11 +28164,11 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
     }
   }
-  const logger$3D = getLogger("add-text-attribute");
+  const logger$3C = getLogger("add-text-attribute");
   function editorRemoveTextAttribute(editor, block, range, attributeName) {
     const { start, end } = range;
-    assert(logger$3D, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
-    assert(logger$3D, attributeName, "invalid attribute name");
+    assert(logger$3C, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3C, 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);
@@ -28214,8 +28176,8 @@ var __publicField = (obj, key, value) => {
   }
   function editorAddTextAttribute(editor, block, range, attributeName, value) {
     const { start, end } = range;
-    assert(logger$3D, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
-    assert(logger$3D, attributeName, "invalid attribute name");
+    assert(logger$3C, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3C, 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);
@@ -28223,7 +28185,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorSetTextColor(editor, block, range, type, value) {
     const { start, end } = range;
-    assert(logger$3D, start.blockId === end.blockId && start.blockId === getBlockId(block), "invalid range");
+    assert(logger$3C, 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);
@@ -28312,10 +28274,10 @@ var __publicField = (obj, key, value) => {
     });
     return [color, backgroundColor];
   }
-  const logger$3C = getLogger("move-complex-block-position");
+  const logger$3B = getLogger("move-complex-block-position");
   function moveComplexBlockPosition(editor, old, type) {
     const block = editor.getBlockById(old.blockId);
-    assert(logger$3C, isComplexKindBlock(editor, block), "is not a complex block");
+    assert(logger$3B, 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 });
@@ -28324,24 +28286,24 @@ var __publicField = (obj, key, value) => {
     }
     return createComplexBlockPosition(block, getContainerId(nextContainer));
   }
-  const logger$3B = getLogger("move-simple-block-position");
+  const logger$3A = getLogger("move-simple-block-position");
   function getFirstChildBlockInComplexBlock(editor, complexBlock) {
     const containers = complexBlockGetAllChildContainers(editor, complexBlock, { visibleOnly: true });
     if (containers.length === 0) {
-      logger$3B.warn("complex block has not any child container, not loaded?");
+      logger$3A.warn("complex block has not any child container, not loaded?");
       return null;
     }
-    assert(logger$3B, containers.length > 0, "complex block has not any child container");
+    assert(logger$3A, 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$3B.warn("complex block has not any child container, not loaded?");
+      logger$3A.warn("complex block has not any child container, not loaded?");
       return null;
     }
-    assert(logger$3B, containers.length > 0, "complex block has not any child container");
+    assert(logger$3A, containers.length > 0, "complex block has not any child container");
     const container = containers[containers.length - 1];
     return getLastChildBlock(container);
   }
@@ -28386,8 +28348,8 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const parentComplexBlock = getParentBlock(container);
-    assert(logger$3B, parentComplexBlock, "child container has not parent block");
-    assert(logger$3B, isComplexKindBlock(editor, parentComplexBlock), "is not a complex block");
+    assert(logger$3A, parentComplexBlock, "child container has not parent block");
+    assert(logger$3A, isComplexKindBlock(editor, parentComplexBlock), "is not a complex block");
     const nextContainer = getComplexBlockClass(editor, parentComplexBlock).getNextContainer(editor, parentComplexBlock, container, type);
     if (nextContainer) {
       if (isFindPrev(type)) {
@@ -28409,7 +28371,7 @@ var __publicField = (obj, key, value) => {
       return null;
     }
     const parentBlock = getParentBlock(container);
-    assert(logger$3B, parentBlock, "child container has not parent block");
+    assert(logger$3A, parentBlock, "child container has not parent block");
     if (isFindPrev(type)) {
       const prev = getPrevBlock(parentBlock);
       if (prev) {
@@ -28464,7 +28426,7 @@ var __publicField = (obj, key, value) => {
     }
     if (!targetBlock) {
       if (isComplexKindBlock(editor, block) && complexBlockGetAllChildContainers(editor, block).length === 0) {
-        logger$3B.warn("complex block has not any child container, not loaded?");
+        logger$3A.warn("complex block has not any child container, not loaded?");
         targetBlock = direction === "ArrowDown" || direction === "ArrowRight" ? getNextVisibleBlock(block) : getPrevVisibleBlock(block);
       }
     }
@@ -28611,10 +28573,10 @@ var __publicField = (obj, key, value) => {
     editorAdjustSelection(editor, "ArrowUp", "select");
     return true;
   }
-  const logger$3A = getLogger("word-offset");
+  const logger$3z = getLogger("word-offset");
   function editorGetWordLeftPos(editor, type) {
     const old = editor.selection.range.focus;
-    assert(logger$3A, old.isSimple(), "invalid range type");
+    assert(logger$3z, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (isEmptyTextBlock(editor, block)) {
       return createSimpleBlockPosition(block, 0, "home");
@@ -28639,7 +28601,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetWordRightPos(editor, type) {
     const old = editor.selection.range.focus;
-    assert(logger$3A, old.isSimple(), "invalid range type");
+    assert(logger$3z, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (isEmptyTextBlock(editor, block)) {
       return createSimpleBlockPosition(block, 0, "end");
@@ -28751,10 +28713,10 @@ var __publicField = (obj, key, value) => {
     editor.selection.setSelection(editor.selection.getAnchorPos(), pos);
     return true;
   }
-  const logger$3z = getLogger("line-offset");
+  const logger$3y = getLogger("line-offset");
   function editorGetLineHomePos(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3z, old.isSimple(), "invalid range type");
+    assert(logger$3y, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (old.offset === 0 || !isTextKindBlock(editor, block)) {
       const newPos2 = createSimpleBlockPosition(block, 0, "home");
@@ -28771,7 +28733,7 @@ var __publicField = (obj, key, value) => {
   }
   function editorGetLineEndPos(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3z, old.isSimple(), "invalid range type");
+    assert(logger$3y, 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");
@@ -28871,7 +28833,7 @@ var __publicField = (obj, key, value) => {
     editorPageDownScroll(editor);
     return true;
   }
-  const logger$3y = getLogger("table-scroll");
+  const logger$3x = getLogger("table-scroll");
   class DomEventHandler {
     constructor(editor, dom, name, handler, data2, options) {
       __publicField(this, "handleEvent", (event) => {
@@ -28903,7 +28865,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$3y.warn(`event has already registered: ${eventName}`);
+          logger$3x.warn(`event has already registered: ${eventName}`);
           return;
         }
         existsHandlers.push(new DomEventHandler(this.editor, element, eventName, eventHandler, data2, options));
@@ -29013,7 +28975,7 @@ var __publicField = (obj, key, value) => {
     });
     return true;
   }
-  const logger$3x = getLogger("select-all");
+  const logger$3w = getLogger("select-all");
   function isContainerSelectedAllChildBlocks(container, range) {
     const firstBlock = getFirstChildBlock(container);
     const lastBlock2 = getLastChildBlock(container);
@@ -29028,8 +28990,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$3x, block, "no parent block");
-    assert(logger$3x, isComplexKindBlock(editor, block), "not a complex block");
+    assert(logger$3w, block, "no parent block");
+    assert(logger$3w, 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];
@@ -29065,13 +29027,13 @@ var __publicField = (obj, key, value) => {
       selectParentContainer(editor, getFirstChildBlock(editor.rootContainer));
       return false;
     }
-    assert(logger$3x, !range.isSimple(), "invalid range type");
+    assert(logger$3w, !range.isSimple(), "invalid range type");
     if (isComplexBlockSelectedAllChildContainer(focusedBlock, range)) {
       selectParentContainer(editor, focusedBlock);
       return false;
     }
-    assert(logger$3x, focusedBlock, "no parent block");
-    assert(logger$3x, isComplexKindBlock(editor, focusedBlock), "not a complex block");
+    assert(logger$3w, focusedBlock, "no parent block");
+    assert(logger$3w, isComplexKindBlock(editor, focusedBlock), "not a complex block");
     selectComplexBlock(editor, focusedBlock);
     return true;
   }
@@ -29219,7 +29181,7 @@ var __publicField = (obj, key, value) => {
     }
     return cloned;
   }
-  const logger$3w = getLogger("selected-block-to-doc");
+  const logger$3v = getLogger("selected-block-to-doc");
   function appendBlockChildren(editor, data2, doc2) {
     if (!data2.children)
       return;
@@ -29240,7 +29202,7 @@ var __publicField = (obj, key, value) => {
     if (isTextKindBlock(editor, selectedBlock.block)) {
       const start = selectedBlock.start;
       const end = selectedBlock.end;
-      assert(logger$3w, data2.text, "no block text");
+      assert(logger$3v, data2.text, "no block text");
       if (start.offset === end.offset) {
         return {
           blocks: {
@@ -29274,8 +29236,8 @@ var __publicField = (obj, key, value) => {
         comments: {}
       };
     }
-    assert(logger$3w, isComplexKindBlock(editor, selectedBlock.block), "not complex block");
-    assert(logger$3w, data2.children, "no children");
+    assert(logger$3v, isComplexKindBlock(editor, selectedBlock.block), "not complex block");
+    assert(logger$3v, data2.children, "no children");
     const ret = {
       blocks: {
         root: [
@@ -29293,9 +29255,9 @@ var __publicField = (obj, key, value) => {
     const end = createSimpleBlockPosition(block, getBlockTextLength$6(editor, block), "end");
     return selectedBlockToDoc(editor, { block, start, end });
   }
-  const logger$3v = getLogger("block-to-doc");
+  const logger$3u = getLogger("block-to-doc");
   function blocksToDoc(editor, blocks) {
-    assert(logger$3v, blocks.length > 0, "invalid params, no blocks");
+    assert(logger$3u, blocks.length > 0, "invalid params, no blocks");
     const docs = blocks.map((b) => blockToDoc(editor, b));
     return mergeDocs(docs);
   }
@@ -29320,7 +29282,7 @@ var __publicField = (obj, key, value) => {
     const newDocs = selectedBlocks.map((s) => selectedBlockToDoc(editor, s));
     return mergeDocs(newDocs);
   }
-  const logger$3u = getLogger("ensure-block-visible");
+  const logger$3t = getLogger("ensure-block-visible");
   function ensureBlockVisible(editor, block) {
     var _a;
     while (block) {
@@ -29330,16 +29292,16 @@ var __publicField = (obj, key, value) => {
         return;
       }
       const parentComplexBlock = getParentBlock(container);
-      assert(logger$3u, parentComplexBlock, "no parent block");
+      assert(logger$3t, 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$3u, parentComplexBlockClass.showChildContainer, "no showChildContainer method");
+        assert(logger$3t, parentComplexBlockClass.showChildContainer, "no showChildContainer method");
         parentComplexBlockClass.showChildContainer(editor, parentComplexBlock, container);
       }
       block = parentComplexBlock;
     }
   }
-  const logger$3t = getLogger("editor-selection");
+  const logger$3s = getLogger("editor-selection");
   class EditorSelection {
     constructor(editor) {
       __publicField(this, "editor");
@@ -29352,7 +29314,7 @@ var __publicField = (obj, key, value) => {
         }
         const range = this.range;
         if (rangeInBlock(deletedBlock, range)) {
-          logger$3t.debug("adjust selection because remote deleted current block");
+          logger$3s.debug("adjust selection because remote deleted current block");
           const newRange = moveSelectionBeforeDeleteBlock(editor, deletedBlock);
           this.setRange(newRange, { noScroll: true, local: false });
         }
@@ -29492,14 +29454,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$3t, false, "invalid block position, out of range");
+          assert(logger$3s, 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$3t, false, "invalid complex block position, no container found");
+          assert(logger$3s, false, "invalid complex block position, no container found");
         }
       }
     }
@@ -29560,7 +29522,7 @@ var __publicField = (obj, key, value) => {
       let container = getParentContainer(block);
       while (isChildContainer(container)) {
         const parentBlock = getParentBlock(container);
-        assert(logger$3t, parentBlock, "parent block not found");
+        assert(logger$3s, parentBlock, "parent block not found");
         addClass(parentBlock, "child-focused");
         container = getParentContainer(parentBlock);
       }
@@ -29678,15 +29640,15 @@ var __publicField = (obj, key, value) => {
     editor.undoManager.redo();
     return true;
   }
-  const logger$3s = getLogger("delete-text");
+  const logger$3r = getLogger("delete-text");
   function editorDeleteText(editor, type, count, insertPos) {
     const pos = insertPos != null ? insertPos : editor.selection.range.start;
     if (!(pos instanceof EditorSimpleBlockPosition)) {
-      assert(logger$3s, false, `invalid insert pos type: ${typeof pos}`);
+      assert(logger$3r, false, `invalid insert pos type: ${typeof pos}`);
     }
     const { blockId } = pos;
     const block = editor.getBlockById(blockId);
-    assert(logger$3s, isTextKindBlock(editor, block), "block is not a text kind block");
+    assert(logger$3r, isTextKindBlock(editor, block), "block is not a text kind block");
     let { offset } = pos;
     if (type === "backward") {
       if (offset - count < 0) {
@@ -29716,7 +29678,7 @@ var __publicField = (obj, key, value) => {
     }
     return false;
   }
-  const logger$3r = getLogger("handle-backspace");
+  const logger$3q = getLogger("handle-backspace");
   function tryDeleteEmptyBlock(editor, block) {
     if (!isEmptyTextBlock(editor, block)) {
       return;
@@ -29756,7 +29718,7 @@ var __publicField = (obj, key, value) => {
             }
           } else {
             tryDeleteEmptyBlock(editor, block);
-            assert(logger$3r, isEmbedBlock(prevBlock), "prev block is not embed block");
+            assert(logger$3q, isEmbedBlock(prevBlock), "prev block is not embed block");
             editor.selection.selectBlock(prevBlock, 1);
           }
         } else {
@@ -29790,7 +29752,7 @@ var __publicField = (obj, key, value) => {
       editor.deleteBlock(block);
     }
   }
-  const logger$3q = getLogger("word-offset");
+  const logger$3p = getLogger("word-offset");
   function handleEditorDelete(editor, event) {
     if (!editor.selection.range.isCollapsed()) {
       editor.clearSelectedContents();
@@ -29827,7 +29789,7 @@ var __publicField = (obj, key, value) => {
   }
   function handleEditorDeleteLeftWord(editor, event) {
     const old = editor.selection.range.focus;
-    assert(logger$3q, old.isSimple(), "invalid range type");
+    assert(logger$3p, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (!isTextKindBlock(editor, block)) {
       editor.deleteBlock(block);
@@ -29869,7 +29831,7 @@ var __publicField = (obj, key, value) => {
   }
   function handleEditorDeleteRightWord(editor, event) {
     const old = editor.selection.range.focus;
-    assert(logger$3q, old.isSimple(), "invalid range type");
+    assert(logger$3p, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (!isTextKindBlock(editor, block)) {
       editor.deleteBlock(block);
@@ -29910,7 +29872,7 @@ var __publicField = (obj, key, value) => {
   }
   function handleEditorDeleteAfterWords(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3q, old.isSimple(), "invalid range type");
+    assert(logger$3p, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (!isTextKindBlock(editor, block)) {
       editor.deleteBlock(block);
@@ -29923,7 +29885,7 @@ var __publicField = (obj, key, value) => {
   }
   function handleEditorDeleteRightChar(editor) {
     const old = editor.selection.range.focus;
-    assert(logger$3q, old.isSimple(), "invalid range type");
+    assert(logger$3p, old.isSimple(), "invalid range type");
     const block = editor.getBlockById(old.blockId);
     if (!isTextKindBlock(editor, block)) {
       editor.deleteBlock(block);
@@ -29994,59 +29956,13 @@ var __publicField = (obj, key, value) => {
     });
     return true;
   }
-  const editorHooks = /* @__PURE__ */ new WeakMap();
-  function registerDocResourceHook(editor, hook) {
-    if (editor.destroyed) {
-      throw new Error("Cannot register a document resource hook on a destroyed editor");
-    }
-    const registration = { hook, collect: hook.collect, rewrite: hook.rewrite };
-    let hooks = editorHooks.get(editor);
-    if (!hooks) {
-      hooks = /* @__PURE__ */ new Set();
-      editorHooks.set(editor, hooks);
-    }
-    const registrations = hooks;
-    registrations.add(registration);
-    return () => {
-      if (!registrations.delete(registration)) {
-        return;
-      }
-      if (registrations.size === 0 && editorHooks.get(editor) === registrations) {
-        editorHooks.delete(editor);
-      }
-    };
-  }
-  function collectDocResourceHooks(editor, doc2, resources) {
-    const hooks = editorHooks.get(editor);
-    if (!hooks) {
-      return;
-    }
-    for (const registration of hooks) {
-      const ids = registration.collect.call(registration.hook, doc2);
-      for (const id of ids) {
-        resources.add(id);
-      }
-    }
-  }
-  function rewriteDocResourceHooks(editor, doc2, resources) {
-    const hooks = editorHooks.get(editor);
-    if (!hooks) {
-      return;
-    }
-    for (const registration of hooks) {
-      registration.rewrite.call(registration.hook, doc2, resources);
-    }
-  }
-  function clearDocResourceHooks(editor) {
-    const hooks = editorHooks.get(editor);
-    if (hooks) {
-      hooks.clear();
-      editorHooks.delete(editor);
-    }
-  }
   function defaultGetResourceFromBlock(editor, doc2, block, resources) {
     if (block.type === "embed") {
       const embedData = block.embedData;
+      if (block.embedType === WIKI_MACRO_TYPE) {
+        getWikiMacroResources(embedData).forEach((resource) => resources.add(resource));
+        return;
+      }
       const src = embedData.src;
       if (src && typeof src === "string") {
         for (const item of src.split("|")) {
@@ -30118,7 +30034,6 @@ var __publicField = (obj, key, value) => {
         defaultGetResourceFromBlock(editor, doc2, block, resources);
       }
     });
-    collectDocResourceHooks(editor, doc2, resources);
     return Array.from(resources);
   }
   function injectDocToHtmlFragment(htmlFragment, doc2) {
@@ -30202,7 +30117,7 @@ var __publicField = (obj, key, value) => {
     const doc2 = blockToDoc(editor, block);
     editorCopyDoc(editor, doc2);
   }
-  const logger$3p = getLogger("input-handler-actions");
+  const logger$3o = getLogger("input-handler-actions");
   function editorHandleEnter(editor, event) {
     if (editor.readonly || !editor.isWritable()) {
       return false;
@@ -30284,7 +30199,7 @@ var __publicField = (obj, key, value) => {
         toPlainText: true
       });
     }).catch((err) => {
-      logger$3p.error(err);
+      logger$3o.error(err);
     });
     return true;
   }
@@ -30434,6 +30349,10 @@ ${codeText}
   function defaultReplaceBlockResources(doc2, block, resources) {
     if (block.type === "embed") {
       const embedData = block.embedData;
+      if (block.embedType === WIKI_MACRO_TYPE) {
+        replaceWikiMacroResources(embedData, resources);
+        return;
+      }
       const src = embedData.src;
       if (src && typeof src === "string") {
         const newSrc = resources.get(src);
@@ -30491,7 +30410,6 @@ ${codeText}
         defaultReplaceBlockResources(doc2, block, resources);
       }
     });
-    rewriteDocResourceHooks(editor, doc2, resources);
   }
   async function addLocalResourcesToDoc(editor, resources) {
     let localResources = resources.filter((res) => res.indexOf(":") === -1);
@@ -31130,14 +31048,14 @@ ${codeText}
       editor.selection.updateSelection(null, { focusBlockChanged: true });
     });
   }
-  const logger$3o = getLogger("transform-selection");
+  const logger$3n = getLogger("transform-selection");
   function transformSelection(editor, blockId, delta, local) {
     const { range } = editor.selection;
     const { anchor: anchor2, focus } = range;
     if (anchor2.blockId !== blockId && focus.blockId !== blockId) {
       return range;
     }
-    assert(logger$3o, anchor2.isSimple() && focus.isSimple(), "invalid text pos type");
+    assert(logger$3n, anchor2.isSimple() && focus.isSimple(), "invalid text pos type");
     let newAnchor = anchor2;
     if (anchor2.blockId === blockId) {
       const newOffset = RichText.transformCursor(anchor2.offset, delta, local);
@@ -31150,12 +31068,12 @@ ${codeText}
     }
     return createEditorSelectionRange(editor, { anchor: newAnchor, focus: newFocus });
   }
-  const logger$3n = getLogger("handle-block-text-changed");
+  const logger$3m = getLogger("handle-block-text-changed");
   function onBlockTextChanged(editor, containerId, blockIndex, actions2, local) {
     const container = editor.getContainerById(containerId);
     const block = getBlockByIndex(container, blockIndex);
     const blockData = editor.doc.getBlockData(containerId, blockIndex);
-    assert(logger$3n, blockData.text, "no block text");
+    assert(logger$3m, blockData.text, "no block text");
     getTextBlockClass(editor, block).setBlockText(editor, block, blockData.text);
     if (!local) {
       const newRange = transformSelection(editor, blockData.id, actions2, local);
@@ -31187,43 +31105,15 @@ ${codeText}
     });
     handleDeleteBlock$8(editor, block, local, { child: false });
   }
-  const logger$3m = getLogger("editor-doc");
+  const logger$3l = getLogger("editor-doc");
   class EditorDoc extends EventCallbacks {
     constructor(editor, externalDoc, localEvents) {
       super();
       __publicField(this, "localEvents", []);
-      __publicField(this, "unsubscribeMacroLocks");
       this.editor = editor;
       this.externalDoc = externalDoc;
       this.externalDoc.registerCallback(this);
       this.registerLocalEvents(localEvents);
-      this.subscribeMacroLocks();
-    }
-    subscribeMacroLocks() {
-      initializeWikiMacroLocks(this.editor);
-      try {
-        this.unsubscribeMacroLocks = this.externalDoc.onWikiMacroLocks((locks) => {
-          updateWikiMacroLocks(this.editor, locks);
-          this.editor.emit("wikiMacroLocksChanged", this.editor);
-        });
-      } catch (error2) {
-        clearWikiMacroLocks(this.editor);
-        if (!(error2 instanceof WikiMacroError) || error2.code !== "READ_ONLY")
-          throw error2;
-      }
-    }
-    requestWikiMacro(message) {
-      if (this.editor.readonly && message.operation !== "locks" && message.operation !== "getEditResult" && message.operation !== "cancelEdit") {
-        return Promise.reject(new WikiMacroError({ code: "READ_ONLY" }));
-      }
-      return this.externalDoc.requestWikiMacro(message);
-    }
-    onWikiMacroLocks(listener) {
-      return this.externalDoc.onWikiMacroLocks(listener);
-    }
-    getDocumentVersion() {
-      var _a, _b;
-      return (_b = (_a = this.externalDoc).getDocumentVersion) == null ? void 0 : _b.call(_a);
     }
     beginBatchUpdate() {
       return this.externalDoc.beginBatchUpdate();
@@ -31258,14 +31148,12 @@ ${codeText}
     }
     verifyBlockWritable(containerId, blockIndex) {
       const block = this.editor.getBlockByIndex(containerId, blockIndex);
-      assert(logger$3m, this.editor.isBlockWritable(block), `block is not writable, ${containerId}, ${blockIndex}`);
+      assert(logger$3l, this.editor.isBlockWritable(block), `block is not writable, ${containerId}, ${blockIndex}`);
     }
     localUpdateBlockText(containerId, blockIndex, actions2, options) {
       const blockData = this.getBlockData(containerId, blockIndex);
-      if (isWikiMacroBlockLocked(this.editor, blockData))
-        throw new WikiMacroError({ code: "LOCK_CONFLICT" });
       const oldText = blockData.text;
-      assert(logger$3m, oldText, `no text, ${containerId}, ${blockIndex}`);
+      assert(logger$3l, oldText, `no text, ${containerId}, ${blockIndex}`);
       const newRange = transformSelection(this.editor, blockData.id, actions2, true);
       const newText = RichText.apply(oldText, actions2);
       this.localEvents.forEach((event) => event.onBeforeUpdateBlockText(containerId, blockData.id, oldText, newText, newRange.toDocRange()));
@@ -31275,15 +31163,11 @@ ${codeText}
     }
     localUpdateBlockData(containerId, blockIndex, delta, newRange, options) {
       const block = this.editor.getBlockByIndex(containerId, blockIndex);
-      const blockedByMacroLease = isWikiMacroBlockLocked(this.editor, this.getBlockData(containerId, blockIndex));
-      if (blockedByMacroLease && (delta.delete.some((key) => key !== "comments") || Object.keys(delta.insert).some((key) => key !== "comments"))) {
-        throw new WikiMacroError({ code: "LOCK_CONFLICT" });
-      }
       if (!this.editor.isBlockWritable(block)) {
         const deletedKeys = Array.from(delta.delete).filter((key) => key !== "comments");
         const insertedKeys = Object.keys(delta.insert).filter((key) => key !== "comments");
         if (deletedKeys.length > 0 || insertedKeys.length > 0) {
-          assert(logger$3m, false, `block is not writable, comment supported only, ${JSON.stringify(delta)}}`);
+          assert(logger$3l, false, `block is not writable, comment supported only, ${JSON.stringify(delta)}}`);
         }
       }
       const oldData = cloneDeep__default.default(this.getBlockData(containerId, blockIndex));
@@ -31294,9 +31178,7 @@ ${codeText}
       return ret;
     }
     localInsertBlock(containerId, blockIndex, data2, newRange, options) {
-      assert(logger$3m, !this.editor.readonly, "editor is readonly");
-      if (isWikiMacroBlockLocked(this.editor, data2))
-        throw new WikiMacroError({ code: "LOCK_CONFLICT" });
+      assert(logger$3l, !this.editor.readonly, "editor is readonly");
       this.localEvents.forEach((event) => event.onBeforeInsertBlock(containerId, blockIndex, data2, newRange));
       const ret = this.externalDoc.localInsertBlock(containerId, blockIndex, data2, newRange);
       if (!(options == null ? void 0 : options.noFocus)) {
@@ -31305,7 +31187,7 @@ ${codeText}
       return ret;
     }
     localDeleteBlock(containerId, blockIndex, newRange) {
-      assert(logger$3m, !this.editor.readonly, "editor is readonly");
+      assert(logger$3l, !this.editor.readonly, "editor is readonly");
       this.verifyBlockWritable(containerId, blockIndex);
       const blockData = cloneDeep__default.default(this.getBlockData(containerId, blockIndex));
       this.localEvents.forEach((event) => event.onBeforeDeleteBlock(containerId, blockIndex, blockData, newRange));
@@ -31314,10 +31196,7 @@ ${codeText}
       return ret;
     }
     localDeleteChildContainers(containerIds) {
-      assert(logger$3m, !this.editor.readonly, "editor is readonly");
-      if (containerIds.some((containerId) => this.getContainerBlocks(containerId).some((block) => isWikiMacroBlockLocked(this.editor, block)))) {
-        throw new WikiMacroError({ code: "LOCK_CONFLICT" });
-      }
+      assert(logger$3l, !this.editor.readonly, "editor is readonly");
       containerIds.forEach((containerId) => {
         const blocks = cloneDeep__default.default(this.getContainerBlocks(containerId));
         this.localEvents.forEach((event) => event.onBeforeDeleteChildContainer(containerId, blocks));
@@ -31325,10 +31204,7 @@ ${codeText}
       return this.externalDoc.localDeleteChildContainers(containerIds);
     }
     localInsertChildContainers(containers) {
-      assert(logger$3m, !this.editor.readonly, "editor is readonly");
-      if (containers.some((container) => container.blocks.some((block) => isWikiMacroBlockLocked(this.editor, block)))) {
-        throw new WikiMacroError({ code: "LOCK_CONFLICT" });
-      }
+      assert(logger$3l, !this.editor.readonly, "editor is readonly");
       const data2 = cloneDeep__default.default(containers);
       data2.forEach((item) => {
         this.localEvents.forEach((event) => event.onBeforeInsertChildContainer(item.containerId, item.blocks));
@@ -31336,7 +31212,7 @@ ${codeText}
       this.externalDoc.localInsertChildContainers(data2);
     }
     onRequestReload(reason) {
-      logger$3m.debug(`reload doc: ${reason}`);
+      logger$3l.debug(`reload doc: ${reason}`);
       this.editor.reload();
       this.callbacks.forEach((c) => {
         var _a;
@@ -31437,11 +31313,6 @@ ${codeText}
       (_b = (_a = this.externalDoc).triggerReAuth) == null ? void 0 : _b.call(_a, auto);
     }
     destroy() {
-      var _a;
-      this.editor.undoManager.destroy();
-      (_a = this.unsubscribeMacroLocks) == null ? void 0 : _a.call(this);
-      this.unsubscribeMacroLocks = void 0;
-      clearWikiMacroLocks(this.editor);
       this.externalDoc.destroy();
       this.clearCallbacks();
     }
@@ -31450,18 +31321,25 @@ ${codeText}
       return (_c = (_b = (_a = this.externalDoc).getServerMeta) == null ? void 0 : _b.call(_a)) != null ? _c : {};
     }
     reset(doc2) {
-      var _a;
-      logger$3m.log("reset doc");
-      (_a = this.unsubscribeMacroLocks) == null ? void 0 : _a.call(this);
-      clearWikiMacroLocks(this.editor);
+      logger$3l.log("reset doc");
       this.externalDoc = doc2;
       this.externalDoc.registerCallback(this);
-      initializeWikiMacroLocks(this.editor);
       this.editor.reload();
-      this.subscribeMacroLocks();
     }
   }
-  const logger$3l = getLogger("undo-action");
+  function addActions(actions2, action) {
+    if (actions2.length === 0) {
+      actions2.push(action);
+      return;
+    }
+    const last = actions2[actions2.length - 1];
+    if (!last.combinable(action)) {
+      actions2.push(action);
+      return;
+    }
+    last.combine(action);
+  }
+  const logger$3k = getLogger("undo-action");
   class Action {
     constructor(editor, containerId, afterRange, batchActionId) {
       __publicField(this, "beforeRange");
@@ -31483,18 +31361,18 @@ ${codeText}
       return false;
     }
     combinable(other) {
-      assert(logger$3l, other, "no other action");
+      assert(logger$3k, other, "no other action");
       return false;
     }
     combine(other) {
-      assert(logger$3l, false, "no other");
+      assert(logger$3k, false, "no other");
     }
     getBatchActionId() {
       return this.batchActionId;
     }
     setAfterRange(range) {
       if (this.afterRange) {
-        logger$3l.warn("after range has already set");
+        logger$3k.warn("after range has already set");
       }
       this.afterRange = range;
     }
@@ -31516,7 +31394,7 @@ ${codeText}
           const containerId = blockData.children[i];
           const container = doc2.blocks[containerId];
           if (!container) {
-            logger$3l.warn(`container (${containerId}) not found, deleted by others?`);
+            logger$3k.warn(`container (${containerId}) not found, deleted by others?`);
             return false;
           }
         }
@@ -31524,45 +31402,6 @@ ${codeText}
       return true;
     }
   }
-  const logger$3k = getLogger("async-undo-action");
-  class AsyncAction extends Action {
-    constructor(editor, operation) {
-      super(editor, "", editor.selection.range.toDocRange());
-      __publicField(this, "operation");
-      this.operation = operation;
-    }
-    apply(direction) {
-      if (!this.operation)
-        return Promise.reject(Object.assign(new Error("Async history action disposed"), { code: "SESSION_EXPIRED" }));
-      return this.operation[direction]();
-    }
-    reportError(error2) {
-      var _a, _b;
-      (_b = (_a = this.operation) == null ? void 0 : _a.onError) == null ? void 0 : _b.call(_a, error2);
-    }
-    dispose() {
-      var _a;
-      const operation = this.operation;
-      this.operation = null;
-      try {
-        (_a = operation == null ? void 0 : operation.onDiscard) == null ? void 0 : _a.call(operation);
-      } catch {
-        logger$3k.error("Async history discard callback failed");
-      }
-    }
-  }
-  function addActions(actions2, action) {
-    if (actions2.length === 0) {
-      actions2.push(action);
-      return;
-    }
-    const last = actions2[actions2.length - 1];
-    if (!last.combinable(action)) {
-      actions2.push(action);
-      return;
-    }
-    last.combine(action);
-  }
   const logger$3j = getLogger("block-action");
   class BlockAction extends Action {
     constructor(editor, containerId, blockIndex, data2, afterRange) {
@@ -31620,32 +31459,10 @@ ${codeText}
   }
   class DeleteBlockAction$1 extends BlockAction {
     undo(editor) {
-      if (this.blockData.type !== "embed" || this.blockData.embedType !== "ones-open-wiki-macro") {
-        return this.insertBlock(editor, this.beforeRange);
-      }
-      const revision = this.blockData.macroRevision;
-      this.blockData.macroRevision = revision + 1;
-      let inserted = false;
-      try {
-        inserted = this.insertBlock(editor, this.beforeRange);
-        return inserted;
-      } finally {
-        if (!inserted)
-          this.blockData.macroRevision = revision;
-      }
+      return this.insertBlock(editor, this.beforeRange);
     }
     redo(editor) {
-      if (this.blockData.type !== "embed" || this.blockData.embedType !== "ones-open-wiki-macro") {
-        return this.deleteBlock(editor, this.afterRange);
-      }
-      const block = editor.findBlockById(this.blockData.id);
-      if (!block)
-        return false;
-      const deletedSnapshot = cloneDeep__default.default(editor.getBlockData(block));
-      const deleted = this.deleteBlock(editor, this.afterRange);
-      if (deleted)
-        this.blockData = deletedSnapshot;
-      return deleted;
+      return this.deleteBlock(editor, this.afterRange);
     }
   }
   class GroupAction extends Action {
@@ -31912,6 +31729,12 @@ ${codeText}
       return this.deleteChildContainer(editor);
     }
   }
+  class AsyncAction extends Action {
+    constructor(editor, operation) {
+      super(editor, "", editor.selection.range.toDocRange());
+      this.operation = operation;
+    }
+  }
   const BATCH_ACTION_TS = 1e3 * 3;
   const logger$3f = getLogger("undo");
   class UndoManager {
@@ -31922,13 +31745,9 @@ ${codeText}
       __publicField(this, "currentGroup", null);
       __publicField(this, "groupCounter", 0);
       __publicField(this, "undoRedoing", false);
-      __publicField(this, "macroSessions", /* @__PURE__ */ new Set());
-      __publicField(this, "macroActionIds", /* @__PURE__ */ new Set());
-      __publicField(this, "pendingMacroAction", null);
-      __publicField(this, "pendingAsyncPromise", null);
       __publicField(this, "undoLocks", /* @__PURE__ */ new Set());
-      __publicField(this, "macroGeneration", 0);
-      __publicField(this, "destroyed", false);
+      __publicField(this, "pendingAction");
+      __publicField(this, "resetVersion", 0);
       __publicField(this, "handleSelectionChange", (editor) => {
         if (this.currentGroup) {
           this.currentGroup.setAfterRange(editor.selection.range.toDocRange());
@@ -31944,155 +31763,107 @@ ${codeText}
       this.editor = editor;
       this.undoCursor = -1;
       this.editor.addListener("selectionChanged", this.handleSelectionChange);
+      this.editor.addListener("destroy", () => this.reset());
+    }
+    reset() {
+      this.resetVersion += 1;
+      this.actions.forEach((action) => this.discard(action));
+      this.actions = [];
+      this.undoCursor = -1;
     }
-    registerMacroEditAction(options) {
-      if (this.destroyed) {
-        throw new WikiMacroError({ code: "SESSION_EXPIRED", message: "Editor destroyed" });
+    prepareSaveUndoState() {
+      if (this.pendingAction)
+        throw new Error("An asynchronous undo action is pending");
+      if (this.undoCursor !== -1) {
+        this.actions.splice(this.undoCursor).forEach((action) => this.discard(action));
+        this.undoCursor = -1;
+      }
+    }
+    addAction(action) {
+      if (this.pendingAction)
+        throw new Error("An asynchronous undo action is pending");
+      if (this.currentGroup) {
+        this.currentGroup.addAction(action);
+      } else {
+        addActions(this.actions, action);
+        setTimeout(() => {
+          this.editor.input.handleChanged(action);
+        });
       }
-      if (this.macroActionIds.has(options.actionId))
-        return;
-      this.addAsyncAction(options);
-      this.macroActionIds.add(options.actionId);
     }
     addAsyncAction(operation) {
-      if (this.destroyed)
-        throw new Error("Editor destroyed");
       if (this.currentGroup)
-        throw new Error("Async actions require an independent undo boundary");
+        throw new Error("An asynchronous undo action cannot join a synchronous group");
       this.prepareSaveUndoState();
       const action = new AsyncAction(this.editor, operation);
-      this.actions.push(action);
-      try {
-        this.editor.input.handleChanged(action);
-      } catch {
-        logger$3f.error("Async history change observer failed");
-      }
+      this.addAction(action);
+      return () => {
+        const index2 = this.actions.indexOf(action);
+        if (index2 === -1)
+          return;
+        this.actions.splice(index2, 1);
+        if (this.undoCursor !== -1 && index2 < this.undoCursor)
+          this.undoCursor -= 1;
+        this.discard(action);
+      };
+    }
+    discard(action) {
+      var _a, _b;
+      if (action instanceof AsyncAction)
+        (_b = (_a = action.operation).onDiscard) == null ? void 0 : _b.call(_a);
     }
     acquireUndoLock() {
-      const lock = Symbol("pending-undo-session");
+      const lock = Symbol("macro-edit-session");
       this.undoLocks.add(lock);
       return () => {
         this.undoLocks.delete(lock);
       };
     }
     async undoAsync() {
-      var _a;
-      if (this.pendingMacroAction)
+      if (this.pendingAction)
         return false;
       const accepted = this.undo();
-      return (_a = this.pendingAsyncPromise) != null ? _a : accepted;
+      return this.pendingAction || accepted;
     }
     async redoAsync() {
-      var _a;
-      if (this.pendingMacroAction)
+      if (this.pendingAction)
         return false;
       const accepted = this.redo();
-      return (_a = this.pendingAsyncPromise) != null ? _a : accepted;
+      return this.pendingAction || accepted;
     }
-    setMacroEditSessionActive(sessionId, active) {
-      if (this.destroyed)
-        return;
-      setWikiMacroLockSession(this.editor, sessionId, active);
-      if (active) {
-        this.macroSessions.add(sessionId);
-      } else {
-        this.macroSessions.delete(sessionId);
-      }
-    }
-    destroy() {
-      this.destroyed = true;
-      this.reset();
-      this.macroSessions.clear();
-      this.undoLocks.clear();
-      this.editor.removeListener("selectionChanged", this.handleSelectionChange);
-    }
-    applyMacroAction(action, direction) {
-      const generation = this.macroGeneration;
-      const cursor = this.undoCursor;
-      const historyLength = this.actions.length;
-      this.pendingMacroAction = action;
-      this.pendingAsyncPromise = Promise.resolve().then(() => action.apply(direction)).then(() => {
-        if (generation !== this.macroGeneration || this.destroyed)
+    runAsyncAction(action, index2, direction) {
+      const release = this.editor.acquireReadonly();
+      const resetVersion = this.resetVersion;
+      this.pendingAction = Promise.resolve().then(() => action.operation[direction]()).then((success) => {
+        if (!success)
           return false;
-        const index2 = this.actions.indexOf(action);
-        if (direction === "undo") {
-          if (index2 < 0)
-            return false;
-          if (this.undoCursor === cursor && this.actions.length === historyLength) {
-            this.undoCursor = index2;
-          } else {
-            this.actions.splice(index2, 1);
-            this.actions.push(action);
-            this.undoCursor = this.actions.length - 1;
+        if (this.resetVersion !== resetVersion || this.actions[index2] !== action)
+          return false;
+        this.undoCursor = direction === "undo" ? index2 : index2 + 1;
+        const range = direction === "undo" ? action.beforeRange : action.afterRange;
+        if (range) {
+          try {
+            this.editor.selection.setRange(fromDocRange(this.editor, range));
+          } catch (error2) {
+            logger$3f.warn(`failed to restore selection after asynchronous ${direction}`);
           }
-        } else if (index2 >= 0 && this.undoCursor === cursor && this.actions.length === historyLength) {
-          this.undoCursor = index2 + 1;
-        } else {
-          if (index2 >= 0)
-            this.actions.splice(index2, 1);
-          this.actions.push(action);
-          this.undoCursor = -1;
-        }
-        try {
-          this.editor.input.handleChanged(action);
-        } catch (error2) {
-          logger$3f.error("Macro history change observer failed");
         }
+        this.editor.input.handleChanged(action);
         return true;
       }).catch((error2) => {
-        if (generation !== this.macroGeneration || this.destroyed)
-          return false;
-        const failure = error2 instanceof Error ? error2 : new Error("Macro history action failed");
         try {
-          action.reportError(failure);
-        } catch (callbackError) {
-          logger$3f.error("Macro history error callback failed");
+          action.operation.onError(error2);
+        } catch (notificationError) {
+          logger$3f.warn("failed to report asynchronous undo error");
         }
         return false;
       }).finally(() => {
-        if (generation === this.macroGeneration) {
-          this.pendingMacroAction = null;
-          this.pendingAsyncPromise = null;
-          if (!this.actions.includes(action))
-            action.dispose();
-        }
+        this.pendingAction = void 0;
+        release();
+        this.checkRange();
       });
       return true;
     }
-    reset() {
-      var _a;
-      this.macroGeneration += 1;
-      (_a = this.pendingMacroAction) == null ? void 0 : _a.dispose();
-      this.pendingMacroAction = null;
-      this.pendingAsyncPromise = null;
-      this.actions.forEach((action) => {
-        if (action instanceof AsyncAction)
-          action.dispose();
-      });
-      this.macroActionIds.clear();
-      this.actions = [];
-      this.undoCursor = -1;
-    }
-    prepareSaveUndoState() {
-      if (this.undoCursor !== -1) {
-        const removed = this.actions.splice(this.undoCursor);
-        removed.forEach((action) => {
-          if (action instanceof AsyncAction && action !== this.pendingMacroAction)
-            action.dispose();
-        });
-        this.undoCursor = -1;
-      }
-    }
-    addAction(action) {
-      if (this.currentGroup) {
-        this.currentGroup.addAction(action);
-      } else {
-        addActions(this.actions, action);
-        setTimeout(() => {
-          this.editor.input.handleChanged(action);
-        });
-      }
-    }
     beginGroup() {
       if (this.groupCounter === 0) {
         assert(logger$3f, !this.currentGroup, "current group already exists");
@@ -32161,22 +31932,19 @@ ${codeText}
       }
     }
     undo() {
-      if (this.destroyed || this.macroSessions.size > 0 || this.undoLocks.size > 0 || this.pendingMacroAction)
+      if (this.pendingAction || this.undoLocks.size)
         return false;
-      const candidate = this.actions[(this.undoCursor === -1 ? this.actions.length : this.undoCursor) - 1];
-      if (candidate instanceof AsyncAction)
-        return this.applyMacroAction(candidate, "undo");
       if (this.undoCursor === -1) {
         this.undoCursor = this.actions.length;
       }
       try {
         this.undoRedoing = true;
         while (this.undoCursor > 0) {
-          const action = this.actions[this.undoCursor - 1];
-          if (action instanceof AsyncAction) {
-            return this.applyMacroAction(action, "undo");
-          }
+          const candidate = this.actions[this.undoCursor - 1];
+          if (candidate instanceof AsyncAction)
+            return this.runAsyncAction(candidate, this.undoCursor - 1, "undo");
           this.undoCursor -= 1;
+          const action = this.actions[this.undoCursor];
           if (action.undo(this.editor)) {
             try {
               this.editor.selection.setRange(fromDocRange(this.editor, action.beforeRange));
@@ -32202,11 +31970,8 @@ ${codeText}
       }
     }
     redo() {
-      if (this.destroyed || this.macroSessions.size > 0 || this.undoLocks.size > 0 || this.pendingMacroAction)
+      if (this.pendingAction || this.undoLocks.size)
         return false;
-      const candidate = this.actions[this.undoCursor];
-      if (candidate instanceof AsyncAction)
-        return this.applyMacroAction(candidate, "redo");
       if (this.undoCursor === -1) {
         this.undoCursor = this.actions.length;
       }
@@ -32214,9 +31979,8 @@ ${codeText}
         this.undoRedoing = true;
         while (this.undoCursor < this.actions.length) {
           const action = this.actions[this.undoCursor];
-          if (action instanceof AsyncAction) {
-            return this.applyMacroAction(action, "redo");
-          }
+          if (action instanceof AsyncAction)
+            return this.runAsyncAction(action, this.undoCursor, "redo");
           this.undoCursor += 1;
           if (action.redo(this.editor)) {
             try {
@@ -32245,7 +32009,7 @@ ${codeText}
       }
     }
     canUndo() {
-      if (this.destroyed || this.macroSessions.size > 0 || this.undoLocks.size > 0 || this.pendingMacroAction)
+      if (this.pendingAction || this.undoLocks.size)
         return false;
       if (this.actions.length === 0) {
         return false;
@@ -32256,7 +32020,7 @@ ${codeText}
       return true;
     }
     canRedo() {
-      if (this.destroyed || this.macroSessions.size > 0 || this.undoLocks.size > 0 || this.pendingMacroAction)
+      if (this.pendingAction || this.undoLocks.size)
         return false;
       if (this.actions.length === 0) {
         return false;
@@ -32283,10 +32047,8 @@ ${codeText}
         if (lastAction === action) {
           return true;
         }
-        if (this.pendingMacroAction || lastAction instanceof AsyncAction) {
-          this.undo();
+        if (lastAction instanceof AsyncAction)
           return false;
-        }
         if (!this.undo()) {
           return false;
         }
@@ -32860,6 +32622,7 @@ ${codeText}
       __publicField(this, "_readonly", false);
       __publicField(this, "_scrollable", true);
       __publicField(this, "_destroyed", false);
+      __publicField(this, "readonlyLocks", /* @__PURE__ */ new Set());
       __publicField(this, "getColor", (index2) => {
         const colors = this.options.colors;
         if (colors.length === 0) {
@@ -32915,11 +32678,21 @@ ${codeText}
       this.emit("load", this, false);
     }
     get readonly() {
-      return this._readonly;
+      return this._readonly || this.readonlyLocks.size > 0;
+    }
+    acquireReadonly() {
+      const lock = Symbol("pending-document-action");
+      this.readonlyLocks.add(lock);
+      this.readonly = this._readonly;
+      return () => {
+        if (!this.readonlyLocks.delete(lock))
+          return;
+        this.readonly = this._readonly;
+      };
     }
     set readonly(val) {
       this._readonly = val;
-      if (val) {
+      if (this.readonly) {
         addClass(this.rootElement, "readonly");
       } else {
         removeClass(this.rootElement, "readonly");
@@ -32993,21 +32766,9 @@ ${codeText}
     createInsertion(blockContent, insertion) {
       return this.editorInsertions.createInsertion(blockContent, insertion);
     }
-    addDocResourceHook(hook) {
-      return registerDocResourceHook(this, hook);
-    }
-    registerMacroEditAction(options) {
-      this.undoManager.registerMacroEditAction(options);
-    }
-    setMacroEditSessionActive(sessionId, active) {
-      if (this.destroyed)
-        return;
-      this.undoManager.setMacroEditSessionActive(sessionId, active);
-    }
     destroy() {
       logger$3b.debug("destroy editor");
       this.emit("destroy", this);
-      this.undoManager.destroy();
       this.input.destroy();
       this.rootContainerObject.destroy();
       this.rootElement.remove();
@@ -33018,7 +32779,6 @@ ${codeText}
       this.domEvents.destroy();
       this.removeAllListeners();
       this.inputHandlers.destroy();
-      clearDocResourceHooks(this);
       this._destroyed = true;
     }
     get destroyed() {
@@ -33033,15 +32793,7 @@ ${codeText}
     isWritable() {
       return editorIsWritable(this);
     }
-    isBlockWritable(block, macroSessionId) {
-      if (macroSessionId && this.readonly)
-        return false;
-      if (Array.isArray(block)) {
-        if (block.some((item) => isWikiMacroElementLocked(this, item, macroSessionId)))
-          return false;
-      } else if (isWikiMacroElementLocked(this, block, macroSessionId)) {
-        return false;
-      }
+    isBlockWritable(block) {
       return editorIsBlockWritable(this, block);
     }
     getChildContainerData(childContainerId) {
@@ -33390,7 +33142,6 @@ ${codeText}
       super();
       __publicField(this, "doc");
       __publicField(this, "serviceUrl");
-      __publicField(this, "documentVersion");
       if (doc2) {
         this.doc = doc2;
       } else {
@@ -33405,16 +33156,6 @@ ${codeText}
         };
       }
       this.serviceUrl = (options == null ? void 0 : options.serverUrl) || "";
-      this.documentVersion = options == null ? void 0 : options.documentVersion;
-    }
-    requestWikiMacro(message) {
-      return Promise.reject(new WikiMacroError({ code: "READ_ONLY", message: "Local and history documents cannot edit Wiki macros" }));
-    }
-    onWikiMacroLocks(listener) {
-      throw new WikiMacroError({ code: "READ_ONLY", message: "Local and history documents have no macro lock channel" });
-    }
-    getDocumentVersion() {
-      return this.documentVersion;
     }
     beginBatchUpdate() {
       return 0;
@@ -33553,9 +33294,8 @@ ${codeText}
     getRemoteUsers() {
       return new RemoteUsers();
     }
-    setDoc(doc2, documentVersion) {
+    setDoc(doc2) {
       this.doc = cloneDeep__default.default(doc2);
-      this.documentVersion = documentVersion;
       this.callbacks.forEach((c) => {
         var _a;
         return (_a = c.onRequestReload) == null ? void 0 : _a.call(c, "change doc");
@@ -39099,11 +38839,6 @@ ${codeText}
       __publicField(this, "connectionStatus", null);
       __publicField(this, "reauthing", false);
       __publicField(this, "ready", false);
-      __publicField(this, "macroRequests", /* @__PURE__ */ new Map());
-      __publicField(this, "macroLocksListeners", /* @__PURE__ */ new Set());
-      __publicField(this, "macroLocks", []);
-      __publicField(this, "macroLocksKnown", false);
-      __publicField(this, "macroLocksLoading", false);
       __publicField(this, "pingOptions", { interval: 5e4, timeout: 15e4 });
       __publicField(this, "handleAuthError", (err) => {
         if (!this.renewTokenFunc) {
@@ -39151,7 +38886,6 @@ ${codeText}
       });
       __publicField(this, "handleDisconnected", (reason) => {
         this.connectionDisconnected = true;
-        this.clearWikiMacroRequests("Document disconnected; query the original request before retrying");
         this.emit("disconnected", reason);
       });
       __publicField(this, "handleVisibilityChange", () => {
@@ -39169,111 +38903,6 @@ ${codeText}
       this.renewTokenFunc = renewTokenFunc;
       this.authMessage = authMessage;
     }
-    loadWikiMacroLocks() {
-      if (this.closed || this.macroLocksLoading || this.macroLocksListeners.size === 0)
-        return;
-      this.macroLocksLoading = true;
-      this.requestWikiMacro({ operation: "locks" }).then((result) => {
-        if (this.closed)
-          return;
-        if (!Array.isArray(result.locks)) {
-          throw new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message: "Macro lock snapshot unavailable" });
-        }
-        this.notifyWikiMacroLocks(result.locks);
-      }).catch(() => {
-        if (!this.closed)
-          logger$31.warn("Macro lock snapshot unavailable");
-      }).finally(() => {
-        this.macroLocksLoading = false;
-      });
-    }
-    requestWikiMacro(message) {
-      var _a;
-      const requestId = genId();
-      if (this.closed || ((_a = this.connection) == null ? void 0 : _a.state) !== "connected" || this.reauthing || this.connectionDisconnected) {
-        return Promise.reject(new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message: "Document connection unavailable" }, requestId));
-      }
-      return new Promise((resolve, reject) => {
-        const timeout = window.setTimeout(() => {
-          this.macroRequests.delete(requestId);
-          reject(new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message: "Macro result unknown; query the original request" }, requestId));
-        }, 6e4);
-        this.macroRequests.set(requestId, { resolve, reject, timeout });
-        try {
-          this.connection.send({
-            a: "wikiMacro",
-            requestId,
-            operation: message.operation,
-            blockId: message.blockId,
-            sessionId: message.sessionId,
-            fence: message.fence,
-            expectedRevision: message.expectedRevision,
-            content: message.content,
-            actionId: message.actionId,
-            direction: message.direction,
-            targetRequestId: message.targetRequestId
-          });
-        } catch (error2) {
-          this.macroRequests.delete(requestId);
-          window.clearTimeout(timeout);
-          reject(new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message: "Unable to send macro request" }, requestId));
-        }
-      });
-    }
-    onWikiMacroLocks(listener) {
-      if (this.closed) {
-        throw new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message: "Document connection closed" });
-      }
-      this.macroLocksListeners.add(listener);
-      try {
-        if (this.macroLocksKnown)
-          listener(this.macroLocks || []);
-      } catch (error2) {
-        this.macroLocksListeners.delete(listener);
-        throw error2;
-      }
-      this.loadWikiMacroLocks();
-      return () => {
-        this.macroLocksListeners.delete(listener);
-      };
-    }
-    handleWikiMacroReply(message) {
-      if (message.operation === "locks" && Array.isArray(message.locks)) {
-        this.notifyWikiMacroLocks(message.locks);
-      }
-      if (!message.requestId)
-        return;
-      const pending = this.macroRequests.get(message.requestId);
-      if (!pending)
-        return;
-      this.macroRequests.delete(message.requestId);
-      window.clearTimeout(pending.timeout);
-      if (message.error) {
-        pending.reject(new WikiMacroError(message.error, message.requestId));
-      } else if (message.result) {
-        pending.resolve({ ...message.result, requestId: message.requestId });
-      } else {
-        pending.reject(new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message: "Invalid macro acknowledgement" }, message.requestId));
-      }
-    }
-    clearWikiMacroRequests(message) {
-      this.macroRequests.forEach((pending, requestId) => {
-        window.clearTimeout(pending.timeout);
-        pending.reject(new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message }, requestId));
-      });
-      this.macroRequests.clear();
-    }
-    notifyWikiMacroLocks(locks) {
-      this.macroLocks = locks;
-      this.macroLocksKnown = true;
-      this.macroLocksListeners.forEach((listener) => {
-        try {
-          listener(locks);
-        } catch (error2) {
-          logger$31.error("Wiki macro lock listener failed");
-        }
-      });
-    }
     getBaseURL() {
       const parsedURL = new URL(this.url);
       const protocol = parsedURL.protocol === "wss:" ? "https:" : "http:";
@@ -39368,10 +38997,6 @@ ${codeText}
         const msg = message;
         if (this.connection)
           this.connection.lastReceiveTime = Date.now();
-        if (msg.a === "wikiMacro") {
-          this.handleWikiMacroReply(msg);
-          return;
-        }
         if ("err" in msg || msg.a === "pong") {
           this.handleMessage(msg);
         } else {
@@ -39388,7 +39013,6 @@ ${codeText}
               this.emit("ready");
               this.ready = true;
               this.connectionDisconnected = false;
-              this.loadWikiMacroLocks();
             }
           }
           try {
@@ -39466,10 +39090,6 @@ ${codeText}
     end(logout) {
       var _a, _b, _c, _d, _e;
       this.closed = true;
-      this.clearWikiMacroRequests("Document connection closed");
-      this.macroLocksListeners.clear();
-      this.macroLocks = [];
-      this.macroLocksKnown = false;
       this.renewTokenFunc = void 0;
       this.removeAllListeners();
       (_a = this.autoRenewToken) == null ? void 0 : _a.destroy();
@@ -39764,16 +39384,10 @@ ${codeText}
       return versions;
     }
     async getVersion(ver) {
-      return (await this.getVersionSnapshot(ver)).doc;
-    }
-    async getVersionSnapshot(ver) {
       const server = this.apiServer();
       const api = `${server}/versions/${ver}`;
       const ret = await this.request(api);
-      return {
-        doc: JSON.parse(ret.data.data),
-        documentVersion: typeof ret.data.documentVersion === "number" ? ret.data.documentVersion : void 0
-      };
+      return JSON.parse(ret.data.data);
     }
     async getLatestVersion() {
       const server = this.apiServer();
@@ -40784,21 +40398,6 @@ ${codeText}
       this.editStatus = new EditStatus(options);
       this.client.connection.addListener("opReceived", this.handleOpReceived);
     }
-    requestWikiMacro(message) {
-      if (this.destroyed) {
-        return Promise.reject(new WikiMacroError({ code: "RESOURCE_SERVICE_UNAVAILABLE", message: "Document destroyed" }));
-      }
-      if (this.getUser().permission !== "w" && message.operation !== "locks" && message.operation !== "getEditResult" && message.operation !== "cancelEdit") {
-        return Promise.reject(new WikiMacroError({ code: "READ_ONLY" }));
-      }
-      return this.client.connection.requestWikiMacro(message);
-    }
-    onWikiMacroLocks(listener) {
-      return this.client.connection.onWikiMacroLocks(listener);
-    }
-    getDocumentVersion() {
-      return typeof this.doc.version === "number" ? this.doc.version : void 0;
-    }
     beginBatchUpdate() {
       this.doc.preventCompose = false;
       this.batching++;
@@ -40926,6 +40525,10 @@ ${codeText}
         });
       });
     }
+    getDocumentVersion() {
+      var _a;
+      return (_a = this.doc.version) != null ? _a : void 0;
+    }
     toJSON() {
       return editorDoc2DocObject(this.data());
     }
@@ -41216,10 +40819,6 @@ ${codeText}
       const data2 = await this.client.getVersion(ver);
       return editorDoc2DocObject(data2);
     }
-    async getVersionSnapshot(ver) {
-      const snapshot2 = await this.client.getVersionSnapshot(ver);
-      return { doc: editorDoc2DocObject(snapshot2.doc), documentVersion: snapshot2.documentVersion };
-    }
     async getLatestVersion() {
       const doc2 = await this.client.getLatestVersion();
       return editorDoc2DocObject(doc2);
@@ -41566,8 +41165,7 @@ ${codeText}
   class ShareDBLocalDoc extends LocalDoc {
     constructor(docObject, _options) {
       super(docObject, {
-        serverUrl: _options.serverUrl,
-        documentVersion: _options.documentVersion
+        serverUrl: _options.serverUrl
       });
       __publicField(this, "_client");
       this._options = _options;
@@ -41674,16 +41272,10 @@ ${codeText}
       return versions;
     }
     async getVersion(ver) {
-      return (await this.getVersionSnapshot(ver)).doc;
-    }
-    async getVersionSnapshot(ver) {
       const server = this.apiServer();
       const api = `${server}/versions/${ver}`;
       const ret = await this.request(api);
-      return {
-        doc: JSON.parse(ret.data.data),
-        documentVersion: typeof ret.data.documentVersion === "number" ? ret.data.documentVersion : void 0
-      };
+      return JSON.parse(ret.data.data);
     }
     async getLatestVersion() {
       const server = this.apiServer();
@@ -41807,10 +41399,6 @@ ${codeText}
       const data2 = await this.client.getVersion(ver);
       return editorDoc2DocObject(data2);
     }
-    async getVersionSnapshot(ver) {
-      const snapshot2 = await this.client.getVersionSnapshot(ver);
-      return { doc: editorDoc2DocObject(snapshot2.doc), documentVersion: snapshot2.documentVersion };
-    }
     async getLatestVersion() {
       const doc2 = await this.client.getLatestVersion();
       return editorDoc2DocObject(doc2);
@@ -64400,8 +63988,6 @@ $$${mathData.mathjaxText}$$
         const blockId = item.data;
         try {
           const block = editor.getBlockById(blockId);
-          if ((item.id === "delete" || item.id === "cut") && isWikiMacroElementLocked(editor, block))
-            return;
           if (item.id === "delete") {
             this.deleteBlock(editor, block);
             return;
@@ -64421,7 +64007,6 @@ $$${mathData.mathjaxText}$$
     commands(editor, blockElement) {
       const locked = isBlockLocked(editor, blockElement);
       const lockedBySelf = locked && isBlockLockedBySelf(editor, blockElement);
-      const macroLeased = isWikiMacroElementLocked(editor, blockElement);
       const data2 = getBlockId(blockElement);
       const isEnvSecure = window.isSecureContext;
       const isBlockExclusive = isExclusiveBlock(blockElement);
@@ -64443,7 +64028,7 @@ $$${mathData.mathjaxText}$$
         data: data2,
         icon: CutIcon,
         order: 20,
-        states: macroLeased || locked && !lockedBySelf || !isEnvSecure || isBlockExclusive ? ["disabled"] : [],
+        states: locked && !lockedBySelf || !isEnvSecure || isBlockExclusive ? ["disabled"] : [],
         disableReason: !isEnvSecure ? i18n$1.t("copyCutProperty.unsafeEnvTips", {
           shortCut: shortcutToDisplayText("CtrlOrCmd+X"),
           operation: i18n$1.t("copyCutProperty.cut")
@@ -64455,7 +64040,7 @@ $$${mathData.mathjaxText}$$
         data: data2,
         icon: DeleteIcon,
         order: 30,
-        states: macroLeased || locked && !lockedBySelf || isBlockExclusive ? ["disabled"] : []
+        states: locked && !lockedBySelf || isBlockExclusive ? ["disabled"] : []
       };
       return {
         group: "standard-block-actions",
@@ -64496,15 +64081,6 @@ $$${mathData.mathjaxText}$$
         this.menu.updateItems(items);
         this.commandBlock = this.currentBlock;
       });
-      __publicField(this, "handleMacroLocksChanged", () => {
-        if (!this.menu.isVisible)
-          return;
-        if (!this.currentBlock || !this.editor.contains(this.currentBlock)) {
-          this.close();
-          return;
-        }
-        this.handleShow();
-      });
       __publicField(this, "handleClose", () => {
         if (shouldFocusToEditor(this.editor)) {
           this.editor.focus();
@@ -64530,7 +64106,6 @@ $$${mathData.mathjaxText}$$
       this.menu.on("close", this.handleClose);
       this.menu.on("click", this.handleItemClick);
       editor.blockHooks.push(new StandardBlockActionHook());
-      editor.addListener("wikiMacroLocksChanged", this.handleMacroLocksChanged);
     }
     addFilter(id, filter) {
       var _a, _b;
@@ -64552,7 +64127,6 @@ $$${mathData.mathjaxText}$$
       return this.menu.isVisible;
     }
     destroy() {
-      this.editor.removeListener("wikiMacroLocksChanged", this.handleMacroLocksChanged);
       this.menu.destroy();
     }
   }
@@ -84090,21 +83664,11 @@ ${docStr}
     assert(logger$C, false, "no local actions for history doc");
   }
   class HistoryDoc extends EventCallbacks {
-    constructor(server, docObject, editorOptions, documentVersion) {
+    constructor(server, docObject, editorOptions) {
       super();
       this.server = server;
       this.docObject = docObject;
       this.editorOptions = editorOptions;
-      this.documentVersion = documentVersion;
-    }
-    requestWikiMacro(message) {
-      return Promise.reject(new WikiMacroError({ code: "READ_ONLY", message: "History documents cannot edit Wiki macros" }));
-    }
-    onWikiMacroLocks(listener) {
-      throw new WikiMacroError({ code: "READ_ONLY", message: "History documents have no macro lock channel" });
-    }
-    getDocumentVersion() {
-      return this.documentVersion;
     }
     beginBatchUpdate() {
       return 0;
@@ -85097,7 +84661,6 @@ ${docStr}
         const forceRequestVersionAsLatest = !!((_d = this.versionOptions) == null ? void 0 : _d.forceRequestVersionAsLatest);
         let docObject;
         let historyData;
-        let snapshotVersion;
         if (from) {
           const requestVersion = forceRequestVersionAsLatest ? -1 : Math.max(version.version, from);
           const requestFrom = forceRequestVersionAsLatest ? from : Math.min(version.version, from);
@@ -85105,18 +84668,12 @@ ${docStr}
           docObject = ret.doc;
           historyData = ret.historyData;
         } else {
-          if (this.versionHelper.getVersionSnapshot) {
-            const snapshot2 = await this.versionHelper.getVersionSnapshot(version.version);
-            docObject = snapshot2.doc;
-            snapshotVersion = snapshot2.documentVersion;
-          } else {
-            docObject = await this.versionHelper.getVersion(version.version);
-          }
+          docObject = await this.versionHelper.getVersion(version.version);
           historyData = [];
         }
         const { editorContainer: editorElement } = this.components;
         editorElement.innerHTML = "";
-        const historyDoc = new HistoryDoc(this.server, docObject, this.editorOptions, snapshotVersion);
+        const historyDoc = new HistoryDoc(this.server, docObject, this.editorOptions);
         const viewer = this.provider.createHistoryEditor(editorElement, historyDoc);
         viewer.editorBlockRenders.registerRender(new OnesEditorHistoryRender());
         viewer.editorBoxes.registerBoxClass(HistoryDeletedTextBox);
@@ -85323,7 +84880,7 @@ ${docStr}
   }
   async function createOnesEditorHistoryDiff(parent, options) {
     var _a;
-    const historyDoc = new HistoryDoc(options.server, options.doc, options.editorOptions, options.documentVersion);
+    const historyDoc = new HistoryDoc(options.server, options.doc, options.editorOptions);
     const viewer = options.provider.createHistoryEditor(parent, historyDoc);
     viewer.editorBlockRenders.registerRender(new OnesEditorHistoryRender());
     viewer.editorBoxes.registerBoxClass(HistoryDeletedTextBox);
@@ -98489,7 +98046,7 @@ ${JSON.stringify(error2, null, 2)}`);
         }
       }
     });
-    editor.version = "5.0.6-beta.DNP8216.3";
+    editor.version = "5.0.6-beta.p8216.2";
     return editor;
   }
   function isDoc(doc2) {
@@ -98625,7 +98182,7 @@ ${JSON.stringify(error2, null, 2)}`);
       OnesEditorDropTarget.register(editor);
       OnesEditorTocProvider.register(editor);
       OnesEditorExclusiveBlock.register(editor);
-      editor.version = "5.0.6-beta.DNP8216.3";
+      editor.version = "5.0.6-beta.p8216.2";
       return editor;
     } catch (error2) {
       try {
@@ -98768,7 +98325,7 @@ ${JSON.stringify(error2, null, 2)}`);
         }
       }
     });
-    editor.version = "5.0.6-beta.DNP8216.3";
+    editor.version = "5.0.6-beta.p8216.2";
     return editor;
   }
   const emojis$1 = {
@@ -144786,10 +144343,10 @@ ${JSON.stringify(error2, null, 2)}`);
   exports2.UnorderedListIcon = UnorderedListIcon;
   exports2.UnorderedListItem = UnorderedListItem;
   exports2.VideoIcon = VideoIcon;
+  exports2.WIKI_MACRO_TYPE = WIKI_MACRO_TYPE;
   exports2.WarningFilledIcon = WarningFilledIcon;
   exports2.WarningIcon = WarningIcon;
   exports2.WebPageIcon = WebPageIcon;
-  exports2.WikiMacroError = WikiMacroError;
   exports2.YoukuIcon = YoukuIcon;
   exports2.ZERO_WIDTH_SPACE_CHAR = ZERO_WIDTH_SPACE_CHAR;
   exports2.abbreviation = abbreviation;
@@ -145142,6 +144699,8 @@ ${JSON.stringify(error2, null, 2)}`);
   exports2.getTextWidth = getTextWidth;
   exports2.getToolbar = getToolbar;
   exports2.getToolbarDefaultItems = getToolbarDefaultItems;
+  exports2.getWikiMacroExportSpec = getWikiMacroExportSpec;
+  exports2.getWikiMacroResources = getWikiMacroResources;
   exports2.groupEachCommand = groupEachCommand;
   exports2.handleBlockElementUpdated = handleBlockElementUpdated$1;
   exports2.hasAltOnly = hasAltOnly;
@@ -145244,12 +144803,11 @@ ${JSON.stringify(error2, null, 2)}`);
   exports2.isToday = isToday;
   exports2.isValidOffset = isValidOffset;
   exports2.isVisibleBlock = isVisibleBlock;
-  exports2.isWikiMacroElementLocked = isWikiMacroElementLocked;
   exports2.isYesterday = isYesterday;
   exports2.loadJs = loadJs;
   exports2.loadJsPromise = loadJsPromise;
   exports2.lockers = lockers;
-  exports2.logger = logger$4w;
+  exports2.logger = logger$4v;
   exports2.markdownToDoc = markdownToDoc;
   exports2.mergeCommands = mergeCommands;
   exports2.mergeDocs = mergeDocs;
@@ -145281,6 +144839,7 @@ ${JSON.stringify(error2, null, 2)}`);
   exports2.replaceAllCaseInsensitive = replaceAllCaseInsensitive;
   exports2.replaceAllText = replaceAllText;
   exports2.replaceText = replaceText;
+  exports2.replaceWikiMacroResources = replaceWikiMacroResources;
   exports2.requestDownload = requestDownload;
   exports2.resetListStart = resetListStart;
   exports2.saveAs = saveAs$1;
@@ -145329,6 +144888,7 @@ ${JSON.stringify(error2, null, 2)}`);
   exports2.updateOpAttributes = updateOpAttributes;
   exports2.updateTextBlockContent = updateTextBlockContent;
   exports2.updateUrl = updateUrl;
+  exports2.wikiMacroToText = wikiMacroToText;
   for (const k in tinyTypedEmitter) {
     if (k !== "default" && !exports2.hasOwnProperty(k))
       Object.defineProperty(exports2, k, {