@xignature/docx-editor 1.0.0

package/dist/chunk-IAU6OTCV.mjs

@@ -0,0 +1,969 @@
+// src/core/core-plugins/registry.ts
+var PluginRegistry = class {
+  plugins = /* @__PURE__ */ new Map();
+  commandHandlers = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Set();
+  initialized = /* @__PURE__ */ new Set();
+  // ==========================================================================
+  // REGISTRATION
+  // ==========================================================================
+  /**
+   * Register a plugin
+   *
+   * @param plugin - The plugin to register
+   * @param options - Optional configuration
+   * @returns Registration result
+   */
+  register(plugin, options) {
+    const warnings = [];
+    if (!plugin.id) {
+      return { success: false, error: "Plugin must have an id" };
+    }
+    if (this.plugins.has(plugin.id)) {
+      return { success: false, error: `Plugin '${plugin.id}' is already registered` };
+    }
+    if (plugin.dependencies) {
+      for (const depId of plugin.dependencies) {
+        if (!this.plugins.has(depId)) {
+          return {
+            success: false,
+            error: `Plugin '${plugin.id}' requires '${depId}' which is not registered`
+          };
+        }
+      }
+    }
+    if (plugin.commandHandlers) {
+      for (const [commandType, handler] of Object.entries(plugin.commandHandlers)) {
+        if (this.commandHandlers.has(commandType)) {
+          const existing = this.commandHandlers.get(commandType);
+          warnings.push(
+            `Command '${commandType}' from '${plugin.id}' overrides handler from '${existing.pluginId}'`
+          );
+        }
+        this.commandHandlers.set(commandType, { pluginId: plugin.id, handler });
+      }
+    }
+    this.plugins.set(plugin.id, plugin);
+    if (plugin.initialize && !this.initialized.has(plugin.id)) {
+      try {
+        const result = plugin.initialize();
+        if (result instanceof Promise) {
+          result.then(() => {
+            this.initialized.add(plugin.id);
+          }).catch((err) => {
+            this.emit({ type: "error", pluginId: plugin.id, error: err });
+          });
+        } else {
+          this.initialized.add(plugin.id);
+        }
+      } catch (err) {
+        this.emit({ type: "error", pluginId: plugin.id, error: err });
+      }
+    }
+    if (options?.debug) {
+      console.log(`[PluginRegistry] Registered plugin: ${plugin.id}`);
+    }
+    this.emit({ type: "registered", plugin });
+    return {
+      success: true,
+      plugin,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+  /**
+   * Unregister a plugin
+   *
+   * @param pluginId - ID of the plugin to unregister
+   * @returns Whether unregistration succeeded
+   */
+  unregister(pluginId) {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin) {
+      return false;
+    }
+    for (const [id, p] of this.plugins) {
+      if (p.dependencies?.includes(pluginId)) {
+        console.warn(`Cannot unregister '${pluginId}': '${id}' depends on it`);
+        return false;
+      }
+    }
+    for (const [commandType, { pluginId: pid }] of this.commandHandlers) {
+      if (pid === pluginId) {
+        this.commandHandlers.delete(commandType);
+      }
+    }
+    if (plugin.destroy) {
+      try {
+        const result = plugin.destroy();
+        if (result instanceof Promise) {
+          result.catch((err) => {
+            this.emit({ type: "error", pluginId, error: err });
+          });
+        }
+      } catch (err) {
+        this.emit({ type: "error", pluginId, error: err });
+      }
+    }
+    this.plugins.delete(pluginId);
+    this.initialized.delete(pluginId);
+    this.emit({ type: "unregistered", pluginId });
+    return true;
+  }
+  // ==========================================================================
+  // QUERIES
+  // ==========================================================================
+  /**
+   * Get a registered plugin by ID
+   *
+   * @param id - Plugin ID
+   * @returns The plugin or undefined
+   */
+  get(id) {
+    return this.plugins.get(id);
+  }
+  /**
+   * Get all registered plugins
+   *
+   * @returns Array of all plugins
+   */
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Check if a plugin is registered
+   *
+   * @param id - Plugin ID
+   * @returns Whether the plugin is registered
+   */
+  has(id) {
+    return this.plugins.has(id);
+  }
+  /**
+   * Get number of registered plugins
+   */
+  get size() {
+    return this.plugins.size;
+  }
+  // ==========================================================================
+  // COMMAND HANDLERS
+  // ==========================================================================
+  /**
+   * Get a command handler for a command type
+   *
+   * @param commandType - The command type
+   * @returns The handler or undefined
+   */
+  getCommandHandler(commandType) {
+    const entry = this.commandHandlers.get(commandType);
+    return entry?.handler;
+  }
+  /**
+   * Get all registered command types
+   *
+   * @returns Array of command type strings
+   */
+  getCommandTypes() {
+    return Array.from(this.commandHandlers.keys());
+  }
+  /**
+   * Check if a command type has a handler
+   *
+   * @param commandType - The command type
+   * @returns Whether a handler exists
+   */
+  hasCommandHandler(commandType) {
+    return this.commandHandlers.has(commandType);
+  }
+  // ==========================================================================
+  // MCP TOOLS
+  // ==========================================================================
+  /**
+   * Get all MCP tools from all registered plugins
+   *
+   * @returns Array of MCP tool definitions
+   */
+  getMcpTools() {
+    const tools = [];
+    for (const plugin of this.plugins.values()) {
+      if (plugin.mcpTools) {
+        tools.push(...plugin.mcpTools);
+      }
+    }
+    return tools;
+  }
+  /**
+   * Get MCP tools from a specific plugin
+   *
+   * @param pluginId - Plugin ID
+   * @returns Array of MCP tool definitions
+   */
+  getMcpToolsForPlugin(pluginId) {
+    const plugin = this.plugins.get(pluginId);
+    return plugin?.mcpTools || [];
+  }
+  /**
+   * Get an MCP tool by name
+   *
+   * @param toolName - Tool name
+   * @returns The tool definition or undefined
+   */
+  getMcpTool(toolName) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.mcpTools) {
+        const tool = plugin.mcpTools.find((t) => t.name === toolName);
+        if (tool) return tool;
+      }
+    }
+    return void 0;
+  }
+  // ==========================================================================
+  // EVENTS
+  // ==========================================================================
+  /**
+   * Add an event listener
+   *
+   * @param listener - Event listener function
+   */
+  addEventListener(listener) {
+    this.eventListeners.add(listener);
+  }
+  /**
+   * Remove an event listener
+   *
+   * @param listener - Event listener function
+   */
+  removeEventListener(listener) {
+    this.eventListeners.delete(listener);
+  }
+  /**
+   * Emit an event to all listeners
+   */
+  emit(event) {
+    for (const listener of this.eventListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error("[PluginRegistry] Event listener error:", err);
+      }
+    }
+  }
+  // ==========================================================================
+  // UTILITIES
+  // ==========================================================================
+  /**
+   * Clear all registered plugins
+   *
+   * Useful for testing or resetting state.
+   */
+  clear() {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.destroy) {
+        try {
+          plugin.destroy();
+        } catch {
+        }
+      }
+    }
+    this.plugins.clear();
+    this.commandHandlers.clear();
+    this.initialized.clear();
+  }
+  /**
+   * Get registry state for debugging
+   */
+  getDebugInfo() {
+    return {
+      plugins: Array.from(this.plugins.keys()),
+      commandTypes: Array.from(this.commandHandlers.keys()),
+      mcpTools: this.getMcpTools().map((t) => t.name),
+      initialized: Array.from(this.initialized)
+    };
+  }
+};
+var pluginRegistry = new PluginRegistry();
+function registerPlugins(plugins, options) {
+  return plugins.map((plugin) => pluginRegistry.register(plugin, options));
+}
+
+// src/core/agent/executor.ts
+function executeCommand(doc, command) {
+  const pluginHandler = pluginRegistry.getCommandHandler(command.type);
+  if (pluginHandler) {
+    return pluginHandler(doc, command);
+  }
+  switch (command.type) {
+    case "insertText":
+      return executeInsertText(doc, command);
+    case "replaceText":
+      return executeReplaceText(doc, command);
+    case "deleteText":
+      return executeDeleteText(doc, command);
+    case "formatText":
+      return executeFormatText(doc, command);
+    case "formatParagraph":
+      return executeFormatParagraph(doc, command);
+    case "applyStyle":
+      return executeApplyStyle(doc, command);
+    case "insertTable":
+      return executeInsertTable(doc, command);
+    case "insertImage":
+      return executeInsertImage(doc, command);
+    case "insertHyperlink":
+      return executeInsertHyperlink(doc, command);
+    case "removeHyperlink":
+      return executeRemoveHyperlink(doc, command);
+    case "insertParagraphBreak":
+      return executeInsertParagraphBreak(doc, command);
+    case "mergeParagraphs":
+      return executeMergeParagraphs(doc, command);
+    case "splitParagraph":
+      return executeSplitParagraph(doc, command);
+    case "setVariable":
+      return executeSetVariable(doc, command);
+    case "applyVariables":
+      return executeApplyVariables(doc, command);
+    default:
+      const _exhaustive = command;
+      throw new Error(`Unknown command type: ${_exhaustive.type}`);
+  }
+}
+function executeCommands(doc, commands) {
+  return commands.reduce((currentDoc, command) => executeCommand(currentDoc, command), doc);
+}
+function cloneDocument(doc) {
+  return JSON.parse(JSON.stringify(doc));
+}
+function getBlockIndexForParagraph(body, paragraphIndex) {
+  let currentParagraphIndex = 0;
+  for (let i = 0; i < body.content.length; i++) {
+    if (body.content[i].type === "paragraph") {
+      if (currentParagraphIndex === paragraphIndex) {
+        return i;
+      }
+      currentParagraphIndex++;
+    }
+  }
+  return -1;
+}
+function getParagraphText(paragraph) {
+  let text = "";
+  for (const item of paragraph.content) {
+    if (item.type === "run") {
+      for (const content of item.content) {
+        if (content.type === "text") {
+          text += content.text;
+        }
+      }
+    } else if (item.type === "hyperlink") {
+      for (const child of item.children) {
+        if (child.type === "run") {
+          for (const content of child.content) {
+            if (content.type === "text") {
+              text += content.text;
+            }
+          }
+        }
+      }
+    }
+  }
+  return text;
+}
+function createTextRun(text, formatting) {
+  return {
+    type: "run",
+    formatting,
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ]
+  };
+}
+function insertTextAtOffset(paragraph, offset, text, formatting) {
+  const newContent = [];
+  let currentOffset = 0;
+  let inserted = false;
+  for (const item of paragraph.content) {
+    if (item.type === "run") {
+      const runText = item.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      const runStart = currentOffset;
+      const runEnd = currentOffset + runText.length;
+      if (!inserted && offset >= runStart && offset <= runEnd) {
+        const insertPos = offset - runStart;
+        if (insertPos > 0) {
+          newContent.push({
+            ...item,
+            content: [{ type: "text", text: runText.slice(0, insertPos) }]
+          });
+        }
+        newContent.push(createTextRun(text, formatting || item.formatting));
+        if (insertPos < runText.length) {
+          newContent.push({
+            ...item,
+            content: [{ type: "text", text: runText.slice(insertPos) }]
+          });
+        }
+        inserted = true;
+      } else {
+        newContent.push(item);
+      }
+      currentOffset = runEnd;
+    } else {
+      newContent.push(item);
+    }
+  }
+  if (!inserted) {
+    newContent.push(createTextRun(text, formatting));
+  }
+  return newContent;
+}
+function deleteTextInParagraph(paragraph, startOffset, endOffset) {
+  const newContent = [];
+  let currentOffset = 0;
+  for (const item of paragraph.content) {
+    if (item.type === "run") {
+      const runText = item.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      const runStart = currentOffset;
+      const runEnd = currentOffset + runText.length;
+      if (runEnd <= startOffset || runStart >= endOffset) {
+        newContent.push(item);
+      } else {
+        let newText = "";
+        if (runStart < startOffset) {
+          newText += runText.slice(0, startOffset - runStart);
+        }
+        if (runEnd > endOffset) {
+          newText += runText.slice(endOffset - runStart);
+        }
+        if (newText.length > 0) {
+          newContent.push({
+            ...item,
+            content: [{ type: "text", text: newText }]
+          });
+        }
+      }
+      currentOffset = runEnd;
+    } else {
+      newContent.push(item);
+    }
+  }
+  return newContent;
+}
+function applyFormattingInParagraph(paragraph, startOffset, endOffset, formatting) {
+  const newContent = [];
+  let currentOffset = 0;
+  for (const item of paragraph.content) {
+    if (item.type === "run") {
+      const runText = item.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      const runStart = currentOffset;
+      const runEnd = currentOffset + runText.length;
+      if (runEnd <= startOffset || runStart >= endOffset) {
+        newContent.push(item);
+      } else if (runStart >= startOffset && runEnd <= endOffset) {
+        newContent.push({
+          ...item,
+          formatting: { ...item.formatting, ...formatting }
+        });
+      } else {
+        const overlapStart = Math.max(startOffset, runStart);
+        const overlapEnd = Math.min(endOffset, runEnd);
+        if (runStart < overlapStart) {
+          newContent.push({
+            ...item,
+            content: [{ type: "text", text: runText.slice(0, overlapStart - runStart) }]
+          });
+        }
+        newContent.push({
+          ...item,
+          formatting: { ...item.formatting, ...formatting },
+          content: [
+            {
+              type: "text",
+              text: runText.slice(overlapStart - runStart, overlapEnd - runStart)
+            }
+          ]
+        });
+        if (runEnd > overlapEnd) {
+          newContent.push({
+            ...item,
+            content: [{ type: "text", text: runText.slice(overlapEnd - runStart) }]
+          });
+        }
+      }
+      currentOffset = runEnd;
+    } else {
+      newContent.push(item);
+    }
+  }
+  return newContent;
+}
+function executeInsertText(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const blockIndex = getBlockIndexForParagraph(body, command.position.paragraphIndex);
+  if (blockIndex === -1) {
+    throw new Error(`Paragraph index ${command.position.paragraphIndex} not found`);
+  }
+  const paragraph = body.content[blockIndex];
+  paragraph.content = insertTextAtOffset(
+    paragraph,
+    command.position.offset,
+    command.text,
+    command.formatting
+  );
+  return newDoc;
+}
+function executeReplaceText(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const { start, end } = command.range;
+  if (start.paragraphIndex === end.paragraphIndex) {
+    const blockIndex = getBlockIndexForParagraph(body, start.paragraphIndex);
+    if (blockIndex === -1) {
+      throw new Error(`Paragraph index ${start.paragraphIndex} not found`);
+    }
+    const paragraph = body.content[blockIndex];
+    paragraph.content = deleteTextInParagraph(paragraph, start.offset, end.offset);
+    paragraph.content = insertTextAtOffset(
+      paragraph,
+      start.offset,
+      command.text,
+      command.formatting
+    );
+  } else {
+    const startBlockIndex = getBlockIndexForParagraph(body, start.paragraphIndex);
+    const startParagraph = body.content[startBlockIndex];
+    const startText = getParagraphText(startParagraph);
+    startParagraph.content = deleteTextInParagraph(startParagraph, start.offset, startText.length);
+    startParagraph.content = insertTextAtOffset(
+      startParagraph,
+      start.offset,
+      command.text,
+      command.formatting
+    );
+    const paragraphsToRemove = [];
+    for (let i = start.paragraphIndex + 1; i <= end.paragraphIndex; i++) {
+      paragraphsToRemove.push(getBlockIndexForParagraph(body, i));
+    }
+    for (let i = paragraphsToRemove.length - 1; i >= 0; i--) {
+      if (paragraphsToRemove[i] !== -1) {
+        body.content.splice(paragraphsToRemove[i], 1);
+      }
+    }
+  }
+  return newDoc;
+}
+function executeDeleteText(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const { start, end } = command.range;
+  if (start.paragraphIndex === end.paragraphIndex) {
+    const blockIndex = getBlockIndexForParagraph(body, start.paragraphIndex);
+    if (blockIndex === -1) {
+      throw new Error(`Paragraph index ${start.paragraphIndex} not found`);
+    }
+    const paragraph = body.content[blockIndex];
+    paragraph.content = deleteTextInParagraph(paragraph, start.offset, end.offset);
+  } else {
+    const startBlockIndex = getBlockIndexForParagraph(body, start.paragraphIndex);
+    const startParagraph = body.content[startBlockIndex];
+    const startText = getParagraphText(startParagraph);
+    startParagraph.content = deleteTextInParagraph(startParagraph, start.offset, startText.length);
+    const endBlockIndex = getBlockIndexForParagraph(body, end.paragraphIndex);
+    const endParagraph = body.content[endBlockIndex];
+    endParagraph.content = deleteTextInParagraph(endParagraph, 0, end.offset);
+    startParagraph.content.push(...endParagraph.content);
+    const indicesToRemove = [];
+    for (let i = start.paragraphIndex + 1; i <= end.paragraphIndex; i++) {
+      indicesToRemove.push(getBlockIndexForParagraph(body, i));
+    }
+    for (let i = indicesToRemove.length - 1; i >= 0; i--) {
+      if (indicesToRemove[i] !== -1) {
+        body.content.splice(indicesToRemove[i], 1);
+      }
+    }
+  }
+  return newDoc;
+}
+function executeFormatText(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const { start, end } = command.range;
+  if (start.paragraphIndex === end.paragraphIndex) {
+    const blockIndex = getBlockIndexForParagraph(body, start.paragraphIndex);
+    if (blockIndex === -1) {
+      throw new Error(`Paragraph index ${start.paragraphIndex} not found`);
+    }
+    const paragraph = body.content[blockIndex];
+    paragraph.content = applyFormattingInParagraph(
+      paragraph,
+      start.offset,
+      end.offset,
+      command.formatting
+    );
+  } else {
+    for (let i = start.paragraphIndex; i <= end.paragraphIndex; i++) {
+      const blockIndex = getBlockIndexForParagraph(body, i);
+      if (blockIndex === -1) continue;
+      const paragraph = body.content[blockIndex];
+      const paragraphText = getParagraphText(paragraph);
+      let startOffset = 0;
+      let endOffset = paragraphText.length;
+      if (i === start.paragraphIndex) {
+        startOffset = start.offset;
+      }
+      if (i === end.paragraphIndex) {
+        endOffset = end.offset;
+      }
+      paragraph.content = applyFormattingInParagraph(
+        paragraph,
+        startOffset,
+        endOffset,
+        command.formatting
+      );
+    }
+  }
+  return newDoc;
+}
+function executeFormatParagraph(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const blockIndex = getBlockIndexForParagraph(body, command.paragraphIndex);
+  if (blockIndex === -1) {
+    throw new Error(`Paragraph index ${command.paragraphIndex} not found`);
+  }
+  const paragraph = body.content[blockIndex];
+  paragraph.formatting = { ...paragraph.formatting, ...command.formatting };
+  if ("numPr" in command.formatting) {
+    const numPr = command.formatting.numPr;
+    if (numPr && numPr.numId !== void 0 && numPr.numId !== 0) {
+      const ilvl = numPr.ilvl ?? 0;
+      const isBullet = numPr.numId === 1;
+      let marker = isBullet ? "\u2022" : `${1}.`;
+      if (newDoc.package.numbering) {
+        const num = newDoc.package.numbering.nums.find((n) => n.numId === numPr.numId);
+        if (num) {
+          const abstractNum = newDoc.package.numbering.abstractNums.find(
+            (a) => a.abstractNumId === num.abstractNumId
+          );
+          if (abstractNum) {
+            const level = abstractNum.levels.find((l) => l.ilvl === ilvl);
+            if (level) {
+              marker = level.lvlText || marker;
+            }
+          }
+        }
+      }
+      paragraph.listRendering = {
+        level: ilvl,
+        numId: numPr.numId,
+        marker,
+        isBullet
+      };
+    } else {
+      delete paragraph.listRendering;
+    }
+  }
+  return newDoc;
+}
+function executeApplyStyle(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const blockIndex = getBlockIndexForParagraph(body, command.paragraphIndex);
+  if (blockIndex === -1) {
+    throw new Error(`Paragraph index ${command.paragraphIndex} not found`);
+  }
+  const paragraph = body.content[blockIndex];
+  paragraph.formatting = {
+    ...paragraph.formatting,
+    styleId: command.styleId
+  };
+  return newDoc;
+}
+function executeInsertTable(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const rows = [];
+  for (let r = 0; r < command.rows; r++) {
+    const cells = [];
+    for (let c = 0; c < command.columns; c++) {
+      const cellText = command.data?.[r]?.[c] || "";
+      cells.push({
+        type: "tableCell",
+        content: [
+          {
+            type: "paragraph",
+            content: cellText ? [createTextRun(cellText)] : []
+          }
+        ]
+      });
+    }
+    rows.push({
+      type: "tableRow",
+      formatting: r === 0 && command.hasHeader ? { header: true } : void 0,
+      cells
+    });
+  }
+  const table = {
+    type: "table",
+    rows
+  };
+  const blockIndex = getBlockIndexForParagraph(body, command.position.paragraphIndex);
+  if (blockIndex === -1) {
+    body.content.push(table);
+  } else {
+    body.content.splice(blockIndex + 1, 0, table);
+  }
+  return newDoc;
+}
+function executeInsertImage(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const blockIndex = getBlockIndexForParagraph(body, command.position.paragraphIndex);
+  if (blockIndex === -1) {
+    throw new Error(`Paragraph index ${command.position.paragraphIndex} not found`);
+  }
+  const paragraph = body.content[blockIndex];
+  const image = {
+    type: "image",
+    rId: `rId_img_${Date.now()}`,
+    src: command.src,
+    alt: command.alt,
+    size: {
+      width: (command.width || 100) * 914400,
+      // Convert pixels to EMU
+      height: (command.height || 100) * 914400
+    },
+    wrap: { type: "inline" }
+  };
+  const imageRun = {
+    type: "run",
+    content: [
+      {
+        type: "drawing",
+        image
+      }
+    ]
+  };
+  const newContent = insertTextAtOffset(paragraph, command.position.offset, "", void 0);
+  let inserted = false;
+  let currentOffset = 0;
+  for (let i = 0; i < newContent.length; i++) {
+    const item = newContent[i];
+    if (item.type === "run") {
+      const runText = item.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      currentOffset += runText.length;
+      if (!inserted && currentOffset >= command.position.offset) {
+        newContent.splice(i + 1, 0, imageRun);
+        inserted = true;
+        break;
+      }
+    }
+  }
+  if (!inserted) {
+    newContent.push(imageRun);
+  }
+  paragraph.content = newContent;
+  return newDoc;
+}
+function executeInsertHyperlink(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const { start, end } = command.range;
+  if (start.paragraphIndex !== end.paragraphIndex) {
+    throw new Error("Hyperlinks cannot span multiple paragraphs");
+  }
+  const blockIndex = getBlockIndexForParagraph(body, start.paragraphIndex);
+  if (blockIndex === -1) {
+    throw new Error(`Paragraph index ${start.paragraphIndex} not found`);
+  }
+  const paragraph = body.content[blockIndex];
+  const paragraphText = getParagraphText(paragraph);
+  const linkText = command.displayText || paragraphText.slice(start.offset, end.offset);
+  paragraph.content = deleteTextInParagraph(paragraph, start.offset, end.offset);
+  const hyperlink = {
+    type: "hyperlink",
+    href: command.url,
+    tooltip: command.tooltip,
+    children: [createTextRun(linkText)]
+  };
+  let inserted = false;
+  let currentOffset = 0;
+  const newContent = [];
+  for (const item of paragraph.content) {
+    if (item.type === "run") {
+      const runText = item.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      const runEnd = currentOffset + runText.length;
+      if (!inserted && currentOffset <= start.offset && start.offset <= runEnd) {
+        const insertPos = start.offset - currentOffset;
+        if (insertPos > 0) {
+          newContent.push({
+            ...item,
+            content: [{ type: "text", text: runText.slice(0, insertPos) }]
+          });
+        }
+        newContent.push(hyperlink);
+        if (insertPos < runText.length) {
+          newContent.push({
+            ...item,
+            content: [{ type: "text", text: runText.slice(insertPos) }]
+          });
+        }
+        inserted = true;
+      } else {
+        newContent.push(item);
+      }
+      currentOffset = runEnd;
+    } else {
+      newContent.push(item);
+    }
+  }
+  if (!inserted) {
+    newContent.push(hyperlink);
+  }
+  paragraph.content = newContent;
+  return newDoc;
+}
+function executeRemoveHyperlink(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const { start } = command.range;
+  const blockIndex = getBlockIndexForParagraph(body, start.paragraphIndex);
+  if (blockIndex === -1) {
+    throw new Error(`Paragraph index ${start.paragraphIndex} not found`);
+  }
+  const paragraph = body.content[blockIndex];
+  const newContent = [];
+  for (const item of paragraph.content) {
+    if (item.type === "hyperlink") {
+      for (const child of item.children) {
+        if (child.type === "run") {
+          newContent.push(child);
+        }
+      }
+    } else {
+      newContent.push(item);
+    }
+  }
+  paragraph.content = newContent;
+  return newDoc;
+}
+function executeInsertParagraphBreak(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const blockIndex = getBlockIndexForParagraph(body, command.position.paragraphIndex);
+  if (blockIndex === -1) {
+    throw new Error(`Paragraph index ${command.position.paragraphIndex} not found`);
+  }
+  const paragraph = body.content[blockIndex];
+  const paragraphText = getParagraphText(paragraph);
+  const beforeContent = deleteTextInParagraph(
+    { ...paragraph, content: [...paragraph.content] },
+    command.position.offset,
+    paragraphText.length
+  );
+  const afterContent = deleteTextInParagraph(
+    { ...paragraph, content: [...paragraph.content] },
+    0,
+    command.position.offset
+  );
+  paragraph.content = beforeContent;
+  const newParagraph = {
+    type: "paragraph",
+    formatting: paragraph.formatting,
+    content: afterContent
+  };
+  body.content.splice(blockIndex + 1, 0, newParagraph);
+  return newDoc;
+}
+function executeMergeParagraphs(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  const startBlockIndex = getBlockIndexForParagraph(body, command.paragraphIndex);
+  if (startBlockIndex === -1) {
+    throw new Error(`Paragraph index ${command.paragraphIndex} not found`);
+  }
+  const baseParagraph = body.content[startBlockIndex];
+  const indicesToRemove = [];
+  for (let i = 1; i <= command.count; i++) {
+    const blockIndex = getBlockIndexForParagraph(body, command.paragraphIndex + i);
+    if (blockIndex !== -1) {
+      const para = body.content[blockIndex];
+      baseParagraph.content.push(...para.content);
+      indicesToRemove.push(blockIndex);
+    }
+  }
+  for (let i = indicesToRemove.length - 1; i >= 0; i--) {
+    body.content.splice(indicesToRemove[i], 1);
+  }
+  return newDoc;
+}
+function executeSplitParagraph(doc, command) {
+  return executeInsertParagraphBreak(doc, {
+    type: "insertParagraphBreak",
+    position: command.position
+  });
+}
+function executeSetVariable(doc, command) {
+  const newDoc = cloneDocument(doc);
+  if (!newDoc.templateVariables) {
+    newDoc.templateVariables = [];
+  }
+  if (!newDoc.templateVariables.includes(command.name)) {
+    newDoc.templateVariables.push(command.name);
+  }
+  return newDoc;
+}
+function executeApplyVariables(doc, command) {
+  const newDoc = cloneDocument(doc);
+  const body = newDoc.package.document;
+  function replaceVariablesInRun(run) {
+    for (const content of run.content) {
+      if (content.type === "text") {
+        for (const [name, value] of Object.entries(command.values)) {
+          const pattern = new RegExp(`\\{${name}\\}`, "g");
+          content.text = content.text.replace(pattern, value);
+        }
+      }
+    }
+  }
+  function replaceVariablesInParagraph(paragraph) {
+    for (const item of paragraph.content) {
+      if (item.type === "run") {
+        replaceVariablesInRun(item);
+      } else if (item.type === "hyperlink") {
+        for (const child of item.children) {
+          if (child.type === "run") {
+            replaceVariablesInRun(child);
+          }
+        }
+      }
+    }
+  }
+  function replaceVariablesInBlock(block) {
+    if (block.type === "paragraph") {
+      replaceVariablesInParagraph(block);
+    } else if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          for (const cellBlock of cell.content) {
+            replaceVariablesInBlock(cellBlock);
+          }
+        }
+      }
+    }
+  }
+  for (const block of body.content) {
+    replaceVariablesInBlock(block);
+  }
+  return newDoc;
+}
+
+export {
+  PluginRegistry,
+  pluginRegistry,
+  registerPlugins,
+  executeCommand,
+  executeCommands
+};