@portone/docx-editor 0.5.1 → 0.6.1

package/dist/editor/stories/storyMarkup.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A side story drawn as markup no editor view stands behind: a note the caret is not in, and later
+ * a comment body or a header preview.
+ *
+ * The runs are drawn by the same spec the editor's run view draws (`editor/views/runMarkView`), so
+ * a story set down here wraps where it would in an editor, and what one kind of story draws
+ * differently comes in as a node spec. Nothing here knows which kind of story it is drawing, or
+ * where the markup goes.
+ *
+ * The schema writes the document's own source onto what it draws (`w:pPr`, a run's `w:rPr`, a
+ * preserved fragment's XML) for an editor to read back, and nothing reads this markup back. So
+ * none of it is kept: a selection the browser copies out of a note, with no copy serializer of the
+ * editor behind it, then carries no more of the document than a copy out of the editor does
+ * (`schema/clipboard`).
+ */
+import { type DOMOutputSpec, type Node as PMNode } from "prosemirror-model";
+import type { FontFallbacks } from "../../styles/fontStack";
+/** How a node type is drawn in place of the way the schema draws it, by node type name */
+export type StoryNodeSpecs = Readonly<Record<string, (node: PMNode) => DOMOutputSpec>>;
+export interface StoryMarkupOptions {
+    readonly fontFallbacks: FontFallbacks;
+    readonly nodeSpecs?: StoryNodeSpecs;
+}
+export declare function storyMarkup(story: PMNode, { fontFallbacks, nodeSpecs }: StoryMarkupOptions): DocumentFragment;

package/dist/editor/stories/storyMarkup.js

@@ -0,0 +1,35 @@
+// src/editor/stories/storyMarkup.ts
+import {
+  DOMSerializer
+} from "prosemirror-model";
+import { runMarkSpec } from "../../schema/index.js";
+var STYLED_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "data-display",
+  "data-underline"
+]);
+function withoutSource(markup) {
+  markup.querySelectorAll("*").forEach((element) => {
+    for (const name of element.getAttributeNames()) {
+      if (name.startsWith("data-") && !STYLED_ATTRIBUTES.has(name)) {
+        element.removeAttribute(name);
+      }
+    }
+  });
+  return markup;
+}
+function storyMarkup(story, { fontFallbacks, nodeSpecs = {} }) {
+  const schema = story.type.schema;
+  const serializer = new DOMSerializer(
+    { ...DOMSerializer.nodesFromSchema(schema), ...nodeSpecs },
+    {
+      ...DOMSerializer.marksFromSchema(schema),
+      run: (mark) => runMarkSpec(mark.attrs, fontFallbacks)
+    }
+  );
+  const markup = document.createDocumentFragment();
+  serializer.serializeFragment(story.content, {}, markup);
+  return withoutSource(markup);
+}
+export {
+  storyMarkup
+};

package/dist/editor/stories/storyState.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The state one side story is edited in.
+ *
+ * A story is a document of the same schema as the body, so it is edited by the same plugins: the
+ * guards, the clipboard, the tabs, the display derivation. What it is not is a document of its
+ * own, so the ones that answer for a whole document stay out - the history, which the main
+ * document keeps for both (`./storyView`), the note and comment plugins, whose subjects a story
+ * does not hold, and the page decorations, since a story is drawn wherever its host puts it.
+ *
+ * The snapshot handed in is the main document's, which is what makes a run resolve here as it
+ * would in the body. Its caller narrows the two values a story answers differently: a story has
+ * nowhere to write a list definition, and the paper it wraps at is the one its anchor stands on.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type Command, EditorState, type Plugin } from "prosemirror-state";
+import type { EditingProtection } from "../../schema/protection";
+import type { SliceNormalizer } from "../clipboard/normalizers";
+import { type EditorDocument } from "../editorDocument";
+import type { SurfaceCapabilities } from "./storyView";
+export interface StoryStateOptions {
+    /** The story as the main document holds it */
+    readonly story: PMNode;
+    /** The main document's snapshot, which the story's display values are resolved against */
+    readonly document: EditorDocument;
+    readonly protection: EditingProtection;
+    /** The keys the surface binds ahead of the editor's own: undo, redo and Escape */
+    readonly keys: Record<string, Command>;
+    /** What the kind of story adds, which is asked before the editor's own keymaps */
+    readonly plugins: readonly Plugin[];
+    readonly normalizers: readonly SliceNormalizer[];
+    /** What this kind of story takes, which the editor's own keys are bound from */
+    readonly takes: SurfaceCapabilities;
+}
+export declare function storyEditorState({ story, document, protection, keys, plugins, normalizers, takes, }: StoryStateOptions): EditorState;

package/dist/editor/stories/storyState.js

@@ -0,0 +1,74 @@
+// src/editor/stories/storyState.ts
+import { baseKeymap } from "prosemirror-commands";
+import { dropCursor } from "prosemirror-dropcursor";
+import { keymap } from "prosemirror-keymap";
+import { EditorState } from "prosemirror-state";
+import { tableEditing } from "prosemirror-tables";
+import { docxClipboard } from "../clipboard/plugin.js";
+import { editorDocument } from "../editorDocument.js";
+import { compositionSelection } from "../plugins/compositionSelection.js";
+import {
+  displayDerivation,
+  withDerivedDisplay
+} from "../plugins/displayDerivation.js";
+import { documentProtection } from "../plugins/documentProtection.js";
+import { docxKeymap, NOTE_KEYS } from "../plugins/keymap.js";
+import { lockedContent } from "../plugins/lockedContent.js";
+import { numberingMarkers } from "../plugins/numberingDecorations.js";
+import { tabCaret } from "../plugins/tabCaret.js";
+import { tabDecorations } from "../plugins/tabDecorations.js";
+import { tabLayout } from "../plugins/tabLayout.js";
+import { tabPointer } from "../plugins/tabPointer.js";
+var CAPABILITY_KEYS = {
+  "Mod-k": "link",
+  [NOTE_KEYS.footnote]: "note",
+  [NOTE_KEYS.endnote]: "note"
+};
+var KEYS_NO_STORY_TAKES = ["Mod-Enter"];
+function storyKeymap(takes) {
+  return Object.fromEntries(
+    Object.entries(docxKeymap).filter(([key]) => {
+      if (KEYS_NO_STORY_TAKES.includes(key)) return false;
+      const needed = CAPABILITY_KEYS[key];
+      return needed === void 0 || takes.has(needed);
+    })
+  );
+}
+function storyEditorState({
+  story,
+  document,
+  protection,
+  keys,
+  plugins,
+  normalizers,
+  takes
+}) {
+  return EditorState.create({
+    doc: withDerivedDisplay(story, document),
+    plugins: [
+      editorDocument(document),
+      lockedContent(),
+      documentProtection({ protection, author: null, editableComments: "own" }),
+      compositionSelection(),
+      // A kind's own key rule stands ahead of the keymaps below: the base keymap answers
+      // Backspace and Enter for every document, so a rule about an empty story would never be
+      // asked behind it
+      ...plugins,
+      keymap(keys),
+      keymap(storyKeymap(takes)),
+      keymap(baseKeymap),
+      dropCursor(),
+      docxClipboard({ normalizers }),
+      tableEditing(),
+      tabDecorations(),
+      tabPointer(),
+      tabLayout(),
+      tabCaret(),
+      displayDerivation(),
+      numberingMarkers()
+    ]
+  });
+}
+export {
+  storyEditorState
+};

package/dist/editor/stories/storyView.d.ts

@@ -0,0 +1,115 @@
+/**
+ * The one editing view a side story is edited in, mounted over the story the caret went into and
+ * taken down when it leaves.
+ *
+ * Everything typed here leaves through the host, which writes it into the main document as one
+ * story change. That is what keeps the guards, the locks and the protection judging a story edit
+ * where they judge a body edit, and what leaves the main document holding the only history: the
+ * undo keys here run the host's.
+ *
+ * This file does not know which kind of story it is drawing or where it is drawn: a note stands
+ * at the foot of a page, a comment body in a rail beside it, a header in a page margin. What
+ * differs between the kinds arrives as `StoryExtensions`.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type EditorState, type Plugin } from "prosemirror-state";
+import { EditorView, type NodeViewConstructor } from "prosemirror-view";
+import { type StoryKey } from "../../schema/stories";
+import type { FontFallbacks } from "../../styles/fontStack";
+import type { SliceNormalizer } from "../clipboard/normalizers";
+import type { EditorDocument } from "../editorDocument";
+export type NodeViewMap = Record<string, NodeViewConstructor>;
+/** What every surface is read and dispatched through, whichever of the two it is */
+interface SurfaceContents {
+    readonly view: EditorView;
+    /** The state on screen, which a control drawn from the surface re-decides itself from */
+    readonly state: EditorState;
+    readonly takes: SurfaceCapabilities;
+}
+/**
+ * The surface holding the caret, which is either the body or one story with the view over it.
+ *
+ * Two editing views cannot stand at once, and this is where that rule is written down: a caller
+ * holding this value has no way to name a second one. What holds it true is the state that decides
+ * which story is open (`ui/notes/useStorySurface`).
+ */
+export type ActiveSurface = ({
+    readonly surface: "body";
+} & SurfaceContents) | ({
+    readonly surface: "story";
+    readonly key: StoryKey;
+} & SurfaceContents);
+export interface StoryHost {
+    /** The main state the story is read from and judged against */
+    readonly state: () => EditorState;
+    /** Writes the story into the main document; false when the main document refused it */
+    write(key: StoryKey, story: PMNode): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    /** Hands the caret back to the main document (Escape) */
+    leave(key: StoryKey): void;
+    /** Whether edits to this story are closed where it is anchored */
+    shut(key: StoryKey): boolean;
+    /** Registers the view that holds the caret, null when it lets go */
+    activate(key: StoryKey, view: EditorView | null): void;
+}
+/**
+ * What a surface takes beyond character and paragraph formatting.
+ *
+ * Every one of these puts something into the document that the part the surface is written back as
+ * has to carry - a relationship, a definition, a part of its own - so which of them a surface takes
+ * is the surface's own to declare, and a control or a key that puts one in asks here rather than
+ * asking which kind of surface it is.
+ */
+export declare const SURFACE_CAPABILITIES: readonly ["list", "table", "image", "link", "note", "comment"];
+export type SurfaceCapability = (typeof SURFACE_CAPABILITIES)[number];
+export type SurfaceCapabilities = ReadonlySet<SurfaceCapability>;
+/** What the body takes, which is everything: it is written back as the document part itself */
+export declare const EVERY_CAPABILITY: SurfaceCapabilities;
+/** What a surface whose writer carries none of them takes */
+export declare const NO_CAPABILITY: SurfaceCapabilities;
+export interface StoryExtensions {
+    readonly plugins: readonly Plugin[];
+    readonly nodeViews: NodeViewMap;
+    readonly normalizers: readonly SliceNormalizer[];
+    /** What this kind of story takes, which its keys and the controls over it are drawn from */
+    readonly takes: SurfaceCapabilities;
+}
+/**
+ * Where the caret goes when the view is mounted: back where it stood, or at the point the reader
+ * pressed, which is what a press on a story no view stands over yet has to say.
+ */
+export type StoryCaret = {
+    readonly kind: "at";
+    readonly anchor: number;
+    readonly head: number;
+} | {
+    readonly kind: "point";
+    readonly left: number;
+    readonly top: number;
+};
+export interface StoryViewOptions {
+    readonly mount: HTMLElement;
+    readonly host: StoryHost;
+    readonly key: StoryKey;
+    readonly document: EditorDocument;
+    readonly fontFallbacks: FontFallbacks;
+    readonly extensions: StoryExtensions;
+    /** Where the caret opens. The end of the story when none is given */
+    readonly caret?: StoryCaret | null;
+    /**
+     * Called with every state this view goes to, which is what a control drawn from the story - a
+     * toolbar acting on it - re-decides itself from.
+     */
+    readonly onStateChange?: (state: EditorState) => void;
+}
+export interface StoryView {
+    readonly view: EditorView;
+    /** Takes a changed main state in; replaces the content only when the story says something else */
+    sync(): void;
+    destroy(): void;
+}
+/** Where the caret stands, in the shape a view mounted again over the same story opens at */
+export declare function caretOf(state: EditorState): StoryCaret;
+export declare function createStoryView({ mount, host, key, document, fontFallbacks, extensions, caret, onStateChange, }: StoryViewOptions): StoryView;
+export {};

package/dist/editor/stories/storyView.js

@@ -0,0 +1,144 @@
+// src/editor/stories/storyView.ts
+import {
+  TextSelection
+} from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { editingProtection, editsShut } from "../../schema/protectionState.js";
+import { sameStory, storyNodeOf } from "../../schema/stories.js";
+import { editorClassNames } from "../../styles/classNames.js";
+import { runMarkView } from "../views/runMarkView.js";
+import { storyEditorState } from "./storyState.js";
+var SURFACE_CAPABILITIES = [
+  "list",
+  "table",
+  "image",
+  "link",
+  "note",
+  "comment"
+];
+var EVERY_CAPABILITY = new Set(
+  SURFACE_CAPABILITIES
+);
+var NO_CAPABILITY = /* @__PURE__ */ new Set();
+function caretOf(state) {
+  return {
+    kind: "at",
+    anchor: state.selection.anchor,
+    head: state.selection.head
+  };
+}
+function placed(state, at, to) {
+  const size = state.doc.content.size;
+  const $anchor = state.doc.resolve(Math.min(Math.max(at, 0), size));
+  const $head = state.doc.resolve(Math.min(Math.max(to, 0), size));
+  return state.apply(
+    state.tr.setSelection(TextSelection.between($anchor, $head))
+  );
+}
+function endComposition(view) {
+  if (!view.composing) return;
+  const marks = view.state.storedMarks ?? view.state.selection.$from.marks();
+  view.dispatch(
+    view.state.tr.setStoredMarks(marks).setMeta("addToHistory", false)
+  );
+}
+function createStoryView({
+  mount,
+  host,
+  key,
+  document,
+  fontFallbacks,
+  extensions,
+  caret = null,
+  onStateChange
+}) {
+  const standing = () => host.shut(key) ? "readOnly" : editingProtection(host.state());
+  let protection = standing();
+  const keys = {
+    "Mod-z": () => host.undo(),
+    "Mod-y": () => host.redo(),
+    "Shift-Mod-z": () => host.redo(),
+    Escape: () => {
+      host.leave(key);
+      return true;
+    }
+  };
+  const built = (story) => storyEditorState({
+    story,
+    document,
+    protection,
+    keys,
+    plugins: extensions.plugins,
+    normalizers: extensions.normalizers,
+    takes: extensions.takes
+  });
+  const storyNow = () => storyNodeOf(host.state().doc, key);
+  const opening = storyNow();
+  if (opening === null) {
+    throw new Error(`the document holds no story named ${key}`);
+  }
+  const view = new EditorView(mount, {
+    state: built(opening),
+    // A standing that shuts the story shuts typing in it, and is read off the state so that a
+    // mode switched while the story is open takes effect without a new view
+    editable: (current) => !editsShut(current),
+    attributes: { class: editorClassNames.storyBody },
+    // The schema can only draw a run with the default fallbacks; this view draws the host's
+    markViews: { run: runMarkView(fontFallbacks) },
+    nodeViews: extensions.nodeViews,
+    dispatchTransaction(transaction) {
+      const next = view.state.applyTransaction(transaction);
+      if (next.state.doc === view.state.doc) {
+        show(next.state);
+        return;
+      }
+      const before = view.state;
+      show(next.state);
+      if (host.write(key, next.state.doc)) return;
+      if (sameStory(storyNow(), next.state.doc)) return;
+      show(before);
+      endComposition(view);
+    }
+  });
+  const show = (next) => {
+    view.updateState(next);
+    onStateChange?.(next);
+  };
+  const open = caret ?? null;
+  if (open === null) {
+    const end = view.state.doc.content.size;
+    show(placed(view.state, end, end));
+  } else if (open.kind === "at") {
+    show(placed(view.state, open.anchor, open.head));
+  } else {
+    const at = view.posAtCoords({ left: open.left, top: open.top });
+    const pos = at?.pos ?? view.state.doc.content.size;
+    show(placed(view.state, pos, pos));
+  }
+  const registerFocus = () => host.activate(key, view);
+  view.dom.addEventListener("focus", registerFocus);
+  return {
+    view,
+    sync() {
+      const story = storyNow();
+      if (story === null) return;
+      const wanted = standing();
+      if (wanted === protection && sameStory(story, view.state.doc)) return;
+      const { anchor, head } = view.state.selection;
+      protection = wanted;
+      show(placed(built(story), anchor, head));
+    },
+    destroy() {
+      view.dom.removeEventListener("focus", registerFocus);
+      host.activate(key, null);
+      view.destroy();
+    }
+  };
+}
+export {
+  EVERY_CAPABILITY,
+  NO_CAPABILITY,
+  SURFACE_CAPABILITIES,
+  caretOf,
+  createStoryView
+};

package/dist/numbering/spellers.d.ts

@@ -6,7 +6,7 @@
  * because it has a speller here, so a marker can never be counted in a format nothing can write.
  */
 /** A `w:numFmt` this editor spells out. Every other one is drawn as a decimal */
-export type NumberFormat = "decimal" | "decimalZero" | "bullet" | "lowerLetter" | "upperLetter" | "lowerRoman" | "upperRoman" | "ganada" | "koreanDigital" | "chineseCounting";
+export type NumberFormat = "decimal" | "decimalZero" | "bullet" | "lowerLetter" | "upperLetter" | "lowerRoman" | "upperRoman" | "ganada" | "koreanDigital" | "chineseCounting" | "chicago";
 export declare function isNumberFormat(value: string | null): value is NumberFormat;
 /**
  * The count as this format writes it, and as a decimal where spelling it out would run past the

package/dist/numbering/spellers.js

@@ -31,6 +31,7 @@ function repeated(symbols, count) {
   return (symbols[index] ?? "").repeat(times);
 }
 var LATIN = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var CHICAGO = "*\u2020\u2021\xA7";
 var GANADA = "\uAC00\uB098\uB2E4\uB77C\uB9C8\uBC14\uC0AC\uC544\uC790\uCC28\uCE74\uD0C0\uD30C\uD558";
 var KOREAN_DIGITS = "\uC601\uC77C\uC774\uC0BC\uC0AC\uC624\uC721\uCE60\uD314\uAD6C";
 function digits(symbols, count) {
@@ -80,7 +81,11 @@ var NUMBER_SPELLERS = {
     spell: (count) => digits(KOREAN_DIGITS, count),
     countsPerChar: POSITIONAL
   },
-  chineseCounting: { spell: chineseCounting, countsPerChar: POSITIONAL }
+  chineseCounting: { spell: chineseCounting, countsPerChar: POSITIONAL },
+  chicago: {
+    spell: (count) => repeated(CHICAGO, count),
+    countsPerChar: CHICAGO.length
+  }
 };
 function isNumberFormat(value) {
   return value !== null && Object.hasOwn(NUMBER_SPELLERS, value);

package/dist/page/blockKinds.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { Decoration, EditorView } from "prosemirror-view";
+import type { PageDemand } from "./demands";
 /** A place inside a block where the next page may, or must, start */
 export interface BreakCandidate {
     /**
@@ -41,13 +42,21 @@ export interface MeasuredBlock {
     minFirstPiece: number;
     /** The document asks for this block to stand on the same page as the start of the block after it */
     keepWithNext: boolean;
+    /**
+     * The places in the block that ask the page they land on for room at its foot, their offsets read
+     * like a candidate's with no space in the block. A block asking for none may leave it out
+     */
+    demands?: readonly PageDemand[];
 }
 /** A page cut the layout decided on: the space opened before the continued piece */
 export interface PageCut {
     at: number;
     height: number;
 }
-/** One block as it stands on the sheet, handed to the kind about to measure it */
+/**
+ * One block as it stands on the sheet, handed to the kind about to measure it and then to every
+ * demand source (`page/demands`)
+ */
 export interface MeasureTarget {
     view: EditorView;
     node: PMNode;
@@ -72,6 +81,15 @@ export interface KindMeasure {
     breakAfter: boolean;
     /** Height the engine's own marks add inside this block, taken off its measured bottom */
     appliedHeight: number;
+    /**
+     * What the engine's marks have opened at each place this block was cut, as the browser drew it,
+     * by the candidate's position. What is drawn there can come out taller than the cut asked for -
+     * a table's spacer row takes half of a collapsed border on each side - and everything else a
+     * kind reports is read off the sheet as drawn, so a place below a cut is taken back to its
+     * natural offset by this rather than by what the layout asked for (`page/measureBlocks`).
+     * A kind that opens nothing leaves it out
+     */
+    opened?: ReadonlyMap<number, number>;
     /**
      * Whether the document asks for this block to stand on the same page as the start of the block
      * after it. A kind whose blocks never do leaves it out
@@ -82,9 +100,10 @@ export interface KindMeasure {
  * Everything the engine does with one shape of breakable block: how one is measured, and how the
  * cuts the layout gave it are drawn.
  *
- * A shape the engine learns later - a footnote area, a paragraph with a floating object hanging
- * out of it - is one more kind rather than another branch in the measurer, in the decorations
- * and in the plugin state at once.
+ * A shape the engine learns later is one more kind rather than another branch in the measurer, in
+ * the decorations and in the plugin state at once. Room a place inside a block asks of the page it
+ * lands on is not a shape: a block has one kind while such a place can stand inside a block of any
+ * kind, so it is asked of every block by a demand source (`page/demands`) instead.
  */
 export interface BlockKind {
     readonly name: string;

package/dist/page/demands/footnoteDemands.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The room a footnote reference asks of the page it lands on: its footnote, drawn at the foot of
+ * that page (`ui/notes`).
+ *
+ * The sheet is measured on every layout pass and nearly every block holds no reference, so which
+ * references a block holds is read off the block node and remembered against it. A node an edit
+ * did not touch is the same node afterwards, so a pass reads nothing off the page for a block with
+ * no reference and walks only the blocks an edit rebuilt.
+ */
+import type { DemandSource } from "./index";
+/** The band footnotes are kept in, which the layout's caller hands the heights of */
+export declare const FOOTNOTE_BAND = "footnote";
+/**
+ * Where footnotes stand among the bands a page keeps (`DemandBand.order`). Word sets them at the
+ * very foot of the body, under anything else the page holds there, so this is the last place
+ */
+export declare const FOOTNOTE_BAND_ORDER = 0;
+export declare const footnoteDemands: DemandSource;

package/dist/page/demands/footnoteDemands.js

@@ -0,0 +1,51 @@
+// src/page/demands/footnoteDemands.ts
+import { docxSchema } from "../../schema/index.js";
+import { storyKey } from "../../schema/stories.js";
+var FOOTNOTE_BAND = "footnote";
+var FOOTNOTE_BAND_ORDER = 0;
+var BAND_NOTE_KINDS = ["footnote"];
+var NO_REFERENCES = [];
+var NO_DEMANDS = [];
+var held = /* @__PURE__ */ new WeakMap();
+function footnoteReferencesIn(block) {
+  const remembered = held.get(block);
+  if (remembered) return remembered;
+  const found = [];
+  block.descendants((node, offset) => {
+    if (node.type !== docxSchema.nodes.noteReference) return true;
+    const id = node.attrs.id;
+    const kind = BAND_NOTE_KINDS.find(
+      (candidate) => candidate === node.attrs.kind
+    );
+    if (kind !== void 0 && typeof id === "string") {
+      found.push({ offset, key: storyKey(kind, id) });
+    }
+    return false;
+  });
+  const references = found.length === 0 ? NO_REFERENCES : found;
+  held.set(block, references);
+  return references;
+}
+var footnoteDemands = {
+  name: "footnote",
+  demandsIn({ view, node, pos, sheetY, top }) {
+    const references = footnoteReferencesIn(node);
+    if (references.length === 0) return NO_DEMANDS;
+    return references.flatMap(({ offset, key }) => {
+      const drawn = view.nodeDOM(pos + 1 + offset);
+      if (!(drawn instanceof Element)) return [];
+      return [
+        {
+          offset: sheetY(drawn.getBoundingClientRect().top) - top,
+          id: key,
+          band: FOOTNOTE_BAND
+        }
+      ];
+    });
+  }
+};
+export {
+  FOOTNOTE_BAND,
+  FOOTNOTE_BAND_ORDER,
+  footnoteDemands
+};

package/dist/page/demands/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Room a place inside a block asks the page it lands on to keep at the foot of its body.
+ *
+ * A block has one kind (`page/blockKinds`), and a place asking for room can stand inside a block of
+ * any kind: a paragraph, or a paragraph in a table cell. So what asks is not a kind but a source,
+ * and every registered source is asked about every block whatever its kind. The layout
+ * (`page/pageLayout`) knows a demand by its band alone, never by what put it there.
+ */
+import type { MeasureTarget } from "../blockKinds";
+/** Room one place in a block asks the page it lands on to keep at the foot */
+export interface PageDemand {
+    /**
+     * The place's top from the block's natural top. A source reads it off the sheet as drawn, the
+     * way a kind reads a candidate (`target.sheetY(viewportY) - target.top`), and the measurement
+     * takes back off the spaces the engine opened inside the block above that place
+     * (`page/measureBlocks`), so no source has to know what any kind draws
+     */
+    readonly offset: number;
+    /** What is kept. One id is kept once on a page, however many places on it ask for it */
+    readonly id: string;
+    /** The band at the foot of the page that keeps it (`DemandBand`) */
+    readonly band: string;
+}
+export interface DemandSource {
+    readonly name: string;
+    demandsIn(target: MeasureTarget): readonly PageDemand[];
+}
+export interface DemandBand {
+    /**
+     * Where this band stands among the bands one page keeps, counted up from the foot of the body:
+     * 0 stands at the very foot and a higher number above it, between the text and the band below.
+     * Without it a page would stack its bands in the order its text happened to reach them, so the
+     * same two bands could come out one way round on one page and the other way round on the next.
+     * Two bands a page may hold together name two different places
+     */
+    readonly order: number;
+    /** Height a page adds once when it holds any demand of this band */
+    readonly overhead: number;
+    /** The height each id takes in the band. An id not measured yet takes none */
+    readonly heights: ReadonlyMap<string, number>;
+}
+/** The sources the editor asks about every block, in the order their demands are listed */
+export declare const DEFAULT_DEMAND_SOURCES: readonly DemandSource[];

package/dist/page/demands/index.js

@@ -0,0 +1,8 @@
+// src/page/demands/index.ts
+import { footnoteDemands } from "./footnoteDemands.js";
+var DEFAULT_DEMAND_SOURCES = [
+  footnoteDemands
+];
+export {
+  DEFAULT_DEMAND_SOURCES
+};