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

package/dist/chunks/{index-BFU5qWH7.cjs → index-Cto-XsBE.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-DpKjVrPl.cjs");
 const vue = require("./vue-De9wkgLl.cjs");
 require("./jszip.min-BPh2MMAa.cjs");
 const eventemitter3 = require("./eventemitter3-BQuRcMPI.cjs");
@@ -15524,7 +15524,7 @@ const canUseDOM = () => {
     return false;
   }
 };
-const summaryVersion = "1.5.0";
+const summaryVersion = "1.6.0-next.1";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -17781,6 +17781,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 +17809,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 +18191,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.1");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -34062,7 +34072,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 +34099,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 +34410,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 +34900,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 +35213,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 +36976,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 +37650,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 +38201,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 +42242,7 @@ const ATOMIC_INLINE_TYPES = /* @__PURE__ */ new Set([
   "lineBreak",
   "page-number",
   "total-page-number",
+  "footnoteReference",
   "passthroughInline",
   "bookmarkEnd"
 ]);
@@ -46346,6 +47267,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 +47334,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 +55762,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 +55819,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 +55856,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 +55917,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 +56207,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 +56513,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 +56565,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 +56653,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 +56727,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 +62629,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);
@@ -75102,6 +76343,7 @@ const getStarterExtensions = () => {
     CommentRangeStart,
     CommentRangeEnd,
     CommentReference,
+    FootnoteReference,
     Document,
     FontFamily,
     FontSize,