@portone/docx-editor 0.5.1 → 0.6.1

package/dist/docx/importDocx.js

@@ -37,7 +37,12 @@ import { readLinkTargets } from "./hyperlink.js";
 import { NO_IMPORT_SOURCES } from "./importParagraph.js";
 import { readImageSources } from "./media.js";
 import { NUMBERING_REL_TYPE } from "./newLists.js";
-import { readNotes } from "./notes.js";
+import { withNoteLabels } from "./notes/numbering.js";
+import {
+  readNoteNumbering,
+  readNotes,
+  specialNotesOf
+} from "./notes/reading.js";
 import { readPart, relatedPartPath } from "./packageParts.js";
 import { A4_PORTRAIT } from "./pageGeometry.js";
 import { readRelationships } from "./relationships.js";
@@ -215,25 +220,13 @@ function readDocx(input) {
   );
   const comments = readComments(parts, mainPartPath);
   const notes = readNotes(parts, mainPartPath);
-  const noteLabels = {
-    footnote: /* @__PURE__ */ new Map(),
-    endnote: /* @__PURE__ */ new Map()
-  };
-  const noteLabel = (kind, id) => {
-    const labels = noteLabels[kind];
-    const existing = labels.get(id);
-    if (existing) return existing;
-    const label = `${labels.size + 1}`;
-    labels.set(id, label);
-    return label;
-  };
+  const noteNumbering = readNoteNumbering(settingsDom);
+  const specialNotes = specialNotesOf(notes);
   const sources = {
     images: readImageSources(parts, mainPartPath),
     themeFonts,
     links: readLinkTargets(parts, mainPartPath),
-    comments,
-    notes,
-    noteLabel
+    comments
   };
   const sessionId = newSessionId();
   const headerFooters = readHeaderFooterStories(
@@ -275,14 +268,18 @@ function readDocx(input) {
       )
     );
   }
-  const doc = docxSchema.nodes.doc.create(
-    {
-      sectPr: scan.sectPr,
-      stories: Object.fromEntries(
-        Array.from(stories, ([key, story]) => [key, story.doc.toJSON()])
-      )
-    },
-    blockNodes
+  const doc = withNoteLabels(
+    docxSchema.nodes.doc.create(
+      {
+        sectPr: scan.sectPr,
+        stories: Object.fromEntries(
+          Array.from(stories, ([key, story]) => [key, story.doc.toJSON()])
+        )
+      },
+      blockNodes
+    ),
+    noteNumbering,
+    specialNotes
   );
   return {
     doc,
@@ -294,7 +291,7 @@ function readDocx(input) {
       documentPrefix: scan.prefix,
       documentSuffix: scan.suffix,
       documentHadBom: hadBom,
-      blocks: blockNodes.map((node, i) => ({
+      blocks: doc.children.map((node, i) => ({
         xml: scan.blocks[i]?.xml ?? "",
         node
       })),
@@ -308,7 +305,9 @@ function readDocx(input) {
       comments,
       commentReferenceIds: new Set(commentReferencesIn(doc).keys()),
       headerFooterStories: headerFooters.refs,
-      stories
+      stories,
+      noteNumbering,
+      specialNotes
     })
   };
 }

package/dist/docx/importParagraph.d.ts

@@ -19,11 +19,10 @@ import type { Node as PMNode } from "prosemirror-model";
 import { type ImportedComments } from "./comments/reading";
 import { type LinkTargets } from "./hyperlink";
 import type { ImageSources } from "./media";
-import { type ImportedNotes, type NoteKind } from "./notes";
 import { type ThemeFonts } from "./theme";
 /**
  * What the body is read with: the images its drawings can point at, the fonts a theme reference
- * resolves to, the addresses its links can point at, and the bodies of its comments and notes.
+ * resolves to, the addresses its links can point at, and the comments its references name.
  * They travel together from `docx/importDocx` down through the tables to here.
  */
 export interface ImportSources {
@@ -31,8 +30,6 @@ export interface ImportSources {
     themeFonts: ThemeFonts;
     links: LinkTargets;
     comments: ImportedComments;
-    notes: ImportedNotes;
-    noteLabel: (kind: NoteKind, id: string) => string;
 }
 export declare const NO_IMPORT_SOURCES: ImportSources;
 /**

package/dist/docx/importParagraph.js

@@ -20,7 +20,6 @@ import {
   preservationOf
 } from "./importPreserved.js";
 import { NO_IMAGES } from "./media.js";
-import { NO_NOTES, noteById } from "./notes.js";
 import { NO_THEME_FONTS } from "./theme.js";
 import { wrapperFits, wrapperKindFor } from "./wrappers.js";
 function runMark(run, themeFonts) {
@@ -47,7 +46,7 @@ function buildImage(el, marks, images) {
     marks
   );
 }
-function buildModelledRunChild(el, marks, images, comments, notes, noteLabel) {
+function buildModelledRunChild(el, marks, images, comments) {
   switch (el.localName) {
     case "t": {
       const text = el.textContent ?? "";
@@ -102,7 +101,6 @@ function buildModelledRunChild(el, marks, images, comments, notes, noteLabel) {
       const id = annotationId(el);
       if (id === null) return null;
       const kind = el.localName === "footnoteReference" ? "footnote" : "endnote";
-      const note = noteById(notes, kind, id);
       const written = attributeByLocalName(el, "customMarkFollows");
       const customMarkFollows = written !== null && (ST_OnOff.parse(written) ?? true);
       return [
@@ -110,7 +108,6 @@ function buildModelledRunChild(el, marks, images, comments, notes, noteLabel) {
           {
             kind,
             id,
-            label: note ? noteLabel(kind, id) : "?",
             customMarkFollows,
             referenceXml: serializeXml(el)
           },
@@ -123,7 +120,7 @@ function buildModelledRunChild(el, marks, images, comments, notes, noteLabel) {
       return null;
   }
 }
-function buildRunNodes(run, images, themeFonts, comments, notes, noteLabel, wrappers = []) {
+function buildRunNodes(run, images, themeFonts, comments, wrappers = []) {
   const mark = runMark(run, themeFonts);
   const marks = wrappers.reduce(
     (set, wrapper) => wrapper.addToSet(set),
@@ -134,14 +131,7 @@ function buildRunNodes(run, images, themeFonts, comments, notes, noteLabel, wrap
     const policy = policyFor(child, "r");
     if (policy.tier === "model") {
       if (child.localName === "rPr") continue;
-      const built = buildModelledRunChild(
-        child,
-        marks,
-        images,
-        comments,
-        notes,
-        noteLabel
-      );
+      const built = buildModelledRunChild(child, marks, images, comments);
       if (built !== null) {
         nodes.push(...built);
         continue;
@@ -176,9 +166,7 @@ var NO_IMPORT_SOURCES = {
   images: NO_IMAGES,
   themeFonts: NO_THEME_FONTS,
   links: NO_LINK_TARGETS,
-  comments: NO_COMMENTS,
-  notes: NO_NOTES,
-  noteLabel: () => "?"
+  comments: NO_COMMENTS
 };
 function buildModelledInline(child, sources, depth, wrappers) {
   if (child.localName === "r") {
@@ -187,8 +175,6 @@ function buildModelledInline(child, sources, depth, wrappers) {
       sources.images,
       sources.themeFonts,
       sources.comments,
-      sources.notes,
-      sources.noteLabel,
       wrappers
     );
   }

package/dist/docx/invariants.d.ts

@@ -17,7 +17,7 @@ import { type DocxSession, type SessionStore } from "./session";
 export interface ExportProblem {
     readonly code: DocxExportErrorCode;
     readonly message: string;
-    /** Where the problem stands in the document. Absent for a problem of the package or of the session */
+    /** Where the problem stands in the document. Absent for a problem of the package, of the session, or of a side story */
     readonly pos?: number;
 }
 /** The problems as the writer sees them, for a caller already inside the writer's parser scope */

package/dist/docx/invariants.js

@@ -8,6 +8,7 @@ import {
 } from "../ooxml/xml.js";
 import { visitPreservedFragments } from "../schema/preservedFragments.js";
 import { unattributedCommentAuthors } from "../schema/protection.js";
+import { HEADER_FOOTER_KINDS } from "../schema/stories.js";
 import {
   commentReferencesIn,
   commentsChanged,
@@ -22,15 +23,25 @@ import {
 } from "./comments/parts.js";
 import { unrecordedAuthors } from "./comments/people.js";
 import { currentCommentBodies } from "./comments/writing.js";
-import { identityProblems } from "./identities.js";
+import {
+  identityProblems,
+  identityProblemsInStories
+} from "./identities.js";
 import { insertedImageSrcs } from "./media.js";
 import { canDefineNewList, newNumIds, startedLists } from "./newLists.js";
 import { CONTENT_TYPES_PATH } from "./packageParts.js";
+import { STORY_ENTRIES_PARTS, STORY_WRITINGS } from "./partPlanners.js";
 import { lostOriginal } from "./serializePreserved.js";
 import {
   originalBlock,
   sessionOf
 } from "./session.js";
+import {
+  storyChangesOf,
+  storyEntriesOf,
+  storyEntriesProblems,
+  unwrittenStoryChanges
+} from "./storyParts.js";
 var bookmarkPairs = {
   name: "bookmarkPairs",
   check(doc, session) {
@@ -153,8 +164,30 @@ var preservedOriginals = {
 };
 var uniqueIdentities = {
   name: "uniqueIdentities",
-  check(doc) {
-    return identityProblems(doc);
+  check(doc, session) {
+    const parts = [
+      ...HEADER_FOOTER_KINDS.flatMap(
+        (kind) => storyChangesOf(doc, session, kind)
+      ).flatMap(
+        (change) => change.change === "edited" ? [[{ story: change.current, frozen: false }]] : []
+      ),
+      ...STORY_ENTRIES_PARTS.map((part) => storyEntriesOf(part, doc, session))
+    ];
+    return [
+      ...identityProblems(doc),
+      ...parts.flatMap((entries) => identityProblemsInStories(entries)).map(({ code, message }) => ({ code, message }))
+    ];
+  }
+};
+var storiesHaveWriters = {
+  name: "storiesHaveWriters",
+  check(doc, session) {
+    return unwrittenStoryChanges(STORY_WRITINGS, doc, session).map(
+      ({ key, change }) => ({
+        code: "unsupported-content",
+        message: `the ${key} story was ${change}, and no part writer carries that into the file`
+      })
+    );
   }
 };
 var listDefinitions = {
@@ -236,14 +269,22 @@ var commentPartRoots = {
     return problems;
   }
 };
+var notePartRoots = {
+  name: "notePartRoots",
+  check: (doc, session) => STORY_ENTRIES_PARTS.flatMap(
+    (part) => storyEntriesProblems(part, doc, session)
+  )
+};
 var EXPORT_INVARIANTS = [
   bookmarkPairs,
   tableGrids,
   preservedOriginals,
   uniqueIdentities,
   listDefinitions,
+  storiesHaveWriters,
   mediaContentTypes,
-  commentPartRoots
+  commentPartRoots,
+  notePartRoots
 ];
 var answered = /* @__PURE__ */ new WeakMap();
 function problemsOf(doc, session) {

package/dist/docx/notes/newNote.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The note an edit puts into a document: a new, empty one, and a copy of one the document holds.
+ *
+ * Both are side stories (`docx/story`), written back by the notes part writer (`./writing`) as an
+ * entry of their own, which is why a copy names none of the blocks its original was read from.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+import { type NoteKind, type StoryKey } from "../../schema/stories";
+import type { FormattingContext } from "../formatting";
+import { type SessionStore } from "../session";
+/**
+ * The elements that stand for a note's own number inside its entry, which is what Word draws the
+ * number from and what a note that keeps its number keeps (`editor/notes/noteSurface`).
+ */
+export declare const NOTE_NUMBER_ELEMENTS: readonly string[];
+/**
+ * The run properties a note's number is written with: the document's own style for it where the
+ * document defines one, and superscript where it does not.
+ */
+export declare function noteNumberRunProps(kind: NoteKind, formatting: FormattingContext): string;
+/**
+ * The story of a new note holding no text yet: one paragraph in the document's style for note
+ * text, opening with the note's number the way Word writes a note it inserts.
+ */
+export declare function newNoteStory(kind: NoteKind, formatting: FormattingContext): PMNode;
+/**
+ * Every id a note of this kind already answers to: the entries the opened part holds, the stories
+ * the document holds, and the ids the references name, whether or not a note stands behind them.
+ */
+export declare function takenNoteIds(doc: PMNode, kind: NoteKind, reserved: ReadonlySet<StoryKey>): Set<string>;
+/** The id one above the largest of these, and never below one */
+export declare function nextNoteId(taken: Iterable<string>): string;
+/**
+ * The story a copied reference's note is given: the same content, naming none of the blocks the
+ * original was read from and none of its paragraph ids, so the export writes it as an entry of its
+ * own rather than as the bytes of the original a second time (`docx/cloning`). A preserved block
+ * that only names its fragment takes the fragment's XML along.
+ */
+export declare function copiedNoteStory(story: PMNode, session: SessionStore | null): PMNode;

package/dist/docx/notes/newNote.js

@@ -0,0 +1,122 @@
+// src/docx/notes/newNote.ts
+import { Fragment } from "prosemirror-model";
+import { elementXml } from "../../ooxml/element.js";
+import { wName } from "../../ooxml/names.js";
+import { docxSchema } from "../../schema/index.js";
+import {
+  NOTE_KINDS,
+  storiesOf,
+  storyKey
+} from "../../schema/stories.js";
+import { CLONE_POLICIES } from "../cloning.js";
+import { originalBlock } from "../session.js";
+import { withStyleFormats } from "../story.js";
+var NOTE_MARKUP = {
+  footnote: {
+    textStyle: "FootnoteText",
+    referenceStyle: "FootnoteReference",
+    numberElement: "footnoteRef"
+  },
+  endnote: {
+    textStyle: "EndnoteText",
+    referenceStyle: "EndnoteReference",
+    numberElement: "endnoteRef"
+  }
+};
+var NOTE_NUMBER_ELEMENTS = NOTE_KINDS.map(
+  (kind) => NOTE_MARKUP[kind].numberElement
+);
+function noteNumberRunProps(kind, formatting) {
+  const { referenceStyle } = NOTE_MARKUP[kind];
+  const property = formatting.styles.get(referenceStyle)?.type === "character" ? elementXml(wName("rStyle"), [[wName("val"), referenceStyle]]) : elementXml(wName("vertAlign"), [[wName("val"), "superscript"]]);
+  return elementXml(wName("rPr"), [], [property]);
+}
+function noteTextProps(kind, formatting) {
+  const { textStyle } = NOTE_MARKUP[kind];
+  return formatting.styles.get(textStyle)?.type === "paragraph" ? elementXml(
+    wName("pPr"),
+    [],
+    [elementXml(wName("pStyle"), [[wName("val"), textStyle]])]
+  ) : null;
+}
+function newNoteStory(kind, formatting) {
+  const { numberElement } = NOTE_MARKUP[kind];
+  const number = docxSchema.nodes.rawRunContent.create(
+    {
+      xml: elementXml(wName(numberElement), []),
+      element: numberElement,
+      display: "chip",
+      text: null,
+      guarded: false
+    },
+    null,
+    [
+      docxSchema.marks.run.create({
+        rPr: noteNumberRunProps(kind, formatting)
+      })
+    ]
+  );
+  const paragraph = docxSchema.nodes.paragraph.create(
+    { pPr: noteTextProps(kind, formatting) },
+    number
+  );
+  return withStyleFormats(
+    docxSchema.nodes.doc.create(null, [paragraph]),
+    formatting
+  );
+}
+var DECIMAL = /^-?\d+$/;
+function takenNoteIds(doc, kind, reserved) {
+  const prefix = storyKey(kind, "");
+  const ids = new Set(
+    [...reserved, ...Object.keys(storiesOf(doc))].flatMap(
+      (key) => key.startsWith(prefix) ? [key.slice(prefix.length)] : []
+    )
+  );
+  doc.descendants((node) => {
+    const id = node.attrs.id;
+    if (node.type === docxSchema.nodes.noteReference && node.attrs.kind === kind && typeof id === "string") {
+      ids.add(id);
+    }
+    return true;
+  });
+  return ids;
+}
+function nextNoteId(taken) {
+  const largest = Array.from(taken).filter((id) => DECIMAL.test(id)).map((id) => BigInt(id)).reduce((max, id) => id > max ? id : max, 0n);
+  return (largest + 1n).toString();
+}
+function copiedBlock(node, session) {
+  if (node.isInline) return node;
+  if (node.type === docxSchema.nodes.paragraph) {
+    return node.type.create(
+      CLONE_POLICIES.paragraph.attrs(node, "copy"),
+      node.content,
+      node.marks
+    );
+  }
+  if (node.type === docxSchema.nodes.rawBlock) {
+    const held = node.attrs.xml;
+    const xml = typeof held === "string" ? held : session === null ? void 0 : originalBlock(node, session)?.xml;
+    return xml === void 0 ? node : node.type.create({ ...node.attrs, xml, srcId: null }, null, node.marks);
+  }
+  const attrs = node.attrs.srcId === void 0 || node.attrs.srcId === null ? node.attrs : { ...node.attrs, srcId: null };
+  return node.type.create(
+    attrs,
+    Fragment.fromArray(
+      node.children.map((child) => copiedBlock(child, session))
+    ),
+    node.marks
+  );
+}
+function copiedNoteStory(story, session) {
+  return copiedBlock(story, session);
+}
+export {
+  NOTE_NUMBER_ELEMENTS,
+  copiedNoteStory,
+  newNoteStory,
+  nextNoteId,
+  noteNumberRunProps,
+  takenNoteIds
+};

package/dist/docx/notes/numbering.d.ts

@@ -0,0 +1,27 @@
+import { type Node as PMNode } from "prosemirror-model";
+import { type StoryKey } from "../../schema/stories";
+import { type NoteNumbering } from "./reading";
+/**
+ * The label each note reference of the body is drawn with, by position.
+ *
+ * Each kind is counted on its own, in the order its references stand: a repeated id takes the
+ * label of its first reference since the count last started, a reference whose custom mark follows
+ * takes neither a label nor a number (§17.11.14), and one calling a separator entry is no note to
+ * count. A section's own properties lay over the settings, and a section that restarts each section
+ * counts from its start again (§17.11.19, §17.11.20), so a note referred to in an earlier section
+ * and again in this one is drawn with this section's own number, as Word draws it. A restart on
+ * each page is counted straight through, since the label would then depend on the pages, which
+ * depend in turn on how wide the labels are drawn.
+ *
+ * It reads the document and what it is handed and nothing else, so the file an edited document
+ * exports opens with the labels the editor drew.
+ */
+export declare function noteLabelsIn(doc: PMNode, numbering: NoteNumbering, special: ReadonlySet<StoryKey>): ReadonlyMap<number, string>;
+/**
+ * What `noteLabelsIn` reads off the document, as one string: the kind, id, and custom mark of each
+ * reference, which section it stands in, and what each section lays over the settings. Two
+ * documents with the same signature are labelled alike under the same numbering.
+ */
+export declare function noteLabelSignature(doc: PMNode): string;
+/** The document with every note reference labelled, and the same node where every label already stood */
+export declare function withNoteLabels(doc: PMNode, numbering: NoteNumbering, special: ReadonlySet<StoryKey>): PMNode;

package/dist/docx/notes/numbering.js

@@ -0,0 +1,120 @@
+// src/docx/notes/numbering.ts
+import { Fragment } from "prosemirror-model";
+import { spellNumber } from "../../numbering/spellers.js";
+import {
+  NOTE_KINDS,
+  storyKey
+} from "../../schema/stories.js";
+import { sectionsOf } from "../sections.js";
+import {
+  withNoteProps
+} from "./reading.js";
+var MAX_LABEL_CHARS = 64;
+function referencesBySection(doc) {
+  const found = [];
+  doc.forEach((block, offset, index) => {
+    block.descendants((node, pos) => {
+      if (node.type.name === "noteReference") {
+        found.push({
+          block: index,
+          reference: { pos: offset + 1 + pos, node }
+        });
+      }
+      return true;
+    });
+  });
+  if (found.length === 0) return [];
+  const sections = sectionsOf(doc);
+  const references = sections.map(() => []);
+  let at = 0;
+  for (const { block, reference } of found) {
+    while (block > sections[at].lastBlock) at += 1;
+    references[at].push(reference);
+  }
+  return sections.map((section, index) => ({
+    section,
+    references: references[index]
+  }));
+}
+function kindOf(node) {
+  return node.attrs.kind === "endnote" ? "endnote" : "footnote";
+}
+function idOf(node) {
+  const id = node.attrs.id;
+  return typeof id === "string" ? id : null;
+}
+function propsIn(section, numbering) {
+  return {
+    footnote: withNoteProps(numbering.footnote, section.props.footnotePr),
+    endnote: withNoteProps(numbering.endnote, section.props.endnotePr)
+  };
+}
+function restarted(count, props) {
+  count.next = props.start;
+  count.taken.clear();
+}
+function labelOf(node, count, props, special) {
+  if (node.attrs.customMarkFollows === true) return "";
+  const id = idOf(node);
+  if (id === null || special.has(storyKey(kindOf(node), id))) return "?";
+  const taken = count.taken.get(id);
+  if (taken !== void 0) return taken;
+  const label = spellNumber(count.next, props.format, MAX_LABEL_CHARS);
+  count.next += 1;
+  count.taken.set(id, label);
+  return label;
+}
+function noteLabelsIn(doc, numbering, special) {
+  const labels = /* @__PURE__ */ new Map();
+  const counts = {
+    footnote: { next: 1, taken: /* @__PURE__ */ new Map() },
+    endnote: { next: 1, taken: /* @__PURE__ */ new Map() }
+  };
+  referencesBySection(doc).forEach(({ section, references }, index) => {
+    const props = propsIn(section, numbering);
+    for (const kind of NOTE_KINDS) {
+      if (index === 0 || props[kind].restart === "eachSect") {
+        restarted(counts[kind], props[kind]);
+      }
+    }
+    for (const { pos, node } of references) {
+      const kind = kindOf(node);
+      labels.set(pos, labelOf(node, counts[kind], props[kind], special));
+    }
+  });
+  return labels;
+}
+function noteLabelSignature(doc) {
+  return JSON.stringify(
+    referencesBySection(doc).map(({ section, references }) => [
+      section.props.footnotePr,
+      section.props.endnotePr,
+      references.map(({ node }) => [
+        kindOf(node),
+        idOf(node),
+        node.attrs.customMarkFollows === true
+      ])
+    ])
+  );
+}
+function relabelled(node, contentStart, labels) {
+  const children = [];
+  let changed = false;
+  node.forEach((child, offset) => {
+    const at = contentStart + offset;
+    const label = labels.get(at);
+    const next = label !== void 0 && child.attrs.label !== label ? child.type.create({ ...child.attrs, label }, null, child.marks) : child.isLeaf ? child : relabelled(child, at + 1, labels);
+    changed ||= next !== child;
+    children.push(next);
+  });
+  return changed ? node.copy(Fragment.from(children)) : node;
+}
+function withNoteLabels(doc, numbering, special) {
+  const labels = noteLabelsIn(doc, numbering, special);
+  return labels.size === 0 ? doc : relabelled(doc, 0, labels);
+}
+export {
+  noteLabelSignature,
+  noteLabelsIn,
+  withNoteLabels
+};

package/dist/docx/notes/reading.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Reads the footnotes and endnotes parts the main part relates to: the entry each holds, which of
+ * them lays the page out rather than says anything, and how each kind is numbered.
+ *
+ * What a note says is a story of its own, read by `docx/story` out of the same part text.
+ */
+import { type NumberFormat } from "../../numbering/spellers";
+import { type NoteKind, type StoryKey } from "../../schema/stories";
+export type { NoteKind } from "../../schema/stories";
+/**
+ * One entry of a notes part as it arrived. What the note says is a story of its own, held on the
+ * document node under `footnote:<id>` or `endnote:<id>` (`docx/story`).
+ */
+export interface ImportedNote {
+    kind: NoteKind;
+    id: string;
+    type: string | null;
+}
+export interface ImportedNotePart {
+    partPath: string | null;
+    /** The raw text of the part, which is what the note stories are sliced out of. null for none */
+    xml: string | null;
+    ordered: readonly ImportedNote[];
+    byId: ReadonlyMap<string, ImportedNote>;
+}
+export interface ImportedNotes {
+    footnotes: ImportedNotePart;
+    endnotes: ImportedNotePart;
+}
+/** Reads both note parts without modifying their original package bytes. */
+export declare function readNotes(parts: Map<string, Uint8Array>, mainPartPath: string): ImportedNotes;
+/**
+ * The entries a notes part lays the page out with rather than numbers - a separator, a
+ * continuation separator, a continuation notice (§17.11.1, §17.11.23) - as the keys their stories
+ * stand under.
+ */
+export declare function specialNotesOf(notes: ImportedNotes): ReadonlySet<StoryKey>;
+/** Where the count of one kind of note goes back to its start (§17.18.74) */
+export type NoteRestart = "continuous" | "eachSect" | "eachPage";
+/** How one kind of note is counted (§17.11.17-20) */
+export interface NoteNumberingProps {
+    readonly format: NumberFormat;
+    readonly start: number;
+    readonly restart: NoteRestart;
+}
+export type NoteNumbering = Readonly<Record<NoteKind, NoteNumberingProps>>;
+export declare const DEFAULT_NOTE_NUMBERING: NoteNumbering;
+/**
+ * What one `w:footnotePr` or `w:endnotePr` names, leaving out every property it does not, and null
+ * for no element at all.
+ *
+ * A format this editor has no speller for is counted in decimal, as a list marker is.
+ */
+export declare function readNoteProps(props: Element | null): Partial<NoteNumberingProps> | null;
+/** The properties with whatever an override names laid over them (§17.11.5, §17.11.11) */
+export declare function withNoteProps(base: NoteNumberingProps, override: Partial<NoteNumberingProps> | null): NoteNumberingProps;
+/** The document-wide note properties settings.xml names (§17.11.4, §17.11.12) */
+export declare function readNoteNumbering(settings: Document | null): NoteNumbering;