docxodus 6.4.0 → 7.0.0

package/dist/editor.bundle.js

@@ -0,0 +1,2143 @@
+"use strict";
+var DocxodusEditor = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/editor.ts
+  var editor_exports = {};
+  __export(editor_exports, {
+    DocxEditor: () => DocxEditor,
+    serializeInlineMarkdown: () => serializeInlineMarkdown
+  });
+
+  // src/pagination.ts
+  var DEFAULT_PAGE_WIDTH = 612;
+  var DEFAULT_PAGE_HEIGHT = 792;
+  var DEFAULT_MARGIN = 72;
+  var MAX_FOOTNOTE_AREA_RATIO = 0.6;
+  var MIN_BODY_CONTENT_HEIGHT = 72;
+  function pxToPt(px) {
+    return px * 0.75;
+  }
+  function ptToPx(pt) {
+    return pt / 0.75;
+  }
+  var DEFAULT_HEADER_FOOTER_HEIGHT = 36;
+  function parseDimensions(section) {
+    const pageWidth = parseFloat(section.dataset.pageWidth || "") || DEFAULT_PAGE_WIDTH;
+    const pageHeight = parseFloat(section.dataset.pageHeight || "") || DEFAULT_PAGE_HEIGHT;
+    const contentWidth = parseFloat(section.dataset.contentWidth || "") || pageWidth - 2 * DEFAULT_MARGIN;
+    const contentHeight = parseFloat(section.dataset.contentHeight || "") || pageHeight - 2 * DEFAULT_MARGIN;
+    const marginTop = parseFloat(section.dataset.marginTop || "") || DEFAULT_MARGIN;
+    const marginRight = parseFloat(section.dataset.marginRight || "") || DEFAULT_MARGIN;
+    const marginBottom = parseFloat(section.dataset.marginBottom || "") || DEFAULT_MARGIN;
+    const marginLeft = parseFloat(section.dataset.marginLeft || "") || DEFAULT_MARGIN;
+    const headerHeight = parseFloat(section.dataset.headerHeight || "") || DEFAULT_HEADER_FOOTER_HEIGHT;
+    const footerHeight = parseFloat(section.dataset.footerHeight || "") || DEFAULT_HEADER_FOOTER_HEIGHT;
+    return {
+      pageWidth,
+      pageHeight,
+      contentWidth,
+      contentHeight,
+      marginTop,
+      marginRight,
+      marginBottom,
+      marginLeft,
+      headerHeight,
+      footerHeight
+    };
+  }
+  var PaginationEngine = class {
+    /**
+     * Creates a new pagination engine.
+     *
+     * @param staging - The staging element or its ID containing the content to paginate
+     * @param container - The container element or its ID where pages will be rendered
+     * @param options - Pagination options
+     */
+    constructor(staging, container, options = {}) {
+      this.pendingFootnoteContinuation = null;
+      this.stagingElement = typeof staging === "string" ? document.getElementById(staging) : staging;
+      this.containerElement = typeof container === "string" ? document.getElementById(container) : container;
+      if (!this.stagingElement) {
+        throw new Error("Staging element not found");
+      }
+      if (!this.containerElement) {
+        throw new Error("Container element not found");
+      }
+      this.scale = options.scale ?? 1;
+      this.cssPrefix = options.cssPrefix ?? "page-";
+      this.showPageNumbers = options.showPageNumbers ?? true;
+      this.pageGap = options.pageGap ?? 20;
+      this.hfRegistry = /* @__PURE__ */ new Map();
+      this.footnoteRegistry = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Runs the pagination process.
+     *
+     * @returns PaginationResult with page information
+     */
+    paginate() {
+      const pages = [];
+      let pageNumber = 1;
+      this.hfRegistry = this.parseHeaderFooterRegistry();
+      this.footnoteRegistry = this.parseFootnoteRegistry();
+      const sections = this.stagingElement.querySelectorAll(
+        "[data-section-index]"
+      );
+      const sectionsToProcess = sections.length > 0 ? Array.from(sections) : [this.stagingElement];
+      for (const section of sectionsToProcess) {
+        const sectionIndex = parseInt(section.dataset.sectionIndex || "0", 10);
+        const dims = parseDimensions(section);
+        this.stagingElement.style.visibility = "hidden";
+        this.stagingElement.style.position = "absolute";
+        this.stagingElement.style.left = "-9999px";
+        this.stagingElement.style.display = "block";
+        section.style.width = `${dims.contentWidth}pt`;
+        const blocks = this.measureBlocks(section, dims);
+        const sectionPages = this.flowToPages(blocks, dims, pageNumber, sectionIndex);
+        pages.push(...sectionPages);
+        pageNumber += sectionPages.length;
+      }
+      this.stagingElement.style.display = "none";
+      return { totalPages: pages.length, pages };
+    }
+    /**
+     * Measures all content blocks in a section.
+     */
+    measureBlocks(section, dims) {
+      const blocks = [];
+      const children = Array.from(section.children);
+      for (const child of children) {
+        if (child.dataset.sectionIndex !== void 0) {
+          const nestedBlocks = this.measureBlocks(child, dims);
+          blocks.push(...nestedBlocks);
+          continue;
+        }
+        const rect = child.getBoundingClientRect();
+        const style = window.getComputedStyle(child);
+        const marginTopPx = parseFloat(style.marginTop) || 0;
+        const marginBottomPx = parseFloat(style.marginBottom) || 0;
+        const heightPt = pxToPt(rect.height);
+        const marginTopPt = pxToPt(marginTopPx);
+        const marginBottomPt = pxToPt(marginBottomPx);
+        const isPageBreak = child.dataset.pageBreak === "true" || child.classList.contains(`${this.cssPrefix}break`);
+        blocks.push({
+          element: child,
+          heightPt,
+          marginTopPt,
+          marginBottomPt,
+          keepWithNext: child.dataset.keepWithNext === "true",
+          keepLines: child.dataset.keepLines === "true",
+          pageBreakBefore: child.dataset.pageBreakBefore === "true",
+          isPageBreak
+        });
+      }
+      return blocks;
+    }
+    /**
+     * Parses the header/footer registry from the staging element.
+     * Also measures heights during parsing for lazy-loading compatibility.
+     */
+    parseHeaderFooterRegistry() {
+      const registry = /* @__PURE__ */ new Map();
+      const registryEl = this.stagingElement.querySelector("#pagination-hf-registry");
+      if (!registryEl) return registry;
+      const sectionWidths = /* @__PURE__ */ new Map();
+      const sections = Array.from(this.stagingElement.querySelectorAll("[data-section-index]"));
+      for (const section of sections) {
+        const idx = parseInt(section.dataset.sectionIndex || "0", 10);
+        const contentWidth = parseFloat(section.dataset.contentWidth || "") || DEFAULT_PAGE_WIDTH - 2 * DEFAULT_MARGIN;
+        sectionWidths.set(idx, contentWidth);
+      }
+      const defaultContentWidth = sectionWidths.get(0) || DEFAULT_PAGE_WIDTH - 2 * DEFAULT_MARGIN;
+      const entries = Array.from(registryEl.querySelectorAll("[data-section][data-hf-type]"));
+      for (const entry of entries) {
+        const sectionIndex = parseInt(entry.dataset.section || "0", 10);
+        const hfType = entry.dataset.hfType;
+        if (!registry.has(sectionIndex)) {
+          registry.set(sectionIndex, {});
+        }
+        const section = registry.get(sectionIndex);
+        const content = entry.cloneNode(true);
+        const contentWidth = sectionWidths.get(sectionIndex) || defaultContentWidth;
+        const measuredHeight = this.measureHeaderFooterHeight(content, contentWidth);
+        switch (hfType) {
+          case "header-default":
+            section.headerDefault = content;
+            section.headerDefaultHeight = measuredHeight;
+            break;
+          case "header-first":
+            section.headerFirst = content;
+            section.headerFirstHeight = measuredHeight;
+            break;
+          case "header-even":
+            section.headerEven = content;
+            section.headerEvenHeight = measuredHeight;
+            break;
+          case "footer-default":
+            section.footerDefault = content;
+            section.footerDefaultHeight = measuredHeight;
+            break;
+          case "footer-first":
+            section.footerFirst = content;
+            section.footerFirstHeight = measuredHeight;
+            break;
+          case "footer-even":
+            section.footerEven = content;
+            section.footerEvenHeight = measuredHeight;
+            break;
+        }
+      }
+      return registry;
+    }
+    /**
+     * Parses the footnote registry from the staging element.
+     */
+    parseFootnoteRegistry() {
+      const registry = /* @__PURE__ */ new Map();
+      const registryEl = this.stagingElement.querySelector("#pagination-footnote-registry");
+      if (!registryEl) return registry;
+      const entries = Array.from(registryEl.querySelectorAll("[data-footnote-id]"));
+      for (const entry of entries) {
+        const footnoteId = entry.dataset.footnoteId;
+        if (footnoteId) {
+          registry.set(footnoteId, entry.cloneNode(true));
+        }
+      }
+      return registry;
+    }
+    /**
+     * Extracts footnote reference IDs from an element.
+     */
+    extractFootnoteRefs(element) {
+      const refs = element.querySelectorAll("[data-footnote-id]");
+      const ids = [];
+      for (const ref of Array.from(refs)) {
+        const id = ref.dataset.footnoteId;
+        if (id && !ids.includes(id)) {
+          ids.push(id);
+        }
+      }
+      return ids;
+    }
+    /**
+     * Measures the height of footnotes for given IDs (in points).
+     * Creates a temporary container to measure the footnotes.
+     * @param footnoteIds - IDs of footnotes to measure
+     * @param contentWidth - Width for measurement
+     * @param continuation - Optional continuation content to include first
+     */
+    measureFootnotesHeight(footnoteIds, contentWidth, continuation) {
+      const hasContinuation = continuation && continuation.remainingElements.length > 0;
+      if (footnoteIds.length === 0 && !hasContinuation || this.footnoteRegistry.size === 0) {
+        return 0;
+      }
+      const measureContainer = document.createElement("div");
+      measureContainer.style.position = "absolute";
+      measureContainer.style.visibility = "hidden";
+      measureContainer.style.width = `${contentWidth}pt`;
+      measureContainer.style.left = "-9999px";
+      const hr = document.createElement("hr");
+      measureContainer.appendChild(hr);
+      if (hasContinuation) {
+        const contWrapper = document.createElement("div");
+        contWrapper.className = "footnote-continuation";
+        for (const el of continuation.remainingElements) {
+          contWrapper.appendChild(el.cloneNode(true));
+        }
+        measureContainer.appendChild(contWrapper);
+      }
+      for (const id of footnoteIds) {
+        const footnote = this.footnoteRegistry.get(id);
+        if (footnote) {
+          measureContainer.appendChild(footnote.cloneNode(true));
+        }
+      }
+      this.stagingElement.appendChild(measureContainer);
+      const rect = measureContainer.getBoundingClientRect();
+      const heightPt = pxToPt(rect.height);
+      this.stagingElement.removeChild(measureContainer);
+      return heightPt;
+    }
+    /**
+     * Measures the height of just the continuation content (in points).
+     */
+    measureContinuationHeight(continuation, contentWidth) {
+      if (!continuation || continuation.remainingElements.length === 0) {
+        return 0;
+      }
+      const measureContainer = document.createElement("div");
+      measureContainer.style.position = "absolute";
+      measureContainer.style.visibility = "hidden";
+      measureContainer.style.width = `${contentWidth}pt`;
+      measureContainer.style.left = "-9999px";
+      const hr = document.createElement("hr");
+      measureContainer.appendChild(hr);
+      for (const el of continuation.remainingElements) {
+        measureContainer.appendChild(el.cloneNode(true));
+      }
+      this.stagingElement.appendChild(measureContainer);
+      const rect = measureContainer.getBoundingClientRect();
+      const heightPt = pxToPt(rect.height);
+      this.stagingElement.removeChild(measureContainer);
+      return heightPt;
+    }
+    /**
+     * Splits a footnote element into parts that fit within the available height.
+     * Returns the elements that fit and the elements that need to continue.
+     */
+    splitFootnoteToFit(footnoteElement, availableHeightPt, contentWidth) {
+      const footnoteContent = footnoteElement.querySelector(".footnote-content");
+      if (!footnoteContent) {
+        return { fits: [footnoteElement.cloneNode(true)], overflow: [] };
+      }
+      const children = Array.from(footnoteContent.children);
+      if (children.length <= 1) {
+        return { fits: [footnoteElement.cloneNode(true)], overflow: [] };
+      }
+      const fits = [];
+      const overflow = [];
+      let currentHeight = 0;
+      const hrMeasure = document.createElement("div");
+      hrMeasure.style.position = "absolute";
+      hrMeasure.style.visibility = "hidden";
+      hrMeasure.style.width = `${contentWidth}pt`;
+      hrMeasure.style.left = "-9999px";
+      const hr = document.createElement("hr");
+      hrMeasure.appendChild(hr);
+      this.stagingElement.appendChild(hrMeasure);
+      const hrHeight = pxToPt(hrMeasure.getBoundingClientRect().height);
+      this.stagingElement.removeChild(hrMeasure);
+      currentHeight = hrHeight;
+      const footnoteNumber = footnoteElement.querySelector(".footnote-number");
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const measureContainer = document.createElement("div");
+        measureContainer.style.position = "absolute";
+        measureContainer.style.visibility = "hidden";
+        measureContainer.style.width = `${contentWidth}pt`;
+        measureContainer.style.left = "-9999px";
+        measureContainer.appendChild(child.cloneNode(true));
+        this.stagingElement.appendChild(measureContainer);
+        const childHeight = pxToPt(measureContainer.getBoundingClientRect().height);
+        this.stagingElement.removeChild(measureContainer);
+        if (currentHeight + childHeight <= availableHeightPt) {
+          fits.push(child.cloneNode(true));
+          currentHeight += childHeight;
+        } else {
+          for (let j = i; j < children.length; j++) {
+            overflow.push(children[j].cloneNode(true));
+          }
+          break;
+        }
+      }
+      return { fits, overflow };
+    }
+    /**
+     * Measures a single footnote's height.
+     */
+    measureSingleFootnoteHeight(footnoteId, contentWidth) {
+      const footnote = this.footnoteRegistry.get(footnoteId);
+      if (!footnote) return 0;
+      const measureContainer = document.createElement("div");
+      measureContainer.style.position = "absolute";
+      measureContainer.style.visibility = "hidden";
+      measureContainer.style.width = `${contentWidth}pt`;
+      measureContainer.style.left = "-9999px";
+      measureContainer.appendChild(footnote.cloneNode(true));
+      this.stagingElement.appendChild(measureContainer);
+      const rect = measureContainer.getBoundingClientRect();
+      const heightPt = pxToPt(rect.height);
+      this.stagingElement.removeChild(measureContainer);
+      return heightPt;
+    }
+    /**
+     * Adds footnotes to a page container, including continuation content.
+     */
+    addPageFootnotes(pageBox, footnoteIds, dims, footnoteHeight, continuation, partialFootnotes) {
+      const hasContinuation = continuation && continuation.remainingElements.length > 0;
+      if (footnoteIds.length === 0 && !hasContinuation) {
+        return;
+      }
+      if (this.footnoteRegistry.size === 0 && !hasContinuation) {
+        return;
+      }
+      const partialFootnoteIds = new Set(partialFootnotes?.map((p) => p.footnoteId) || []);
+      const maxFootnoteHeight = Math.min(
+        footnoteHeight,
+        dims.contentHeight * MAX_FOOTNOTE_AREA_RATIO
+      );
+      const footnotesDiv = document.createElement("div");
+      footnotesDiv.className = `${this.cssPrefix}footnotes`;
+      footnotesDiv.style.position = "absolute";
+      footnotesDiv.style.bottom = `${dims.marginBottom}pt`;
+      footnotesDiv.style.left = `${dims.marginLeft}pt`;
+      footnotesDiv.style.width = `${dims.contentWidth}pt`;
+      footnotesDiv.style.boxSizing = "border-box";
+      footnotesDiv.style.maxHeight = `${maxFootnoteHeight}pt`;
+      footnotesDiv.style.overflow = "hidden";
+      const hr = document.createElement("hr");
+      footnotesDiv.appendChild(hr);
+      if (hasContinuation) {
+        const contWrapper = document.createElement("div");
+        contWrapper.className = "footnote-continuation";
+        for (const el of continuation.remainingElements) {
+          contWrapper.appendChild(el.cloneNode(true));
+        }
+        footnotesDiv.appendChild(contWrapper);
+      }
+      for (const id of footnoteIds) {
+        const partial = partialFootnotes?.find((p) => p.footnoteId === id);
+        if (partial) {
+          const footnote = this.footnoteRegistry.get(id);
+          if (footnote) {
+            const partialDiv = document.createElement("div");
+            partialDiv.className = "footnote-item";
+            partialDiv.dataset.footnoteId = id;
+            const numberSpan = footnote.querySelector(".footnote-number");
+            if (numberSpan) {
+              partialDiv.appendChild(numberSpan.cloneNode(true));
+            }
+            const contentSpan = document.createElement("span");
+            contentSpan.className = "footnote-content";
+            for (const el of partial.fittingElements) {
+              contentSpan.appendChild(el.cloneNode(true));
+            }
+            partialDiv.appendChild(contentSpan);
+            footnotesDiv.appendChild(partialDiv);
+          }
+        } else {
+          const footnote = this.footnoteRegistry.get(id);
+          if (footnote) {
+            footnotesDiv.appendChild(footnote.cloneNode(true));
+          }
+        }
+      }
+      pageBox.appendChild(footnotesDiv);
+    }
+    /**
+     * Selects the appropriate header for a page based on section, page position, and page number.
+     */
+    selectHeader(sectionIndex, pageInSection, globalPageNumber) {
+      const sectionHf = this.hfRegistry.get(sectionIndex);
+      if (!sectionHf) return void 0;
+      if (pageInSection === 1 && sectionHf.headerFirst) {
+        return sectionHf.headerFirst;
+      }
+      if (globalPageNumber % 2 === 0 && sectionHf.headerEven) {
+        return sectionHf.headerEven;
+      }
+      return sectionHf.headerDefault;
+    }
+    /**
+     * Selects the appropriate footer for a page based on section, page position, and page number.
+     */
+    selectFooter(sectionIndex, pageInSection, globalPageNumber) {
+      const sectionHf = this.hfRegistry.get(sectionIndex);
+      if (!sectionHf) return void 0;
+      if (pageInSection === 1 && sectionHf.footerFirst) {
+        return sectionHf.footerFirst;
+      }
+      if (globalPageNumber % 2 === 0 && sectionHf.footerEven) {
+        return sectionHf.footerEven;
+      }
+      return sectionHf.footerDefault;
+    }
+    /**
+     * Computes effective header, footer, and content heights for a specific page position.
+     * Uses pre-measured header/footer heights from the registry.
+     * This method is deterministic - same inputs always produce same outputs.
+     * This enables lazy loading compatibility since available height can be computed
+     * for any page position without knowing the page's content.
+     */
+    getEffectiveHeights(dims, sectionIndex, pageInSection, globalPageNumber) {
+      const sectionHf = this.hfRegistry.get(sectionIndex);
+      let headerHeight = dims.marginTop;
+      if (sectionHf) {
+        let measuredHeaderHeight;
+        if (pageInSection === 1 && sectionHf.headerFirstHeight != null) {
+          measuredHeaderHeight = sectionHf.headerFirstHeight;
+        } else if (globalPageNumber % 2 === 0 && sectionHf.headerEvenHeight != null) {
+          measuredHeaderHeight = sectionHf.headerEvenHeight;
+        } else if (sectionHf.headerDefaultHeight != null) {
+          measuredHeaderHeight = sectionHf.headerDefaultHeight;
+        }
+        if (measuredHeaderHeight != null) {
+          headerHeight = Math.max(dims.marginTop, measuredHeaderHeight);
+        }
+      }
+      let footerHeight = dims.marginBottom;
+      if (sectionHf) {
+        let measuredFooterHeight;
+        if (pageInSection === 1 && sectionHf.footerFirstHeight != null) {
+          measuredFooterHeight = sectionHf.footerFirstHeight;
+        } else if (globalPageNumber % 2 === 0 && sectionHf.footerEvenHeight != null) {
+          measuredFooterHeight = sectionHf.footerEvenHeight;
+        } else if (sectionHf.footerDefaultHeight != null) {
+          measuredFooterHeight = sectionHf.footerDefaultHeight;
+        }
+        if (measuredFooterHeight != null) {
+          footerHeight = Math.max(dims.marginBottom, measuredFooterHeight);
+        }
+      }
+      const headerExpansion = headerHeight - dims.marginTop;
+      const footerExpansion = footerHeight - dims.marginBottom;
+      const contentHeight = dims.contentHeight - headerExpansion - footerExpansion;
+      return { headerHeight, footerHeight, contentHeight };
+    }
+    /**
+     * Measures the content height of a header or footer element.
+     * This is needed because headers/footers can contain more content than fits in the margin area.
+     */
+    measureHeaderFooterHeight(source, contentWidth) {
+      const measureContainer = document.createElement("div");
+      measureContainer.style.position = "absolute";
+      measureContainer.style.visibility = "hidden";
+      measureContainer.style.width = `${contentWidth}pt`;
+      measureContainer.style.left = "-9999px";
+      measureContainer.style.paddingBottom = "4pt";
+      for (const child of Array.from(source.childNodes)) {
+        measureContainer.appendChild(child.cloneNode(true));
+      }
+      this.stagingElement.appendChild(measureContainer);
+      const rect = measureContainer.getBoundingClientRect();
+      const heightPt = pxToPt(rect.height);
+      this.stagingElement.removeChild(measureContainer);
+      return heightPt;
+    }
+    /**
+     * Flows measured blocks into page containers.
+     * Implements a single-pass, forward-only algorithm that is compatible with future lazy loading.
+     * Supports footnote continuation - long footnotes can split across pages.
+     */
+    flowToPages(blocks, dims, startPageNumber, sectionIndex) {
+      const pages = [];
+      let currentContent = [];
+      let pageNumber = startPageNumber;
+      let pageInSection = 1;
+      let { contentHeight: effectiveContentHeight } = this.getEffectiveHeights(
+        dims,
+        sectionIndex,
+        pageInSection,
+        pageNumber
+      );
+      let remainingHeight = effectiveContentHeight;
+      let prevMarginBottomPt = 0;
+      let currentFootnoteIds = [];
+      let currentFootnoteHeight = 0;
+      let currentContinuation = this.pendingFootnoteContinuation;
+      let nextPageContinuation = null;
+      let currentPartialFootnotes = [];
+      if (currentContinuation && currentContinuation.remainingElements.length > 0) {
+        currentFootnoteHeight = this.measureContinuationHeight(currentContinuation, dims.contentWidth);
+      }
+      const finishPage = () => {
+        if (currentContent.length === 0 && !currentContinuation) return;
+        const page = this.createPage(
+          dims,
+          pageNumber,
+          sectionIndex,
+          currentContent,
+          pageInSection,
+          currentFootnoteIds,
+          currentFootnoteHeight,
+          currentContinuation,
+          currentPartialFootnotes.length > 0 ? currentPartialFootnotes : void 0
+        );
+        pages.push(page);
+        pageNumber++;
+        pageInSection++;
+        currentContent = [];
+        const newHeights = this.getEffectiveHeights(dims, sectionIndex, pageInSection, pageNumber);
+        effectiveContentHeight = newHeights.contentHeight;
+        remainingHeight = effectiveContentHeight;
+        prevMarginBottomPt = 0;
+        currentFootnoteIds = [];
+        currentPartialFootnotes = [];
+        currentContinuation = nextPageContinuation;
+        nextPageContinuation = null;
+        if (currentContinuation && currentContinuation.remainingElements.length > 0) {
+          currentFootnoteHeight = this.measureContinuationHeight(currentContinuation, dims.contentWidth);
+        } else {
+          currentFootnoteHeight = 0;
+        }
+      };
+      for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        const nextBlock = blocks[i + 1];
+        if (block.isPageBreak) {
+          finishPage();
+          continue;
+        }
+        if (block.pageBreakBefore && currentContent.length > 0) {
+          finishPage();
+        }
+        const blockFootnoteIds = this.extractFootnoteRefs(block.element);
+        const newFootnoteIds = blockFootnoteIds.filter((id) => !currentFootnoteIds.includes(id));
+        let additionalFootnoteHeight = 0;
+        if (newFootnoteIds.length > 0 && this.footnoteRegistry.size > 0) {
+          const combinedFootnoteIds = [...currentFootnoteIds, ...newFootnoteIds];
+          const totalFootnoteHeight = this.measureFootnotesHeight(
+            combinedFootnoteIds,
+            dims.contentWidth,
+            currentContinuation
+          );
+          additionalFootnoteHeight = totalFootnoteHeight - currentFootnoteHeight;
+        }
+        const isFirstOnPage = currentContent.length === 0;
+        let effectiveMarginTop = block.marginTopPt;
+        if (!isFirstOnPage) {
+          effectiveMarginTop = Math.max(block.marginTopPt, prevMarginBottomPt) - prevMarginBottomPt;
+        }
+        const blockSpace = effectiveMarginTop + block.heightPt + additionalFootnoteHeight;
+        let neededHeight = blockSpace;
+        if (block.keepWithNext && nextBlock && !nextBlock.isPageBreak) {
+          const collapsedMargin = Math.max(block.marginBottomPt, nextBlock.marginTopPt);
+          neededHeight = effectiveMarginTop + block.heightPt + collapsedMargin + nextBlock.heightPt + additionalFootnoteHeight;
+        }
+        const effectiveRemainingHeight = remainingHeight - currentFootnoteHeight;
+        const bodyContentUsed = effectiveContentHeight - remainingHeight;
+        const maxFootnoteArea = effectiveContentHeight * MAX_FOOTNOTE_AREA_RATIO;
+        const maxFootnoteExpansion = Math.max(0, maxFootnoteArea - currentFootnoteHeight);
+        if (blockSpace <= effectiveRemainingHeight) {
+          currentContent.push(block.element.cloneNode(true));
+          remainingHeight -= effectiveMarginTop + block.heightPt + block.marginBottomPt;
+          prevMarginBottomPt = block.marginBottomPt;
+          if (newFootnoteIds.length > 0) {
+            currentFootnoteIds.push(...newFootnoteIds);
+            currentFootnoteHeight += additionalFootnoteHeight;
+          }
+        } else if (block.heightPt + block.marginTopPt <= effectiveContentHeight) {
+          const blockSpaceWithoutFootnotes = effectiveMarginTop + block.heightPt;
+          const minBodySpaceNeeded = bodyContentUsed + blockSpaceWithoutFootnotes + MIN_BODY_CONTENT_HEIGHT;
+          const canExpandFootnotes = minBodySpaceNeeded <= effectiveContentHeight;
+          if (newFootnoteIds.length > 0 && blockSpaceWithoutFootnotes <= effectiveRemainingHeight) {
+            currentContent.push(block.element.cloneNode(true));
+            remainingHeight -= effectiveMarginTop + block.heightPt + block.marginBottomPt;
+            prevMarginBottomPt = block.marginBottomPt;
+            const availableForFootnotes = Math.min(
+              maxFootnoteArea,
+              effectiveContentHeight - bodyContentUsed - blockSpaceWithoutFootnotes
+            );
+            for (const footnoteId of newFootnoteIds) {
+              const footnote = this.footnoteRegistry.get(footnoteId);
+              if (!footnote) continue;
+              const footnoteHeight = this.measureSingleFootnoteHeight(footnoteId, dims.contentWidth);
+              const spaceLeftForFootnotes = availableForFootnotes - currentFootnoteHeight;
+              if (footnoteHeight <= spaceLeftForFootnotes) {
+                currentFootnoteIds.push(footnoteId);
+                currentFootnoteHeight += footnoteHeight;
+              } else {
+                if (spaceLeftForFootnotes > 20) {
+                  const { fits, overflow } = this.splitFootnoteToFit(
+                    footnote,
+                    spaceLeftForFootnotes,
+                    dims.contentWidth
+                  );
+                  if (fits.length > 0) {
+                    currentFootnoteIds.push(footnoteId);
+                    currentPartialFootnotes.push({
+                      footnoteId,
+                      fittingElements: fits
+                    });
+                    nextPageContinuation = {
+                      footnoteId,
+                      remainingElements: overflow
+                    };
+                    currentFootnoteHeight = availableForFootnotes;
+                  } else {
+                    nextPageContinuation = {
+                      footnoteId,
+                      remainingElements: Array.from(footnote.querySelectorAll(".footnote-content > *")).map((el) => el.cloneNode(true))
+                    };
+                    if (nextPageContinuation.remainingElements.length === 0) {
+                      nextPageContinuation.remainingElements = [footnote.cloneNode(true)];
+                    }
+                  }
+                } else {
+                  nextPageContinuation = {
+                    footnoteId,
+                    remainingElements: Array.from(footnote.querySelectorAll(".footnote-content > *")).map((el) => el.cloneNode(true))
+                  };
+                  if (nextPageContinuation.remainingElements.length === 0) {
+                    nextPageContinuation.remainingElements = [footnote.cloneNode(true)];
+                  }
+                }
+              }
+            }
+          } else if (canExpandFootnotes && newFootnoteIds.length > 0) {
+            const expandedFootnoteSpace = Math.min(maxFootnoteArea, additionalFootnoteHeight + currentFootnoteHeight);
+            const bodySpaceAfterExpansion = effectiveContentHeight - expandedFootnoteSpace;
+            if (blockSpaceWithoutFootnotes <= bodySpaceAfterExpansion - bodyContentUsed) {
+              currentContent.push(block.element.cloneNode(true));
+              remainingHeight = bodySpaceAfterExpansion - bodyContentUsed - blockSpaceWithoutFootnotes;
+              prevMarginBottomPt = block.marginBottomPt;
+              currentFootnoteIds.push(...newFootnoteIds);
+              currentFootnoteHeight = expandedFootnoteSpace;
+            } else {
+              finishPage();
+              const newPageFootnoteHeight = blockFootnoteIds.length > 0 ? this.measureFootnotesHeight(blockFootnoteIds, dims.contentWidth, currentContinuation) : currentContinuation ? this.measureContinuationHeight(currentContinuation, dims.contentWidth) : 0;
+              const newPageSpace = block.marginTopPt + block.heightPt + block.marginBottomPt;
+              currentContent.push(block.element.cloneNode(true));
+              remainingHeight = effectiveContentHeight - newPageSpace;
+              prevMarginBottomPt = block.marginBottomPt;
+              currentFootnoteIds = [...blockFootnoteIds];
+              currentFootnoteHeight = newPageFootnoteHeight;
+            }
+          } else {
+            finishPage();
+            const newPageFootnoteHeight = blockFootnoteIds.length > 0 ? this.measureFootnotesHeight(blockFootnoteIds, dims.contentWidth, currentContinuation) : currentContinuation ? this.measureContinuationHeight(currentContinuation, dims.contentWidth) : 0;
+            const newPageSpace = block.marginTopPt + block.heightPt + block.marginBottomPt;
+            currentContent.push(block.element.cloneNode(true));
+            remainingHeight = effectiveContentHeight - newPageSpace;
+            prevMarginBottomPt = block.marginBottomPt;
+            currentFootnoteIds = [...blockFootnoteIds];
+            currentFootnoteHeight = newPageFootnoteHeight;
+          }
+        } else {
+          if (currentContent.length > 0) {
+            finishPage();
+          }
+          currentContent.push(block.element.cloneNode(true));
+          currentFootnoteIds = [...blockFootnoteIds];
+          finishPage();
+        }
+      }
+      finishPage();
+      this.pendingFootnoteContinuation = nextPageContinuation;
+      return pages;
+    }
+    /**
+     * Creates a page container element.
+     */
+    createPage(dims, pageNumber, sectionIndex, content, pageInSection, footnoteIds = [], footnoteHeight = 0, continuation, partialFootnotes) {
+      const pageBox = document.createElement("div");
+      pageBox.className = `${this.cssPrefix}box`;
+      pageBox.style.width = `${dims.pageWidth}pt`;
+      pageBox.style.height = `${dims.pageHeight}pt`;
+      pageBox.style.overflow = "hidden";
+      pageBox.style.position = "relative";
+      if (this.scale !== 1) {
+        pageBox.style.zoom = String(this.scale);
+        pageBox.style.transform = `scale(${this.scale})`;
+        pageBox.style.transformOrigin = "top left";
+        const heightReductionPt = dims.pageHeight * (1 - this.scale);
+        const widthReductionPt = dims.pageWidth * (1 - this.scale);
+        const heightReductionPx = ptToPx(heightReductionPt);
+        const widthReductionPx = ptToPx(widthReductionPt);
+        pageBox.style.marginRight = `-${widthReductionPx}px`;
+        pageBox.style.marginBottom = `${this.pageGap - heightReductionPx}px`;
+      }
+      pageBox.style.willChange = "transform";
+      pageBox.style.contain = "layout paint";
+      pageBox.dataset.pageNumber = String(pageNumber);
+      pageBox.dataset.sectionIndex = String(sectionIndex);
+      const effectiveHeights = this.getEffectiveHeights(dims, sectionIndex, pageInSection, pageNumber);
+      const headerSource = this.selectHeader(sectionIndex, pageInSection, pageNumber);
+      if (headerSource) {
+        const headerDiv = document.createElement("div");
+        headerDiv.className = `${this.cssPrefix}header`;
+        headerDiv.style.position = "absolute";
+        headerDiv.style.top = "0";
+        headerDiv.style.left = `${dims.marginLeft}pt`;
+        headerDiv.style.width = `${dims.contentWidth}pt`;
+        headerDiv.style.height = `${effectiveHeights.headerHeight}pt`;
+        headerDiv.style.overflow = "hidden";
+        headerDiv.style.boxSizing = "border-box";
+        headerDiv.style.display = "flex";
+        headerDiv.style.flexDirection = "column";
+        headerDiv.style.justifyContent = "flex-end";
+        headerDiv.style.paddingBottom = "4pt";
+        for (const child of Array.from(headerSource.childNodes)) {
+          headerDiv.appendChild(child.cloneNode(true));
+        }
+        pageBox.appendChild(headerDiv);
+      }
+      const contentAreaTop = effectiveHeights.headerHeight;
+      const contentAreaHeight = effectiveHeights.contentHeight;
+      const contentArea = document.createElement("div");
+      contentArea.className = `${this.cssPrefix}content`;
+      contentArea.style.position = "absolute";
+      contentArea.style.top = `${contentAreaTop}pt`;
+      contentArea.style.left = `${dims.marginLeft}pt`;
+      contentArea.style.width = `${dims.contentWidth}pt`;
+      contentArea.style.height = `${contentAreaHeight}pt`;
+      contentArea.style.overflow = "hidden";
+      for (const el of content) {
+        contentArea.appendChild(el);
+      }
+      pageBox.appendChild(contentArea);
+      const hasContinuation = continuation && continuation.remainingElements.length > 0;
+      if (footnoteIds.length > 0 || hasContinuation) {
+        this.addPageFootnotes(pageBox, footnoteIds, dims, footnoteHeight, continuation, partialFootnotes);
+      }
+      const footerSource = this.selectFooter(sectionIndex, pageInSection, pageNumber);
+      if (footerSource) {
+        const footerDiv = document.createElement("div");
+        footerDiv.className = `${this.cssPrefix}footer`;
+        footerDiv.style.position = "absolute";
+        footerDiv.style.bottom = "0";
+        footerDiv.style.left = `${dims.marginLeft}pt`;
+        footerDiv.style.width = `${dims.contentWidth}pt`;
+        footerDiv.style.height = `${effectiveHeights.footerHeight}pt`;
+        footerDiv.style.overflow = "hidden";
+        footerDiv.style.boxSizing = "border-box";
+        footerDiv.style.display = "flex";
+        footerDiv.style.flexDirection = "column";
+        footerDiv.style.justifyContent = "flex-start";
+        footerDiv.style.paddingTop = "4pt";
+        for (const child of Array.from(footerSource.childNodes)) {
+          footerDiv.appendChild(child.cloneNode(true));
+        }
+        pageBox.appendChild(footerDiv);
+      }
+      if (this.showPageNumbers) {
+        const pageNum = document.createElement("div");
+        pageNum.className = `${this.cssPrefix}number`;
+        pageNum.textContent = String(pageNumber);
+        pageBox.appendChild(pageNum);
+      }
+      this.containerElement.appendChild(pageBox);
+      return {
+        pageNumber,
+        sectionIndex,
+        dimensions: dims,
+        element: pageBox
+      };
+    }
+  };
+  function paginateHtml(html, container, options = {}) {
+    const containerEl = typeof container === "string" ? document.getElementById(container) : container;
+    if (!containerEl) {
+      throw new Error("Container element not found");
+    }
+    containerEl.innerHTML = html;
+    const cssPrefix = options.cssPrefix ?? "page-";
+    const staging = containerEl.querySelector("#pagination-staging") || containerEl.querySelector(`.${cssPrefix}staging`);
+    const pageContainer = containerEl.querySelector("#pagination-container") || containerEl.querySelector(`.${cssPrefix}container`);
+    if (!staging) {
+      throw new Error(
+        "Pagination staging element not found. Make sure the HTML was generated with PaginationMode.Paginated"
+      );
+    }
+    if (!pageContainer) {
+      throw new Error("Pagination container element not found");
+    }
+    const engine = new PaginationEngine(staging, pageContainer, options);
+    return engine.paginate();
+  }
+
+  // src/editor.ts
+  var EDITABLE_TAGS = /* @__PURE__ */ new Set(["P", "H1", "H2", "H3", "H4", "H5", "H6"]);
+  function fontWeightIsBold(w) {
+    if (w === "bold" || w === "bolder") return true;
+    const n = parseInt(w, 10);
+    return !Number.isNaN(n) && n >= 600;
+  }
+  function escapeInlineMarkdown(text) {
+    return text.replace(/([\\`*_[\]])/g, "\\$1");
+  }
+  function collectInlineSegments(node, out) {
+    node.childNodes.forEach((child) => {
+      if (child.nodeType === 1 && child.hasAttribute?.("data-list-marker")) return;
+      if (child.nodeType === 3) {
+        const text = child.textContent ?? "";
+        if (!text) return;
+        const parent = child.parentElement;
+        let bold = false;
+        let italic = false;
+        let href = null;
+        if (parent && typeof getComputedStyle === "function") {
+          const cs = getComputedStyle(parent);
+          bold = fontWeightIsBold(cs.fontWeight);
+          italic = cs.fontStyle === "italic" || cs.fontStyle === "oblique";
+          const a = parent.closest("a");
+          href = a ? a.getAttribute("href") : null;
+        }
+        out.push({ text, bold, italic, href });
+      } else if (child.nodeType === 1) {
+        const el = child;
+        if (el.tagName === "BR") {
+          out.push({ text: "\n", bold: false, italic: false, href: null });
+          return;
+        }
+        collectInlineSegments(el, out);
+      }
+    });
+  }
+  function segToMarkdown(seg) {
+    if (seg.text === "\n") return "  \n";
+    let md = escapeInlineMarkdown(seg.text).replace(/[ \t]*\n/g, "  \n");
+    if (/\S/.test(seg.text)) {
+      if (seg.bold && seg.italic) md = `***${md}***`;
+      else if (seg.bold) md = `**${md}**`;
+      else if (seg.italic) md = `*${md}*`;
+    }
+    if (seg.href) md = `[${md}](${seg.href})`;
+    return md;
+  }
+  function serializeInlineMarkdown(block) {
+    const segs = [];
+    collectInlineSegments(block, segs);
+    const merged = [];
+    for (const s of segs) {
+      const prev = merged[merged.length - 1];
+      if (prev && prev.text !== "\n" && s.text !== "\n" && prev.bold === s.bold && prev.italic === s.italic && prev.href === s.href) {
+        prev.text += s.text;
+      } else {
+        merged.push({ ...s });
+      }
+    }
+    return merged.map(segToMarkdown).join("").trim();
+  }
+  function isListBlock(block) {
+    return !!block.querySelector(":scope > [data-list-marker]");
+  }
+  function isInMarker(node) {
+    let el = node && node.nodeType === 1 ? node : node?.parentElement ?? null;
+    while (el) {
+      if (el.hasAttribute && el.hasAttribute("data-list-marker")) return true;
+      el = el.parentElement;
+    }
+    return false;
+  }
+  var BIDI_MARK_CLASS = "\u200E\u200F\u061C\u202A-\u202E\u2066-\u2069";
+  var BIDI_MARKS_RE_G = new RegExp(`[${BIDI_MARK_CLASS}]`, "g");
+  var BIDI_MARK_RE = new RegExp(`[${BIDI_MARK_CLASS}]`);
+  function stripBidi(s) {
+    return s.replace(BIDI_MARKS_RE_G, "");
+  }
+  function domOffsetForContentOffset(s, n) {
+    let content = 0;
+    for (let i = 0; i < s.length; i++) {
+      if (content >= n) return i;
+      if (!BIDI_MARK_RE.test(s[i])) content++;
+    }
+    return s.length;
+  }
+  function contentOffsetOf(block, container, offset) {
+    let count = 0;
+    let done = false;
+    const walk = (node) => {
+      if (done) return;
+      if (node.nodeType === 3) {
+        if (node === container) {
+          if (!isInMarker(node)) count += stripBidi((node.textContent ?? "").slice(0, offset)).length;
+          done = true;
+          return;
+        }
+        if (!isInMarker(node)) count += stripBidi(node.textContent ?? "").length;
+      } else {
+        if (node === container) {
+          const kids = Array.from(node.childNodes);
+          for (let i = 0; i < offset && i < kids.length; i++) walk(kids[i]);
+          done = true;
+          return;
+        }
+        node.childNodes.forEach(walk);
+      }
+    };
+    walk(block);
+    return count;
+  }
+  function caretOffsetIn(block) {
+    const sel = typeof window !== "undefined" ? window.getSelection() : null;
+    if (!sel || sel.rangeCount === 0) return null;
+    const range = sel.getRangeAt(0);
+    if (!block.contains(range.startContainer)) return null;
+    return contentOffsetOf(block, range.startContainer, range.startOffset);
+  }
+  function blockContentText(block) {
+    let out = "";
+    const walk = (node) => {
+      if (node.nodeType === 3) {
+        if (!isInMarker(node)) out += stripBidi(node.textContent ?? "");
+      } else {
+        node.childNodes.forEach(walk);
+      }
+    };
+    walk(block);
+    return out;
+  }
+  function trimmedSplitOffset(block, domOffset) {
+    const content = blockContentText(block);
+    const leading = content.length - content.replace(/^\s+/, "").length;
+    const trimmedLen = content.trim().length;
+    return Math.max(0, Math.min(domOffset - Math.min(domOffset, leading), trimmedLen));
+  }
+  function contentPositionIn(el, offset) {
+    let remaining = offset;
+    let result = null;
+    let lastText = null;
+    const walk = (node) => {
+      if (result) return;
+      if (node.nodeType === 3) {
+        if (isInMarker(node)) return;
+        const raw = node.textContent ?? "";
+        const len = stripBidi(raw).length;
+        lastText = node;
+        if (remaining <= len) {
+          result = { node, offset: domOffsetForContentOffset(raw, remaining) };
+          return;
+        }
+        remaining -= len;
+      } else {
+        node.childNodes.forEach(walk);
+      }
+    };
+    walk(el);
+    if (result) return result;
+    if (lastText) return { node: lastText, offset: (lastText.textContent ?? "").length };
+    return { node: el, offset: el.childNodes.length };
+  }
+  function placeCaretAtOffset(el, offset) {
+    const sel = typeof window !== "undefined" ? window.getSelection() : null;
+    if (!sel) return;
+    el.focus();
+    const range = document.createRange();
+    let remaining = offset;
+    let placed = false;
+    const walk = (node) => {
+      if (placed) return;
+      if (node.nodeType === 3) {
+        if (isInMarker(node)) return;
+        const raw = node.textContent ?? "";
+        const len = stripBidi(raw).length;
+        if (remaining <= len) {
+          range.setStart(node, domOffsetForContentOffset(raw, remaining));
+          placed = true;
+        } else {
+          remaining -= len;
+        }
+      } else {
+        node.childNodes.forEach(walk);
+      }
+    };
+    walk(el);
+    if (!placed) {
+      range.selectNodeContents(el);
+      range.collapse(false);
+    } else {
+      range.collapse(true);
+    }
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+  function selectionSpanIn(block) {
+    const sel = typeof window !== "undefined" ? window.getSelection() : null;
+    if (!sel || sel.rangeCount === 0) return null;
+    const range = sel.getRangeAt(0);
+    if (range.collapsed) return null;
+    if (!block.contains(range.startContainer) || !block.contains(range.endContainer)) return null;
+    const start = contentOffsetOf(block, range.startContainer, range.startOffset);
+    const end = contentOffsetOf(block, range.endContainer, range.endOffset);
+    return { start: Math.min(start, end), length: Math.abs(end - start) };
+  }
+  function selectRange(el, start, length) {
+    const sel = typeof window !== "undefined" ? window.getSelection() : null;
+    if (!sel || !el.isConnected) return;
+    el.focus();
+    const range = document.createRange();
+    const end = start + length;
+    let pos = 0;
+    let startSet = false;
+    const walk = (node) => {
+      for (const child of Array.from(node.childNodes)) {
+        if (child.nodeType === 3) {
+          if (isInMarker(child)) continue;
+          const raw = child.textContent ?? "";
+          const len = stripBidi(raw).length;
+          if (!startSet && pos + len >= start) {
+            range.setStart(child, domOffsetForContentOffset(raw, start - pos));
+            startSet = true;
+          }
+          if (startSet && pos + len >= end) {
+            range.setEnd(child, domOffsetForContentOffset(raw, end - pos));
+            return true;
+          }
+          pos += len;
+        } else if (walk(child)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    if (walk(el) || startSet) {
+      sel.removeAllRanges();
+      sel.addRange(range);
+    }
+  }
+  function inBorderWrapper(el) {
+    const style = el.parentElement?.getAttribute("style") ?? "";
+    return /border-(top|bottom|left|right):\s*(?!none)[^;]+/i.test(style);
+  }
+  function selectionHasFormat(key, fallback) {
+    const sel = typeof window !== "undefined" ? window.getSelection() : null;
+    let el = fallback;
+    if (sel && sel.rangeCount > 0) {
+      const n = sel.getRangeAt(0).startContainer;
+      el = n.nodeType === 3 ? n.parentElement : n;
+    }
+    if (!el || typeof getComputedStyle !== "function") return false;
+    const cs = getComputedStyle(el);
+    switch (key) {
+      case "bold":
+        return fontWeightIsBold(cs.fontWeight);
+      case "italic":
+        return cs.fontStyle === "italic" || cs.fontStyle === "oblique";
+      case "underline":
+        return cs.textDecorationLine.includes("underline");
+      case "strike":
+        return cs.textDecorationLine.includes("line-through");
+      case "code":
+        return /mono|courier|consolas/i.test(cs.fontFamily);
+      case "superscript":
+        return cs.verticalAlign === "super" || !!el.closest("sup");
+      case "subscript":
+        return cs.verticalAlign === "sub" || !!el.closest("sub");
+      default:
+        return false;
+    }
+  }
+  function completeArgs(bytes, cssPrefix, fabricate, paginated, scale) {
+    return [
+      bytes,
+      "Document",
+      cssPrefix,
+      fabricate,
+      "",
+      -1,
+      "comment-",
+      /* paginationMode */
+      paginated ? 1 : 0,
+      /* paginationScale */
+      scale,
+      "page-",
+      false,
+      0,
+      "annot-",
+      /* renderFootnotesAndEndnotes */
+      false,
+      /* renderHeadersAndFooters */
+      paginated,
+      false,
+      true,
+      true,
+      false,
+      null,
+      /* stampAnchors */
+      true
+    ];
+  }
+  var DocxEditor = class _DocxEditor {
+    constructor(container, exports, handle, options) {
+      /** Map a block's current bare unid → its full kind:scope:unid (DocxSession anchor). */
+      this.unidToFullId = /* @__PURE__ */ new Map();
+      /** The most recently focused editable block — the target for ribbon/format commands. */
+      this.activeBlock = null;
+      this.closed = false;
+      /**
+       * Re-entrancy guard for node replacement. Replacing a contenteditable block that still holds
+       * focus removes the focused node, which fires a SYNCHRONOUS `blur` → re-enters commitBlock; the
+       * interleaved second replaceWith then throws NotFoundError ("node ... no longer a child") and the
+       * structural edit (split/merge/format) is lost. While this flag is set, commitBlock no-ops.
+       */
+      this.replacing = false;
+      /**
+       * The last real (non-collapsed) text selection inside an editable block. A toolbar control that
+       * must take focus to be used — the font-size combobox — blurs the block and collapses the live
+       * selection, so without this an operation triggered from such a control could only target the
+       * whole paragraph (S-1 smoke-test finding 3). Refreshed whenever a non-empty selection sits in a
+       * block, and cleared when a caret is collapsed inside a block (so it never goes stale).
+       */
+      this.lastSelection = null;
+      /** Track the last meaningful selection so focus-stealing toolbar controls can still target it. */
+      this.onSelectionChange = () => {
+        if (this.closed) return;
+        const sel = typeof window !== "undefined" ? window.getSelection() : null;
+        if (!sel || sel.rangeCount === 0) return;
+        const range = sel.getRangeAt(0);
+        const block = this.editableBlockOf(range.commonAncestorContainer);
+        if (!block) return;
+        const unid = block.getAttribute("data-anchor");
+        if (!unid) return;
+        if (range.collapsed) {
+          this.lastSelection = null;
+          return;
+        }
+        const span = selectionSpanIn(block);
+        if (span) this.lastSelection = { unid, span };
+      };
+      this.container = container;
+      this.exports = exports;
+      this.handle = handle;
+      this.options = options;
+      this.editRoot = container;
+      if (typeof document !== "undefined")
+        document.addEventListener("selectionchange", this.onSelectionChange);
+    }
+    /** The editable block (contenteditable [data-anchor]) containing `node`, if any, within this editor. */
+    editableBlockOf(node) {
+      if (!node) return null;
+      const start = node.nodeType === 1 ? node : node.parentElement;
+      const block = start?.closest('[data-anchor][contenteditable="true"]') ?? null;
+      return block && this.editRoot.contains(block) ? block : null;
+    }
+    /** Open a document, render it into `container`, and wire up editing. */
+    static open(container, bytes, exports, options = {}) {
+      const opts = {
+        cssPrefix: options.cssPrefix ?? "docx-",
+        fabricateClasses: options.fabricateClasses ?? false,
+        editable: options.editable ?? true,
+        paginated: options.paginated ?? false,
+        scale: options.scale ?? 1,
+        onEdit: options.onEdit
+      };
+      const handle = exports.DocxSessionBridge.OpenSession(bytes, '{"persistAnchorIds":true}');
+      const editor = new _DocxEditor(container, exports, handle, opts);
+      editor.refreshAnchorMap();
+      const fullHtml = exports.DocumentConverter.ConvertDocxToHtmlComplete(
+        ...completeArgs(bytes, opts.cssPrefix, opts.fabricateClasses, opts.paginated, opts.scale)
+      );
+      if (opts.paginated) editor.mountPaginated(fullHtml);
+      else editor.mountHtml(fullHtml);
+      return editor;
+    }
+    /**
+     * Open a fresh, blank document (a "New document" — single empty paragraph, Normal style,
+     * US-Letter section) and wire up editing. The seed bytes come from the WASM bridge so the
+     * result opens cleanly in Word too.
+     */
+    static openBlank(container, exports, options = {}) {
+      return _DocxEditor.open(container, exports.DocxSessionBridge.CreateBlankDocx(), exports, options);
+    }
+    /** Lossless DOCX bytes reflecting all edits. */
+    save() {
+      this.assertOpen();
+      return this.exports.DocxSessionBridge.Save(this.handle);
+    }
+    /** Release the underlying WASM session. The editor is unusable afterward. */
+    close() {
+      if (this.closed) return;
+      this.closed = true;
+      if (typeof document !== "undefined")
+        document.removeEventListener("selectionchange", this.onSelectionChange);
+      this.exports.DocxSessionBridge.CloseSession(this.handle);
+    }
+    /**
+     * Switch between continuous and paginated rendering WITHOUT losing edits. Re-renders from the
+     * LIVE session, so every committed edit (and the undo/redo history) survives the toggle — unlike
+     * re-opening the original bytes, which silently discards session edits. No-op if already `value`.
+     */
+    setPaginated(value) {
+      this.assertOpen();
+      if (this.options.paginated === value) return;
+      this.options.paginated = value;
+      this.remount();
+    }
+    /** The editor's current DOM (for inspection/tests). */
+    get root() {
+      return this.container;
+    }
+    // ─── internals ───────────────────────────────────────────────────────
+    assertOpen() {
+      if (this.closed) throw new Error("DocxEditor is closed");
+    }
+    /** Rebuild unid → full-anchor-id from the live session projection. */
+    refreshAnchorMap() {
+      const proj = JSON.parse(this.exports.DocxSessionBridge.Project(this.handle));
+      this.unidToFullId.clear();
+      for (const [fullId, target] of Object.entries(proj.anchorIndex)) {
+        this.unidToFullId.set(target.unid, fullId);
+      }
+    }
+    /** Continuous (non-paginated) mount: inject the converter's styles + body, wire blocks. */
+    mountHtml(fullHtml) {
+      const parsed = new DOMParser().parseFromString(fullHtml, "text/html");
+      const styles = Array.from(parsed.querySelectorAll("style")).map((s) => s.outerHTML).join("");
+      this.container.innerHTML = styles + parsed.body.innerHTML;
+      this.editRoot = this.container;
+      if (this.options.editable) this.wireBlocks(this.container);
+    }
+    /** Paginated mount: flow blocks into page boxes via pagination.ts, wire the page clones. */
+    mountPaginated(fullHtml) {
+      paginateHtml(fullHtml, this.container, { scale: this.options.scale, cssPrefix: "page-" });
+      this.container.querySelector("#pagination-staging, .page-staging")?.remove();
+      const pageRoot = this.container.querySelector("#pagination-container") ?? this.container;
+      this.editRoot = pageRoot;
+      if (this.options.editable) this.wireBlocks(pageRoot);
+    }
+    wireBlocks(root) {
+      root.querySelectorAll("[data-anchor]").forEach((el) => this.wireBlock(el));
+    }
+    wireBlock(el) {
+      if (!EDITABLE_TAGS.has(el.tagName)) return;
+      const unid = el.getAttribute("data-anchor");
+      if (!unid || !this.unidToFullId.has(unid)) return;
+      el.setAttribute("contenteditable", "true");
+      el.querySelectorAll("[data-list-marker]").forEach((m) => m.setAttribute("contenteditable", "false"));
+      el.dataset.committedText = blockContentText(el);
+      el.addEventListener("focus", () => {
+        this.activeBlock = el;
+      });
+      el.addEventListener("blur", () => this.commitBlock(el));
+      el.addEventListener("keydown", (ev) => this.onKeydown(el, ev));
+    }
+    /**
+     * Replace `oldEl` with `newNodes`, suppressing the re-entrant blur→commit that removing a focused
+     * block fires (see `replacing`), AND tolerating the case where a synchronous blur during focus
+     * transfer detaches `oldEl` between the caller's checks and here. `replaceWith` then throws
+     * NotFoundError ("node … no longer a child … moved in a blur event handler") — `isConnected`
+     * alone doesn't catch this race. The session is already updated, so a skipped/failed visual swap
+     * leaves correct content (the typed DOM); the next commit or remount reconciles it. This is why
+     * the catch is silent rather than rethrowing — there's no lost data, only a deferred re-render.
+     * Returns true if the swap happened.
+     */
+    replaceNode(oldEl, ...newNodes) {
+      const prev = this.replacing;
+      this.replacing = true;
+      try {
+        if (!oldEl.parentNode) return false;
+        oldEl.replaceWith(...newNodes);
+        return true;
+      } catch {
+        return false;
+      } finally {
+        this.replacing = prev;
+      }
+    }
+    /** Commit a block edit on blur: diff → run-preserving session op → re-render only this block. */
+    commitBlock(el) {
+      if (this.closed || this.replacing) return;
+      const unid = el.getAttribute("data-anchor");
+      if (!unid) return;
+      const fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const result = this.commitTextChange(el, fullId);
+      if (!result) return;
+      if (!result.success) {
+        const fresh = this.renderInto(fullId);
+        if (fresh && this.replaceNode(el, fresh)) {
+          this.wireBlock(fresh);
+          if (this.activeBlock === el) this.activeBlock = fresh;
+        }
+        return;
+      }
+      const newAnchor = result.modified?.[0]?.id ?? fullId;
+      const newUnid = result.modified?.[0]?.unid ?? unid;
+      if (el.querySelector(":scope > [data-list-marker]")) {
+        el.dataset.committedText = blockContentText(el);
+        this.options.onEdit?.({ anchorId: newAnchor, unid: newUnid });
+        return;
+      }
+      const html = this.exports.DocxSessionBridge.RenderBlockHtml(
+        this.handle,
+        newAnchor,
+        this.options.cssPrefix,
+        this.options.fabricateClasses
+      );
+      if (html.charCodeAt(0) !== 123) {
+        const fresh = new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+        if (fresh && this.replaceNode(el, fresh)) {
+          this.unidToFullId.delete(unid);
+          this.unidToFullId.set(newUnid, newAnchor);
+          this.wireBlock(fresh);
+          if (this.activeBlock === el) this.activeBlock = fresh;
+        }
+      }
+      this.options.onEdit?.({ anchorId: newAnchor, unid: newUnid });
+    }
+    // ─── M2: structural editing ──────────────────────────────────────────
+    onKeydown(el, ev) {
+      if (this.closed) return;
+      if ((ev.ctrlKey || ev.metaKey) && !ev.altKey) {
+        const k = ev.key.toLowerCase();
+        const fmt = { b: "bold", i: "italic", u: "underline" };
+        if (fmt[k]) {
+          ev.preventDefault();
+          this.format(fmt[k]);
+          return;
+        }
+        if (k === "z") {
+          ev.preventDefault();
+          ev.shiftKey ? this.redo() : this.undo();
+          return;
+        }
+        if (k === "y") {
+          ev.preventDefault();
+          this.redo();
+          return;
+        }
+      }
+      const inTableCell = !!el.closest("table");
+      if (ev.key === "Tab") {
+        if (inTableCell) {
+          ev.preventDefault();
+          return;
+        }
+        if (isListBlock(el)) {
+          ev.preventDefault();
+          this.activeBlock = el;
+          this.setListLevel(ev.shiftKey ? -1 : 1);
+          return;
+        }
+      }
+      if (ev.key === "Enter" && ev.shiftKey && !ev.isComposing) {
+        ev.preventDefault();
+        this.insertLineBreakAtCaret();
+        return;
+      }
+      if (ev.key === "Enter" && !ev.shiftKey && !ev.isComposing) {
+        ev.preventDefault();
+        this.splitAtCaret(el);
+      } else if (ev.key === "Backspace") {
+        const sel = typeof window !== "undefined" ? window.getSelection() : null;
+        if (sel && sel.isCollapsed && caretOffsetIn(el) === 0 && !inTableCell) {
+          const prev = this.previousEditable(el);
+          if (prev) {
+            ev.preventDefault();
+            this.mergeWithPrevious(prev, el);
+          }
+        }
+      }
+    }
+    /** Shift+Enter: insert an intra-paragraph line break at the caret. Delegates to the
+     *  native `insertLineBreak` command, which inserts a <br> AND positions the caret
+     *  after it correctly (handling the browser's bogus trailing-<br> rule) so typing
+     *  continues on the new line. Commits (on blur) as a w:br via the "  \n" hard break
+     *  the serializer emits for a <br>. */
+    insertLineBreakAtCaret() {
+      if (typeof document !== "undefined" && typeof document.execCommand === "function") {
+        document.execCommand("insertLineBreak");
+      }
+    }
+    /** Enter: split the block at the caret into two paragraphs. */
+    splitAtCaret(el) {
+      const rawOffset = caretOffsetIn(el);
+      const unid = el.getAttribute("data-anchor");
+      if (rawOffset == null || !unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const offset = trimmedSplitOffset(el, rawOffset);
+      const idx = this.blockIndex(el);
+      const wrappedInBorder = inBorderWrapper(el);
+      fullId = this.syncBlock(el, fullId);
+      const res = this.parseEdit(this.exports.DocxSessionBridge.SplitParagraph(this.handle, fullId, offset));
+      if (!res.success) return;
+      const first = res.modified?.[0];
+      const second = res.created?.[0];
+      if (!first || !second) return;
+      if (this.affectsList(res) || wrappedInBorder) {
+        this.remount(idx + 1, false);
+        this.options.onEdit?.({ anchorId: second.id, unid: second.unid });
+        return;
+      }
+      const firstEl = this.renderInto(first.id);
+      const secondEl = this.renderInto(second.id);
+      if (!firstEl || !secondEl) return;
+      if (!this.replaceNode(el, firstEl, secondEl)) return;
+      this.unidToFullId.delete(unid);
+      this.unidToFullId.set(first.unid, first.id);
+      this.unidToFullId.set(second.unid, second.id);
+      this.wireBlock(firstEl);
+      this.wireBlock(secondEl);
+      placeCaretAtOffset(secondEl, 0);
+      this.options.onEdit?.({ anchorId: second.id, unid: second.unid });
+    }
+    /** Backspace at block start: merge this block into the previous one. */
+    mergeWithPrevious(prev, el) {
+      const prevUnid = prev.getAttribute("data-anchor");
+      const thisUnid = el.getAttribute("data-anchor");
+      if (!prevUnid || !thisUnid) return;
+      let prevId = this.unidToFullId.get(prevUnid);
+      let thisId = this.unidToFullId.get(thisUnid);
+      if (!prevId || !thisId) return;
+      const prevIdx = this.blockIndex(prev);
+      const wrappedInBorder = inBorderWrapper(prev) || inBorderWrapper(el);
+      prevId = this.syncBlock(prev, prevId);
+      thisId = this.syncBlock(el, thisId);
+      const caret = (prev.textContent ?? "").length;
+      const res = this.parseEdit(this.exports.DocxSessionBridge.MergeParagraphs(this.handle, prevId, thisId));
+      if (!res.success) return;
+      const merged = res.modified?.[0];
+      if (!merged) return;
+      if (this.affectsList(res) || wrappedInBorder) {
+        this.remount(prevIdx, true);
+        this.options.onEdit?.({ anchorId: merged.id, unid: merged.unid });
+        return;
+      }
+      const mergedEl = this.renderInto(merged.id);
+      if (!mergedEl) return;
+      if (!this.replaceNode(prev, mergedEl)) return;
+      el.remove();
+      this.unidToFullId.delete(prevUnid);
+      this.unidToFullId.delete(thisUnid);
+      this.unidToFullId.set(merged.unid, merged.id);
+      this.wireBlock(mergedEl);
+      placeCaretAtOffset(mergedEl, caret);
+      this.options.onEdit?.({ anchorId: merged.id, unid: merged.unid });
+    }
+    /**
+     * Apply the block's pending text change to the session with full inline-formatting fidelity.
+     * Diffs the committed content text (markers + bidi excluded) against the current content text
+     * and rewrites only the changed span via ReplaceTextAtSpan — every untouched run keeps its exact
+     * rPr, and typed text inherits the boundary run's formatting. Returns the parsed EditResult, or
+     * null when there is no change. Empty/whitespace-only baselines (e.g. the placeholder space the
+     * converter renders for an empty paragraph, whose DOM text doesn't line up with the session's
+     * empty run text) are rebuilt via ReplaceText — there is no inline formatting to preserve there.
+     */
+    commitTextChange(el, fullId) {
+      const old = stripBidi(el.dataset.committedText ?? "");
+      const next = blockContentText(el);
+      if (old === next) return null;
+      if (old.trim().length === 0) {
+        return this.parseEdit(
+          this.exports.DocxSessionBridge.ReplaceText(this.handle, fullId, serializeInlineMarkdown(el))
+        );
+      }
+      const minLen = Math.min(old.length, next.length);
+      let p = 0;
+      while (p < minLen && old[p] === next[p]) p++;
+      let s = 0;
+      while (s < minLen - p && old[old.length - 1 - s] === next[next.length - 1 - s]) s++;
+      let start = p;
+      let len = old.length - p - s;
+      let middle = next.slice(p, next.length - s);
+      if (len === 0) {
+        if (start > 0) {
+          start -= 1;
+          len = 1;
+          middle = old[start] + middle;
+        } else {
+          len = 1;
+          middle = middle + old[0];
+        }
+      }
+      return this.parseEdit(
+        this.exports.DocxSessionBridge.ReplaceTextAtSpan(this.handle, fullId, start, len, middle)
+      );
+    }
+    /** Flush a block's current (uncommitted) text to the session; returns the live full id. */
+    syncBlock(el, fullId) {
+      const result = this.commitTextChange(el, fullId);
+      if (!result || !result.success) return fullId;
+      el.dataset.committedText = blockContentText(el);
+      return result.modified?.[0]?.id ?? fullId;
+    }
+    /** Render a block by anchor and parse it into a detached element (null on error). */
+    renderInto(anchorId) {
+      const html = this.exports.DocxSessionBridge.RenderBlockHtml(
+        this.handle,
+        anchorId,
+        this.options.cssPrefix,
+        this.options.fabricateClasses
+      );
+      if (html.charCodeAt(0) === 123) return null;
+      return new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+    }
+    /** The editable block immediately before `el` in document order, or null. */
+    previousEditable(el) {
+      const all = Array.from(
+        this.editRoot.querySelectorAll('[data-anchor][contenteditable="true"]')
+      );
+      const i = all.indexOf(el);
+      return i > 0 ? all[i - 1] : null;
+    }
+    parseEdit(json) {
+      try {
+        return JSON.parse(json);
+      } catch {
+        return { success: false };
+      }
+    }
+    // ─── M5: formatting commands (ribbon) ────────────────────────────────
+    // ─── Multi-block selection helpers (format a whole stack of paragraphs at once) ──────
+    /** Editable blocks the current selection covers, in document order. Uses Range.comparePoint
+     *  (robust to a selection boundary that normalized onto a wrapper element rather than a block
+     *  or text node — Range.intersectsNode misses the end block at a `(block, childCount)` boundary).
+     *  A collapsed or single-block selection yields just the active block. */
+    selectedBlocks() {
+      const sel = typeof window !== "undefined" ? window.getSelection() : null;
+      const all = Array.from(
+        this.editRoot.querySelectorAll('[data-anchor][contenteditable="true"]')
+      );
+      if (sel && sel.rangeCount > 0 && !sel.isCollapsed) {
+        const range = sel.getRangeAt(0);
+        const hit = all.filter((b) => {
+          try {
+            const startsAfterEnd = range.comparePoint(b, 0) > 0;
+            const endsBeforeStart = range.comparePoint(b, b.childNodes.length) < 0;
+            return !startsAfterEnd && !endsBeforeStart;
+          } catch {
+            return false;
+          }
+        });
+        if (hit.length > 1) return hit;
+      }
+      return this.activeBlock ? [this.activeBlock] : [];
+    }
+    /** The selection's span within `block`, clipped to the block (for inline ops across blocks):
+     *  the first block runs selection-start→end-of-block, middle blocks are whole, the last block
+     *  runs start-of-block→selection-end. Returns null for a whole-block apply. */
+    blockSpanForSelection(block) {
+      const sel = typeof window !== "undefined" ? window.getSelection() : null;
+      if (!sel || sel.rangeCount === 0 || sel.isCollapsed) return null;
+      const range = sel.getRangeAt(0);
+      const hasStart = block.contains(range.startContainer);
+      const hasEnd = block.contains(range.endContainer);
+      if (hasStart && hasEnd) return selectionSpanIn(block);
+      const contentLen = blockContentText(block).length;
+      if (hasStart) {
+        const start = contentOffsetOf(block, range.startContainer, range.startOffset);
+        return { start, length: Math.max(0, contentLen - start) };
+      }
+      if (hasEnd) {
+        const end = contentOffsetOf(block, range.endContainer, range.endOffset);
+        return { start: 0, length: end };
+      }
+      return { start: 0, length: contentLen };
+    }
+    /** Apply an inline ApplyFormat op to each block's slice of the selection, then reconcile
+     *  the DOM incrementally (see {@link finishMultiBlockOp} — a full remount costs a whole-
+     *  document convert, seconds on a large doc, where per-block swaps are ~10 ms each).
+     *  Returns false (caller falls back to the single-block path) for a 1-block selection. */
+    applyInlineOpAcrossBlocks(blocks, op) {
+      if (blocks.length <= 1) return false;
+      const targets = this.multiBlockTargets(blocks);
+      for (const t of targets) {
+        if (!t.fullId || t.span && t.span.length === 0) continue;
+        const synced = this.syncBlock(t.block, t.fullId);
+        const res = this.parseEdit(this.exports.DocxSessionBridge.ApplyFormat(
+          this.handle,
+          synced,
+          t.span ? JSON.stringify(t.span) : "",
+          JSON.stringify(op)
+        ));
+        if (res.success) t.res = res;
+      }
+      this.finishMultiBlockOp(targets, false);
+      return true;
+    }
+    /** Apply a whole-block (paragraph-level) op to each selected block, then reconcile the DOM
+     *  incrementally ({@link finishMultiBlockOp}). `forceRemount` is for ops whose rendering
+     *  needs whole-document context (e.g. border-div regrouping after clearBorders). Returns
+     *  false for a 1-block selection (caller uses the single-block path). */
+    applyParagraphOpAcrossBlocks(blocks, run, forceRemount = false) {
+      if (blocks.length <= 1) return false;
+      const targets = this.multiBlockTargets(blocks);
+      for (const t of targets) {
+        if (!t.fullId) continue;
+        const synced = this.syncBlock(t.block, t.fullId);
+        const res = this.parseEdit(run(synced));
+        if (res.success) t.res = res;
+      }
+      this.finishMultiBlockOp(targets, forceRemount);
+      return true;
+    }
+    /** Snapshot each selected block's identity + selection slice BEFORE any session op runs
+     *  (ops never mutate the DOM, so spans captured here stay valid until the swap phase). */
+    multiBlockTargets(blocks) {
+      return blocks.map((b) => {
+        const unid = b.getAttribute("data-anchor");
+        return {
+          block: b,
+          unid,
+          fullId: unid ? this.unidToFullId.get(unid) : void 0,
+          span: this.blockSpanForSelection(b),
+          res: null
+        };
+      });
+    }
+    /**
+     * Reconcile the DOM after a multi-block op. Fidelity-identical to the single-block path by
+     * construction: each edited block is swapped for its own session-attached single-block
+     * render — exactly what format()/setFontSize()/applyParagraphFormat() do for one block —
+     * so a multi-block apply is N single-block applies, not one whole-document re-render
+     * (which froze the UI for the full-document convert time on every ribbon action). Falls
+     * back to ONE full remount when the op touched a list item (numbering continuation needs
+     * whole-document context) or the caller forced it. Restores the cross-block selection so
+     * consecutive ribbon actions (center, then bold) keep targeting the same range.
+     */
+    finishMultiBlockOp(targets, forceRemount) {
+      const edited = targets.filter((t) => t.res && t.unid);
+      if (edited.length === 0) return;
+      if (forceRemount || this.options.paginated || edited.some((t) => this.affectsList(t.res))) {
+        this.remount();
+        return;
+      }
+      const swapped = [];
+      for (const t of edited) {
+        const fresh = this.swapBlock(t.block, t.unid, t.res.modified?.[0]);
+        swapped.push({ el: fresh ?? t.block, span: t.span });
+      }
+      const first = swapped[0];
+      const last = swapped[swapped.length - 1];
+      if (!first.el.isConnected || !last.el.isConnected) return;
+      const sel = typeof window !== "undefined" ? window.getSelection() : null;
+      if (!sel) return;
+      const startOff = first.span?.start ?? 0;
+      const endOff = last.span ? last.span.start + last.span.length : blockContentText(last.el).length;
+      const startPos = contentPositionIn(first.el, startOff);
+      const endPos = contentPositionIn(last.el, endOff);
+      try {
+        const range = document.createRange();
+        range.setStart(startPos.node, startPos.offset);
+        range.setEnd(endPos.node, endPos.offset);
+        sel.removeAllRanges();
+        sel.addRange(range);
+      } catch {
+      }
+    }
+    /**
+     * Toggle (or set) an inline format on the current selection in the active block.
+     * A selection spanning multiple blocks applies to each. With no selection, applies to
+     * the whole paragraph. Routes through DocxSession (`ApplyFormat`) so it is lossless and
+     * supports underline/strike, not just markdown.
+     */
+    format(key, value) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const blocks = this.selectedBlocks();
+      if (blocks.length > 1) {
+        const on0 = value ?? !selectionHasFormat(key, blocks[0]);
+        const multiOp = key === "superscript" || key === "subscript" ? { vertAlign: on0 ? key : "" } : { [key]: on0 };
+        if (this.applyInlineOpAcrossBlocks(blocks, multiOp)) return;
+      }
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const span = selectionSpanIn(block);
+      const on = value ?? !selectionHasFormat(key, block);
+      const op = key === "superscript" || key === "subscript" ? { vertAlign: on ? key : "" } : { [key]: on };
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(
+        this.exports.DocxSessionBridge.ApplyFormat(
+          this.handle,
+          fullId,
+          span ? JSON.stringify(span) : "",
+          JSON.stringify(op)
+        )
+      );
+      if (!res.success) return;
+      if (this.affectsList(res)) {
+        this.remount(this.blockIndex(block), false);
+        return;
+      }
+      const fresh = this.swapBlock(block, unid, res.modified?.[0]);
+      if (fresh && span) selectRange(fresh, span.start, span.length);
+      else fresh?.focus();
+    }
+    /**
+     * Set the font size (in points) of the current selection in the active block; with no
+     * selection, applies to the whole paragraph. `pts <= 0` clears the explicit size. Routes
+     * through DocxSession `ApplyFormat` (`w:sz`), so it is lossless and survives save.
+     */
+    setFontSize(pts) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const blocks = this.selectedBlocks();
+      if (blocks.length > 1 && this.applyInlineOpAcrossBlocks(blocks, { fontSizePts: pts })) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      let span = selectionSpanIn(block);
+      if (!span && this.lastSelection && this.lastSelection.unid === unid) span = this.lastSelection.span;
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(
+        this.exports.DocxSessionBridge.ApplyFormat(
+          this.handle,
+          fullId,
+          span ? JSON.stringify(span) : "",
+          JSON.stringify({ fontSizePts: pts })
+        )
+      );
+      if (!res.success) return;
+      if (this.affectsList(res)) {
+        this.remount(this.blockIndex(block), false);
+        return;
+      }
+      const fresh = this.swapBlock(block, unid, res.modified?.[0]);
+      if (fresh && span) selectRange(fresh, span.start, span.length);
+      else fresh?.focus();
+    }
+    /**
+     * Set the font family of the current selection in the active block; with no selection,
+     * applies to the whole paragraph. `""` clears the explicit font (inherits the style/default).
+     * Routes through DocxSession `ApplyFormat` (`w:rFonts`), so it is lossless and survives save.
+     * Multi-block + last-selection plumbing matches {@link setFontSize} (a focus-stealing font
+     * dropdown still applies to the real sub-range).
+     */
+    setFontFamily(name) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const blocks = this.selectedBlocks();
+      if (blocks.length > 1 && this.applyInlineOpAcrossBlocks(blocks, { fontFamily: name })) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      let span = selectionSpanIn(block);
+      if (!span && this.lastSelection && this.lastSelection.unid === unid) span = this.lastSelection.span;
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(
+        this.exports.DocxSessionBridge.ApplyFormat(
+          this.handle,
+          fullId,
+          span ? JSON.stringify(span) : "",
+          JSON.stringify({ fontFamily: name })
+        )
+      );
+      if (!res.success) return;
+      if (this.affectsList(res)) {
+        this.remount(this.blockIndex(block), false);
+        return;
+      }
+      const fresh = this.swapBlock(block, unid, res.modified?.[0]);
+      if (fresh && span) selectRange(fresh, span.start, span.length);
+      else fresh?.focus();
+    }
+    /** Set paragraph alignment (left/center/right/justify) on the active block. */
+    setAlignment(alignment) {
+      this.applyParagraphFormat({ alignment });
+    }
+    /**
+     * Insert an S-1-style horizontal rule (an empty paragraph with a bottom border) after the
+     * active block. `weight` is the rule thickness in eighths of a point (default 12 ≈ 1.5pt).
+     * Re-renders fully (a new block needs whole-document context to lay out).
+     */
+    insertHorizontalRule(weight = 12, style = "single", position = "below") {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const idx = this.blockIndex(block);
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(
+        this.exports.DocxSessionBridge.InsertHorizontalRule(
+          this.handle,
+          fullId,
+          position === "above" ? "before" : "after",
+          JSON.stringify({ style, size: weight, color: "auto" })
+        )
+      );
+      if (!res.success) return;
+      this.remount(idx, false);
+    }
+    /**
+     * Insert a `rows`×`cols` table after the active block. `options.cellContents` (row-major
+     * markdown) seeds the cells, `options.borderless` makes an invisible layout table, and
+     * `options.cellAlignment` aligns every cell. Re-renders fully (tables need document context).
+     */
+    insertTable(rows, cols, options) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const idx = this.blockIndex(block);
+      fullId = this.syncBlock(block, fullId);
+      const emptyHere = !block.closest("table") && blockContentText(block).replace(/[\s ]+/g, "").length === 0;
+      const res = this.parseEdit(
+        this.exports.DocxSessionBridge.InsertTable(
+          this.handle,
+          fullId,
+          emptyHere ? "before" : "after",
+          rows,
+          cols,
+          options ? JSON.stringify(options) : ""
+        )
+      );
+      if (!res.success) return;
+      this.remount(idx, false);
+    }
+    // ─── Table row / column editing (active block must be inside a table cell) ──────────
+    /** Run a table-structure op on the active cell (a cell-paragraph block) and re-render. */
+    tableEdit(run) {
+      const block = this.activeBlock;
+      if (this.closed || !block || !block.closest("table")) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const idx = this.blockIndex(block);
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(run(fullId));
+      if (!res.success) return;
+      this.remount(idx, false);
+    }
+    /** Insert a row above/below the active cell's row. No-op outside a table. */
+    insertTableRow(where) {
+      this.tableEdit(
+        (a) => this.exports.DocxSessionBridge.InsertTableRow(this.handle, a, where === "above" ? "before" : "after")
+      );
+    }
+    /** Insert a column left/right of the active cell's column. No-op outside a table. */
+    insertTableColumn(where) {
+      this.tableEdit(
+        (a) => this.exports.DocxSessionBridge.InsertTableColumn(this.handle, a, where === "left" ? "before" : "after")
+      );
+    }
+    /** Delete the active cell's row (deleting the last row removes the table). No-op outside a table. */
+    deleteTableRow() {
+      this.tableEdit((a) => this.exports.DocxSessionBridge.DeleteTableRow(this.handle, a));
+    }
+    /** Delete the active cell's column (deleting the last column removes the table). No-op outside a table. */
+    deleteTableColumn() {
+      this.tableEdit((a) => this.exports.DocxSessionBridge.DeleteTableColumn(this.handle, a));
+    }
+    /**
+     * Indent/outdent the active block. On a LIST item this changes the list NESTING LEVEL
+     * (`SetListLevel`) so numbering nests (e.g. 1, 2 → a sub-level) rather than the item just
+     * shifting sideways with flat numbering. On a plain paragraph it adjusts the left indent by
+     * `deltaTwips` (default ±720 = 0.5"), clamped at 0.
+     */
+    indent(deltaTwips = 720) {
+      if (this.activeBlock && isListBlock(this.activeBlock)) {
+        this.setListLevel(deltaTwips >= 0 ? 1 : -1);
+        return;
+      }
+      this.applyParagraphFormat({ indentDelta: deltaTwips });
+    }
+    /** Change the active list item's nesting level by `delta` (+1 deeper, −1 shallower). */
+    setListLevel(delta) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const idx = this.blockIndex(block);
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(this.exports.DocxSessionBridge.SetListLevel(this.handle, fullId, delta));
+      if (!res.success) return;
+      this.remount(idx, false);
+    }
+    /** Toggle (or set) page-break-before on the active block. */
+    pageBreakBefore(value = true) {
+      this.applyParagraphFormat({ pageBreakBefore: value });
+    }
+    /**
+     * Toggle the active block between a bullet/numbered list item and a plain paragraph.
+     * Clicking the same kind it already is removes the list; any other state applies the kind.
+     */
+    toggleList(kind) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      let membership = null;
+      try {
+        membership = JSON.parse(this.exports.DocxSessionBridge.GetListMembership(this.handle, fullId));
+      } catch {
+      }
+      const isThisKind = !!membership && typeof membership.format === "string" && membership.format.toLowerCase().startsWith(kind === "bullet" ? "bullet" : "decimal");
+      const idx = this.blockIndex(block);
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(
+        this.exports.DocxSessionBridge.ApplyListFormat(this.handle, fullId, isThisKind ? "none" : kind)
+      );
+      if (!res.success) return;
+      this.remount(idx, false);
+    }
+    /** Clear all paragraph borders (e.g. remove an inserted horizontal rule) on the active block —
+     *  or every block in a multi-block selection. The engine/wire already accept `clearBorders`;
+     *  this surfaces it on the editor so an HR border is removable (S-1 smoke-test finding 1b). */
+    clearParagraphBorders() {
+      this.applyParagraphFormat({ clearBorders: true });
+    }
+    /**
+     * Delete the active block (e.g. a stray empty paragraph left above/below a table). Routes
+     * through DocxSession `DeleteBlock` + re-render, focusing the previous block. No-op when the
+     * caret is inside a table (remove cells via the table toolbar's delete row/column instead) and
+     * no-op when it is the only editable block (don't empty the document). Closes the S-1
+     * smoke-test "no block-delete affordance" gap.
+     */
+    deleteBlock() {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      if (block.closest("table")) return;
+      if (this.editableList().length <= 1) return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      const fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const idx = this.blockIndex(block);
+      const res = this.parseEdit(this.exports.DocxSessionBridge.DeleteBlock(this.handle, fullId));
+      if (!res.success) return;
+      this.remount(Math.max(0, idx - 1), true);
+    }
+    applyParagraphFormat(op) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const blocks = this.selectedBlocks();
+      if (blocks.length > 1 && this.applyParagraphOpAcrossBlocks(
+        blocks,
+        (id) => this.exports.DocxSessionBridge.SetParagraphFormat(this.handle, id, JSON.stringify(op)),
+        // A border change regroups the wrapping border <div>s — whole-document context.
+        !!op.clearBorders
+      ))
+        return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const idx = this.blockIndex(block);
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(
+        this.exports.DocxSessionBridge.SetParagraphFormat(this.handle, fullId, JSON.stringify(op))
+      );
+      if (!res.success) return;
+      if (this.affectsList(res) || op.clearBorders) {
+        this.remount(idx, false);
+        return;
+      }
+      this.swapBlock(block, unid, res.modified?.[0])?.focus();
+    }
+    /** Set the paragraph style of the active block — or of every block in a multi-block selection
+     *  (e.g. "Heading1", "Heading2", "Normal"). */
+    setParagraphStyle(styleId) {
+      const block = this.activeBlock;
+      if (this.closed || !block) return;
+      const blocks = this.selectedBlocks();
+      if (blocks.length > 1 && this.applyParagraphOpAcrossBlocks(
+        blocks,
+        (id) => this.exports.DocxSessionBridge.SetParagraphStyle(this.handle, id, styleId)
+      ))
+        return;
+      const unid = block.getAttribute("data-anchor");
+      if (!unid) return;
+      let fullId = this.unidToFullId.get(unid);
+      if (!fullId) return;
+      const idx = this.blockIndex(block);
+      fullId = this.syncBlock(block, fullId);
+      const res = this.parseEdit(this.exports.DocxSessionBridge.SetParagraphStyle(this.handle, fullId, styleId));
+      if (!res.success) return;
+      if (this.affectsList(res)) {
+        this.remount(idx, false);
+        return;
+      }
+      this.swapBlock(block, unid, res.modified?.[0])?.focus();
+    }
+    /** Undo the last edit (re-renders the document). */
+    undo() {
+      if (this.closed) return;
+      if (this.exports.DocxSessionBridge.Undo(this.handle)) this.remount();
+    }
+    /** Redo the last undone edit (re-renders the document). */
+    redo() {
+      if (this.closed) return;
+      if (this.exports.DocxSessionBridge.Redo(this.handle)) this.remount();
+    }
+    /** Which inline formats the current selection carries — for ribbon button highlighting. */
+    queryFormatState() {
+      const block = this.activeBlock ?? this.editRoot;
+      return {
+        bold: selectionHasFormat("bold", block),
+        italic: selectionHasFormat("italic", block),
+        underline: selectionHasFormat("underline", block),
+        strike: selectionHasFormat("strike", block),
+        code: selectionHasFormat("code", block),
+        superscript: selectionHasFormat("superscript", block),
+        subscript: selectionHasFormat("subscript", block)
+      };
+    }
+    /** Re-render one block from the live session by EditResult ref, swapping it in place. */
+    swapBlock(oldEl, oldUnid, ref) {
+      const anchorId = ref?.id ?? this.unidToFullId.get(oldUnid);
+      const newUnid = ref?.unid ?? oldUnid;
+      if (!anchorId) return null;
+      const fresh = this.renderInto(anchorId);
+      if (!fresh || !this.replaceNode(oldEl, fresh)) return null;
+      this.unidToFullId.delete(oldUnid);
+      this.unidToFullId.set(newUnid, anchorId);
+      this.wireBlock(fresh);
+      this.activeBlock = fresh;
+      this.options.onEdit?.({ anchorId, unid: newUnid });
+      return fresh;
+    }
+    /**
+     * Full-document HTML from the live session. Prefers the session-attached
+     * `RenderHtml` bridge — the saved bytes never cross the JS/WASM boundary
+     * (two multi-MB copies per remount on a large doc) — and falls back to
+     * Save + ConvertDocxToHtmlComplete for older WASM bundles. Both paths use
+     * the same option profile, so the rendered HTML is identical.
+     */
+    renderFullHtml() {
+      const bridge = this.exports.DocxSessionBridge;
+      if (typeof bridge.RenderHtml === "function") {
+        const html = bridge.RenderHtml(
+          this.handle,
+          this.options.cssPrefix,
+          this.options.fabricateClasses,
+          this.options.paginated,
+          this.options.scale
+        );
+        if (html.charCodeAt(0) !== 123) return html;
+      }
+      const bytes = bridge.Save(this.handle);
+      return this.exports.DocumentConverter.ConvertDocxToHtmlComplete(
+        ...completeArgs(bytes, this.options.cssPrefix, this.options.fabricateClasses, this.options.paginated, this.options.scale)
+      );
+    }
+    /** Editable blocks in document order. */
+    editableList() {
+      return Array.from(this.editRoot.querySelectorAll('[data-anchor][contenteditable="true"]'));
+    }
+    blockIndex(el) {
+      return this.editableList().indexOf(el);
+    }
+    /**
+     * True when an edit produced or touched a list item (kind "li"). List markers and
+     * numbering CONTINUATION need whole-document context, which a single-block render lacks
+     * (every item would render as "1."), so such edits re-render the whole document.
+     */
+    affectsList(res) {
+      return [...res.modified ?? [], ...res.created ?? []].some((r) => r.kind === "li");
+    }
+    /**
+     * Full re-render from current session state (after undo/redo, and after list edits where
+     * single-block rendering can't compute numbering). Optionally focus the editable block at
+     * `focusIndex` (caret at start, or end if `caretAtEnd`) — addressed by index because a
+     * block's content-hashed unid changes across the save/reproject a remount performs.
+     */
+    remount(focusIndex = -1, caretAtEnd = false) {
+      this.refreshAnchorMap();
+      const fullHtml = this.renderFullHtml();
+      this.activeBlock = null;
+      if (this.options.paginated) this.mountPaginated(fullHtml);
+      else this.mountHtml(fullHtml);
+      if (focusIndex >= 0) {
+        const blocks = this.editableList();
+        const target = blocks[Math.min(focusIndex, blocks.length - 1)];
+        if (target) {
+          this.activeBlock = target;
+          placeCaretAtOffset(target, caretAtEnd ? (target.textContent ?? "").length : 0);
+        }
+      }
+    }
+  };
+  return __toCommonJS(editor_exports);
+})();