oasis-editor 0.0.84 → 0.0.86

package/dist/{index-9_ibx79n.js → index-DFKc0jbc.js}

@@ -2483,7 +2483,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-lNYRC99y.js").then((m) => {
+    import("./OasisEditorApp-CE15GH_N.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -5201,14 +5201,16 @@ function projectFootnoteBlocksForPage(document2, footnoteReferenceIds, page, tot
     if (!footnote) continue;
     const projected = projectBlocks(
       footnote.blocks,
-      page.index,
-      totalPages,
-      measuredHeights,
-      measuredParagraphLayouts,
-      document2.styles,
-      contentWidth,
-      measurer,
-      (_c = document2.settings) == null ? void 0 : _c.defaultTabStop
+      {
+        pageIndex: page.index,
+        totalPages,
+        measuredHeights,
+        measuredParagraphLayouts,
+        styles: document2.styles,
+        contentWidth,
+        measurer,
+        defaultTabStop: (_c = document2.settings) == null ? void 0 : _c.defaultTabStop
+      }
     );
     for (const block of projected) {
       blocks.push({
@@ -12773,7 +12775,16 @@ function estimateTableBlockHeight(table, styles, contentWidth, measurer = domTex
     defaultTabStop
   );
 }
-function projectHeaderFooterBlocksWithDependencies(blocks, deps, pageIndex, totalPages, measuredHeights, _measuredParagraphLayouts, styles, contentWidth, measurer, defaultTabStop) {
+function projectHeaderFooterBlocksWithDependencies(blocks, deps, context2 = {}) {
+  const {
+    pageIndex,
+    totalPages,
+    measuredHeights,
+    styles,
+    contentWidth,
+    measurer,
+    defaultTabStop
+  } = context2;
   return blocks.map((block, index) => {
     if (block.type === "paragraph") {
       const layout = deps.projectParagraphLayout(
@@ -12812,7 +12823,7 @@ function projectHeaderFooterBlocksWithDependencies(blocks, deps, pageIndex, tota
     };
   });
 }
-function projectHeaderFooterBlocks(blocks, pageIndex, totalPages, measuredHeights, measuredParagraphLayouts, styles, contentWidth, measurer = domTextMeasurer, defaultTabStop) {
+function projectHeaderFooterBlocks(blocks, context2 = {}) {
   return projectHeaderFooterBlocksWithDependencies(
     blocks,
     {
@@ -12820,14 +12831,10 @@ function projectHeaderFooterBlocks(blocks, pageIndex, totalPages, measuredHeight
       estimateTableBlockHeight,
       getProjectedParagraphBlockHeight
     },
-    pageIndex,
-    totalPages,
-    measuredHeights,
-    measuredParagraphLayouts,
-    styles,
-    contentWidth,
-    measurer,
-    defaultTabStop
+    {
+      ...context2,
+      measurer: context2.measurer ?? domTextMeasurer
+    }
   );
 }
 const MAX_COLUMN_BALANCE_ITERATIONS = 100;
@@ -13827,14 +13834,16 @@ function resolveEffectiveVerticalMetrics(pageSettings, headerBlocks, footerBlock
 function createHeaderFooterVariantProjector(context2) {
   return (blocks, contentWidth, pageIndex, totalPageCount) => blocks ? context2.projectHeaderFooterBlocks(
     blocks,
-    pageIndex,
-    totalPageCount,
-    context2.measuredHeights,
-    context2.measuredParagraphLayouts,
-    context2.documentStyles,
-    contentWidth,
-    context2.measurer,
-    context2.defaultTabStop
+    {
+      pageIndex,
+      totalPages: totalPageCount,
+      measuredHeights: context2.measuredHeights,
+      measuredParagraphLayouts: context2.measuredParagraphLayouts,
+      styles: context2.documentStyles,
+      contentWidth,
+      measurer: context2.measurer,
+      defaultTabStop: context2.defaultTabStop
+    }
   ) : void 0;
 }
 function projectTallestHeaderVariant(section, contentWidth, projectHeaderFooterVariant) {
@@ -14000,7 +14009,7 @@ function projectDocumentSections(context2, reservedHeightByPageIndex) {
     )
   };
 }
-function* iterateFootnoteReferenceRuns(document2) {
+function* iterateNoteReferenceRuns(document2, runKind) {
   const sections = getDocumentSectionsCanonical(document2);
   for (const section of sections) {
     const zones = [
@@ -14016,7 +14025,7 @@ function* iterateFootnoteReferenceRuns(document2) {
       for (const block of blocks) {
         for (const paragraph of getBlockParagraphs(block)) {
           for (const run of paragraph.runs) {
-            if (run.kind === "footnoteReference") {
+            if (run.kind === runKind) {
               yield { paragraph, run };
             }
           }
@@ -14025,103 +14034,56 @@ function* iterateFootnoteReferenceRuns(document2) {
     }
   }
 }
-const LOWER_LETTERS = "abcdefghijklmnopqrstuvwxyz";
-const ROMAN_NUMERALS = [
-  [1e3, "m"],
-  [900, "cm"],
-  [500, "d"],
-  [400, "cd"],
-  [100, "c"],
-  [90, "xc"],
-  [50, "l"],
-  [40, "xl"],
-  [10, "x"],
-  [9, "ix"],
-  [5, "v"],
-  [4, "iv"],
-  [1, "i"]
-];
-function toRoman(value) {
-  if (value <= 0) return String(value);
-  let remaining = value;
-  let result = "";
-  for (const [size, glyph] of ROMAN_NUMERALS) {
-    while (remaining >= size) {
-      result += glyph;
-      remaining -= size;
-    }
-  }
-  return result;
-}
-function toLetters(value) {
-  if (value <= 0) return String(value);
-  let remaining = value;
-  let result = "";
-  while (remaining > 0) {
-    const digit = (remaining - 1) % 26;
-    result = LOWER_LETTERS[digit] + result;
-    remaining = Math.floor((remaining - 1) / 26);
-  }
-  return result;
-}
-const SYMBOL_MARKS = ["*", "†", "‡", "§", "¶", "#"];
-function getFootnoteDisplayMarker(oneBasedIndex, format = "decimal") {
-  switch (format) {
-    case "lowerRoman":
-      return toRoman(oneBasedIndex);
-    case "upperRoman":
-      return toRoman(oneBasedIndex).toUpperCase();
-    case "lowerLetter":
-      return toLetters(oneBasedIndex);
-    case "upperLetter":
-      return toLetters(oneBasedIndex).toUpperCase();
-    case "symbol": {
-      const slot = (oneBasedIndex - 1) % SYMBOL_MARKS.length;
-      const cycles = Math.floor((oneBasedIndex - 1) / SYMBOL_MARKS.length) + 1;
-      return SYMBOL_MARKS[slot].repeat(cycles);
-    }
-    case "decimal":
-    default:
-      return String(oneBasedIndex);
-  }
-}
-function findFootnoteReference(document2, footnoteId) {
+function findNoteReference(document2, traversal, noteId) {
   var _a;
-  for (const entry of iterateFootnoteReferenceRuns(document2)) {
-    if (((_a = getRunFootnoteReference(entry.run)) == null ? void 0 : _a.footnoteId) === footnoteId) {
+  for (const entry of iterateNoteReferenceRuns(document2, traversal.runKind)) {
+    if (((_a = traversal.getRef(entry.run)) == null ? void 0 : _a.id) === noteId) {
       return entry;
     }
   }
   return null;
 }
-function renumberFootnotes(document2) {
-  var _a, _b;
-  const footnotes = document2.footnotes;
-  if (!footnotes || Object.keys(footnotes.items).length === 0) {
-    return document2;
+function listReferencedNotes(document2, traversal) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  let counter2 = 0;
+  for (const { run } of iterateNoteReferenceRuns(document2, traversal.runKind)) {
+    const ref = traversal.getRef(run);
+    if (!ref) continue;
+    if (seen.has(ref.id)) continue;
+    seen.add(ref.id);
+    if (!ref.customMark) {
+      counter2 += 1;
+    }
+    result.push({
+      id: ref.id,
+      customMark: ref.customMark,
+      index: ref.customMark ? 0 : counter2
+    });
   }
-  const format = ((_a = footnotes.settings) == null ? void 0 : _a.numberFormat) ?? "decimal";
-  const startAt = ((_b = footnotes.settings) == null ? void 0 : _b.startAt) ?? 1;
+  return result;
+}
+function computeNoteRenumber(document2, collection, traversal) {
+  var _a, _b;
+  const format = ((_a = collection.settings) == null ? void 0 : _a.numberFormat) ?? "decimal";
+  const startAt = ((_b = collection.settings) == null ? void 0 : _b.startAt) ?? 1;
   const referenced = /* @__PURE__ */ new Set();
-  const markerByFootnoteId = /* @__PURE__ */ new Map();
+  const markerById = /* @__PURE__ */ new Map();
   let autoCounter = startAt - 1;
-  for (const { run } of iterateFootnoteReferenceRuns(document2)) {
-    const ref = getRunFootnoteReference(run);
+  for (const { run } of iterateNoteReferenceRuns(document2, traversal.runKind)) {
+    const ref = traversal.getRef(run);
     if (!ref) continue;
-    referenced.add(ref.footnoteId);
+    referenced.add(ref.id);
     if (ref.customMark) {
-      markerByFootnoteId.set(ref.footnoteId, ref.customMark);
+      markerById.set(ref.id, ref.customMark);
       continue;
     }
-    if (!markerByFootnoteId.has(ref.footnoteId)) {
+    if (!markerById.has(ref.id)) {
       autoCounter += 1;
-      markerByFootnoteId.set(
-        ref.footnoteId,
-        getFootnoteDisplayMarker(autoCounter, format)
-      );
+      markerById.set(ref.id, traversal.formatMarker(autoCounter, format));
     }
   }
-  let mutatedSections = false;
+  let sectionsChanged = false;
   const sections = getDocumentSectionsCanonical(document2).map((section) => {
     const rewriteBlocks = (blocks) => {
       if (!blocks) return blocks;
@@ -14129,7 +14091,11 @@ function renumberFootnotes(document2) {
       const nextBlocks = blocks.map((block) => {
         switch (block.type) {
           case "paragraph": {
-            const updated = rewriteParagraphMarkers$1(block, markerByFootnoteId);
+            const updated = rewriteParagraphMarkers(
+              block,
+              traversal,
+              markerById
+            );
             if (updated !== block) blockChanged = true;
             return updated;
           }
@@ -14140,9 +14106,10 @@ function renumberFootnotes(document2) {
               const nextCells = row.cells.map((cell) => {
                 let cellChanged = false;
                 const nextCellBlocks = cell.blocks.map((p) => {
-                  const updated = rewriteParagraphMarkers$1(
+                  const updated = rewriteParagraphMarkers(
                     p,
-                    markerByFootnoteId
+                    traversal,
+                    markerById
                   );
                   if (updated !== p) cellChanged = true;
                   return updated;
@@ -14164,7 +14131,7 @@ function renumberFootnotes(document2) {
         }
       });
       if (!blockChanged) return blocks;
-      mutatedSections = true;
+      sectionsChanged = true;
       return nextBlocks;
     };
     return {
@@ -14180,31 +14147,21 @@ function renumberFootnotes(document2) {
   });
   const nextItems = {};
   let itemsChanged = false;
-  for (const [id, footnote] of Object.entries(footnotes.items)) {
+  for (const [id, body] of Object.entries(collection.items)) {
     if (referenced.has(id)) {
-      nextItems[id] = footnote;
+      nextItems[id] = body;
     } else {
       itemsChanged = true;
     }
   }
-  if (!mutatedSections && !itemsChanged) {
-    return document2;
-  }
-  return {
-    ...document2,
-    sections: mutatedSections ? sections : document2.sections,
-    footnotes: {
-      ...footnotes,
-      items: itemsChanged ? nextItems : footnotes.items
-    }
-  };
+  return { sections, sectionsChanged, nextItems, itemsChanged };
 }
-function rewriteParagraphMarkers$1(paragraph, markerByFootnoteId) {
+function rewriteParagraphMarkers(paragraph, traversal, markerById) {
   let runChanged = false;
   const nextRuns = paragraph.runs.map((run) => {
-    const ref = getRunFootnoteReference(run);
+    const ref = traversal.getRef(run);
     if (!ref) return run;
-    const desired = markerByFootnoteId.get(ref.footnoteId);
+    const desired = markerById.get(ref.id);
     if (desired === void 0) return run;
     if (run.text === desired) return run;
     runChanged = true;
@@ -14213,167 +14170,134 @@ function rewriteParagraphMarkers$1(paragraph, markerByFootnoteId) {
   if (!runChanged) return paragraph;
   return { ...paragraph, runs: nextRuns };
 }
-function* iterateEndnoteReferenceRuns(document2) {
-  const sections = getDocumentSectionsCanonical(document2);
-  for (const section of sections) {
-    const zones = [
-      section.header ?? [],
-      section.firstPageHeader ?? [],
-      section.evenPageHeader ?? [],
-      section.blocks,
-      section.footer ?? [],
-      section.firstPageFooter ?? [],
-      section.evenPageFooter ?? []
-    ];
-    for (const blocks of zones) {
-      for (const block of blocks) {
-        for (const paragraph of getBlockParagraphs(block)) {
-          for (const run of paragraph.runs) {
-            if (run.kind === "endnoteReference") {
-              yield { paragraph, run };
-            }
-          }
-        }
-      }
+function iterateFootnoteReferenceRuns(document2) {
+  return iterateNoteReferenceRuns(document2, "footnoteReference");
+}
+const LOWER_LETTERS = "abcdefghijklmnopqrstuvwxyz";
+const ROMAN_NUMERALS = [
+  [1e3, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"]
+];
+function toRoman(value) {
+  if (value <= 0) return String(value);
+  let remaining = value;
+  let result = "";
+  for (const [size, glyph] of ROMAN_NUMERALS) {
+    while (remaining >= size) {
+      result += glyph;
+      remaining -= size;
     }
   }
+  return result;
 }
-function listReferencedEndnotes(document2) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  let counter2 = 0;
-  for (const { run } of iterateEndnoteReferenceRuns(document2)) {
-    const ref = getRunEndnoteReference(run);
-    if (!ref) continue;
-    if (seen.has(ref.endnoteId)) continue;
-    seen.add(ref.endnoteId);
-    if (!ref.customMark) {
-      counter2 += 1;
-    }
-    result.push({
-      endnoteId: ref.endnoteId,
-      customMark: ref.customMark,
-      index: ref.customMark ? 0 : counter2
-    });
+function toLetters(value) {
+  if (value <= 0) return String(value);
+  let remaining = value;
+  let result = "";
+  while (remaining > 0) {
+    const digit = (remaining - 1) % 26;
+    result = LOWER_LETTERS[digit] + result;
+    remaining = Math.floor((remaining - 1) / 26);
   }
   return result;
 }
-function renumberEndnotes(document2) {
-  var _a, _b;
-  const endnotes = document2.endnotes;
-  if (!endnotes || Object.keys(endnotes.items).length === 0) {
+const SYMBOL_MARKS = ["*", "†", "‡", "§", "¶", "#"];
+function getFootnoteDisplayMarker(oneBasedIndex, format = "decimal") {
+  switch (format) {
+    case "lowerRoman":
+      return toRoman(oneBasedIndex);
+    case "upperRoman":
+      return toRoman(oneBasedIndex).toUpperCase();
+    case "lowerLetter":
+      return toLetters(oneBasedIndex);
+    case "upperLetter":
+      return toLetters(oneBasedIndex).toUpperCase();
+    case "symbol": {
+      const slot = (oneBasedIndex - 1) % SYMBOL_MARKS.length;
+      const cycles = Math.floor((oneBasedIndex - 1) / SYMBOL_MARKS.length) + 1;
+      return SYMBOL_MARKS[slot].repeat(cycles);
+    }
+    case "decimal":
+    default:
+      return String(oneBasedIndex);
+  }
+}
+const footnoteTraversal = {
+  runKind: "footnoteReference",
+  getRef: (run) => {
+    const ref = getRunFootnoteReference(run);
+    return ref ? { id: ref.footnoteId, customMark: ref.customMark } : void 0;
+  },
+  formatMarker: getFootnoteDisplayMarker
+};
+function findFootnoteReference(document2, footnoteId) {
+  return findNoteReference(document2, footnoteTraversal, footnoteId);
+}
+function renumberFootnotes(document2) {
+  const footnotes = document2.footnotes;
+  if (!footnotes || Object.keys(footnotes.items).length === 0) {
     return document2;
   }
-  const format = ((_a = endnotes.settings) == null ? void 0 : _a.numberFormat) ?? "decimal";
-  const startAt = ((_b = endnotes.settings) == null ? void 0 : _b.startAt) ?? 1;
-  const referenced = /* @__PURE__ */ new Set();
-  const markerByEndnoteId = /* @__PURE__ */ new Map();
-  let autoCounter = startAt - 1;
-  for (const { run } of iterateEndnoteReferenceRuns(document2)) {
-    const ref = getRunEndnoteReference(run);
-    if (!ref) continue;
-    referenced.add(ref.endnoteId);
-    if (ref.customMark) {
-      markerByEndnoteId.set(ref.endnoteId, ref.customMark);
-      continue;
-    }
-    if (!markerByEndnoteId.has(ref.endnoteId)) {
-      autoCounter += 1;
-      markerByEndnoteId.set(
-        ref.endnoteId,
-        getFootnoteDisplayMarker(autoCounter, format)
-      );
-    }
+  const { sections, sectionsChanged, nextItems, itemsChanged } = computeNoteRenumber(document2, footnotes, footnoteTraversal);
+  if (!sectionsChanged && !itemsChanged) {
+    return document2;
   }
-  let mutatedSections = false;
-  const sections = getDocumentSectionsCanonical(document2).map((section) => {
-    const rewriteBlocks = (blocks) => {
-      if (!blocks) return blocks;
-      let blockChanged = false;
-      const nextBlocks = blocks.map((block) => {
-        switch (block.type) {
-          case "paragraph": {
-            const updated = rewriteParagraphMarkers(block, markerByEndnoteId);
-            if (updated !== block) blockChanged = true;
-            return updated;
-          }
-          case "table": {
-            let tableChanged = false;
-            const nextRows = block.rows.map((row) => {
-              let rowChanged = false;
-              const nextCells = row.cells.map((cell) => {
-                let cellChanged = false;
-                const nextCellBlocks = cell.blocks.map((p) => {
-                  const updated = rewriteParagraphMarkers(p, markerByEndnoteId);
-                  if (updated !== p) cellChanged = true;
-                  return updated;
-                });
-                if (!cellChanged) return cell;
-                rowChanged = true;
-                return { ...cell, blocks: nextCellBlocks };
-              });
-              if (!rowChanged) return row;
-              tableChanged = true;
-              return { ...row, cells: nextCells };
-            });
-            if (!tableChanged) return block;
-            blockChanged = true;
-            return { ...block, rows: nextRows };
-          }
-          default:
-            return assertNever(block, "block");
-        }
-      });
-      if (!blockChanged) return blocks;
-      mutatedSections = true;
-      return nextBlocks;
-    };
-    return {
-      ...section,
-      blocks: rewriteBlocks(section.blocks) ?? section.blocks,
-      header: rewriteBlocks(section.header),
-      firstPageHeader: rewriteBlocks(section.firstPageHeader),
-      evenPageHeader: rewriteBlocks(section.evenPageHeader),
-      footer: rewriteBlocks(section.footer),
-      firstPageFooter: rewriteBlocks(section.firstPageFooter),
-      evenPageFooter: rewriteBlocks(section.evenPageFooter)
-    };
-  });
-  const nextItems = {};
-  let itemsChanged = false;
-  for (const [id, endnote] of Object.entries(endnotes.items)) {
-    if (referenced.has(id)) {
-      nextItems[id] = endnote;
-    } else {
-      itemsChanged = true;
+  return {
+    ...document2,
+    sections: sectionsChanged ? sections : document2.sections,
+    footnotes: {
+      ...footnotes,
+      items: itemsChanged ? nextItems : footnotes.items
     }
+  };
+}
+const endnoteTraversal = {
+  runKind: "endnoteReference",
+  getRef: (run) => {
+    const ref = getRunEndnoteReference(run);
+    return ref ? { id: ref.endnoteId, customMark: ref.customMark } : void 0;
+  },
+  formatMarker: getFootnoteDisplayMarker
+};
+function iterateEndnoteReferenceRuns(document2) {
+  return iterateNoteReferenceRuns(document2, "endnoteReference");
+}
+function listReferencedEndnotes(document2) {
+  return listReferencedNotes(document2, endnoteTraversal).map((info) => ({
+    endnoteId: info.id,
+    customMark: info.customMark,
+    index: info.index
+  }));
+}
+function renumberEndnotes(document2) {
+  const endnotes = document2.endnotes;
+  if (!endnotes || Object.keys(endnotes.items).length === 0) {
+    return document2;
   }
-  if (!mutatedSections && !itemsChanged) {
+  const { sections, sectionsChanged, nextItems, itemsChanged } = computeNoteRenumber(document2, endnotes, endnoteTraversal);
+  if (!sectionsChanged && !itemsChanged) {
     return document2;
   }
   return {
     ...document2,
-    sections: mutatedSections ? sections : document2.sections,
+    sections: sectionsChanged ? sections : document2.sections,
     endnotes: {
       ...endnotes,
       items: itemsChanged ? nextItems : endnotes.items
     }
   };
 }
-function rewriteParagraphMarkers(paragraph, markerByEndnoteId) {
-  let runChanged = false;
-  const nextRuns = paragraph.runs.map((run) => {
-    const ref = getRunEndnoteReference(run);
-    if (!ref) return run;
-    const desired = markerByEndnoteId.get(ref.endnoteId);
-    if (desired === void 0) return run;
-    if (run.text === desired) return run;
-    runChanged = true;
-    return { ...run, text: desired };
-  });
-  if (!runChanged) return paragraph;
-  return { ...paragraph, runs: nextRuns };
-}
 const FLOW_ID_PREFIX = "endnote-flow";
 function makeMarkerRun(endnoteId, marker) {
   return {
@@ -35709,7 +35633,7 @@ function importDocxInWorker(buffer, options = {}) {
     const worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "" + new URL("assets/importDocxWorker-8fivvDCX.js", import.meta.url).href,
+        "" + new URL("assets/importDocxWorker-C94l6-O5.js", import.meta.url).href,
         import.meta.url
       ),
       {

package/dist/layoutProjection/footnotePagination.d.ts

@@ -1,11 +1,11 @@
-import { EditorBlockNode, EditorDocument, EditorLayoutBlock, EditorLayoutPage, EditorLayoutParagraph } from '../core/model.js';
+import { EditorDocument, EditorLayoutPage, EditorLayoutParagraph } from '../core/model.js';
 import { ITextMeasurer } from '../core/engine.js';
+import { HeaderFooterBlockProjector } from './headerFooterLayoutContext.js';
 
 export declare const FOOTNOTE_SEPARATOR_HEIGHT = 10;
 export declare const FOOTNOTE_BLOCK_GAP = 2;
 export declare const FOOTNOTE_MARKER_GUTTER_PX = 24;
 export declare const MAX_FOOTNOTE_LAYOUT_ITERATIONS = 4;
-export type HeaderFooterBlockProjector = (blocks: EditorBlockNode[], pageIndex?: number, totalPages?: number, measuredHeights?: Record<string, number>, measuredParagraphLayouts?: Record<string, EditorLayoutParagraph>, styles?: EditorDocument["styles"], contentWidth?: number, measurer?: ITextMeasurer, defaultTabStop?: number) => EditorLayoutBlock[];
 export declare function collectPageFootnoteReferenceIds(page: EditorLayoutPage): string[];
 export interface FootnotePaginationContext {
     document: EditorDocument;

package/dist/layoutProjection/headerFooterFootnotes.d.ts

@@ -1,4 +1,4 @@
-import { EditorBlockNode, EditorLayoutBlock, EditorLayoutParagraph, EditorNamedStyle } from '../core/model.js';
-import { ITextMeasurer } from '../core/engine.js';
+import { EditorBlockNode, EditorLayoutBlock } from '../core/model.js';
+import { HeaderFooterLayoutContext } from './headerFooterLayoutContext.js';
 
-export declare function projectHeaderFooterBlocks(blocks: EditorBlockNode[], pageIndex?: number, totalPages?: number, measuredHeights?: Record<string, number>, measuredParagraphLayouts?: Record<string, EditorLayoutParagraph>, styles?: Record<string, EditorNamedStyle>, contentWidth?: number, measurer?: ITextMeasurer, defaultTabStop?: number): EditorLayoutBlock[];
+export declare function projectHeaderFooterBlocks(blocks: EditorBlockNode[], context?: HeaderFooterLayoutContext): EditorLayoutBlock[];

package/dist/layoutProjection/headerFooterLayoutContext.d.ts

@@ -0,0 +1,14 @@
+import { EditorBlockNode, EditorLayoutBlock, EditorLayoutParagraph, EditorNamedStyle } from '../core/model.js';
+import { ITextMeasurer } from '../core/engine.js';
+
+export interface HeaderFooterLayoutContext {
+    pageIndex?: number;
+    totalPages?: number;
+    measuredHeights?: Record<string, number>;
+    measuredParagraphLayouts?: Record<string, EditorLayoutParagraph>;
+    styles?: Record<string, EditorNamedStyle>;
+    contentWidth?: number;
+    measurer?: ITextMeasurer;
+    defaultTabStop?: number;
+}
+export type HeaderFooterBlockProjector = (blocks: EditorBlockNode[], context?: HeaderFooterLayoutContext) => EditorLayoutBlock[];

package/dist/layoutProjection/headerFooterProjection.d.ts

@@ -1,5 +1,6 @@
 import { EditorBlockNode, EditorLayoutBlock, EditorLayoutParagraph, EditorNamedStyle, EditorParagraphNode } from '../core/model.js';
 import { ITextMeasurer } from '../core/engine.js';
+import { HeaderFooterLayoutContext } from './headerFooterLayoutContext.js';
 
 type ProjectParagraphLayoutFn = (paragraph: EditorParagraphNode, pageIndex?: number, totalPages?: number, styles?: Record<string, EditorNamedStyle>, contentWidth?: number, measurer?: ITextMeasurer, defaultTabStop?: number) => EditorLayoutParagraph;
 type EstimateTableBlockHeightFn = (block: Extract<EditorBlockNode, {
@@ -10,5 +11,5 @@ export declare function projectHeaderFooterBlocksWithDependencies(blocks: Editor
     projectParagraphLayout: ProjectParagraphLayoutFn;
     estimateTableBlockHeight: EstimateTableBlockHeightFn;
     getProjectedParagraphBlockHeight: GetProjectedParagraphBlockHeightFn;
-}, pageIndex?: number, totalPages?: number, measuredHeights?: Record<string, number>, _measuredParagraphLayouts?: Record<string, EditorLayoutParagraph>, styles?: Record<string, EditorNamedStyle>, contentWidth?: number, measurer?: ITextMeasurer, defaultTabStop?: number): EditorLayoutBlock[];
+}, context?: HeaderFooterLayoutContext): EditorLayoutBlock[];
 export {};