@portone/docx-editor 0.6.0 → 0.6.1

package/dist/page/pageLayout.d.ts

@@ -19,6 +19,7 @@
 import { type PageGeometry } from "../docx/pageGeometry";
 import type { DocumentSection, SectionProperties } from "../docx/sections";
 import type { MeasuredBlock, PageCut } from "./blockKinds";
+import type { DemandBand } from "./demands";
 export type { MeasuredBlock };
 /** The paper measured in the pixels the sheet is drawn with */
 export interface PagePixels {
@@ -128,6 +129,51 @@ export interface PageStart {
      */
     crossed: boolean;
 }
+/** The room one page keeps at the foot of its body for one band (`page/demands`) */
+export interface PageReservation {
+    page: number;
+    band: string;
+    /** The ids the page keeps, in the order it took them: those carried over from the page before first */
+    ids: readonly string[];
+    /**
+     * Where the band starts, measured from the top of the body like a split. The bands a page keeps
+     * stand one under the next in the order it took them, from the end of its body above the room.
+     * A page that could not give its bands all the room they ask for gives them what lies under the
+     * text that has to stay on it, so a band starts no higher than that text ends
+     */
+    top: number;
+    /**
+     * The band's overhead and the height of each id, which the page's body ends above. A demand
+     * taller than an empty page's body is counted whole, though the page has less to give it
+     */
+    height: number;
+}
+/**
+ * Rows laid after the last block of the document rather than beside any place in it
+ * (`page/demands`), which is where the endnotes stand.
+ *
+ * They are given whatever the last page has left below its text, and go on down pages of their
+ * own from there. Nothing in the layout knows what they hold: a row is an id and a height, and
+ * what draws them is told back which page each landed on.
+ */
+export interface TrailingRows {
+    /** Height set aside once, above the first row, wherever the rows begin */
+    readonly overhead: number;
+    readonly rows: readonly {
+        readonly id: string;
+        readonly height: number;
+    }[];
+}
+/** The trailing rows one page holds, top to bottom */
+export interface TrailingPlacement {
+    page: number;
+    /** Where the rows begin on this page, measured from the top of the body like a split */
+    top: number;
+    /** The rows this page holds, in the order they are laid */
+    ids: readonly string[];
+    /** The rows' heights, and the overhead on the page the rows begin on */
+    height: number;
+}
 export interface PageLayout {
     /** Only the blocks to be moved down to the next page */
     pushes: BlockPush[];
@@ -144,6 +190,10 @@ export interface PageLayout {
      * margin needs the sheet drawn down to this.
      */
     marginBottom: number;
+    /** What each page keeps at its foot, page by page, one entry per band a page holds */
+    reserved: readonly PageReservation[];
+    /** Where the rows laid after the last block landed, one entry per page holding any */
+    trailing: readonly TrailingPlacement[];
 }
 export interface PageLayoutInput {
     blocks: readonly MeasuredBlock[];
@@ -153,6 +203,16 @@ export interface PageLayoutInput {
      * unless that section is `continuous`.
      */
     sections: readonly SectionPixels[];
+    /**
+     * The bands the blocks' demands are kept in, by name. A demand naming a band not given here is
+     * kept nowhere, so with none given the pages are the ones the blocks alone come to
+     */
+    bands?: ReadonlyMap<string, DemandBand>;
+    /**
+     * The rows laid after the last block, which open pages of their own where the last page has no
+     * room left for them. Left out, the pages end with the blocks
+     */
+    trailing?: TrailingRows;
 }
 /**
  * Distributes the blocks across pages.
@@ -169,5 +229,21 @@ export interface PageLayoutInput {
  * after it and the first piece of the block the keeps end at.
  * Each block is measured against the paper of its own section, and the first block of a section
  * opens a page of its own unless the section it opens declares `continuous`.
+ *
+ * A demand (`page/demands`) asks the page its place lands on for room at the foot, and that page's
+ * body ends above the room: whatever would stand in it is pushed, parted or crossed onto the next
+ * page exactly as at the end of the paper, the demand's own piece included when the room it asks
+ * for does not fit beneath that piece. The page ends and page tops stay where the paper puts them,
+ * except the place a block taller than a page crosses, which is the end of the body above the room.
+ * A demand is never parted. Where the content that has to stay on a page leaves no room for it, it
+ * is carried whole to the top of the next page's band with every demand after it on that page, and
+ * past the last block a page is opened for them; one taller than an empty page's body could fit
+ * nowhere, so it stays where it landed. A block that opens its page is never pushed off it to make
+ * room, which would leave a page holding nothing but what was carried onto it.
+ *
+ * The trailing rows are laid last, under the last block on the page it ends on, and go on down
+ * pages of their own where that page has no room left. They stand above whatever that page keeps
+ * at its foot, the way the text does, and a page opened for them belongs to the section the last
+ * block belongs to, so it carries that section's header and footer.
  */
-export declare function pageLayout({ blocks, sections }: PageLayoutInput): PageLayout;
+export declare function pageLayout({ blocks, sections, bands, trailing: trailingRows, }: PageLayoutInput): PageLayout;

package/dist/page/pageLayout.js

@@ -58,6 +58,60 @@ var TOLERANCE_PX = 0.5;
 function round(value) {
   return Math.round(value * 100) / 100;
 }
+var NO_BANDS = /* @__PURE__ */ new Map();
+var NO_DEMANDS = [];
+function emptyRoom() {
+  return { bands: /* @__PURE__ */ new Map(), kept: [], height: 0 };
+}
+function keep(bands, room, taken) {
+  const { demand } = taken;
+  const band = bands.get(demand.band);
+  if (!band || room.bands.get(demand.band)?.has(demand.id)) return;
+  const ids = room.bands.get(demand.band);
+  if (ids) {
+    ids.add(demand.id);
+  } else {
+    room.bands.set(demand.band, /* @__PURE__ */ new Set([demand.id]));
+    room.height += band.overhead;
+  }
+  room.kept.push(taken);
+  room.height += band.heights.get(demand.id) ?? 0;
+}
+function letGo(bands, room) {
+  const taken = room.kept.pop();
+  const band = taken && bands.get(taken.demand.band);
+  const ids = taken && room.bands.get(taken.demand.band);
+  if (!taken || !band || !ids) return void 0;
+  ids.delete(taken.demand.id);
+  room.height -= band.heights.get(taken.demand.id) ?? 0;
+  if (ids.size === 0) {
+    room.bands.delete(taken.demand.band);
+    room.height -= band.overhead;
+  }
+  if (room.kept.length === 0) room.height = 0;
+  return taken;
+}
+function bandHeight(band, ids) {
+  let height = band.overhead;
+  for (const id of ids) height += band.heights.get(id) ?? 0;
+  return height;
+}
+function roomAdded(bands, room, demands) {
+  if (demands.length === 0) return 0;
+  const trial = {
+    bands: new Map(
+      Array.from(room.bands, ([name, ids]) => [name, new Set(ids)])
+    ),
+    kept: [...room.kept],
+    height: room.height
+  };
+  for (const demand of demands) keep(bands, trial, { demand, order: 0 });
+  return trial.height - room.height;
+}
+function demandsInOrder(block) {
+  const demands = block.demands ?? NO_DEMANDS;
+  return demands.length < 2 ? demands : [...demands].sort((a, b) => a.offset - b.offset);
+}
 function withinSections(pages, sections) {
   let section = null;
   let within = 0;
@@ -101,10 +155,17 @@ function keptExtents(blocks, laid) {
   settle();
   return extents;
 }
-function pageLayout({ blocks, sections }) {
+function pageLayout({
+  blocks,
+  sections,
+  bands = NO_BANDS,
+  trailing: trailingRows
+}) {
   const pushes = [];
   const cuts = [];
   const splits = [];
+  const reserved = [];
+  const trailing = [];
   let blockPos = blocks[0]?.pos ?? 0;
   const opened = [
     { page: 1, bodyStart: 0, pos: blockPos, crossed: false }
@@ -119,7 +180,9 @@ function pageLayout({ blocks, sections }) {
       splits,
       pages: withinSections(opened, sections),
       bodyHeight: 0,
-      marginBottom: 0
+      marginBottom: 0,
+      reserved,
+      trailing
     };
   }
   const blockSections = blocks.map(
@@ -136,16 +199,82 @@ function pageLayout({ blocks, sections }) {
   let cursor = 0;
   let paper = laid[0]?.paper ?? roomy;
   const stepTo = (opening) => paper.pageStep - paper.marginTop + opening.marginTop;
+  let room = emptyRoom();
+  let carried = [];
+  let reached = 0;
+  let held = 0;
+  const reservedHere = () => Math.min(room.height, Math.max(0, pageStart + paper.bodyHeight - held));
+  const bodyEnd = () => pageStart + paper.bodyHeight - reservedHere();
+  const endsOnPage = (bottom) => bottom <= pageStart + paper.bodyHeight + TOLERANCE_PX;
+  const settle = (floor, onPaper = paper) => {
+    held = Math.max(held, floor);
+    while (held + room.height > pageStart + onPaper.bodyHeight + TOLERANCE_PX) {
+      const last = room.kept.at(-1);
+      if (last === void 0 || roomAdded(bands, emptyRoom(), [last.demand]) > onPaper.bodyHeight + TOLERANCE_PX) {
+        return;
+      }
+      letGo(bands, room);
+      carried.push(last);
+    }
+  };
+  const recordRoom = (page) => {
+    const held2 = [...room.bands].flatMap(([name, ids]) => {
+      const band = bands.get(name);
+      return band ? [{ name, ids, band }] : [];
+    }).sort((a, b) => b.band.order - a.band.order);
+    let top = bodyEnd();
+    for (const { name, ids, band } of held2) {
+      const height = bandHeight(band, ids);
+      reserved.push({
+        page,
+        band: name,
+        ids: [...ids],
+        top: round(top),
+        height: round(height)
+      });
+      top += height;
+    }
+  };
   const split = (y, crossed, forced, opening = paper) => {
     const page = splits.length + 2;
+    recordRoom(page - 1);
     splits.push({ y: round(y), page, forced, crossed });
     pageStart = crossed ? y : y + stepTo(opening);
     opened.push({ page, bodyStart: round(pageStart), pos: blockPos, crossed });
+    room = emptyRoom();
+    held = pageStart;
+    const waiting = carried;
+    carried = [];
+    waiting.sort((a, b) => a.order - b.order);
+    for (const taken of waiting) keep(bands, room, taken);
+    settle(pageStart, opening);
   };
   const crossTo = (y) => {
-    while (y > pageStart + paper.bodyHeight + TOLERANCE_PX) {
-      split(pageStart + paper.bodyHeight, true, false);
+    while (y > bodyEnd() + TOLERANCE_PX) {
+      const end = bodyEnd();
+      split(
+        end > pageStart + TOLERANCE_PX ? end : pageStart + paper.bodyHeight,
+        true,
+        false
+      );
+    }
+  };
+  const place = (bottom, demands, placeOf) => {
+    for (const demand of demands) {
+      if (!bands.has(demand.band)) continue;
+      if (!endsOnPage(bottom)) crossTo(placeOf(demand));
+      const taken = { demand, order: reached };
+      reached += 1;
+      const alreadyKept = room.bands.get(demand.band)?.has(demand.id) === true;
+      if (carried.length > 0 && !alreadyKept) {
+        carried.push(taken);
+      } else {
+        keep(bands, room, taken);
+        settle(placeOf(demand));
+      }
     }
+    if (endsOnPage(bottom)) settle(bottom);
+    crossTo(bottom);
   };
   const kept = keptExtents(blocks, laid);
   let breakAfterPrevious = false;
@@ -159,7 +288,10 @@ function pageLayout({ blocks, sections }) {
     const first = kept.get(index) ?? block.minFirstPiece;
     const overflows = top + first > pageEnd + TOLERANCE_PX;
     const fits = first <= opening.bodyHeight + TOLERANCE_PX;
-    const push = startsPage || overflows && fits ? Math.max(0, pageEnd + stepTo(opening) - top) : 0;
+    const demands = demandsInOrder(block);
+    const firstDemands = demands.length === 0 ? NO_DEMANDS : demands.filter((demand) => demand.offset < first);
+    const crowded = top > pageStart + TOLERANCE_PX && top + first + roomAdded(bands, room, firstDemands) > bodyEnd() + TOLERANCE_PX && first + roomAdded(bands, emptyRoom(), firstDemands) <= opening.bodyHeight + TOLERANCE_PX;
+    const push = startsPage || overflows && fits || crowded ? Math.max(0, pageEnd + stepTo(opening) - top) : 0;
     if (push > 0 || startsPage) split(pageEnd, false, startsPage, opening);
     paper = opening;
     if (push > 0) {
@@ -173,15 +305,23 @@ function pageLayout({ blocks, sections }) {
     const pageBodyHeight = paper.bodyHeight;
     let added = 0;
     let pieceStart = 0;
+    let untaken = 0;
     for (let index2 = 0; index2 <= block.candidates.length; index2 += 1) {
       const cut = index2 === 0 ? null : block.candidates[index2 - 1];
-      const pieceEnd = block.candidates[index2]?.offset ?? block.height;
+      const next = block.candidates[index2];
+      const pieceEnd = next?.offset ?? block.height;
+      const taken = untaken;
+      while (untaken < demands.length && (next === void 0 || (demands[untaken]?.offset ?? 0) < pieceEnd)) {
+        untaken += 1;
+      }
+      const pieceDemands = taken === untaken ? NO_DEMANDS : demands.slice(taken, untaken);
       const pieceTop = contentTop + pieceStart + added;
       let pieceBottom = contentTop + pieceEnd + added;
       if (cut) {
         if (cut.forced) crossTo(pieceTop);
         const pageBottom = pageStart + pageBodyHeight;
-        const cutHere = cut.forced || pieceBottom > pageBottom + TOLERANCE_PX && pieceTop > pageStart + TOLERANCE_PX && pieceEnd - pieceStart <= pageBodyHeight + TOLERANCE_PX;
+        const size = pieceEnd - pieceStart;
+        const cutHere = cut.forced || pieceTop > pageStart + TOLERANCE_PX && (pieceBottom > pageBottom + TOLERANCE_PX && size <= pageBodyHeight + TOLERANCE_PX || pieceBottom + roomAdded(bands, room, pieceDemands) > bodyEnd() + TOLERANCE_PX && size + roomAdded(bands, emptyRoom(), pieceDemands) <= pageBodyHeight + TOLERANCE_PX);
         if (cutHere) {
           split(pageBottom, false, cut.forced);
           const height = Math.max(0, pageStart - pieceTop);
@@ -190,12 +330,47 @@ function pageLayout({ blocks, sections }) {
           pieceBottom += height + cut.repeatHeight;
         }
       }
-      crossTo(pieceBottom);
+      const shift = contentTop + added;
+      place(pieceBottom, pieceDemands, (demand) => shift + demand.offset);
       pieceStart = pieceEnd;
     }
     cursor = contentTop + block.height + added;
     breakAfterPrevious = block.breakAfter;
   }
+  const drainCarried = () => {
+    while (carried.length > 0) {
+      split(pageStart + paper.bodyHeight, false, false);
+    }
+  };
+  drainCarried();
+  let laidHere;
+  let below = Math.max(cursor, pageStart);
+  for (const [at, row] of (trailingRows?.rows ?? []).entries()) {
+    const above = at === 0 ? trailingRows?.overhead ?? 0 : 0;
+    const opens = below + above + row.height > bodyEnd() + TOLERANCE_PX && below > pageStart + TOLERANCE_PX;
+    if (opens) {
+      laidHere = void 0;
+      split(pageStart + paper.bodyHeight, false, false);
+      below = pageStart;
+    }
+    const top = below + above;
+    if (laidHere === void 0) {
+      laidHere = {
+        page: splits.length + 1,
+        top: round(below),
+        ids: [row.id],
+        height: round(above + row.height)
+      };
+      trailing.push(laidHere);
+    } else {
+      laidHere.ids = [...laidHere.ids, row.id];
+      laidHere.height = round(laidHere.height + row.height);
+    }
+    below = top + row.height;
+    settle(below);
+  }
+  drainCarried();
+  recordRoom(splits.length + 1);
   return {
     pushes,
     cuts,
@@ -203,7 +378,9 @@ function pageLayout({ blocks, sections }) {
     pages: withinSections(opened, sections),
     // The last page is filled out in full on the paper of the section it opens with
     bodyHeight: round(pageStart + paper.bodyHeight),
-    marginBottom: paper.marginBottom
+    marginBottom: paper.marginBottom,
+    reserved,
+    trailing
   };
 }
 export {

package/dist/page/usePageLayout.d.ts

@@ -10,7 +10,8 @@
  */
 import type { EditorView } from "prosemirror-view";
 import { type RefObject } from "react";
-import { type SectionPixels } from "./pageLayout";
+import type { DemandBand } from "./demands";
+import { type SectionPixels, type TrailingRows } from "./pageLayout";
 /** One place where a page parts from the next. The position is measured on the sheet */
 export interface PageMark {
     page: number;
@@ -19,6 +20,33 @@ export interface PageMark {
     height: number;
     crossed: boolean;
 }
+/** The room one page keeps at the foot of its body for one band, measured on the sheet */
+export interface ReservedRoom {
+    band: string;
+    /** What the page keeps there, in the order it took them (`page/pageLayout`) */
+    ids: readonly string[];
+    top: number;
+    /**
+     * The height the page gives the band, down to the end of its body. Less than the band asks for
+     * where it holds more than the page could give it
+     */
+    height: number;
+    /** Whether the band asks for more than that height */
+    clipped: boolean;
+}
+/** The rows laid after the last block that one page holds, measured on the sheet */
+export interface TrailingRoom {
+    /** What the page holds, in the order they are laid (`page/pageLayout`) */
+    ids: readonly string[];
+    top: number;
+    /**
+     * The height the page gives the rows, down to the end of its body. Less than they ask for where
+     * one of them is taller than the room the page had left
+     */
+    height: number;
+    /** Whether the rows ask for more than that height */
+    clipped: boolean;
+}
 /** The paper area of one visual page, used to place its header and footer stories. */
 export interface PageFace {
     page: number;
@@ -34,6 +62,13 @@ export interface PageFace {
     left: number;
     width: number;
     crossed: boolean;
+    /** What the page keeps at the foot of its body, one entry per band, top to bottom */
+    reserved: readonly ReservedRoom[];
+    /**
+     * The rows laid after the last block that landed on this page, measured on the sheet, and null
+     * for a page holding none (`page/pageLayout`)
+     */
+    trailing: TrailingRoom | null;
 }
 export interface PageOverlay {
     left: number;
@@ -55,6 +90,26 @@ interface PageLayoutOptions {
      * change by the caller. A4 where a document names none, and where none is open
      */
     sections?: readonly SectionPixels[];
+    /**
+     * The bands the demands of the text are kept in (`page/demands`), by name. Left out, the pages
+     * are the ones the blocks alone come to, which is also what a document asking for no room
+     * should be laid out through. A new value lays the pages out again
+     */
+    bands?: ReadonlyMap<string, DemandBand>;
+    /**
+     * The rows laid after the last block of the document, which open pages of their own where the
+     * last page has no room left for them. A new value lays the pages out again
+     */
+    trailing?: TrailingRows;
+    /**
+     * Whether anything drawn over the sheet besides the body is composing, such as the view over a
+     * note being edited.
+     *
+     * A measurement moves the room a band is kept in, and what is drawn in that room is drawn again
+     * wherever it lands, which would take an open composition down with it. So the frame is taken
+     * again until that composition is over, the way it is for the body's own.
+     */
+    composing?: () => boolean;
 }
-export declare function usePageLayout({ view, layer, enabled, revision, sections, }: PageLayoutOptions): PageOverlay | null;
+export declare function usePageLayout({ view, layer, enabled, revision, sections, bands, trailing, composing, }: PageLayoutOptions): PageOverlay | null;
 export {};

package/dist/page/usePageLayout.js

@@ -14,6 +14,18 @@ import {
   pageLayout,
   sectionPaperAt
 } from "./pageLayout.js";
+var NO_ROOM = [];
+function trailingOn(placement, contentTop, bodyBottom) {
+  if (placement === void 0) return null;
+  const top = contentTop + placement.top;
+  const height = Math.max(0, bodyBottom - top);
+  return {
+    ids: placement.ids,
+    top,
+    height: Math.min(placement.height, height),
+    clipped: placement.height > height
+  };
+}
 function useFrameThrottle(run, hold) {
   const latest = useRef({ run, hold });
   const frame = useRef(0);
@@ -51,7 +63,10 @@ function usePageLayout({
   layer,
   enabled,
   revision,
-  sections
+  sections,
+  bands,
+  trailing,
+  composing
 }) {
   const [overlay, setOverlay] = useState(null);
   const papers = sections === void 0 || sections.length === 0 ? A4_SECTION_PIXELS : sections;
@@ -60,7 +75,19 @@ function usePageLayout({
       const box = layer.current;
       if (!view || !box || !enabled) return;
       const measured = measureSheet(view, box);
-      const layout = pageLayout({ blocks: measured.blocks, sections: papers });
+      const layout = pageLayout({
+        blocks: measured.blocks,
+        sections: papers,
+        bands,
+        trailing
+      });
+      const roomOn = /* @__PURE__ */ new Map();
+      for (const room of layout.reserved) {
+        roomOn.set(room.page, [...roomOn.get(room.page) ?? [], room]);
+      }
+      const laidOn = new Map(
+        layout.trailing.map((placement) => [placement.page, placement])
+      );
       const paperOf = (pos) => sectionPaperAt(papers, pos);
       const sheet = paperOf(0);
       setPageMarks(view, { pushes: layout.pushes, cuts: layout.cuts });
@@ -83,6 +110,7 @@ function usePageLayout({
         pages: layout.pages.map((start) => {
           const paper = paperOf(start.pos);
           const paperTop = measured.contentTop + start.bodyStart - (start.crossed ? 0 : paper.marginTop);
+          const bodyBottom = measured.contentTop + start.bodyStart + paper.bodyHeight;
           return {
             page: start.page,
             pos: start.pos,
@@ -91,19 +119,36 @@ function usePageLayout({
             footerTop: paperTop + paper.pageHeight - paper.marginBottom / 2,
             left: sheet.marginLeft,
             width: sheet.bodyWidth,
-            crossed: start.crossed
+            crossed: start.crossed,
+            trailing: trailingOn(
+              laidOn.get(start.page),
+              measured.contentTop,
+              bodyBottom
+            ),
+            reserved: roomOn.get(start.page)?.map((room) => {
+              const top = measured.contentTop + room.top;
+              const height = Math.max(0, bodyBottom - top);
+              return {
+                band: room.band,
+                ids: room.ids,
+                top,
+                height: Math.min(room.height, height),
+                clipped: room.height > height
+              };
+            }) ?? NO_ROOM
           };
         })
       };
       setOverlay((previous) => sameOverlay(previous, next) ? previous : next);
     },
-    () => view?.composing === true
+    () => view?.composing === true || composing?.() === true
   );
   useEffect(() => {
     if (enabled) remeasure();
-  }, [remeasure, revision, enabled]);
+  }, [remeasure, revision, enabled, bands, trailing]);
   useEffect(() => {
     if (enabled) return;
+    setOverlay(null);
     layer.current?.style.removeProperty(editorCssVariables.sheetHeight);
     if (!view) return;
     setPageMarks(view, { pushes: [], cuts: [] });

package/dist/schema/attrRoles.js

@@ -103,8 +103,9 @@ var NODE_ATTR_ROLES = {
     id: { role: "source", class: "identity" },
     customMarkFollows: { role: "source", class: "model" },
     referenceXml: { role: "source", class: "preserved" },
-    // Worked out from the notes part as the document was opened, and the writer puts back the
-    // reference alone: a note renumbered around an edit is the same reference it was
+    // Worked out again from the reference order and the numbering properties after every edit that
+    // moves them (`docx/notes/numbering`), and the writer puts back the reference alone: a note
+    // renumbered around an edit is the same reference it was
     label: { role: "display", class: "derived" }
   },
   rawRunContent: {

package/dist/schema/docxSchema.js

@@ -35,6 +35,7 @@ import {
   tableStyle
 } from "../styles/inlineStyle.js";
 import { imageNodeSpec, runMarkSpec } from "./rendering.js";
+import { noteName } from "./stories.js";
 import { WRAPPER_ATTRS, WRAPPER_GROUP } from "./wrappers.js";
 import { imageNodeSpec as imageNodeSpec2, runMarkSpec as runMarkSpec2 } from "./rendering.js";
 var NO_STORIES = Object.freeze({});
@@ -790,7 +791,6 @@ var docxSchema = new Schema({
         referenceXml: { default: null }
       },
       toDOM(node) {
-        const kind = node.attrs.kind === "endnote" ? "Endnote" : "Footnote";
         const label = text(node.attrs.label) ?? "?";
         return [
           "sup",
@@ -801,7 +801,10 @@ var docxSchema = new Schema({
             "data-note-label": label,
             "data-custom-mark-follows": node.attrs.customMarkFollows === true ? "1" : void 0,
             "data-reference-xml": text(node.attrs.referenceXml),
-            "aria-label": `${kind} ${label}`
+            "aria-label": noteName(
+              node.attrs.kind === "endnote" ? "endnote" : "footnote",
+              label
+            )
           },
           node.attrs.customMarkFollows === true ? "" : label
         ];

package/dist/schema/editGuard.d.ts

@@ -46,7 +46,7 @@ export type EditIntent =
  * against the places it puts that guard to the test, and a place naming a guard that no longer
  * stands has to be a mistake the compiler catches rather than an annotation answering for nothing.
  */
-export type EditGuardName = "protection" | "lock" | "preserved" | "note" | "section";
+export type EditGuardName = "protection" | "lock" | "preserved" | "section";
 /** What every guard answers, whichever of the two judgements it is written as */
 interface GuardCommon {
     readonly name: EditGuardName;

package/dist/schema/guards.js

@@ -4,7 +4,7 @@ import {
   transactionReaches
 } from "./editGuard.js";
 import { lockGuard } from "./locks.js";
-import { noteGuard, preservedGuard, sectionGuard } from "./preservedGuards.js";
+import { preservedGuard, sectionGuard } from "./preservedGuards.js";
 import {
   isCommentNode,
   protectionAllows
@@ -37,7 +37,6 @@ var EDIT_GUARDS = [
   protectionGuard,
   lockGuard,
   preservedGuard,
-  noteGuard,
   sectionGuard
 ];
 function judgesSteps(guard) {

package/dist/schema/preservedGuards.d.ts

@@ -1,15 +1,14 @@
 /**
  * The guards over what a document is opened with and the editor only preserves: the fragments a
- * file falls apart without, the reference standing where a footnote or an endnote is called, and
- * the paragraph that ends a section.
+ * file falls apart without, and the paragraph that ends a section.
  *
  * The first of those is the two ends of a bookmark range, the two ends of a permission or move
  * range, and the pieces of a field, which say what they say only in the order they stand in. None
  * of it is content the editor writes, so nothing in it can put such a thing back once it is gone,
  * and a document that lost one of a bookmark's two ends cannot be written back as a file at all
- * (`docx/exportDocx` refuses it). What the first two guards hold is therefore the whole list of
- * the nodes they answer for, in the order the document carries them; a section break, which an
- * edit may legitimately move from one paragraph to another, is held by its number instead.
+ * (`docx/exportDocx` refuses it). What that guard holds is therefore the whole list of the nodes
+ * it answers for, in the order the document carries them; a section break, which an edit may
+ * legitimately move from one paragraph to another, is held by its number instead.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type ChangeGuard, type EditGuardName } from "./editGuard";
@@ -30,7 +29,6 @@ type Signature = (node: PMNode) => string;
  */
 export declare function preservedNodeGuard(name: EditGuardName, holds: (node: PMNode) => boolean, signature: Signature): ChangeGuard;
 export declare const preservedGuard: ChangeGuard;
-export declare const noteGuard: ChangeGuard;
 /**
  * A guard that lets a change through only while it leaves at least as many section breaks standing
  * as it found.