@ones-editor/editor 5.0.5 → 5.0.6-beta.DNP8216.2

package/dist/index.js

@@ -24923,6 +24923,19 @@ 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$4b = getLogger("create-text-op");
   function createTextOp(text2, attributes) {
     assert(logger$4b, text2, "text is empty");
@@ -27514,6 +27527,83 @@ var __publicField = (obj, key, value) => {
     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$3J = getLogger("delete-block");
   function getAllChildContainers(editor, blockData, containerIds) {
     if (blockData.children) {
@@ -27543,6 +27633,8 @@ var __publicField = (obj, key, value) => {
     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) {
@@ -27909,6 +28001,9 @@ 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));
@@ -29899,6 +29994,56 @@ 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;
@@ -29973,6 +30118,7 @@ var __publicField = (obj, key, value) => {
         defaultGetResourceFromBlock(editor, doc2, block, resources);
       }
     });
+    collectDocResourceHooks(editor, doc2, resources);
     return Array.from(resources);
   }
   function injectDocToHtmlFragment(htmlFragment, doc2) {
@@ -30345,6 +30491,7 @@ ${codeText}
         defaultReplaceBlockResources(doc2, block, resources);
       }
     });
+    rewriteDocResourceHooks(editor, doc2, resources);
   }
   async function addLocalResourcesToDoc(editor, resources) {
     let localResources = resources.filter((res) => res.indexOf(":") === -1);
@@ -31045,10 +31192,38 @@ ${codeText}
     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();
@@ -31087,6 +31262,8 @@ ${codeText}
     }
     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$3l, oldText, `no text, ${containerId}, ${blockIndex}`);
       const newRange = transformSelection(this.editor, blockData.id, actions2, true);
@@ -31098,6 +31275,10 @@ ${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");
@@ -31114,6 +31295,8 @@ ${codeText}
     }
     localInsertBlock(containerId, blockIndex, data2, newRange, options) {
       assert(logger$3l, !this.editor.readonly, "editor is readonly");
+      if (isWikiMacroBlockLocked(this.editor, data2))
+        throw new WikiMacroError({ code: "LOCK_CONFLICT" });
       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)) {
@@ -31132,6 +31315,9 @@ ${codeText}
     }
     localDeleteChildContainers(containerIds) {
       assert(logger$3l, !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" });
+      }
       containerIds.forEach((containerId) => {
         const blocks = cloneDeep__default.default(this.getContainerBlocks(containerId));
         this.localEvents.forEach((event) => event.onBeforeDeleteChildContainer(containerId, blocks));
@@ -31140,6 +31326,9 @@ ${codeText}
     }
     localInsertChildContainers(containers) {
       assert(logger$3l, !this.editor.readonly, "editor is readonly");
+      if (containers.some((container) => container.blocks.some((block) => isWikiMacroBlockLocked(this.editor, block)))) {
+        throw new WikiMacroError({ code: "LOCK_CONFLICT" });
+      }
       const data2 = cloneDeep__default.default(containers);
       data2.forEach((item) => {
         this.localEvents.forEach((event) => event.onBeforeInsertChildContainer(item.containerId, item.blocks));
@@ -31248,6 +31437,11 @@ ${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();
     }
@@ -31256,24 +31450,17 @@ ${codeText}
       return (_c = (_b = (_a = this.externalDoc).getServerMeta) == null ? void 0 : _b.call(_a)) != null ? _c : {};
     }
     reset(doc2) {
+      var _a;
       logger$3l.log("reset doc");
+      (_a = this.unsubscribeMacroLocks) == null ? void 0 : _a.call(this);
+      clearWikiMacroLocks(this.editor);
       this.externalDoc = doc2;
       this.externalDoc.registerCallback(this);
+      initializeWikiMacroLocks(this.editor);
       this.editor.reload();
+      this.subscribeMacroLocks();
     }
   }
-  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) {
@@ -31337,6 +31524,38 @@ ${codeText}
       return true;
     }
   }
+  class MacroEditAction extends Action {
+    constructor(editor, options) {
+      super(editor, "", editor.selection.range.toDocRange());
+      __publicField(this, "options");
+      this.options = options;
+    }
+    apply(direction) {
+      if (!this.options) {
+        return Promise.reject(new WikiMacroError({ code: "SESSION_EXPIRED", message: "Macro history action disposed" }));
+      }
+      return this.options[direction]();
+    }
+    reportError(error2) {
+      var _a, _b;
+      (_b = (_a = this.options) == null ? void 0 : _a.onError) == null ? void 0 : _b.call(_a, error2);
+    }
+    dispose() {
+      this.options = null;
+    }
+  }
+  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) {
@@ -31394,10 +31613,32 @@ ${codeText}
   }
   class DeleteBlockAction$1 extends BlockAction {
     undo(editor) {
-      return this.insertBlock(editor, this.beforeRange);
+      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;
+      }
     }
     redo(editor) {
-      return this.deleteBlock(editor, this.afterRange);
+      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;
     }
   }
   class GroupAction extends Action {
@@ -31674,6 +31915,11 @@ ${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, "macroGeneration", 0);
+      __publicField(this, "destroyed", false);
       __publicField(this, "handleSelectionChange", (editor) => {
         if (this.currentGroup) {
           this.currentGroup.setAfterRange(editor.selection.range.toDocRange());
@@ -31690,13 +31936,104 @@ ${codeText}
       this.undoCursor = -1;
       this.editor.addListener("selectionChanged", this.handleSelectionChange);
     }
+    registerMacroEditAction(options) {
+      if (this.destroyed) {
+        throw new WikiMacroError({ code: "SESSION_EXPIRED", message: "Editor destroyed" });
+      }
+      if (this.macroActionIds.has(options.actionId))
+        return;
+      this.prepareSaveUndoState();
+      this.macroActionIds.add(options.actionId);
+      const action = new MacroEditAction(this.editor, options);
+      this.actions.push(action);
+      this.editor.input.handleChanged(action);
+    }
+    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.editor.removeListener("selectionChanged", this.handleSelectionChange);
+    }
+    applyMacroAction(action, direction) {
+      const generation = this.macroGeneration;
+      const cursor = this.undoCursor;
+      const historyLength = this.actions.length;
+      this.pendingMacroAction = action;
+      Promise.resolve().then(() => action.apply(direction)).then(() => {
+        if (generation !== this.macroGeneration || this.destroyed)
+          return;
+        const index2 = this.actions.indexOf(action);
+        if (direction === "undo") {
+          if (index2 < 0)
+            return;
+          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;
+          }
+        } 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");
+        }
+      }).catch((error2) => {
+        if (generation !== this.macroGeneration || this.destroyed)
+          return;
+        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");
+        }
+      }).finally(() => {
+        if (generation === this.macroGeneration) {
+          this.pendingMacroAction = null;
+          if (!this.actions.includes(action))
+            action.dispose();
+        }
+      });
+      return true;
+    }
     reset() {
+      var _a;
+      this.macroGeneration += 1;
+      (_a = this.pendingMacroAction) == null ? void 0 : _a.dispose();
+      this.pendingMacroAction = null;
+      this.actions.forEach((action) => {
+        if (action instanceof MacroEditAction)
+          action.dispose();
+      });
+      this.macroActionIds.clear();
       this.actions = [];
       this.undoCursor = -1;
     }
     prepareSaveUndoState() {
       if (this.undoCursor !== -1) {
-        this.actions.splice(this.undoCursor);
+        const removed = this.actions.splice(this.undoCursor);
+        removed.forEach((action) => {
+          if (action instanceof MacroEditAction && action !== this.pendingMacroAction)
+            action.dispose();
+        });
         this.undoCursor = -1;
       }
     }
@@ -31778,14 +32115,22 @@ ${codeText}
       }
     }
     undo() {
+      if (this.destroyed || this.macroSessions.size > 0 || this.pendingMacroAction)
+        return false;
+      const candidate = this.actions[(this.undoCursor === -1 ? this.actions.length : this.undoCursor) - 1];
+      if (candidate instanceof MacroEditAction)
+        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 MacroEditAction) {
+            return this.applyMacroAction(action, "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));
@@ -31811,6 +32156,11 @@ ${codeText}
       }
     }
     redo() {
+      if (this.destroyed || this.macroSessions.size > 0 || this.pendingMacroAction)
+        return false;
+      const candidate = this.actions[this.undoCursor];
+      if (candidate instanceof MacroEditAction)
+        return this.applyMacroAction(candidate, "redo");
       if (this.undoCursor === -1) {
         this.undoCursor = this.actions.length;
       }
@@ -31818,6 +32168,9 @@ ${codeText}
         this.undoRedoing = true;
         while (this.undoCursor < this.actions.length) {
           const action = this.actions[this.undoCursor];
+          if (action instanceof MacroEditAction) {
+            return this.applyMacroAction(action, "redo");
+          }
           this.undoCursor += 1;
           if (action.redo(this.editor)) {
             try {
@@ -31846,6 +32199,8 @@ ${codeText}
       }
     }
     canUndo() {
+      if (this.destroyed || this.macroSessions.size > 0 || this.pendingMacroAction)
+        return false;
       if (this.actions.length === 0) {
         return false;
       }
@@ -31855,6 +32210,8 @@ ${codeText}
       return true;
     }
     canRedo() {
+      if (this.destroyed || this.macroSessions.size > 0 || this.pendingMacroAction)
+        return false;
       if (this.actions.length === 0) {
         return false;
       }
@@ -31880,6 +32237,10 @@ ${codeText}
         if (lastAction === action) {
           return true;
         }
+        if (this.pendingMacroAction || lastAction instanceof MacroEditAction) {
+          this.undo();
+          return false;
+        }
         if (!this.undo()) {
           return false;
         }
@@ -32586,9 +32947,21 @@ ${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();
@@ -32599,6 +32972,7 @@ ${codeText}
       this.domEvents.destroy();
       this.removeAllListeners();
       this.inputHandlers.destroy();
+      clearDocResourceHooks(this);
       this._destroyed = true;
     }
     get destroyed() {
@@ -32613,7 +32987,15 @@ ${codeText}
     isWritable() {
       return editorIsWritable(this);
     }
-    isBlockWritable(block) {
+    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;
+      }
       return editorIsBlockWritable(this, block);
     }
     getChildContainerData(childContainerId) {
@@ -32962,6 +33344,7 @@ ${codeText}
       super();
       __publicField(this, "doc");
       __publicField(this, "serviceUrl");
+      __publicField(this, "documentVersion");
       if (doc2) {
         this.doc = doc2;
       } else {
@@ -32976,6 +33359,16 @@ ${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;
@@ -33114,8 +33507,9 @@ ${codeText}
     getRemoteUsers() {
       return new RemoteUsers();
     }
-    setDoc(doc2) {
+    setDoc(doc2, documentVersion) {
       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");
@@ -38659,6 +39053,11 @@ ${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) {
@@ -38706,6 +39105,7 @@ ${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", () => {
@@ -38723,6 +39123,111 @@ ${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:";
@@ -38817,6 +39322,10 @@ ${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 {
@@ -38833,6 +39342,7 @@ ${codeText}
               this.emit("ready");
               this.ready = true;
               this.connectionDisconnected = false;
+              this.loadWikiMacroLocks();
             }
           }
           try {
@@ -38910,6 +39420,10 @@ ${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();
@@ -39204,10 +39718,16 @@ ${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 JSON.parse(ret.data.data);
+      return {
+        doc: JSON.parse(ret.data.data),
+        documentVersion: typeof ret.data.documentVersion === "number" ? ret.data.documentVersion : void 0
+      };
     }
     async getLatestVersion() {
       const server = this.apiServer();
@@ -40218,6 +40738,21 @@ ${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++;
@@ -40635,6 +41170,10 @@ ${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);
@@ -40981,7 +41520,8 @@ ${codeText}
   class ShareDBLocalDoc extends LocalDoc {
     constructor(docObject, _options) {
       super(docObject, {
-        serverUrl: _options.serverUrl
+        serverUrl: _options.serverUrl,
+        documentVersion: _options.documentVersion
       });
       __publicField(this, "_client");
       this._options = _options;
@@ -41088,10 +41628,16 @@ ${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 JSON.parse(ret.data.data);
+      return {
+        doc: JSON.parse(ret.data.data),
+        documentVersion: typeof ret.data.documentVersion === "number" ? ret.data.documentVersion : void 0
+      };
     }
     async getLatestVersion() {
       const server = this.apiServer();
@@ -41215,6 +41761,10 @@ ${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);
@@ -63804,6 +64354,8 @@ $$${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;
@@ -63823,6 +64375,7 @@ $$${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);
@@ -63844,7 +64397,7 @@ $$${mathData.mathjaxText}$$
         data: data2,
         icon: CutIcon,
         order: 20,
-        states: locked && !lockedBySelf || !isEnvSecure || isBlockExclusive ? ["disabled"] : [],
+        states: macroLeased || locked && !lockedBySelf || !isEnvSecure || isBlockExclusive ? ["disabled"] : [],
         disableReason: !isEnvSecure ? i18n$1.t("copyCutProperty.unsafeEnvTips", {
           shortCut: shortcutToDisplayText("CtrlOrCmd+X"),
           operation: i18n$1.t("copyCutProperty.cut")
@@ -63856,7 +64409,7 @@ $$${mathData.mathjaxText}$$
         data: data2,
         icon: DeleteIcon,
         order: 30,
-        states: locked && !lockedBySelf || isBlockExclusive ? ["disabled"] : []
+        states: macroLeased || locked && !lockedBySelf || isBlockExclusive ? ["disabled"] : []
       };
       return {
         group: "standard-block-actions",
@@ -63897,6 +64450,15 @@ $$${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();
@@ -63922,6 +64484,7 @@ $$${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;
@@ -63943,6 +64506,7 @@ $$${mathData.mathjaxText}$$
       return this.menu.isVisible;
     }
     destroy() {
+      this.editor.removeListener("wikiMacroLocksChanged", this.handleMacroLocksChanged);
       this.menu.destroy();
     }
   }
@@ -83480,11 +84044,21 @@ ${docStr}
     assert(logger$C, false, "no local actions for history doc");
   }
   class HistoryDoc extends EventCallbacks {
-    constructor(server, docObject, editorOptions) {
+    constructor(server, docObject, editorOptions, documentVersion) {
       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;
@@ -84477,6 +85051,7 @@ ${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);
@@ -84484,12 +85059,18 @@ ${docStr}
           docObject = ret.doc;
           historyData = ret.historyData;
         } else {
-          docObject = await this.versionHelper.getVersion(version.version);
+          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);
+          }
           historyData = [];
         }
         const { editorContainer: editorElement } = this.components;
         editorElement.innerHTML = "";
-        const historyDoc = new HistoryDoc(this.server, docObject, this.editorOptions);
+        const historyDoc = new HistoryDoc(this.server, docObject, this.editorOptions, snapshotVersion);
         const viewer = this.provider.createHistoryEditor(editorElement, historyDoc);
         viewer.editorBlockRenders.registerRender(new OnesEditorHistoryRender());
         viewer.editorBoxes.registerBoxClass(HistoryDeletedTextBox);
@@ -84696,7 +85277,7 @@ ${docStr}
   }
   async function createOnesEditorHistoryDiff(parent, options) {
     var _a;
-    const historyDoc = new HistoryDoc(options.server, options.doc, options.editorOptions);
+    const historyDoc = new HistoryDoc(options.server, options.doc, options.editorOptions, options.documentVersion);
     const viewer = options.provider.createHistoryEditor(parent, historyDoc);
     viewer.editorBlockRenders.registerRender(new OnesEditorHistoryRender());
     viewer.editorBoxes.registerBoxClass(HistoryDeletedTextBox);
@@ -97862,7 +98443,7 @@ ${JSON.stringify(error2, null, 2)}`);
         }
       }
     });
-    editor.version = "5.0.5";
+    editor.version = "5.0.6-beta.DNP8216.2";
     return editor;
   }
   function isDoc(doc2) {
@@ -97998,7 +98579,7 @@ ${JSON.stringify(error2, null, 2)}`);
       OnesEditorDropTarget.register(editor);
       OnesEditorTocProvider.register(editor);
       OnesEditorExclusiveBlock.register(editor);
-      editor.version = "5.0.5";
+      editor.version = "5.0.6-beta.DNP8216.2";
       return editor;
     } catch (error2) {
       try {
@@ -98141,7 +98722,7 @@ ${JSON.stringify(error2, null, 2)}`);
         }
       }
     });
-    editor.version = "5.0.5";
+    editor.version = "5.0.6-beta.DNP8216.2";
     return editor;
   }
   const emojis$1 = {
@@ -144162,6 +144743,7 @@ ${JSON.stringify(error2, null, 2)}`);
   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;
@@ -144616,6 +145198,7 @@ ${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;