@harbour-enterprises/superdoc 1.5.0 → 1.6.0-next.2

package/dist/chunks/{index-BFU5qWH7.cjs → index-D-7HfDnq.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const jszip = require("./jszip-C8_CqJxM.cjs");
 const helpers$1 = require("./helpers-nOdwpmwb.cjs");
-const superEditor_converter = require("./SuperConverter-DmX1tktl.cjs");
+const superEditor_converter = require("./SuperConverter-DrhNM5Cd.cjs");
 const vue = require("./vue-De9wkgLl.cjs");
 require("./jszip.min-BPh2MMAa.cjs");
 const eventemitter3 = require("./eventemitter3-BQuRcMPI.cjs");
@@ -9387,6 +9387,158 @@ class Schema {
     return Object.fromEntries(markEntries);
   }
 }
+const positionTrackerKey = new superEditor_converter.PluginKey("positionTracker");
+function createPositionTrackerPlugin() {
+  return new superEditor_converter.Plugin({
+    key: positionTrackerKey,
+    state: {
+      init() {
+        return {
+          decorations: DecorationSet.empty,
+          generation: 0
+        };
+      },
+      apply(tr, state) {
+        let { decorations, generation } = state;
+        const meta = tr.getMeta(positionTrackerKey);
+        if (meta?.action === "add") {
+          decorations = decorations.add(tr.doc, meta.decorations);
+        } else if (meta?.action === "remove") {
+          const toRemove = decorations.find().filter((decoration) => meta.ids.includes(decoration.spec.id));
+          decorations = decorations.remove(toRemove);
+        } else if (meta?.action === "removeByType") {
+          const toRemove = decorations.find().filter((decoration) => decoration.spec.type === meta.type);
+          decorations = decorations.remove(toRemove);
+        }
+        if (tr.docChanged) {
+          decorations = decorations.map(tr.mapping, tr.doc);
+          generation += 1;
+        }
+        return { decorations, generation };
+      }
+    },
+    props: {
+      decorations() {
+        return DecorationSet.empty;
+      }
+    }
+  });
+}
+class PositionTracker {
+  #editor;
+  constructor(editor) {
+    this.#editor = editor;
+  }
+  #getState() {
+    if (!this.#editor?.state) return null;
+    return positionTrackerKey.getState(this.#editor.state) ?? null;
+  }
+  track(from3, to, spec) {
+    const id = uuid.v4();
+    if (!this.#editor?.state) return id;
+    const fullSpec = { kind: "range", ...spec, id };
+    const deco = Decoration.inline(from3, to, {}, fullSpec);
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "add",
+      decorations: [deco]
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+    return id;
+  }
+  trackMany(ranges) {
+    if (!this.#editor?.state) {
+      return ranges.map(() => uuid.v4());
+    }
+    const ids = [];
+    const decorations = [];
+    for (const { from: from3, to, spec } of ranges) {
+      const id = uuid.v4();
+      ids.push(id);
+      const fullSpec = { kind: "range", ...spec, id };
+      decorations.push(Decoration.inline(from3, to, {}, fullSpec));
+    }
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "add",
+      decorations
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+    return ids;
+  }
+  untrack(id) {
+    if (!this.#editor?.state) return;
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "remove",
+      ids: [id]
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+  }
+  untrackMany(ids) {
+    if (!this.#editor?.state || ids.length === 0) return;
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "remove",
+      ids
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+  }
+  untrackByType(type) {
+    if (!this.#editor?.state) return;
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "removeByType",
+      type
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+  }
+  resolve(id) {
+    const state = this.#getState();
+    if (!state) return null;
+    const found = state.decorations.find().find((decoration) => decoration.spec.id === id);
+    if (!found) return null;
+    const spec = found.spec;
+    return {
+      id: spec.id,
+      from: found.from,
+      to: found.to,
+      spec
+    };
+  }
+  resolveMany(ids) {
+    const result = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      result.set(id, null);
+    }
+    const state = this.#getState();
+    if (!state || ids.length === 0) return result;
+    const idSet = new Set(ids);
+    for (const decoration of state.decorations.find()) {
+      const spec = decoration.spec;
+      if (idSet.has(spec.id)) {
+        result.set(spec.id, {
+          id: spec.id,
+          from: decoration.from,
+          to: decoration.to,
+          spec
+        });
+      }
+    }
+    return result;
+  }
+  findByType(type) {
+    const state = this.#getState();
+    if (!state) return [];
+    return state.decorations.find().filter((decoration) => decoration.spec.type === type).map((decoration) => {
+      const spec = decoration.spec;
+      return {
+        id: spec.id,
+        from: decoration.from,
+        to: decoration.to,
+        spec
+      };
+    });
+  }
+  get generation() {
+    return this.#getState()?.generation ?? 0;
+  }
+}
 class OxmlNode extends Node$1 {
   constructor(config) {
     super(config);
@@ -11747,6 +11899,34 @@ const EditorFocus = Extension.create({
     return [editorFocusPlugin];
   }
 });
+const PositionTrackerExtension = Extension.create({
+  name: "positionTracker",
+  addStorage() {
+    return {
+      tracker: null
+    };
+  },
+  addPmPlugins() {
+    return [createPositionTrackerPlugin()];
+  },
+  onCreate() {
+    const existing = this.editor?.positionTracker ?? this.storage.tracker;
+    if (existing) {
+      this.storage.tracker = existing;
+      this.editor.positionTracker = existing;
+      return;
+    }
+    const tracker = new PositionTracker(this.editor);
+    this.storage.tracker = tracker;
+    this.editor.positionTracker = tracker;
+  },
+  onDestroy() {
+    if (this.editor?.positionTracker === this.storage.tracker) {
+      this.editor.positionTracker = null;
+    }
+    this.storage.tracker = null;
+  }
+});
 class EventEmitter {
   #events = /* @__PURE__ */ new Map();
   /**
@@ -15524,7 +15704,7 @@ const canUseDOM = () => {
     return false;
   }
 };
-const summaryVersion = "1.5.0";
+const summaryVersion = "1.6.0-next.2";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -17017,7 +17197,7 @@ class Editor extends EventEmitter {
    */
   #createExtensionService() {
     const allowedExtensions = ["extension", "node", "mark"];
-    const coreExtensions = [Editable, Commands, EditorFocus, Keymap];
+    const coreExtensions = [Editable, Commands, EditorFocus, Keymap, PositionTrackerExtension];
     const externalExtensions = this.options.externalExtensions || [];
     const allExtensions = [...coreExtensions, ...this.options.extensions].filter((extension) => {
       const extensionType = typeof extension?.type === "string" ? extension.type : void 0;
@@ -17781,6 +17961,10 @@ class Editor extends EventEmitter {
       const hasCustomSettings = !!this.converter.convertedXml["word/settings.xml"]?.elements?.length;
       const customSettings = hasCustomSettings ? this.converter.schemaToXml(this.converter.convertedXml["word/settings.xml"]?.elements?.[0]) : null;
       const rels = this.converter.schemaToXml(this.converter.convertedXml["word/_rels/document.xml.rels"].elements[0]);
+      const footnotesData = this.converter.convertedXml["word/footnotes.xml"];
+      const footnotesXml = footnotesData?.elements?.[0] ? this.converter.schemaToXml(footnotesData.elements[0]) : null;
+      const footnotesRelsData = this.converter.convertedXml["word/_rels/footnotes.xml.rels"];
+      const footnotesRelsXml = footnotesRelsData?.elements?.[0] ? this.converter.schemaToXml(footnotesRelsData.elements[0]) : null;
       const media = this.converter.addedMedia;
       const updatedHeadersFooters = {};
       Object.entries(this.converter.convertedXml).forEach(([name, json2]) => {
@@ -17805,6 +17989,12 @@ class Editor extends EventEmitter {
       if (hasCustomSettings) {
         updatedDocs["word/settings.xml"] = String(customSettings);
       }
+      if (footnotesXml) {
+        updatedDocs["word/footnotes.xml"] = String(footnotesXml);
+      }
+      if (footnotesRelsXml) {
+        updatedDocs["word/_rels/footnotes.xml.rels"] = String(footnotesRelsXml);
+      }
       if (comments.length) {
         const commentsXml = this.converter.schemaToXml(this.converter.convertedXml["word/comments.xml"].elements[0]);
         const commentsExtendedXml = this.converter.schemaToXml(
@@ -18181,7 +18371,7 @@ class Editor extends EventEmitter {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.5.0");
+    console.debug("[checkVersionMigrations] Current editor version", "1.6.0-next.2");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -34062,7 +34252,7 @@ function getParagraphSpacingBefore(block) {
   const value = spacing?.before ?? spacing?.lineSpaceBefore;
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
-function getParagraphSpacingAfter(block) {
+function getParagraphSpacingAfter$1(block) {
   const spacing = block.attrs?.spacing;
   const value = spacing?.after ?? spacing?.lineSpaceAfter;
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
@@ -34089,7 +34279,7 @@ function getMeasureHeight(block, measure) {
 }
 const DEFAULT_PAGE_SIZE$2 = { w: 612, h: 792 };
 const DEFAULT_MARGINS$2 = { top: 72, right: 72, bottom: 72, left: 72 };
-const COLUMN_EPSILON = 1e-4;
+const COLUMN_EPSILON$1 = 1e-4;
 const layoutDebugEnabled$1 = typeof vue.process$1 !== "undefined" && typeof vue.process$1.env !== "undefined" && Boolean(vue.process$1.env.SD_DEBUG_LAYOUT);
 const layoutLog = (...args) => {
   if (!layoutDebugEnabled$1) return;
@@ -34400,7 +34590,13 @@ function layoutDocument(blocks, measures, options = {}) {
   const paginator = createPaginator({
     margins: paginatorMargins,
     getActiveTopMargin: () => activeTopMargin,
-    getActiveBottomMargin: () => activeBottomMargin,
+    getActiveBottomMargin: () => {
+      const reserves = options.footnoteReservedByPageIndex;
+      const pageIndex = Math.max(0, pageCount - 1);
+      const reserve = Array.isArray(reserves) ? reserves[pageIndex] : 0;
+      const reservePx = typeof reserve === "number" && Number.isFinite(reserve) && reserve > 0 ? reserve : 0;
+      return activeBottomMargin + reservePx;
+    },
     getActiveHeaderDistance: () => activeHeaderDistance,
     getActiveFooterDistance: () => activeFooterDistance,
     getActivePageSize: () => activePageSize,
@@ -34884,7 +35080,7 @@ function layoutDocument(blocks, measures, options = {}) {
           if (!shouldSkipAnchoredTable) {
             let state = paginator.ensurePage();
             const availableHeight = state.contentBottom - state.cursorY;
-            const spacingAfter = getParagraphSpacingAfter(paraBlock);
+            const spacingAfter = getParagraphSpacingAfter$1(paraBlock);
             const currentHeight = getMeasureHeight(paraBlock, measure);
             const nextHeight = getMeasureHeight(nextBlock, nextMeasure);
             const nextIsParagraph = nextBlock.kind === "paragraph" && nextMeasure.kind === "paragraph";
@@ -35197,7 +35393,7 @@ function normalizeColumns(input, contentWidth) {
   const gap = Math.max(0, input?.gap ?? 0);
   const totalGap = gap * (count - 1);
   const width = (contentWidth - totalGap) / count;
-  if (width <= COLUMN_EPSILON) {
+  if (width <= COLUMN_EPSILON$1) {
     return {
       count: 1,
       gap: 0,
@@ -36960,6 +37156,417 @@ const perfLog = (...args) => {
   if (!layoutDebugEnabled) return;
   console.log(...args);
 };
+const isFootnotesLayoutInput = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (!Array.isArray(v.refs)) return false;
+  if (!(v.blocksById instanceof Map)) return false;
+  return true;
+};
+const findPageIndexForPos = (layout, pos) => {
+  if (!Number.isFinite(pos)) return null;
+  const fallbackRanges = [];
+  for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex++) {
+    const page = layout.pages[pageIndex];
+    let minStart = null;
+    let maxEnd = null;
+    for (const fragment of page.fragments) {
+      const pmStart = fragment.pmStart;
+      const pmEnd = fragment.pmEnd;
+      if (pmStart == null || pmEnd == null) continue;
+      if (minStart == null || pmStart < minStart) minStart = pmStart;
+      if (maxEnd == null || pmEnd > maxEnd) maxEnd = pmEnd;
+      if (pos >= pmStart && pos <= pmEnd) {
+        return pageIndex;
+      }
+    }
+    fallbackRanges[pageIndex] = minStart != null && maxEnd != null ? { pageIndex, minStart, maxEnd } : null;
+  }
+  let best = null;
+  for (const entry of fallbackRanges) {
+    if (!entry) continue;
+    const distance = pos < entry.minStart ? entry.minStart - pos : pos > entry.maxEnd ? pos - entry.maxEnd : 0;
+    if (!best || distance < best.distance) {
+      best = { pageIndex: entry.pageIndex, distance };
+    }
+  }
+  if (best) return best.pageIndex;
+  if (layout.pages.length > 0) return layout.pages.length - 1;
+  return null;
+};
+const footnoteColumnKey = (pageIndex, columnIndex) => `${pageIndex}:${columnIndex}`;
+const COLUMN_EPSILON = 0.01;
+const normalizeColumnsForFootnotes = (input, contentWidth) => {
+  const rawCount = Number.isFinite(input?.count) ? Math.floor(input.count) : 1;
+  const count = Math.max(1, rawCount || 1);
+  const gap = Math.max(0, input?.gap ?? 0);
+  const totalGap = gap * (count - 1);
+  const width = (contentWidth - totalGap) / count;
+  if (!Number.isFinite(width) || width <= COLUMN_EPSILON) {
+    return {
+      count: 1,
+      gap: 0,
+      width: Math.max(0, contentWidth)
+    };
+  }
+  return { count, gap, width };
+};
+const resolveSectionColumnsByIndex = (options, blocks) => {
+  const result = /* @__PURE__ */ new Map();
+  let activeColumns = options.columns ?? { count: 1, gap: 0 };
+  if (blocks && blocks.length > 0) {
+    for (const block of blocks) {
+      if (block.kind !== "sectionBreak") continue;
+      const sectionIndexRaw = block.attrs?.sectionIndex;
+      const sectionIndex = typeof sectionIndexRaw === "number" && Number.isFinite(sectionIndexRaw) ? sectionIndexRaw : result.size;
+      if (block.columns) {
+        activeColumns = { count: block.columns.count, gap: block.columns.gap };
+      }
+      result.set(sectionIndex, { ...activeColumns });
+    }
+  }
+  if (result.size === 0) {
+    result.set(0, { ...activeColumns });
+  }
+  return result;
+};
+const resolvePageColumns = (layout, options, blocks) => {
+  const sectionColumns = resolveSectionColumnsByIndex(options, blocks);
+  const result = /* @__PURE__ */ new Map();
+  for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex += 1) {
+    const page = layout.pages[pageIndex];
+    const pageSize = page.size ?? layout.pageSize ?? DEFAULT_PAGE_SIZE$1;
+    const marginLeft = normalizeMargin(
+      page.margins?.left,
+      normalizeMargin(options.margins?.left, DEFAULT_MARGINS$1.left)
+    );
+    const marginRight = normalizeMargin(
+      page.margins?.right,
+      normalizeMargin(options.margins?.right, DEFAULT_MARGINS$1.right)
+    );
+    const contentWidth = pageSize.w - (marginLeft + marginRight);
+    const sectionIndex = page.sectionIndex ?? 0;
+    const columnsConfig = sectionColumns.get(sectionIndex) ?? options.columns ?? { count: 1, gap: 0 };
+    const normalized = normalizeColumnsForFootnotes(columnsConfig, contentWidth);
+    result.set(pageIndex, { ...normalized, left: marginLeft, contentWidth });
+  }
+  return result;
+};
+const findFragmentForPos = (page, pos) => {
+  for (const fragment of page.fragments) {
+    const pmStart = fragment.pmStart;
+    const pmEnd = fragment.pmEnd;
+    if (pmStart == null || pmEnd == null) continue;
+    if (pos >= pmStart && pos <= pmEnd) {
+      return fragment;
+    }
+  }
+  return null;
+};
+const assignFootnotesToColumns = (layout, refs, pageColumns) => {
+  const result = /* @__PURE__ */ new Map();
+  const seenByColumn = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const pageIndex = findPageIndexForPos(layout, ref.pos);
+    if (pageIndex == null) continue;
+    const columns = pageColumns.get(pageIndex);
+    const page = layout.pages[pageIndex];
+    let columnIndex = 0;
+    if (columns && columns.count > 1 && page) {
+      const fragment = findFragmentForPos(page, ref.pos);
+      if (fragment && typeof fragment.x === "number") {
+        const columnStride = columns.width + columns.gap;
+        const rawIndex = columnStride > 0 ? Math.floor((fragment.x - columns.left) / columnStride) : 0;
+        columnIndex = Math.max(0, Math.min(columns.count - 1, rawIndex));
+      }
+    }
+    const key2 = footnoteColumnKey(pageIndex, columnIndex);
+    let seen = seenByColumn.get(key2);
+    if (!seen) {
+      seen = /* @__PURE__ */ new Set();
+      seenByColumn.set(key2, seen);
+    }
+    if (seen.has(ref.id)) continue;
+    seen.add(ref.id);
+    const pageMap = result.get(pageIndex) ?? /* @__PURE__ */ new Map();
+    const list = pageMap.get(columnIndex) ?? [];
+    list.push(ref.id);
+    pageMap.set(columnIndex, list);
+    result.set(pageIndex, pageMap);
+  }
+  return result;
+};
+const resolveFootnoteMeasurementWidth = (options, blocks) => {
+  const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE$1;
+  const margins = {
+    right: normalizeMargin(options.margins?.right, DEFAULT_MARGINS$1.right),
+    left: normalizeMargin(options.margins?.left, DEFAULT_MARGINS$1.left)
+  };
+  let width = pageSize.w - (margins.left + margins.right);
+  let activeColumns = options.columns ?? { count: 1, gap: 0 };
+  let activePageSize = pageSize;
+  let activeMargins = { ...margins };
+  const resolveColumnWidth = () => {
+    const contentWidth = activePageSize.w - (activeMargins.left + activeMargins.right);
+    const normalized = normalizeColumnsForFootnotes(activeColumns, contentWidth);
+    return normalized.width;
+  };
+  width = resolveColumnWidth();
+  if (blocks && blocks.length > 0) {
+    for (const block of blocks) {
+      if (block.kind !== "sectionBreak") continue;
+      activePageSize = block.pageSize ?? activePageSize;
+      activeMargins = {
+        right: normalizeMargin(block.margins?.right, activeMargins.right),
+        left: normalizeMargin(block.margins?.left, activeMargins.left)
+      };
+      if (block.columns) {
+        activeColumns = { count: block.columns.count, gap: block.columns.gap };
+      }
+      const w = resolveColumnWidth();
+      if (w > 0 && w < width) width = w;
+    }
+  }
+  if (!Number.isFinite(width) || width <= 0) return 0;
+  return width;
+};
+const MIN_FOOTNOTE_BODY_HEIGHT = 1;
+const DEFAULT_FOOTNOTE_SEPARATOR_SPACING_BEFORE = 12;
+const computeMaxFootnoteReserve = (layoutForPages, pageIndex, baseReserve = 0) => {
+  const page = layoutForPages.pages?.[pageIndex];
+  if (!page) return 0;
+  const pageSize = page.size ?? layoutForPages.pageSize ?? DEFAULT_PAGE_SIZE$1;
+  const topMargin = normalizeMargin(page.margins?.top, DEFAULT_MARGINS$1.top);
+  const bottomWithReserve = normalizeMargin(page.margins?.bottom, DEFAULT_MARGINS$1.bottom);
+  const baseReserveSafe = Number.isFinite(baseReserve) ? Math.max(0, baseReserve) : 0;
+  const bottomMargin = Math.max(0, bottomWithReserve - baseReserveSafe);
+  const availableForBody = pageSize.h - topMargin - bottomMargin;
+  if (!Number.isFinite(availableForBody)) return 0;
+  return Math.max(0, availableForBody - MIN_FOOTNOTE_BODY_HEIGHT);
+};
+const sumLineHeights$1 = (lines, fromLine, toLine) => {
+  if (!lines || fromLine >= toLine) return 0;
+  let total = 0;
+  for (let i = fromLine; i < toLine; i += 1) {
+    total += lines[i]?.lineHeight ?? 0;
+  }
+  return total;
+};
+const getParagraphSpacingAfter = (block) => {
+  const spacing = block.attrs?.spacing;
+  const value = spacing?.after ?? spacing?.lineSpaceAfter;
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+};
+const resolveSeparatorSpacingBefore = (rangesByFootnoteId, measuresById, explicitValue, fallbackValue) => {
+  if (typeof explicitValue === "number" && Number.isFinite(explicitValue)) {
+    return Math.max(0, explicitValue);
+  }
+  for (const ranges of rangesByFootnoteId.values()) {
+    for (const range of ranges) {
+      if (range.kind === "paragraph") {
+        const measure = measuresById.get(range.blockId);
+        if (measure?.kind !== "paragraph") continue;
+        const lineHeight2 = measure.lines?.[range.fromLine]?.lineHeight ?? measure.lines?.[0]?.lineHeight;
+        if (typeof lineHeight2 === "number" && Number.isFinite(lineHeight2) && lineHeight2 > 0) {
+          return lineHeight2;
+        }
+      }
+      if (range.kind === "list-item") {
+        const measure = measuresById.get(range.blockId);
+        if (measure?.kind !== "list") continue;
+        const itemMeasure = measure.items.find((item) => item.itemId === range.itemId);
+        const lineHeight2 = itemMeasure?.paragraph?.lines?.[range.fromLine]?.lineHeight ?? itemMeasure?.paragraph?.lines?.[0]?.lineHeight;
+        if (typeof lineHeight2 === "number" && Number.isFinite(lineHeight2) && lineHeight2 > 0) {
+          return lineHeight2;
+        }
+      }
+    }
+  }
+  return Math.max(0, fallbackValue);
+};
+const getRangeRenderHeight = (range) => {
+  if (range.kind === "paragraph" || range.kind === "list-item") {
+    const spacing = range.toLine >= range.totalLines ? range.spacingAfter : 0;
+    return range.height + spacing;
+  }
+  return range.height;
+};
+const buildFootnoteRanges = (blocks, measuresById) => {
+  const ranges = [];
+  blocks.forEach((block) => {
+    const measure = measuresById.get(block.id);
+    if (!measure) return;
+    if (block.kind === "paragraph") {
+      if (measure.kind !== "paragraph") return;
+      const lineCount = measure.lines?.length ?? 0;
+      if (lineCount === 0) return;
+      ranges.push({
+        kind: "paragraph",
+        blockId: block.id,
+        fromLine: 0,
+        toLine: lineCount,
+        totalLines: lineCount,
+        height: sumLineHeights$1(measure.lines, 0, lineCount),
+        spacingAfter: getParagraphSpacingAfter(block)
+      });
+      return;
+    }
+    if (block.kind === "list") {
+      if (measure.kind !== "list") return;
+      block.items.forEach((item) => {
+        const itemMeasure = measure.items.find((entry) => entry.itemId === item.id);
+        if (!itemMeasure) return;
+        const lineCount = itemMeasure.paragraph.lines?.length ?? 0;
+        if (lineCount === 0) return;
+        ranges.push({
+          kind: "list-item",
+          blockId: block.id,
+          itemId: item.id,
+          fromLine: 0,
+          toLine: lineCount,
+          totalLines: lineCount,
+          height: sumLineHeights$1(itemMeasure.paragraph.lines, 0, lineCount),
+          spacingAfter: getParagraphSpacingAfter(item.paragraph)
+        });
+      });
+      return;
+    }
+    if (block.kind === "table" && measure.kind === "table") {
+      const height = Math.max(0, measure.totalHeight ?? 0);
+      if (height > 0) {
+        ranges.push({ kind: "table", blockId: block.id, height });
+      }
+      return;
+    }
+    if (block.kind === "image" && measure.kind === "image") {
+      const height = Math.max(0, measure.height ?? 0);
+      if (height > 0) {
+        ranges.push({ kind: "image", blockId: block.id, height });
+      }
+      return;
+    }
+    if (block.kind === "drawing" && measure.kind === "drawing") {
+      const height = Math.max(0, measure.height ?? 0);
+      if (height > 0) {
+        ranges.push({ kind: "drawing", blockId: block.id, height });
+      }
+    }
+  });
+  return ranges;
+};
+const splitRangeAtHeight = (range, availableHeight, measuresById) => {
+  if (availableHeight <= 0) return { fitted: null, remaining: range };
+  if (range.kind !== "paragraph") {
+    return getRangeRenderHeight(range) <= availableHeight ? { fitted: range, remaining: null } : { fitted: null, remaining: range };
+  }
+  const measure = measuresById.get(range.blockId);
+  if (!measure || measure.kind !== "paragraph" || !measure.lines) {
+    return getRangeRenderHeight(range) <= availableHeight ? { fitted: range, remaining: null } : { fitted: null, remaining: range };
+  }
+  let accumulatedHeight = 0;
+  let splitLine = range.fromLine;
+  for (let i = range.fromLine; i < range.toLine; i += 1) {
+    const lineHeight2 = measure.lines[i]?.lineHeight ?? 0;
+    if (accumulatedHeight + lineHeight2 > availableHeight) break;
+    accumulatedHeight += lineHeight2;
+    splitLine = i + 1;
+  }
+  if (splitLine === range.fromLine) {
+    return { fitted: null, remaining: range };
+  }
+  const fitted = {
+    ...range,
+    toLine: splitLine,
+    height: sumLineHeights$1(measure.lines, range.fromLine, splitLine)
+  };
+  if (splitLine >= range.toLine) {
+    return getRangeRenderHeight(fitted) <= availableHeight ? { fitted, remaining: null } : { fitted: null, remaining: range };
+  }
+  const remaining = {
+    ...range,
+    fromLine: splitLine,
+    height: sumLineHeights$1(measure.lines, splitLine, range.toLine)
+  };
+  return { fitted, remaining };
+};
+const forceFitFirstRange = (range, measuresById) => {
+  if (range.kind !== "paragraph") {
+    return { fitted: range, remaining: null };
+  }
+  const measure = measuresById.get(range.blockId);
+  if (!measure || measure.kind !== "paragraph" || !measure.lines?.length) {
+    return { fitted: range, remaining: null };
+  }
+  const nextLine = Math.min(range.fromLine + 1, range.toLine);
+  const fitted = {
+    ...range,
+    toLine: nextLine,
+    height: sumLineHeights$1(measure.lines, range.fromLine, nextLine)
+  };
+  if (nextLine >= range.toLine) {
+    return { fitted, remaining: null };
+  }
+  const remaining = {
+    ...range,
+    fromLine: nextLine,
+    height: sumLineHeights$1(measure.lines, nextLine, range.toLine)
+  };
+  return { fitted, remaining };
+};
+const fitFootnoteContent = (id, inputRanges, availableHeight, pageIndex, columnIndex, isContinuation, measuresById, forceFirstRange) => {
+  const fittedRanges = [];
+  let remainingRanges = [];
+  let usedHeight = 0;
+  const maxHeight = Math.max(0, availableHeight);
+  for (let index2 = 0; index2 < inputRanges.length; index2 += 1) {
+    const range = inputRanges[index2];
+    const remainingSpace = maxHeight - usedHeight;
+    const rangeHeight = getRangeRenderHeight(range);
+    if (rangeHeight <= remainingSpace) {
+      fittedRanges.push(range);
+      usedHeight += rangeHeight;
+      continue;
+    }
+    if (range.kind === "paragraph") {
+      const split = splitRangeAtHeight(range, remainingSpace, measuresById);
+      if (split.fitted && getRangeRenderHeight(split.fitted) <= remainingSpace) {
+        fittedRanges.push(split.fitted);
+        usedHeight += getRangeRenderHeight(split.fitted);
+      }
+      if (split.remaining) {
+        remainingRanges = [split.remaining, ...inputRanges.slice(index2 + 1)];
+      } else {
+        remainingRanges = inputRanges.slice(index2 + 1);
+      }
+      break;
+    }
+    remainingRanges = [range, ...inputRanges.slice(index2 + 1)];
+    break;
+  }
+  if (fittedRanges.length === 0 && forceFirstRange && inputRanges.length > 0) {
+    const forced = forceFitFirstRange(inputRanges[0], measuresById);
+    if (forced.fitted) {
+      fittedRanges.push(forced.fitted);
+      usedHeight = getRangeRenderHeight(forced.fitted);
+      remainingRanges = [];
+      if (forced.remaining) {
+        remainingRanges.push(forced.remaining);
+      }
+      remainingRanges.push(...inputRanges.slice(1));
+    }
+  }
+  return {
+    slice: {
+      id,
+      pageIndex,
+      columnIndex,
+      isContinuation,
+      ranges: fittedRanges,
+      totalHeight: usedHeight
+    },
+    remainingRanges
+  };
+};
 async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, options, measureBlock2, headerFooter) {
   performance.now();
   const dirty = computeDirtyRegions(previousBlocks, nextBlocks);
@@ -37223,6 +37830,497 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
       converged
     });
   }
+  let extraBlocks;
+  let extraMeasures;
+  const footnotesInput = isFootnotesLayoutInput(options.footnotes) ? options.footnotes : null;
+  if (footnotesInput && footnotesInput.refs.length > 0 && footnotesInput.blocksById.size > 0) {
+    const gap = typeof footnotesInput.gap === "number" && Number.isFinite(footnotesInput.gap) ? footnotesInput.gap : 2;
+    const topPadding = typeof footnotesInput.topPadding === "number" && Number.isFinite(footnotesInput.topPadding) ? footnotesInput.topPadding : 6;
+    const dividerHeight = typeof footnotesInput.dividerHeight === "number" && Number.isFinite(footnotesInput.dividerHeight) ? footnotesInput.dividerHeight : 6;
+    const safeGap = Math.max(0, gap);
+    const safeTopPadding = Math.max(0, topPadding);
+    const safeDividerHeight = Math.max(0, dividerHeight);
+    const continuationDividerHeight = safeDividerHeight;
+    const continuationDividerWidthFactor = 0.3;
+    const footnoteWidth = resolveFootnoteMeasurementWidth(options, currentBlocks);
+    if (footnoteWidth > 0) {
+      const footnoteConstraints = { maxWidth: footnoteWidth, maxHeight: measurementHeight };
+      const collectFootnoteIdsByColumn = (idsByColumn2) => {
+        const ids = /* @__PURE__ */ new Set();
+        idsByColumn2.forEach((columns) => {
+          columns.forEach((list) => {
+            list.forEach((id) => ids.add(id));
+          });
+        });
+        return ids;
+      };
+      const measureFootnoteBlocks = async (ids) => {
+        const needed = /* @__PURE__ */ new Map();
+        ids.forEach((id) => {
+          const blocks2 = footnotesInput.blocksById.get(id) ?? [];
+          blocks2.forEach((block) => {
+            if (block?.id && !needed.has(block.id)) {
+              needed.set(block.id, block);
+            }
+          });
+        });
+        const blocks = Array.from(needed.values());
+        const measuresById2 = /* @__PURE__ */ new Map();
+        await Promise.all(
+          blocks.map(async (block) => {
+            const cached = measureCache.get(block, footnoteConstraints.maxWidth, footnoteConstraints.maxHeight);
+            if (cached) {
+              measuresById2.set(block.id, cached);
+              return;
+            }
+            const measurement = await measureBlock2(block, footnoteConstraints);
+            measureCache.set(block, footnoteConstraints.maxWidth, footnoteConstraints.maxHeight, measurement);
+            measuresById2.set(block.id, measurement);
+          })
+        );
+        return { blocks, measuresById: measuresById2 };
+      };
+      const computeFootnoteLayoutPlan = (layoutForPages, idsByColumn2, measuresById2, baseReserves = [], pageColumns2) => {
+        const pageCount = layoutForPages.pages.length;
+        const slicesByPage = /* @__PURE__ */ new Map();
+        const reserves2 = new Array(pageCount).fill(0);
+        const hasContinuationByColumn = /* @__PURE__ */ new Map();
+        const rangesByFootnoteId = /* @__PURE__ */ new Map();
+        const cappedPages = /* @__PURE__ */ new Set();
+        const allIds = collectFootnoteIdsByColumn(idsByColumn2);
+        allIds.forEach((id) => {
+          const blocks = footnotesInput.blocksById.get(id) ?? [];
+          rangesByFootnoteId.set(id, buildFootnoteRanges(blocks, measuresById2));
+        });
+        const separatorSpacingBefore = resolveSeparatorSpacingBefore(
+          rangesByFootnoteId,
+          measuresById2,
+          footnotesInput.separatorSpacingBefore,
+          DEFAULT_FOOTNOTE_SEPARATOR_SPACING_BEFORE
+        );
+        const safeSeparatorSpacingBefore = Math.max(0, separatorSpacingBefore);
+        let pendingByColumn = /* @__PURE__ */ new Map();
+        for (let pageIndex = 0; pageIndex < pageCount; pageIndex += 1) {
+          const baseReserve = Number.isFinite(baseReserves?.[pageIndex]) ? Math.max(0, baseReserves[pageIndex]) : 0;
+          const maxReserve = computeMaxFootnoteReserve(layoutForPages, pageIndex, baseReserve);
+          const columns = pageColumns2.get(pageIndex);
+          const columnCount = Math.max(1, Math.floor(columns?.count ?? 1));
+          const pendingForPage = /* @__PURE__ */ new Map();
+          pendingByColumn.forEach((entries, columnIndex) => {
+            const targetIndex = columnIndex < columnCount ? columnIndex : Math.max(0, columnCount - 1);
+            const list = pendingForPage.get(targetIndex) ?? [];
+            list.push(...entries);
+            pendingForPage.set(targetIndex, list);
+          });
+          pendingByColumn = /* @__PURE__ */ new Map();
+          const pageSlices = [];
+          let pageReserve = 0;
+          for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
+            let usedHeight = 0;
+            const columnSlices = [];
+            const nextPending = [];
+            let stopPlacement = false;
+            const columnKey = footnoteColumnKey(pageIndex, columnIndex);
+            const placeFootnote = (id, ranges, isContinuation) => {
+              if (!ranges || ranges.length === 0) {
+                return { placed: false, remaining: [] };
+              }
+              const isFirstSlice = columnSlices.length === 0;
+              const separatorBefore = isFirstSlice ? safeSeparatorSpacingBefore : 0;
+              const separatorHeight = isFirstSlice ? isContinuation ? continuationDividerHeight : safeDividerHeight : 0;
+              const overhead = isFirstSlice ? separatorBefore + separatorHeight + safeTopPadding : 0;
+              const gapBefore = !isFirstSlice ? safeGap : 0;
+              const availableHeight = Math.max(0, maxReserve - usedHeight - overhead - gapBefore);
+              const { slice: slice2, remainingRanges } = fitFootnoteContent(
+                id,
+                ranges,
+                availableHeight,
+                pageIndex,
+                columnIndex,
+                isContinuation,
+                measuresById2,
+                isFirstSlice && maxReserve > 0
+              );
+              if (slice2.ranges.length === 0) {
+                return { placed: false, remaining: ranges };
+              }
+              if (isFirstSlice) {
+                usedHeight += overhead;
+                if (isContinuation) {
+                  hasContinuationByColumn.set(columnKey, true);
+                }
+              }
+              if (gapBefore > 0) {
+                usedHeight += gapBefore;
+              }
+              usedHeight += slice2.totalHeight;
+              columnSlices.push(slice2);
+              return { placed: true, remaining: remainingRanges };
+            };
+            const pending = pendingForPage.get(columnIndex) ?? [];
+            for (const entry of pending) {
+              if (stopPlacement) {
+                nextPending.push(entry);
+                continue;
+              }
+              if (!entry.ranges || entry.ranges.length === 0) continue;
+              const result = placeFootnote(entry.id, entry.ranges, true);
+              if (!result.placed) {
+                nextPending.push(entry);
+                stopPlacement = true;
+                continue;
+              }
+              if (result.remaining.length > 0) {
+                nextPending.push({ id: entry.id, ranges: result.remaining });
+              }
+            }
+            if (!stopPlacement) {
+              const ids = idsByColumn2.get(pageIndex)?.get(columnIndex) ?? [];
+              for (let idIndex = 0; idIndex < ids.length; idIndex += 1) {
+                const id = ids[idIndex];
+                const ranges = rangesByFootnoteId.get(id) ?? [];
+                if (ranges.length === 0) continue;
+                const result = placeFootnote(id, ranges, false);
+                if (!result.placed) {
+                  nextPending.push({ id, ranges });
+                  for (let remainingIndex = idIndex + 1; remainingIndex < ids.length; remainingIndex += 1) {
+                    const remainingId = ids[remainingIndex];
+                    const remainingRanges = rangesByFootnoteId.get(remainingId) ?? [];
+                    nextPending.push({ id: remainingId, ranges: remainingRanges });
+                  }
+                  stopPlacement = true;
+                  break;
+                }
+                if (result.remaining.length > 0) {
+                  nextPending.push({ id, ranges: result.remaining });
+                }
+              }
+            }
+            if (columnSlices.length > 0) {
+              const rawReserve = Math.max(0, Math.ceil(usedHeight));
+              const cappedReserve = Math.min(rawReserve, maxReserve);
+              if (cappedReserve < rawReserve) {
+                cappedPages.add(pageIndex);
+              }
+              pageReserve = Math.max(pageReserve, cappedReserve);
+              pageSlices.push(...columnSlices);
+            }
+            if (nextPending.length > 0) {
+              pendingByColumn.set(columnIndex, nextPending);
+            }
+          }
+          if (pageSlices.length > 0) {
+            slicesByPage.set(pageIndex, pageSlices);
+          }
+          reserves2[pageIndex] = pageReserve;
+        }
+        if (cappedPages.size > 0) {
+          console.warn("[layout] Footnote reserve capped to preserve body area", {
+            pages: Array.from(cappedPages)
+          });
+        }
+        if (pendingByColumn.size > 0) {
+          const pendingIds = /* @__PURE__ */ new Set();
+          pendingByColumn.forEach((entries) => entries.forEach((entry) => pendingIds.add(entry.id)));
+          console.warn("[layout] Footnote content truncated: extends beyond document pages", {
+            ids: Array.from(pendingIds)
+          });
+        }
+        return { slicesByPage, reserves: reserves2, hasContinuationByColumn, separatorSpacingBefore: safeSeparatorSpacingBefore };
+      };
+      const injectFragments = (layoutForPages, plan2, measuresById2, reservesByPageIndex, blockById, pageColumns2) => {
+        const decorativeBlocks = [];
+        const decorativeMeasures = [];
+        for (let pageIndex = 0; pageIndex < layoutForPages.pages.length; pageIndex++) {
+          const page = layoutForPages.pages[pageIndex];
+          page.footnoteReserved = Math.max(0, reservesByPageIndex[pageIndex] ?? plan2.reserves[pageIndex] ?? 0);
+          const slices = plan2.slicesByPage.get(pageIndex) ?? [];
+          if (slices.length === 0) continue;
+          if (!page.margins) continue;
+          const pageSize = page.size ?? layoutForPages.pageSize;
+          const marginLeft = normalizeMargin(
+            page.margins.left,
+            normalizeMargin(options.margins?.left, DEFAULT_MARGINS$1.left)
+          );
+          const marginRight = normalizeMargin(
+            page.margins.right,
+            normalizeMargin(options.margins?.right, DEFAULT_MARGINS$1.right)
+          );
+          const pageContentWidth = pageSize.w - (marginLeft + marginRight);
+          const fallbackColumns = normalizeColumnsForFootnotes(
+            options.columns ?? { count: 1, gap: 0 },
+            pageContentWidth
+          );
+          const columns = pageColumns2.get(pageIndex) ?? {
+            ...fallbackColumns,
+            left: marginLeft
+          };
+          const bandTopY = pageSize.h - (page.margins.bottom ?? 0);
+          const slicesByColumn = /* @__PURE__ */ new Map();
+          slices.forEach((slice2) => {
+            const columnIndex = Number.isFinite(slice2.columnIndex) ? slice2.columnIndex : 0;
+            const list = slicesByColumn.get(columnIndex) ?? [];
+            list.push(slice2);
+            slicesByColumn.set(columnIndex, list);
+          });
+          slicesByColumn.forEach((columnSlices, rawColumnIndex) => {
+            if (columnSlices.length === 0) return;
+            const columnIndex = Math.max(0, Math.min(columns.count - 1, rawColumnIndex));
+            const columnStride = columns.width + columns.gap;
+            const columnX = columns.left + columnIndex * columnStride;
+            const contentWidth = Math.min(columns.width, footnoteWidth);
+            if (!Number.isFinite(contentWidth) || contentWidth <= 0) return;
+            const columnKey = footnoteColumnKey(pageIndex, columnIndex);
+            const isContinuation = plan2.hasContinuationByColumn.get(columnKey) ?? false;
+            let cursorY = bandTopY + Math.max(0, plan2.separatorSpacingBefore);
+            const separatorHeight = isContinuation ? continuationDividerHeight : safeDividerHeight;
+            const separatorWidth = isContinuation ? Math.max(0, contentWidth * continuationDividerWidthFactor) : contentWidth;
+            if (separatorHeight > 0 && separatorWidth > 0) {
+              const separatorId = isContinuation ? `footnote-continuation-separator-page-${page.number}-col-${columnIndex}` : `footnote-separator-page-${page.number}-col-${columnIndex}`;
+              decorativeBlocks.push({
+                kind: "drawing",
+                id: separatorId,
+                drawingKind: "vectorShape",
+                geometry: { width: separatorWidth, height: separatorHeight },
+                shapeKind: "rect",
+                fillColor: "#000000",
+                strokeColor: null,
+                strokeWidth: 0
+              });
+              decorativeMeasures.push({
+                kind: "drawing",
+                drawingKind: "vectorShape",
+                width: separatorWidth,
+                height: separatorHeight,
+                scale: 1,
+                naturalWidth: separatorWidth,
+                naturalHeight: separatorHeight,
+                geometry: { width: separatorWidth, height: separatorHeight }
+              });
+              page.fragments.push({
+                kind: "drawing",
+                blockId: separatorId,
+                drawingKind: "vectorShape",
+                x: columnX,
+                y: cursorY,
+                width: separatorWidth,
+                height: separatorHeight,
+                geometry: { width: separatorWidth, height: separatorHeight },
+                scale: 1
+              });
+              cursorY += separatorHeight;
+            }
+            cursorY += safeTopPadding;
+            columnSlices.forEach((slice2, sliceIndex) => {
+              slice2.ranges.forEach((range) => {
+                if (range.kind === "paragraph") {
+                  const measure = measuresById2.get(range.blockId);
+                  if (!measure || measure.kind !== "paragraph") return;
+                  const marker = measure.marker;
+                  page.fragments.push({
+                    kind: "para",
+                    blockId: range.blockId,
+                    fromLine: range.fromLine,
+                    toLine: range.toLine,
+                    x: columnX,
+                    y: cursorY,
+                    width: contentWidth,
+                    continuesFromPrev: range.fromLine > 0,
+                    continuesOnNext: range.toLine < range.totalLines,
+                    ...marker?.markerWidth != null ? { markerWidth: marker.markerWidth } : {},
+                    ...marker?.markerTextWidth != null ? { markerTextWidth: marker.markerTextWidth } : {},
+                    ...marker?.gutterWidth != null ? { markerGutter: marker.gutterWidth } : {}
+                  });
+                  cursorY += getRangeRenderHeight(range);
+                  return;
+                }
+                if (range.kind === "list-item") {
+                  const measure = measuresById2.get(range.blockId);
+                  const block = blockById.get(range.blockId);
+                  if (!measure || measure.kind !== "list") return;
+                  if (!block || block.kind !== "list") return;
+                  const itemMeasure = measure.items.find((entry) => entry.itemId === range.itemId);
+                  if (!itemMeasure) return;
+                  const indentLeft = Number.isFinite(itemMeasure.indentLeft) ? itemMeasure.indentLeft : 0;
+                  const markerWidth = Number.isFinite(itemMeasure.markerWidth) ? itemMeasure.markerWidth : 0;
+                  const itemWidth = Math.max(0, contentWidth - indentLeft - markerWidth);
+                  page.fragments.push({
+                    kind: "list-item",
+                    blockId: range.blockId,
+                    itemId: range.itemId,
+                    fromLine: range.fromLine,
+                    toLine: range.toLine,
+                    x: columnX + indentLeft + markerWidth,
+                    y: cursorY,
+                    width: itemWidth,
+                    markerWidth,
+                    continuesFromPrev: range.fromLine > 0,
+                    continuesOnNext: range.toLine < range.totalLines
+                  });
+                  cursorY += getRangeRenderHeight(range);
+                  return;
+                }
+                if (range.kind === "table") {
+                  const measure = measuresById2.get(range.blockId);
+                  const block = blockById.get(range.blockId);
+                  if (!measure || measure.kind !== "table") return;
+                  if (!block || block.kind !== "table") return;
+                  const tableWidthRaw = Math.max(0, measure.totalWidth ?? 0);
+                  let tableWidth = Math.min(contentWidth, tableWidthRaw);
+                  let tableX = columnX;
+                  const justification = typeof block.attrs?.justification === "string" ? block.attrs.justification : void 0;
+                  if (justification === "center") {
+                    tableX = columnX + Math.max(0, (contentWidth - tableWidth) / 2);
+                  } else if (justification === "right" || justification === "end") {
+                    tableX = columnX + Math.max(0, contentWidth - tableWidth);
+                  } else {
+                    const indentValue = block.attrs?.tableIndent?.width;
+                    const indent = typeof indentValue === "number" && Number.isFinite(indentValue) ? indentValue : 0;
+                    tableX += indent;
+                    tableWidth = Math.max(0, tableWidth - indent);
+                  }
+                  page.fragments.push({
+                    kind: "table",
+                    blockId: range.blockId,
+                    fromRow: 0,
+                    toRow: block.rows.length,
+                    x: tableX,
+                    y: cursorY,
+                    width: tableWidth,
+                    height: Math.max(0, measure.totalHeight ?? 0)
+                  });
+                  cursorY += getRangeRenderHeight(range);
+                  return;
+                }
+                if (range.kind === "image") {
+                  const measure = measuresById2.get(range.blockId);
+                  if (!measure || measure.kind !== "image") return;
+                  page.fragments.push({
+                    kind: "image",
+                    blockId: range.blockId,
+                    x: columnX,
+                    y: cursorY,
+                    width: Math.min(contentWidth, Math.max(0, measure.width ?? 0)),
+                    height: Math.max(0, measure.height ?? 0)
+                  });
+                  cursorY += getRangeRenderHeight(range);
+                  return;
+                }
+                if (range.kind === "drawing") {
+                  const measure = measuresById2.get(range.blockId);
+                  const block = blockById.get(range.blockId);
+                  if (!measure || measure.kind !== "drawing") return;
+                  if (!block || block.kind !== "drawing") return;
+                  page.fragments.push({
+                    kind: "drawing",
+                    blockId: range.blockId,
+                    drawingKind: block.drawingKind,
+                    x: columnX,
+                    y: cursorY,
+                    width: Math.min(contentWidth, Math.max(0, measure.width ?? 0)),
+                    height: Math.max(0, measure.height ?? 0),
+                    geometry: measure.geometry,
+                    scale: measure.scale
+                  });
+                  cursorY += getRangeRenderHeight(range);
+                }
+              });
+              if (sliceIndex < columnSlices.length - 1) {
+                cursorY += safeGap;
+              }
+            });
+          });
+        }
+        return { decorativeBlocks, decorativeMeasures };
+      };
+      const resolveFootnoteAssignments = (layoutForPages) => {
+        const columns = resolvePageColumns(layoutForPages, options, currentBlocks);
+        const idsByColumn2 = assignFootnotesToColumns(layoutForPages, footnotesInput.refs, columns);
+        return { columns, idsByColumn: idsByColumn2 };
+      };
+      let { columns: pageColumns, idsByColumn } = resolveFootnoteAssignments(layout);
+      let { measuresById } = await measureFootnoteBlocks(collectFootnoteIdsByColumn(idsByColumn));
+      let plan = computeFootnoteLayoutPlan(layout, idsByColumn, measuresById, [], pageColumns);
+      let reserves = plan.reserves;
+      if (reserves.some((h2) => h2 > 0)) {
+        layout = layoutDocument(currentBlocks, currentMeasures, {
+          ...options,
+          footnoteReservedByPageIndex: reserves,
+          headerContentHeights,
+          footerContentHeights,
+          remeasureParagraph: (block, maxWidth, firstLineIndent) => remeasureParagraph(block, maxWidth, firstLineIndent)
+        });
+        ({ columns: pageColumns, idsByColumn } = resolveFootnoteAssignments(layout));
+        ({ measuresById } = await measureFootnoteBlocks(collectFootnoteIdsByColumn(idsByColumn)));
+        plan = computeFootnoteLayoutPlan(layout, idsByColumn, measuresById, reserves, pageColumns);
+        reserves = plan.reserves;
+        layout = layoutDocument(currentBlocks, currentMeasures, {
+          ...options,
+          footnoteReservedByPageIndex: reserves,
+          headerContentHeights,
+          footerContentHeights,
+          remeasureParagraph: (block, maxWidth, firstLineIndent) => remeasureParagraph(block, maxWidth, firstLineIndent)
+        });
+        let { columns: finalPageColumns, idsByColumn: finalIdsByColumn } = resolveFootnoteAssignments(layout);
+        let { blocks: finalBlocks, measuresById: finalMeasuresById } = await measureFootnoteBlocks(
+          collectFootnoteIdsByColumn(finalIdsByColumn)
+        );
+        let finalPlan = computeFootnoteLayoutPlan(
+          layout,
+          finalIdsByColumn,
+          finalMeasuresById,
+          reserves,
+          finalPageColumns
+        );
+        const finalReserves = finalPlan.reserves;
+        let reservesAppliedToLayout = reserves;
+        const reservesDiffer = finalReserves.length !== reserves.length || finalReserves.some((h2, i) => (reserves[i] ?? 0) !== h2) || reserves.some((h2, i) => (finalReserves[i] ?? 0) !== h2);
+        if (reservesDiffer) {
+          layout = layoutDocument(currentBlocks, currentMeasures, {
+            ...options,
+            footnoteReservedByPageIndex: finalReserves,
+            headerContentHeights,
+            footerContentHeights,
+            remeasureParagraph: (block, maxWidth, firstLineIndent) => remeasureParagraph(block, maxWidth, firstLineIndent)
+          });
+          reservesAppliedToLayout = finalReserves;
+          ({ columns: finalPageColumns, idsByColumn: finalIdsByColumn } = resolveFootnoteAssignments(layout));
+          ({ blocks: finalBlocks, measuresById: finalMeasuresById } = await measureFootnoteBlocks(
+            collectFootnoteIdsByColumn(finalIdsByColumn)
+          ));
+          finalPlan = computeFootnoteLayoutPlan(
+            layout,
+            finalIdsByColumn,
+            finalMeasuresById,
+            reservesAppliedToLayout,
+            finalPageColumns
+          );
+        }
+        const blockById = /* @__PURE__ */ new Map();
+        finalBlocks.forEach((block) => {
+          blockById.set(block.id, block);
+        });
+        const injected = injectFragments(
+          layout,
+          finalPlan,
+          finalMeasuresById,
+          reservesAppliedToLayout,
+          blockById,
+          finalPageColumns
+        );
+        const alignedBlocks = [];
+        const alignedMeasures = [];
+        finalBlocks.forEach((block) => {
+          const measure = finalMeasuresById.get(block.id);
+          if (!measure) return;
+          alignedBlocks.push(block);
+          alignedMeasures.push(measure);
+        });
+        extraBlocks = injected ? alignedBlocks.concat(injected.decorativeBlocks) : alignedBlocks;
+        extraMeasures = injected ? alignedMeasures.concat(injected.decorativeMeasures) : alignedMeasures;
+      }
+    }
+  }
   let headers;
   let footers;
   if (headerFooter?.constraints && (headerFooter.headerBlocks || headerFooter.footerBlocks)) {
@@ -37283,7 +38381,9 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
     measures: currentMeasures,
     dirty,
     headers,
-    footers
+    footers,
+    extraBlocks,
+    extraMeasures
   };
 }
 const DEFAULT_PAGE_SIZE$1 = { w: 612, h: 792 };
@@ -41322,6 +42422,7 @@ const ATOMIC_INLINE_TYPES = /* @__PURE__ */ new Set([
   "lineBreak",
   "page-number",
   "total-page-number",
+  "footnoteReference",
   "passthroughInline",
   "bookmarkEnd"
 ]);
@@ -46346,6 +47447,28 @@ function paragraphToFlowBlocks$1(para, nextBlockId, positions, defaultFont, defa
   let partIndex = 0;
   let tabOrdinal = 0;
   let suppressedByVanish = false;
+  const toSuperscriptDigits2 = (value) => {
+    const map3 = {
+      "0": "⁰",
+      "1": "¹",
+      "2": "²",
+      "3": "³",
+      "4": "⁴",
+      "5": "⁵",
+      "6": "⁶",
+      "7": "⁷",
+      "8": "⁸",
+      "9": "⁹"
+    };
+    return String(value ?? "").split("").map((ch) => map3[ch] ?? ch).join("");
+  };
+  const resolveFootnoteDisplayNumber2 = (id) => {
+    const key2 = id == null ? null : String(id);
+    if (!key2) return null;
+    const mapping = converterContext?.footnoteNumberById;
+    const mapped = mapping && typeof mapping === "object" ? mapping[key2] : void 0;
+    return typeof mapped === "number" && Number.isFinite(mapped) && mapped > 0 ? mapped : null;
+  };
   const nextId = () => partIndex === 0 ? baseBlockId : `${baseBlockId}-${partIndex}`;
   const attachAnchorParagraphId = (block, anchorParagraphId) => {
     const applicableKinds = /* @__PURE__ */ new Set(["drawing", "image", "table"]);
@@ -46391,6 +47514,34 @@ function paragraphToFlowBlocks$1(para, nextBlockId, positions, defaultFont, defa
     });
   };
   const visitNode = (node, inheritedMarks = [], activeSdt, activeRunStyleId = null, activeRunProperties, activeHidden = false) => {
+    if (node.type === "footnoteReference") {
+      const mergedMarks = [...node.marks ?? [], ...inheritedMarks ?? []];
+      const refPos = positions.get(node);
+      const id = node.attrs?.id;
+      const displayId = resolveFootnoteDisplayNumber2(id) ?? id ?? "*";
+      const displayText = toSuperscriptDigits2(displayId);
+      const run = textNodeToRun(
+        { type: "text", text: displayText },
+        positions,
+        defaultFont,
+        defaultSize,
+        [],
+        // marks applied after linked styles/base defaults
+        activeSdt,
+        hyperlinkConfig,
+        themeColors
+      );
+      const inlineStyleId = getInlineStyleId(mergedMarks);
+      applyRunStyles2(run, inlineStyleId, activeRunStyleId);
+      applyBaseRunDefaults(run, baseRunDefaults, defaultFont, defaultSize);
+      applyMarksToRun(run, mergedMarks, hyperlinkConfig, themeColors);
+      if (refPos) {
+        run.pmStart = refPos.start;
+        run.pmEnd = refPos.end;
+      }
+      currentRuns.push(run);
+      return;
+    }
     if (activeHidden && node.type !== "run") {
       suppressedByVanish = true;
       return;
@@ -54791,12 +55942,36 @@ class PresentationEditor extends EventEmitter {
       const sectionMetadata = [];
       let blocks;
       let bookmarks = /* @__PURE__ */ new Map();
+      let converterContext = void 0;
       try {
         const converter2 = this.#editor.converter;
-        const converterContext = converter2 ? {
+        const footnoteNumberById = {};
+        try {
+          const seen = /* @__PURE__ */ new Set();
+          let counter = 1;
+          this.#editor?.state?.doc?.descendants?.((node) => {
+            if (node?.type?.name !== "footnoteReference") return;
+            const rawId = node?.attrs?.id;
+            if (rawId == null) return;
+            const key2 = String(rawId);
+            if (!key2 || seen.has(key2)) return;
+            seen.add(key2);
+            footnoteNumberById[key2] = counter;
+            counter += 1;
+          });
+        } catch {
+        }
+        try {
+          if (converter2 && typeof converter2 === "object") {
+            converter2["footnoteNumberById"] = footnoteNumberById;
+          }
+        } catch {
+        }
+        converterContext = converter2 ? {
           docx: converter2.convertedXml,
           numbering: converter2.numbering,
-          linkedStyles: converter2.linkedStyles
+          linkedStyles: converter2.linkedStyles,
+          ...Object.keys(footnoteNumberById).length ? { footnoteNumberById } : {}
         } : void 0;
         const atomNodeTypes = getAtomNodeTypes(this.#editor?.schema ?? null);
         const positionMap = this.#editor?.state?.doc && docJson ? buildPositionMapFromPmDoc(this.#editor.state.doc, docJson) : null;
@@ -54824,13 +55999,20 @@ class PresentationEditor extends EventEmitter {
         this.#handleLayoutError("render", new Error("toFlowBlocks returned undefined blocks"));
         return;
       }
-      const layoutOptions = this.#resolveLayoutOptions(blocks, sectionMetadata);
+      const baseLayoutOptions = this.#resolveLayoutOptions(blocks, sectionMetadata);
+      const footnotesLayoutInput = this.#buildFootnotesLayoutInput({
+        converterContext,
+        themeColors: this.#editor?.converter?.themeColors ?? void 0
+      });
+      const layoutOptions = footnotesLayoutInput ? { ...baseLayoutOptions, footnotes: footnotesLayoutInput } : baseLayoutOptions;
       const previousBlocks = this.#layoutState.blocks;
       const previousLayout = this.#layoutState.layout;
       let layout;
       let measures;
       let headerLayouts;
       let footerLayouts;
+      let extraBlocks;
+      let extraMeasures;
       const headerFooterInput = this.#buildHeaderFooterInput();
       try {
         const result = await incrementalLayout(
@@ -54854,6 +56036,8 @@ class PresentationEditor extends EventEmitter {
           return;
         }
         ({ layout, measures } = result);
+        extraBlocks = Array.isArray(result.extraBlocks) ? result.extraBlocks : void 0;
+        extraMeasures = Array.isArray(result.extraMeasures) ? result.extraMeasures : void 0;
         layout.pageGap = this.#getEffectivePageGap();
         layout.layoutEpoch = layoutEpoch;
         headerLayouts = result.headers;
@@ -54913,6 +56097,10 @@ class PresentationEditor extends EventEmitter {
         footerBlocks.push(...rIdResult.blocks);
         footerMeasures.push(...rIdResult.measures);
       }
+      if (extraBlocks && extraMeasures && extraBlocks.length === extraMeasures.length && extraBlocks.length > 0) {
+        footerBlocks.push(...extraBlocks);
+        footerMeasures.push(...extraMeasures);
+      }
       painter.setData?.(
         blocks,
         measures,
@@ -55199,6 +56387,123 @@ class PresentationEditor extends EventEmitter {
       sectionMetadata
     };
   }
+  #buildFootnotesLayoutInput({
+    converterContext,
+    themeColors
+  }) {
+    const footnoteNumberById = converterContext?.footnoteNumberById;
+    const toSuperscriptDigits2 = (value) => {
+      const map3 = {
+        "0": "⁰",
+        "1": "¹",
+        "2": "²",
+        "3": "³",
+        "4": "⁴",
+        "5": "⁵",
+        "6": "⁶",
+        "7": "⁷",
+        "8": "⁸",
+        "9": "⁹"
+      };
+      const str = String(value ?? "");
+      return str.split("").map((ch) => map3[ch] ?? ch).join("");
+    };
+    const ensureFootnoteMarker = (blocks, id) => {
+      const displayNumberRaw = footnoteNumberById && typeof footnoteNumberById === "object" ? footnoteNumberById[id] : void 0;
+      const displayNumber = typeof displayNumberRaw === "number" && Number.isFinite(displayNumberRaw) && displayNumberRaw > 0 ? displayNumberRaw : 1;
+      const firstParagraph = blocks.find((b2) => b2?.kind === "paragraph");
+      if (!firstParagraph) return;
+      const runs = Array.isArray(firstParagraph.runs) ? firstParagraph.runs : [];
+      const markerText = toSuperscriptDigits2(displayNumber);
+      const baseRun = runs.find((r2) => {
+        const dataAttrs = r2.dataAttrs;
+        if (dataAttrs?.["data-sd-footnote-number"]) return false;
+        const pmStart = r2.pmStart;
+        const pmEnd = r2.pmEnd;
+        return typeof pmStart === "number" && Number.isFinite(pmStart) && typeof pmEnd === "number" && Number.isFinite(pmEnd);
+      });
+      const markerPmStart = baseRun?.pmStart ?? null;
+      const markerPmEnd = markerPmStart != null ? baseRun?.pmEnd != null ? Math.max(markerPmStart, Math.min(baseRun.pmEnd, markerPmStart + markerText.length)) : markerPmStart + markerText.length : null;
+      const alreadyHasMarker = runs.some((r2) => {
+        const dataAttrs = r2.dataAttrs;
+        return Boolean(dataAttrs?.["data-sd-footnote-number"]);
+      });
+      if (alreadyHasMarker) {
+        if (markerPmStart != null && markerPmEnd != null) {
+          const markerRun2 = runs.find((r2) => {
+            const dataAttrs = r2.dataAttrs;
+            return Boolean(dataAttrs?.["data-sd-footnote-number"]);
+          });
+          if (markerRun2) {
+            if (markerRun2.pmStart == null) markerRun2.pmStart = markerPmStart;
+            if (markerRun2.pmEnd == null) markerRun2.pmEnd = markerPmEnd;
+          }
+        }
+        return;
+      }
+      const firstTextRun = runs.find((r2) => typeof r2.text === "string");
+      const markerRun = {
+        kind: "text",
+        text: markerText,
+        dataAttrs: {
+          "data-sd-footnote-number": "true"
+        },
+        ...markerPmStart != null ? { pmStart: markerPmStart } : {},
+        ...markerPmEnd != null ? { pmEnd: markerPmEnd } : {}
+      };
+      markerRun.fontFamily = typeof firstTextRun?.fontFamily === "string" ? firstTextRun.fontFamily : "Arial";
+      markerRun.fontSize = typeof firstTextRun?.fontSize === "number" && Number.isFinite(firstTextRun.fontSize) ? firstTextRun.fontSize : 12;
+      if (firstTextRun?.color != null) markerRun.color = firstTextRun.color;
+      runs.unshift(markerRun);
+      firstParagraph.runs = runs;
+    };
+    const state = this.#editor?.state;
+    if (!state) return null;
+    const converter = this.#editor?.converter;
+    const importedFootnotes = Array.isArray(converter?.footnotes) ? converter.footnotes : [];
+    if (importedFootnotes.length === 0) return null;
+    const refs = [];
+    const idsInUse = /* @__PURE__ */ new Set();
+    state.doc.descendants((node, pos) => {
+      if (node.type?.name !== "footnoteReference") return;
+      const id = node.attrs?.id;
+      if (id == null) return;
+      const key2 = String(id);
+      const insidePos = Math.min(pos + 1, state.doc.content.size);
+      refs.push({ id: key2, pos: insidePos });
+      idsInUse.add(key2);
+    });
+    if (refs.length === 0) return null;
+    const blocksById = /* @__PURE__ */ new Map();
+    idsInUse.forEach((id) => {
+      const entry = importedFootnotes.find((f) => String(f?.id) === id);
+      const content = entry?.content;
+      if (!Array.isArray(content) || content.length === 0) return;
+      try {
+        const clonedContent = JSON.parse(JSON.stringify(content));
+        const footnoteDoc = { type: "doc", content: clonedContent };
+        const result = toFlowBlocks(footnoteDoc, {
+          blockIdPrefix: `footnote-${id}-`,
+          enableRichHyperlinks: true,
+          themeColors,
+          converterContext
+        });
+        if (result?.blocks?.length) {
+          ensureFootnoteMarker(result.blocks, id);
+          blocksById.set(id, result.blocks);
+        }
+      } catch {
+      }
+    });
+    if (blocksById.size === 0) return null;
+    return {
+      refs,
+      blocksById,
+      gap: 2,
+      topPadding: 4,
+      dividerHeight: 1
+    };
+  }
   #buildHeaderFooterInput() {
     if (!this.#headerFooterAdapter) {
       return null;
@@ -55388,7 +56693,8 @@ class PresentationEditor extends EventEmitter {
             const fragments2 = slotPage2.fragments ?? [];
             const pageHeight2 = page?.size?.h ?? layout.pageSize?.h ?? this.#layoutOptions.pageSize?.h ?? DEFAULT_PAGE_SIZE.h;
             const margins2 = pageMargins ?? layout.pages[0]?.margins ?? this.#layoutOptions.margins ?? DEFAULT_MARGINS;
-            const box2 = this.#computeDecorationBox(kind, margins2, pageHeight2);
+            const decorationMargins2 = kind === "footer" ? this.#stripFootnoteReserveFromBottomMargin(margins2, page ?? null) : margins2;
+            const box2 = this.#computeDecorationBox(kind, decorationMargins2, pageHeight2);
             const rawLayoutHeight2 = rIdLayout.layout.height ?? 0;
             const metrics2 = this.#computeHeaderFooterMetrics(
               kind,
@@ -55439,7 +56745,8 @@ class PresentationEditor extends EventEmitter {
       const fragments = slotPage.fragments ?? [];
       const pageHeight = page?.size?.h ?? layout.pageSize?.h ?? this.#layoutOptions.pageSize?.h ?? DEFAULT_PAGE_SIZE.h;
       const margins = pageMargins ?? layout.pages[0]?.margins ?? this.#layoutOptions.margins ?? DEFAULT_MARGINS;
-      const box = this.#computeDecorationBox(kind, margins, pageHeight);
+      const decorationMargins = kind === "footer" ? this.#stripFootnoteReserveFromBottomMargin(margins, page ?? null) : margins;
+      const box = this.#computeDecorationBox(kind, decorationMargins, pageHeight);
       const rawLayoutHeight = variant.layout.height ?? 0;
       const metrics = this.#computeHeaderFooterMetrics(kind, rawLayoutHeight, box, pageHeight, margins.footer ?? 0);
       const fallbackId = this.#headerFooterManager?.getVariantId(kind, headerFooterType);
@@ -55526,6 +56833,16 @@ class PresentationEditor extends EventEmitter {
       return { x: left2, width, height, offset: offset2 };
     }
   }
+  #stripFootnoteReserveFromBottomMargin(pageMargins, page) {
+    const reserveRaw = page?.footnoteReserved;
+    const reserve = typeof reserveRaw === "number" && Number.isFinite(reserveRaw) && reserveRaw > 0 ? reserveRaw : 0;
+    if (!reserve) return pageMargins;
+    const bottomRaw = pageMargins.bottom;
+    const bottom2 = typeof bottomRaw === "number" && Number.isFinite(bottomRaw) ? bottomRaw : 0;
+    const nextBottom = Math.max(0, bottom2 - reserve);
+    if (nextBottom === bottom2) return pageMargins;
+    return { ...pageMargins, bottom: nextBottom };
+  }
   /**
    * Computes the expected header/footer section type for a page based on document configuration.
    *
@@ -55590,7 +56907,8 @@ class PresentationEditor extends EventEmitter {
         height: headerPayload?.hitRegion?.height ?? headerBox.height
       });
       const footerPayload = this.#footerDecorationProvider?.(page.number, margins, page);
-      const footerBox = this.#computeDecorationBox("footer", margins, actualPageHeight);
+      const footerBoxMargins = this.#stripFootnoteReserveFromBottomMargin(margins, page);
+      const footerBox = this.#computeDecorationBox("footer", footerBoxMargins, actualPageHeight);
       this.#footerRegions.set(pageIndex, {
         kind: "footer",
         headerId: footerPayload?.headerId,
@@ -61491,6 +62809,109 @@ const CommentsMark = Mark.create({
     return [CommentMarkName$1, Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes)];
   }
 });
+const toSuperscriptDigits = (value) => {
+  const map3 = {
+    0: "⁰",
+    1: "¹",
+    2: "²",
+    3: "³",
+    4: "⁴",
+    5: "⁵",
+    6: "⁶",
+    7: "⁷",
+    8: "⁸",
+    9: "⁹"
+  };
+  return String(value ?? "").split("").map((ch) => map3[ch] ?? ch).join("");
+};
+const resolveFootnoteDisplayNumber = (editor, id) => {
+  const key2 = id == null ? null : String(id);
+  if (!key2) return null;
+  const map3 = editor?.converter?.footnoteNumberById;
+  const mapped = map3 && typeof map3 === "object" ? map3[key2] : void 0;
+  return typeof mapped === "number" && Number.isFinite(mapped) && mapped > 0 ? mapped : null;
+};
+class FootnoteReferenceNodeView {
+  constructor(node, getPos, decorations, editor, htmlAttributes = {}) {
+    this.node = node;
+    this.getPos = getPos;
+    this.editor = editor;
+    this.dom = this.#renderDom(node, htmlAttributes);
+  }
+  #renderDom(node, htmlAttributes) {
+    const el = document.createElement("sup");
+    el.className = "sd-footnote-ref";
+    el.setAttribute("contenteditable", "false");
+    el.setAttribute("aria-label", "Footnote reference");
+    Object.entries(htmlAttributes).forEach(([key2, value]) => {
+      if (value != null && value !== false) {
+        el.setAttribute(key2, String(value));
+      }
+    });
+    const id = node?.attrs?.id;
+    if (id != null) {
+      el.setAttribute("data-footnote-id", String(id));
+      const display = resolveFootnoteDisplayNumber(this.editor, id) ?? id;
+      el.textContent = toSuperscriptDigits(display);
+    } else {
+      el.textContent = "*";
+    }
+    return el;
+  }
+  update(node) {
+    const incomingType = node?.type?.name;
+    const currentType = this.node?.type?.name;
+    if (!incomingType || incomingType !== currentType) return false;
+    this.node = node;
+    const id = node?.attrs?.id;
+    if (id != null) {
+      this.dom.setAttribute("data-footnote-id", String(id));
+      const display = resolveFootnoteDisplayNumber(this.editor, id) ?? id;
+      this.dom.textContent = toSuperscriptDigits(display);
+    } else {
+      this.dom.removeAttribute("data-footnote-id");
+      this.dom.textContent = "*";
+    }
+    return true;
+  }
+}
+const FootnoteReference = Node$1.create({
+  name: "footnoteReference",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: false,
+  draggable: false,
+  addOptions() {
+    return {
+      htmlAttributes: {
+        "data-footnote-ref": "true"
+      }
+    };
+  },
+  addAttributes() {
+    return {
+      id: {
+        default: null
+      },
+      customMarkFollows: {
+        default: null
+      }
+    };
+  },
+  addNodeView() {
+    return ({ node, editor, getPos, decorations }) => {
+      const htmlAttributes = this.options.htmlAttributes;
+      return new FootnoteReferenceNodeView(node, getPos, decorations, editor, htmlAttributes);
+    };
+  },
+  parseDOM() {
+    return [{ tag: "sup[data-footnote-id]" }];
+  },
+  renderDOM({ htmlAttributes }) {
+    return ["sup", Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes)];
+  }
+});
 let cache$1 = /* @__PURE__ */ new WeakMap();
 function getParagraphContext(paragraph, startPos, helpers2, revision, compute) {
   const cached = cache$1.get(paragraph);
@@ -74303,14 +75724,317 @@ function getMatchHighlights(state) {
   let search2 = searchKey.getState(state);
   return search2 ? search2.deco : DecorationSet.empty;
 }
-function setSearchState(tr, query, range = null, options = {}) {
-  if (options != null && (typeof options !== "object" || Array.isArray(options))) {
-    throw new TypeError("setSearchState options must be an object");
+const BLOCK_SEPARATOR = "\n";
+const ATOM_PLACEHOLDER = "";
+class SearchIndex {
+  /** @type {string} */
+  text = "";
+  /** @type {Segment[]} */
+  segments = [];
+  /** @type {boolean} */
+  valid = false;
+  /** @type {number} */
+  docSize = 0;
+  /**
+   * Build the search index from a ProseMirror document.
+   * Uses doc.textBetween for the flattened string and walks
+   * the document to build the segment offset map.
+   *
+   * @param {import('prosemirror-model').Node} doc - The ProseMirror document
+   */
+  build(doc2) {
+    this.text = doc2.textBetween(0, doc2.content.size, BLOCK_SEPARATOR, ATOM_PLACEHOLDER);
+    this.segments = [];
+    this.docSize = doc2.content.size;
+    let offset2 = 0;
+    this.#walkNodeContent(doc2, 0, offset2, (segment) => {
+      this.segments.push(segment);
+      offset2 = segment.offsetEnd;
+    });
+    this.valid = true;
+  }
+  /**
+   * Walk the content of a node to build segments.
+   * This method processes the children of a node, given the position
+   * where the node's content starts.
+   *
+   * @param {import('prosemirror-model').Node} node - Current node
+   * @param {number} contentStart - Document position where this node's content starts
+   * @param {number} offset - Current offset in flattened string
+   * @param {(segment: Segment) => void} addSegment - Callback to add a segment
+   * @returns {number} The new offset after processing this node's content
+   */
+  #walkNodeContent(node, contentStart, offset2, addSegment) {
+    let currentOffset = offset2;
+    let isFirstChild = true;
+    node.forEach((child, childContentOffset) => {
+      const childDocPos = contentStart + childContentOffset;
+      if (child.isBlock && !isFirstChild) {
+        addSegment({
+          offsetStart: currentOffset,
+          offsetEnd: currentOffset + 1,
+          docFrom: childDocPos,
+          docTo: childDocPos,
+          kind: "blockSep"
+        });
+        currentOffset += 1;
+      }
+      currentOffset = this.#walkNode(child, childDocPos, currentOffset, addSegment);
+      isFirstChild = false;
+    });
+    return currentOffset;
+  }
+  /**
+   * Recursively walk a node and its descendants to build segments.
+   *
+   * @param {import('prosemirror-model').Node} node - Current node
+   * @param {number} docPos - Document position at start of this node
+   * @param {number} offset - Current offset in flattened string
+   * @param {(segment: Segment) => void} addSegment - Callback to add a segment
+   * @returns {number} The new offset after processing this node
+   */
+  #walkNode(node, docPos, offset2, addSegment) {
+    if (node.isText) {
+      const text = node.text || "";
+      if (text.length > 0) {
+        addSegment({
+          offsetStart: offset2,
+          offsetEnd: offset2 + text.length,
+          docFrom: docPos,
+          docTo: docPos + text.length,
+          kind: "text"
+        });
+        return offset2 + text.length;
+      }
+      return offset2;
+    }
+    if (node.isLeaf) {
+      if (node.type.name === "hard_break") {
+        addSegment({
+          offsetStart: offset2,
+          offsetEnd: offset2 + 1,
+          docFrom: docPos,
+          docTo: docPos + node.nodeSize,
+          kind: "hardBreak"
+        });
+        return offset2 + 1;
+      }
+      addSegment({
+        offsetStart: offset2,
+        offsetEnd: offset2 + 1,
+        docFrom: docPos,
+        docTo: docPos + node.nodeSize,
+        kind: "atom"
+      });
+      return offset2 + 1;
+    }
+    return this.#walkNodeContent(node, docPos + 1, offset2, addSegment);
+  }
+  /**
+   * Mark the index as stale. It will be rebuilt on next search.
+   */
+  invalidate() {
+    this.valid = false;
+  }
+  /**
+   * Check if the index needs rebuilding for the given document.
+   *
+   * @param {import('prosemirror-model').Node} doc - The document to check against
+   * @returns {boolean} True if index is stale and needs rebuilding
+   */
+  isStale(doc2) {
+    return !this.valid || doc2.content.size !== this.docSize;
+  }
+  /**
+   * Ensure the index is valid for the given document.
+   * Rebuilds if stale.
+   *
+   * @param {import('prosemirror-model').Node} doc - The document
+   */
+  ensureValid(doc2) {
+    if (this.isStale(doc2)) {
+      this.build(doc2);
+    }
+  }
+  /**
+   * Convert an offset range in the flattened string to document ranges.
+   * Skips separator/atom segments and returns only text ranges.
+   *
+   * @param {number} start - Start offset in flattened string
+   * @param {number} end - End offset in flattened string
+   * @returns {DocRange[]} Array of document ranges (text segments only)
+   */
+  offsetRangeToDocRanges(start2, end2) {
+    const ranges = [];
+    for (const segment of this.segments) {
+      if (segment.offsetEnd <= start2) continue;
+      if (segment.offsetStart >= end2) break;
+      if (segment.kind !== "text") continue;
+      const overlapStart = Math.max(start2, segment.offsetStart);
+      const overlapEnd = Math.min(end2, segment.offsetEnd);
+      if (overlapStart < overlapEnd) {
+        const startInSegment = overlapStart - segment.offsetStart;
+        const endInSegment = overlapEnd - segment.offsetStart;
+        ranges.push({
+          from: segment.docFrom + startInSegment,
+          to: segment.docFrom + endInSegment
+        });
+      }
+    }
+    return ranges;
+  }
+  /**
+   * Find the document position for a given offset in the flattened string.
+   *
+   * @param {number} offset - Offset in flattened string
+   * @returns {number|null} Document position, or null if not found
+   */
+  offsetToDocPos(offset2) {
+    for (const segment of this.segments) {
+      if (offset2 >= segment.offsetStart && offset2 < segment.offsetEnd) {
+        if (segment.kind === "text") {
+          return segment.docFrom + (offset2 - segment.offsetStart);
+        }
+        return segment.docFrom;
+      }
+    }
+    if (this.segments.length > 0 && offset2 === this.segments[this.segments.length - 1].offsetEnd) {
+      const lastSeg = this.segments[this.segments.length - 1];
+      return lastSeg.docTo;
+    }
+    return null;
+  }
+  /**
+   * Escape special regex characters in a string.
+   *
+   * @param {string} str - String to escape
+   * @returns {string} Escaped string safe for use in RegExp
+   */
+  static escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Convert a plain search string to a whitespace-flexible regex pattern.
+   * This allows matching across paragraph boundaries.
+   *
+   * @param {string} searchString - The search string
+   * @returns {string} Regex pattern string
+   */
+  static toFlexiblePattern(searchString) {
+    const parts = searchString.split(/\s+/).filter((part) => part.length > 0);
+    if (parts.length === 0) return "";
+    return parts.map((part) => SearchIndex.escapeRegex(part)).join("\\s+");
+  }
+  /**
+   * Search the index for matches.
+   *
+   * @param {string | RegExp} pattern - Search pattern (string or regex)
+   * @param {Object} options - Search options
+   * @param {boolean} [options.caseSensitive=false] - Case sensitive search
+   * @param {number} [options.maxMatches=1000] - Maximum number of matches to return
+   * @returns {Array<{start: number, end: number, text: string}>} Array of matches with offsets
+   */
+  search(pattern, options = {}) {
+    const { caseSensitive = false, maxMatches = 1e3 } = options;
+    const matches = [];
+    let regex;
+    if (pattern instanceof RegExp) {
+      const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+      regex = new RegExp(pattern.source, flags);
+    } else if (typeof pattern === "string") {
+      if (pattern.length === 0) return matches;
+      const flexiblePattern = SearchIndex.toFlexiblePattern(pattern);
+      if (flexiblePattern.length === 0) return matches;
+      const flags = caseSensitive ? "g" : "gi";
+      regex = new RegExp(flexiblePattern, flags);
+    } else {
+      return matches;
+    }
+    let match;
+    while ((match = regex.exec(this.text)) !== null && matches.length < maxMatches) {
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        text: match[0]
+      });
+      if (match[0].length === 0) {
+        regex.lastIndex++;
+      }
+    }
+    return matches;
   }
-  const highlight = typeof options?.highlight === "boolean" ? options.highlight : true;
-  return tr.setMeta(searchKey, { query, range, highlight });
 }
+const customSearchHighlightsKey = new superEditor_converter.PluginKey("customSearchHighlights");
 const isRegExp = (value) => Object.prototype.toString.call(value) === "[object RegExp]";
+const resolveInlineTextPosition = (doc2, position, direction) => {
+  const docSize = doc2.content.size;
+  if (!Number.isFinite(position) || position < 0 || position > docSize) {
+    return position;
+  }
+  const step = direction === "forward" ? 1 : -1;
+  let current = position;
+  let iterations = 0;
+  while (iterations < 8) {
+    iterations += 1;
+    const resolved = doc2.resolve(current);
+    const boundaryNode = direction === "forward" ? resolved.nodeAfter : resolved.nodeBefore;
+    if (!boundaryNode) break;
+    if (boundaryNode.isText) break;
+    if (!boundaryNode.isInline || boundaryNode.isAtom || boundaryNode.content.size === 0) break;
+    const next = current + step;
+    if (next < 0 || next > docSize) break;
+    current = next;
+    const adjacent = doc2.resolve(current);
+    const checkNode = direction === "forward" ? adjacent.nodeAfter : adjacent.nodeBefore;
+    if (checkNode && checkNode.isText) break;
+  }
+  return current;
+};
+const resolveSearchRange = ({ doc: doc2, from: from3, to, expectedText, highlights }) => {
+  const docSize = doc2.content.size;
+  let resolvedFrom = Math.max(0, Math.min(from3, docSize));
+  let resolvedTo = Math.max(0, Math.min(to, docSize));
+  if (highlights) {
+    const windowStart = Math.max(0, resolvedFrom - 4);
+    const windowEnd = Math.min(docSize, resolvedTo + 4);
+    const candidates = highlights.find(windowStart, windowEnd);
+    if (candidates.length > 0) {
+      let chosen = candidates[0];
+      if (expectedText) {
+        const matching = candidates.filter(
+          (decoration) => doc2.textBetween(decoration.from, decoration.to) === expectedText
+        );
+        if (matching.length > 0) {
+          chosen = matching[0];
+        }
+      }
+      resolvedFrom = chosen.from;
+      resolvedTo = chosen.to;
+    }
+  }
+  const normalizedFrom = resolveInlineTextPosition(doc2, resolvedFrom, "forward");
+  const normalizedTo = resolveInlineTextPosition(doc2, resolvedTo, "backward");
+  if (Number.isFinite(normalizedFrom) && Number.isFinite(normalizedTo) && normalizedFrom <= normalizedTo) {
+    resolvedFrom = normalizedFrom;
+    resolvedTo = normalizedTo;
+  }
+  return { from: resolvedFrom, to: resolvedTo };
+};
+const getPositionTracker = (editor) => {
+  if (!editor) return null;
+  if (editor.positionTracker) return editor.positionTracker;
+  const storageTracker = editor.storage?.positionTracker?.tracker;
+  if (storageTracker) {
+    editor.positionTracker = storageTracker;
+    return storageTracker;
+  }
+  const tracker = new PositionTracker(editor);
+  if (editor.storage?.positionTracker) {
+    editor.storage.positionTracker.tracker = tracker;
+  }
+  editor.positionTracker = tracker;
+  return tracker;
+};
 const Search = Extension.create({
   // @ts-expect-error - Storage type mismatch will be fixed in TS migration
   addStorage() {
@@ -74319,29 +76043,58 @@ const Search = Extension.create({
        * @private
        * @type {SearchMatch[]|null}
        */
-      searchResults: []
+      searchResults: [],
+      /**
+       * @private
+       * @type {boolean}
+       * Whether to apply CSS highlight classes to matches
+       */
+      highlightEnabled: true,
+      /**
+       * @private
+       * @type {SearchIndex}
+       * Lazily-built search index for cross-paragraph matching
+       */
+      searchIndex: new SearchIndex()
     };
   },
   addPmPlugins() {
     const editor = this.editor;
     const storage = this.storage;
+    const searchIndexInvalidatorPlugin = new superEditor_converter.Plugin({
+      key: new superEditor_converter.PluginKey("searchIndexInvalidator"),
+      appendTransaction(transactions, oldState, newState) {
+        const docChanged = transactions.some((tr) => tr.docChanged);
+        if (docChanged && storage?.searchIndex) {
+          storage.searchIndex.invalidate();
+        }
+        return null;
+      }
+    });
     const searchHighlightWithIdPlugin = new superEditor_converter.Plugin({
-      key: new superEditor_converter.PluginKey("customSearchHighlights"),
+      key: customSearchHighlightsKey,
       props: {
         decorations(state) {
           if (!editor) return null;
           const matches = storage?.searchResults;
           if (!matches?.length) return null;
-          const decorations = matches.map(
-            (match) => Decoration.inline(match.from, match.to, {
-              id: `search-match-${match.id}`
-            })
-          );
+          const highlightEnabled = storage?.highlightEnabled !== false;
+          const decorations = [];
+          for (const match of matches) {
+            const attrs = highlightEnabled ? { id: `search-match-${match.id}`, class: "ProseMirror-search-match" } : { id: `search-match-${match.id}` };
+            if (match.ranges && match.ranges.length > 0) {
+              for (const range of match.ranges) {
+                decorations.push(Decoration.inline(range.from, range.to, attrs));
+              }
+            } else {
+              decorations.push(Decoration.inline(match.from, match.to, attrs));
+            }
+          }
           return DecorationSet.create(state.doc, decorations);
         }
       }
     });
-    return [search(), searchHighlightWithIdPlugin];
+    return [search(), searchIndexInvalidatorPlugin, searchHighlightWithIdPlugin];
   },
   addCommands() {
     return {
@@ -74355,21 +76108,51 @@ const Search = Extension.create({
       goToFirstMatch: () => (
         /** @returns {boolean} */
         ({ state, editor, dispatch }) => {
+          const searchResults = this.storage?.searchResults;
+          if (Array.isArray(searchResults) && searchResults.length > 0) {
+            const firstMatch = searchResults[0];
+            const from3 = firstMatch.ranges?.[0]?.from ?? firstMatch.from;
+            const to = firstMatch.ranges?.[0]?.to ?? firstMatch.to;
+            if (typeof from3 !== "number" || typeof to !== "number") {
+              return false;
+            }
+            editor.view.focus();
+            const tr2 = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, from3, to)).scrollIntoView();
+            if (dispatch) dispatch(tr2);
+            const presentationEditor2 = editor.presentationEditor;
+            if (presentationEditor2 && typeof presentationEditor2.scrollToPosition === "function") {
+              const didScroll = presentationEditor2.scrollToPosition(from3, { block: "center" });
+              if (didScroll) return true;
+            }
+            try {
+              const domPos = editor.view.domAtPos(from3);
+              if (domPos?.node?.scrollIntoView) {
+                domPos.node.scrollIntoView(true);
+              }
+            } catch {
+            }
+            return true;
+          }
           const highlights = getMatchHighlights(state);
           if (!highlights) return false;
           const decorations = highlights.find();
           if (!decorations?.length) return false;
-          const firstMatch = decorations[0];
+          const firstDeco = decorations[0];
           editor.view.focus();
-          const tr = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, firstMatch.from, firstMatch.to)).scrollIntoView();
+          const tr = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, firstDeco.from, firstDeco.to)).scrollIntoView();
           if (dispatch) dispatch(tr);
           const presentationEditor = editor.presentationEditor;
           if (presentationEditor && typeof presentationEditor.scrollToPosition === "function") {
-            const didScroll = presentationEditor.scrollToPosition(firstMatch.from, { block: "center" });
+            const didScroll = presentationEditor.scrollToPosition(firstDeco.from, { block: "center" });
             if (didScroll) return true;
           }
-          const domPos = editor.view.domAtPos(firstMatch.from);
-          domPos?.node?.scrollIntoView(true);
+          try {
+            const domPos = editor.view.domAtPos(firstDeco.from);
+            if (domPos?.node?.scrollIntoView) {
+              domPos.node.scrollIntoView(true);
+            }
+          } catch {
+          }
           return true;
         }
       ),
@@ -74387,53 +76170,57 @@ const Search = Extension.create({
        *
        * // Search without visual highlighting
        * const silentMatches = editor.commands.search('test', { highlight: false })
-       * @note Returns array of SearchMatch objects with positions and IDs
+       *
+       * // Cross-paragraph search (works by default for plain strings)
+       * const crossParagraphMatches = editor.commands.search('end of paragraph start of next')
+       * @note Returns array of SearchMatch objects with positions and IDs.
+       *       Plain string searches are whitespace-flexible and match across paragraphs.
+       *       Regex searches match exactly as specified.
        */
       search: (patternInput, options = {}) => (
         /** @returns {SearchMatch[]} */
-        ({ state, dispatch }) => {
+        ({ state, dispatch, editor }) => {
           if (options != null && (typeof options !== "object" || Array.isArray(options))) {
             throw new TypeError("Search options must be an object");
           }
           const highlight = typeof options?.highlight === "boolean" ? options.highlight : true;
-          let pattern;
+          const maxMatches = typeof options?.maxMatches === "number" ? options.maxMatches : 1e3;
           let caseSensitive = false;
-          let regexp = false;
-          const wholeWord = false;
+          let searchPattern = patternInput;
           if (isRegExp(patternInput)) {
-            const regexPattern = (
-              /** @type {RegExp} */
-              patternInput
-            );
-            regexp = true;
-            pattern = regexPattern.source;
-            caseSensitive = !regexPattern.flags.includes("i");
+            caseSensitive = !patternInput.flags.includes("i");
+            searchPattern = patternInput;
           } else if (typeof patternInput === "string" && /^\/(.+)\/([gimsuy]*)$/.test(patternInput)) {
             const [, body, flags] = patternInput.match(/^\/(.+)\/([gimsuy]*)$/);
-            regexp = true;
-            pattern = body;
             caseSensitive = !flags.includes("i");
+            searchPattern = new RegExp(body, flags.includes("g") ? flags : flags + "g");
           } else {
-            pattern = String(patternInput);
+            searchPattern = String(patternInput);
           }
-          const query = new SearchQuery({
-            search: pattern,
+          const searchIndex = this.storage.searchIndex;
+          searchIndex.ensureValid(state.doc);
+          const indexMatches = searchIndex.search(searchPattern, {
             caseSensitive,
-            regexp,
-            wholeWord
+            maxMatches
           });
-          const tr = setSearchState(state.tr, query, null, { highlight });
-          dispatch(tr);
-          const newState = state.apply(tr);
-          const decoSet = getMatchHighlights(newState);
-          const matches = decoSet ? decoSet.find() : [];
-          const resultMatches = matches.map((d) => ({
-            from: d.from,
-            to: d.to,
-            text: newState.doc.textBetween(d.from, d.to),
-            id: uuid.v4()
-          }));
+          const resultMatches = [];
+          for (const indexMatch of indexMatches) {
+            const ranges = searchIndex.offsetRangeToDocRanges(indexMatch.start, indexMatch.end);
+            if (ranges.length === 0) continue;
+            const matchTexts = ranges.map((r2) => state.doc.textBetween(r2.from, r2.to));
+            const combinedText = matchTexts.join("");
+            const match = {
+              from: ranges[0].from,
+              to: ranges[ranges.length - 1].to,
+              text: combinedText,
+              id: uuid.v4(),
+              ranges,
+              trackerIds: []
+            };
+            resultMatches.push(match);
+          }
           this.storage.searchResults = resultMatches;
+          this.storage.highlightEnabled = highlight;
           return resultMatches;
         }
       ),
@@ -74444,12 +76231,48 @@ const Search = Extension.create({
        * @example
        * const searchResults = editor.commands.search('test string')
        * editor.commands.goToSearchResult(searchResults[3])
-       * @note Scrolls to match and selects it
+       * @note Scrolls to match and selects it. For multi-range matches (cross-paragraph),
+       *       selects the first range and scrolls to it.
        */
       goToSearchResult: (match) => (
         /** @returns {boolean} */
         ({ state, dispatch, editor }) => {
-          const { from: from3, to } = match;
+          const positionTracker = getPositionTracker(editor);
+          const doc2 = state.doc;
+          const highlights = getMatchHighlights(state);
+          let from3, to;
+          if (match?.ranges && match.ranges.length > 0 && match?.trackerIds && match.trackerIds.length > 0) {
+            if (positionTracker?.resolve && match.trackerIds[0]) {
+              const resolved = positionTracker.resolve(match.trackerIds[0]);
+              if (resolved) {
+                from3 = resolved.from;
+                to = resolved.to;
+              }
+            }
+            if (from3 === void 0) {
+              from3 = match.ranges[0].from;
+              to = match.ranges[0].to;
+            }
+          } else {
+            from3 = match.from;
+            to = match.to;
+            if (positionTracker?.resolve && match?.id) {
+              const resolved = positionTracker.resolve(match.id);
+              if (resolved) {
+                from3 = resolved.from;
+                to = resolved.to;
+              }
+            }
+          }
+          const normalized = resolveSearchRange({
+            doc: doc2,
+            from: from3,
+            to,
+            expectedText: match?.text ?? null,
+            highlights
+          });
+          from3 = normalized.from;
+          to = normalized.to;
           editor.view.focus();
           const tr = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, from3, to)).scrollIntoView();
           if (dispatch) dispatch(tr);
@@ -75102,6 +76925,7 @@ const getStarterExtensions = () => {
     CommentRangeStart,
     CommentRangeEnd,
     CommentReference,
+    FootnoteReference,
     Document,
     FontFamily,
     FontSize,