@portone/docx-editor 0.6.0 → 0.6.2

package/dist/docx/sections.d.ts

@@ -11,6 +11,7 @@
  * arrived as, and a rewritten child is swapped into the spot `CT_SectPr` lays down.
  */
 import type { Node as PMNode } from "prosemirror-model";
+import { type NoteNumberingProps } from "./notes/reading";
 import { type PageGeometry } from "./pageGeometry";
 export type HeaderFooterVariant = "default" | "first" | "even";
 /** The variants a `w:headerReference` or a `w:footerReference` may name. §17.6.12, §17.6.5 */
@@ -35,6 +36,10 @@ export interface SectionProperties {
     pageNumberStart: number | null;
     /** §17.6.22 `w:type/@w:val`; null when omitted (nextPage) */
     type: "continuous" | "evenPage" | "nextPage" | "oddPage" | "nextColumn" | null;
+    /** §17.11.11 `w:footnotePr`; null where the section counts footnotes as the settings do */
+    footnotePr: Partial<NoteNumberingProps> | null;
+    /** §17.11.5 `w:endnotePr`; null where the section counts endnotes as the settings do */
+    endnotePr: Partial<NoteNumberingProps> | null;
 }
 /** What a section the document does not spell out lays down: the paper every document used to be drawn on */
 export declare const DEFAULT_SECTION: SectionProperties;

package/dist/docx/sections.js

@@ -15,6 +15,7 @@ import {
   R_NS,
   W_NS
 } from "../ooxml/xml.js";
+import { readNoteProps } from "./notes/reading.js";
 import {
   A4_PORTRAIT,
   readPageGeometry
@@ -32,7 +33,9 @@ var DEFAULT_SECTION = {
   footerRefs: NO_REFS,
   titlePg: false,
   pageNumberStart: null,
-  type: null
+  type: null,
+  footnotePr: null,
+  endnotePr: null
 };
 var SECTION_TYPES = [
   "continuous",
@@ -86,7 +89,9 @@ function readSectionProperties(sectPr) {
     footerRefs: storyRefs(sectPr, "footer"),
     titlePg: isOnElement(childByLocalName(sectPr, "titlePg")),
     pageNumberStart: pageNumberStart(sectPr),
-    type: sectionType(sectPr)
+    type: sectionType(sectPr),
+    footnotePr: readNoteProps(childByLocalName(sectPr, "footnotePr")),
+    endnotePr: readNoteProps(childByLocalName(sectPr, "endnotePr"))
   };
 }
 function parseSectionProperties(xml) {

package/dist/docx/serializeParagraph.js

@@ -1,5 +1,9 @@
 // src/docx/serializeParagraph.ts
-import { elementXml, emptyTagXml, openTagXml } from "../ooxml/element.js";
+import {
+  elementXml,
+  emptyTagXml,
+  openTagXml
+} from "../ooxml/element.js";
 import { DocxExportError } from "../ooxml/errors.js";
 import {
   imageDrawingXml,
@@ -85,8 +89,9 @@ function renderInline(node, images) {
     if (typeof original === "string") return original;
     const id = node.attrs.id;
     const name = node.attrs.kind === "endnote" ? "endnoteReference" : "footnoteReference";
+    const customMark = node.attrs.customMarkFollows === true ? [[wName("customMarkFollows"), "1"]] : [];
     if (typeof id === "string") {
-      return elementXml(wName(name), [[wName("id"), id]]);
+      return elementXml(wName(name), [...customMark, [wName("id"), id]]);
     }
     throw new DocxExportError(
       "lost-original",

package/dist/docx/serializePreserved.d.ts

@@ -7,8 +7,12 @@
  * the same way, from here.
  */
 import type { Node as PMNode } from "prosemirror-model";
+import { type ExportProblemReason, type ExportProblemStory } from "../ooxml/errors";
 import type { ExportRefs } from "./exportRefs";
 import { type SessionStore } from "./session";
 /** Why there is no original to write, which a block that came in from another document answers differently */
-export declare function lostOriginal(node: PMNode, session: SessionStore | null): string;
+export declare function lostOriginal(node: PMNode, session: SessionStore | null, story: ExportProblemStory | null): {
+    readonly message: string;
+    readonly reason: ExportProblemReason;
+};
 export declare function serializePreservedBlock(node: PMNode, refs: ExportRefs): string;

package/dist/docx/serializePreserved.js

@@ -1,20 +1,37 @@
 // src/docx/serializePreserved.ts
-import { DocxExportError } from "../ooxml/errors.js";
+import {
+  DocxExportError
+} from "../ooxml/errors.js";
 import { originalBlock, splitBlockKey } from "./session.js";
-function lostOriginal(node, session) {
+function lostOriginal(node, session, story) {
   const srcId = node.attrs.srcId;
   const key = typeof srcId === "string" ? splitBlockKey(srcId) : null;
-  return key === null || key.sessionId === session?.sessionId ? "a preserved block has lost its original XML" : `a preserved block comes from another document (${key.sessionId})`;
+  const name = node.type.name;
+  if (key === null || key.sessionId === session?.sessionId) {
+    return {
+      message: "a preserved block has lost its original XML",
+      reason: { kind: "lost-preserved-xml", node: name, story }
+    };
+  }
+  return {
+    message: `a preserved block comes from another document (${key.sessionId})`,
+    reason: {
+      kind: "preserved-from-another-document",
+      node: name,
+      sessionId: key.sessionId,
+      story
+    }
+  };
 }
 function serializePreservedBlock(node, refs) {
   const xml = node.attrs.xml;
   if (typeof xml === "string") return xml;
   const imported = refs.session ? originalBlock(node, refs.session) : void 0;
   if (!imported) {
-    throw new DocxExportError(
-      "lost-original",
-      lostOriginal(node, refs.session)
-    );
+    const { message, reason } = lostOriginal(node, refs.session, null);
+    throw new DocxExportError("lost-original", message, {
+      problem: { code: "lost-original", message, reason }
+    });
   }
   return imported.xml;
 }

package/dist/docx/session.d.ts

@@ -14,6 +14,7 @@ import { type StoryKey } from "../schema/stories";
 import type { ImportedComments } from "./comments/reading";
 import { type FormattingContext, type ParagraphStyleOption } from "./formatting";
 import type { HeaderFooterStories } from "./headersFooters";
+import type { NoteNumbering } from "./notes/reading";
 import type { PageGeometry } from "./pageGeometry";
 import type { ImportedStory } from "./story";
 export interface ImportedBlock {
@@ -83,6 +84,10 @@ export declare class SessionStore implements DocxSession, SessionIdentity {
      * instead (`docx/story`), so the two compare the way a body block and its original do.
      */
     readonly stories: ReadonlyMap<StoryKey, ImportedStory>;
+    /** How the settings count each kind of note, which a section may override (`docx/notes/numbering`) */
+    readonly noteNumbering: NoteNumbering;
+    /** The note entries that lay out the page rather than say anything: separators and the continuation notice */
+    readonly specialNotes: ReadonlySet<StoryKey>;
     constructor(opened: Omit<SessionStore, "kind" | "blocksOf">);
     /**
      * The blocks of one story as it arrived, which is what a block key of that story indexes into.

package/dist/docx/session.js

@@ -51,6 +51,10 @@ var SessionStore = class {
    * instead (`docx/story`), so the two compare the way a body block and its original do.
    */
   stories;
+  /** How the settings count each kind of note, which a section may override (`docx/notes/numbering`) */
+  noteNumbering;
+  /** The note entries that lay out the page rather than say anything: separators and the continuation notice */
+  specialNotes;
   constructor(opened) {
     this.sessionId = opened.sessionId;
     this.parts = opened.parts;
@@ -70,6 +74,8 @@ var SessionStore = class {
     this.commentReferenceIds = opened.commentReferenceIds;
     this.headerFooterStories = opened.headerFooterStories;
     this.stories = opened.stories;
+    this.noteNumbering = opened.noteNumbering;
+    this.specialNotes = opened.specialNotes;
   }
   /**
    * The blocks of one story as it arrived, which is what a block key of that story indexes into.

package/dist/docx/storyParts.d.ts

@@ -0,0 +1,133 @@
+/**
+ * The side stories a part beside the body is written from, told apart by what an edit did to each.
+ *
+ * Whether a story has to be written again is one question every story writer asks, so it is asked
+ * here once. A writer answering it for itself would be free to keep a story another writer drops,
+ * and the export invariants would have a third answer of their own.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { DocxExportErrorCode, ExportPartName, ExportProblemReason } from "../ooxml/errors";
+import { type StoryKey, type StoryKind } from "../schema/stories";
+import { type StoryToSettle } from "./identities";
+import type { PartPlanner } from "./partPlan";
+import type { SessionStore } from "./session";
+import type { ImportedStory } from "./story";
+export type StoryChange = {
+    readonly change: "kept";
+    readonly imported: ImportedStory;
+} | {
+    readonly change: "edited";
+    readonly imported: ImportedStory;
+    readonly current: PMNode;
+} | {
+    readonly change: "removed";
+    readonly imported: ImportedStory;
+} | {
+    readonly change: "added";
+    readonly key: StoryKey;
+    readonly current: PMNode;
+};
+/** Every story of this kind the package arrived with or the document now holds, in part order then id order */
+export declare function storyChangesOf(doc: PMNode, session: SessionStore, kind: StoryKind): readonly StoryChange[];
+export type StoryChanged = Exclude<StoryChange["change"], "kept">;
+export declare const EVERY_STORY_CHANGE: readonly StoryChanged[];
+/**
+ * What one part writer carries into the file: the kind of story it writes and the changes to one
+ * it writes back. A change it leaves out has nowhere to go, and `docx/invariants` refuses it.
+ */
+export interface StoryWriting {
+    readonly kind: StoryKind;
+    readonly changes: readonly StoryChanged[];
+    /** The stories it writes as the bytes they arrived as, whose change it therefore carries nowhere */
+    frozenEntries(session: SessionStore): ReadonlySet<StoryKey>;
+}
+/** What a part holding one entry per story writes, which is every change to a story of its kind */
+export declare function storyEntriesWriting(part: StoryEntriesPart): StoryWriting;
+/** A writer that takes these changes to every story of the kind, freezing none of them */
+export declare function storyWriting(kind: StoryKind, changes: readonly StoryChanged[]): StoryWriting;
+/** A change to a side story that no part writer carries into the file */
+export interface UnwrittenStoryChange {
+    readonly key: StoryKey;
+    readonly change: StoryChanged;
+}
+/**
+ * Every change the document made to a side story that no part writer carries into the file, as the
+ * key it stands under and what was done to it.
+ *
+ * A story changes on the document node whether or not a writer carries it, so a kind with no
+ * writer at all, a change a writer leaves out - a header story added or removed, which the header
+ * writer does not write - and a change to an entry written as it arrived are all reported here
+ * rather than dropped from the file without a word.
+ */
+export declare function unwrittenStoryChanges(writings: readonly StoryWriting[], doc: PMNode, session: SessionStore): readonly UnwrittenStoryChange[];
+/** One side story the export writes block by block, under the key it stands at */
+export interface RewrittenStory {
+    readonly key: StoryKey;
+    readonly story: PMNode;
+}
+/**
+ * Every side story the export writes block by block, which is every one a part writer carries an
+ * addition or an edit of.
+ *
+ * A story the writer hands back as the bytes it arrived as - one nobody touched, one its part
+ * freezes, one whose change no writer carries, which `unwrittenStoryChanges` refuses instead -
+ * goes out holding exactly what it came in holding, so nothing about it can newly be refused. The
+ * same "changed and written" answer decides both, so a writer and the invariants cannot disagree
+ * about which story is written from a node.
+ */
+export declare function rewrittenStories(writings: readonly StoryWriting[], doc: PMNode, session: SessionStore): readonly RewrittenStory[];
+/** A part holding one entry per story, e.g. `w:footnotes` holding a `w:footnote` apiece */
+export interface StoryEntriesPart {
+    readonly name: ExportPartName;
+    readonly kind: StoryKind;
+    readonly relType: string;
+    readonly contentType: string;
+    /** The file name a part this planner creates takes beside the main part, ahead of any number */
+    readonly stem: string;
+    /** The local name of the part's root element */
+    readonly root: string;
+    /** The local name of the element each story stands in */
+    readonly entry: string;
+    /** The ids the document's references to this part name, which a part this planner creates keeps clear of */
+    referencedIds(doc: PMNode): ReadonlySet<string>;
+    /**
+     * The stories this part writes as the bytes they arrived as, whatever the document now says of
+     * them, and none for a part that writes every story it holds. `docx/invariants` refuses a change
+     * to one before anything is written.
+     */
+    frozenEntries(session: SessionStore): ReadonlySet<StoryKey>;
+    /** The entries a part this planner creates opens with, before any story */
+    prelude(taken: ReadonlySet<string>): string;
+}
+/** One story a part writes, beside the key it stands under */
+export interface StoryEntry extends StoryToSettle {
+    readonly key: StoryKey;
+}
+/**
+ * The stories a part is written with, in the order it writes them, and none where no story of its
+ * kind changed and the part is not written at all. The identity pass runs over this list as one
+ * part, and the export invariants ask the same list.
+ */
+export declare function storyEntriesOf(part: StoryEntriesPart, doc: PMNode, session: SessionStore): readonly StoryEntry[];
+/** One reason the part cannot take the changes its stories went through */
+export interface StoryPartProblem {
+    readonly code: DocxExportErrorCode;
+    readonly message: string;
+    readonly reason: ExportProblemReason;
+}
+/**
+ * Why the part cannot take what the document did to its stories, or none when it can. The part the
+ * package holds is rewritten around its root element, and a part the package lacks is declared in
+ * the content types part, which the export does not write from nothing.
+ */
+export declare function storyEntriesProblems(part: StoryEntriesPart, doc: PMNode, session: SessionStore): readonly StoryPartProblem[];
+/**
+ * A planner for a part holding one entry per story.
+ *
+ * Nothing is written while every story of the kind stands as it arrived, so an untouched package
+ * hands the part back as its own bytes. Once one changed, the part is written in the order it holds
+ * its entries: an untouched entry as it arrived, an edited one again, a removed one not at all,
+ * and every story added since after them in id order. A package holding no such part gets one,
+ * with its relationship, its content type, and the entries `prelude` opens it with.
+ */
+export declare function storyEntriesPlanner(part: StoryEntriesPart): PartPlanner;

package/dist/docx/storyParts.js

@@ -0,0 +1,314 @@
+// src/docx/storyParts.ts
+import { attrsText, openTagXml } from "../ooxml/element.js";
+import { NAMESPACES, wName } from "../ooxml/names.js";
+import {
+  ensureRootDeclarations,
+  partRootProblem,
+  splicePart
+} from "../ooxml/partSplice.js";
+import { ST_DecimalNumber } from "../ooxml/simpleTypes.js";
+import { parseAttrs, readTag, rootTagAt } from "../ooxml/tagScan.js";
+import {
+  attributeByLocalName,
+  decodeUtf8,
+  elementChildren,
+  encodeUtf8,
+  parseXml
+} from "../ooxml/xml.js";
+import { sameSource } from "../schema/sourceEquality.js";
+import {
+  asStoryKey,
+  STORY_KINDS,
+  splitStoryKey,
+  storiesOf,
+  storyKey,
+  storyNodeOf
+} from "../schema/stories.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
+import { withUniqueStoryIdentities } from "./identities.js";
+import {
+  availablePartPath,
+  CONTENT_TYPES_PATH,
+  readPart,
+  relatedPartPath
+} from "./packageParts.js";
+import { directoryOf } from "./relationships.js";
+import { scanBlocksIn } from "./scan.js";
+import { serializeStory } from "./serializeStory.js";
+var DECIMAL = /^-?\d+$/;
+function byId(a, b) {
+  if (DECIMAL.test(a) && DECIMAL.test(b)) return Number(a) - Number(b);
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function arrivedChange(doc, imported) {
+  const current = storyNodeOf(doc, imported.key);
+  if (current === null) return { change: "removed", imported };
+  return sameSource(current, imported.doc) ? { change: "kept", imported } : { change: "edited", imported, current };
+}
+function storyChangesOf(doc, session, kind) {
+  const arrived = Array.from(session.stories.values()).filter((imported) => imported.kind === kind).map((imported) => arrivedChange(doc, imported));
+  const added = Object.keys(storiesOf(doc)).flatMap((text) => {
+    const key = asStoryKey(text);
+    return key === null || !key.startsWith(`${kind}:`) || session.stories.has(key) ? [] : [key];
+  }).sort((a, b) => byId(splitStoryKey(a).id, splitStoryKey(b).id)).flatMap((key) => {
+    const current = storyNodeOf(doc, key);
+    return current === null ? [] : [{ change: "added", key, current }];
+  });
+  return [...arrived, ...added];
+}
+function changed(changes) {
+  return changes.some((change) => change.change !== "kept");
+}
+var EVERY_STORY_CHANGE = [
+  "edited",
+  "removed",
+  "added"
+];
+var NO_FROZEN_ENTRIES = /* @__PURE__ */ new Set();
+function storyEntriesWriting(part) {
+  return {
+    kind: part.kind,
+    changes: EVERY_STORY_CHANGE,
+    frozenEntries: (session) => part.frozenEntries(session)
+  };
+}
+function storyWriting(kind, changes) {
+  return { kind, changes, frozenEntries: () => NO_FROZEN_ENTRIES };
+}
+function unwrittenStoryChanges(writings, doc, session) {
+  const byKind = new Map(writings.map((writing) => [writing.kind, writing]));
+  return STORY_KINDS.flatMap((kind) => {
+    const writing = byKind.get(kind);
+    const frozen = writing?.frozenEntries(session) ?? NO_FROZEN_ENTRIES;
+    return storyChangesOf(doc, session, kind).flatMap((entry) => {
+      if (entry.change === "kept") return [];
+      const key = entry.change === "added" ? entry.key : entry.imported.key;
+      const written = writing !== void 0 && writing.changes.includes(entry.change) && !frozen.has(key);
+      return written ? [] : [{ key, change: entry.change }];
+    });
+  });
+}
+function rewrittenStories(writings, doc, session) {
+  const byKind = new Map(writings.map((writing) => [writing.kind, writing]));
+  return STORY_KINDS.flatMap((kind) => {
+    const writing = byKind.get(kind);
+    if (writing === void 0) return [];
+    const frozen = writing.frozenEntries(session);
+    return storyChangesOf(doc, session, kind).flatMap(
+      (entry) => {
+        if (entry.change !== "added" && entry.change !== "edited") return [];
+        const key = entry.change === "added" ? entry.key : entry.imported.key;
+        return writing.changes.includes(entry.change) && !frozen.has(key) ? [{ key, story: entry.current }] : [];
+      }
+    );
+  });
+}
+function writtenStoryOf(change, frozen) {
+  if (change.change === "added") return change.current;
+  if (change.change === "kept" || frozen.has(change.imported.key)) {
+    return change.imported.doc;
+  }
+  return change.change === "edited" ? change.current : null;
+}
+function writtenStories(changes, frozen) {
+  return changes.flatMap((change) => {
+    const story = writtenStoryOf(change, frozen);
+    if (story === null) return [];
+    const key = change.change === "added" ? change.key : change.imported.key;
+    return [
+      {
+        change,
+        key,
+        story,
+        frozen: change.change !== "added" && frozen.has(key)
+      }
+    ];
+  });
+}
+function storyEntriesOf(part, doc, session) {
+  const changes = storyChangesOf(doc, session, part.kind);
+  return changed(changes) ? writtenStories(changes, part.frozenEntries(session)) : [];
+}
+function addedIdProblems(part, changes) {
+  return changes.flatMap((change) => {
+    if (change.change !== "added") return [];
+    const story = splitStoryKey(change.key);
+    return ST_DecimalNumber.parse(story.id) === null ? [
+      {
+        code: "unsupported-content",
+        message: `the ${change.key} story is named by no whole number, and a ${wName(part.entry)} is identified by one`,
+        reason: { kind: "story-id-not-a-number", story }
+      }
+    ] : [];
+  });
+}
+function storyEntriesProblems(part, doc, session) {
+  const changes = storyChangesOf(doc, session, part.kind);
+  if (!changed(changes)) return [];
+  const added = addedIdProblems(part, changes);
+  if (added.length > 0) return added;
+  const xml = readPart(
+    session.parts,
+    relatedPartPath(session.parts, session.mainPartPath, part.relType)
+  );
+  if (xml !== null) {
+    const problem = partRootProblem(xml, part.root);
+    return problem === null ? [] : [
+      {
+        code: "malformed-xml",
+        message: problem,
+        reason: { kind: "unwritable-part-root", part: part.name }
+      }
+    ];
+  }
+  return session.parts.has(CONTENT_TYPES_PATH) ? [] : [
+    {
+      code: "missing-content-types",
+      message: `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`,
+      reason: { kind: "missing-content-types", part: part.name }
+    }
+  ];
+}
+var ENTRY_MARKUP = { namespaces: { w: NAMESPACES.w } };
+var XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+function containerOf(part, id) {
+  const name = wName(part.entry);
+  return {
+    open: openTagXml(name, attrsText([[wName("id"), id]])),
+    close: `</${name}>`
+  };
+}
+function entryXml(part, { change, frozen }, settled, refs) {
+  if (change.change === "added") {
+    return serializeStory(
+      settled,
+      null,
+      containerOf(part, splitStoryKey(change.key).id),
+      refs
+    );
+  }
+  const { imported } = change;
+  return frozen || settled === imported.doc ? imported.xml : serializeStory(settled, imported, imported, refs);
+}
+function beforeClosingTag(suffix) {
+  let at = suffix.indexOf("<");
+  while (at !== -1) {
+    const tag = readTag(suffix, at);
+    if (tag === null || tag.kind === "close") return suffix.slice(0, at);
+    at = suffix.indexOf("<", tag.end);
+  }
+  return suffix;
+}
+function rewrittenPart(part, xml, arrived, appended) {
+  const scan = scanBlocksIn(xml, (_tag, depth) => depth === 0);
+  const seen = /* @__PURE__ */ new Set();
+  const entries = elementChildren(parseXml(xml).documentElement).map(
+    (el, at) => {
+      const slice = scan?.blocks[at]?.xml ?? "";
+      const id = el.localName === part.entry ? attributeByLocalName(el, "id") : null;
+      if (id === null) return slice;
+      if (seen.has(id)) return "";
+      seen.add(id);
+      const entry = arrived.get(storyKey(part.kind, id));
+      return entry === void 0 ? "" : slice.slice(0, slice.indexOf("<")) + entry;
+    }
+  );
+  return ensureRootDeclarations(
+    splicePart(xml, {
+      root: part.root,
+      replaceChildren: entries.join("") + appended + beforeClosingTag(scan?.suffix ?? "")
+    }),
+    ENTRY_MARKUP
+  );
+}
+function mainDeclarations(documentPrefix) {
+  const at = rootTagAt(documentPrefix);
+  const tag = at === -1 ? null : readTag(documentPrefix, at);
+  if (tag === null || tag.kind !== "open") return [];
+  const attrs = parseAttrs(documentPrefix.slice(tag.nameEnd, tag.end - 1));
+  return (attrs ?? []).filter(
+    ([name]) => name.startsWith("xmlns:") && name !== "xmlns:w" || name === "mc:Ignorable"
+  );
+}
+function createdPart(part, session, children) {
+  const name = wName(part.root);
+  const declarations = attrsText(mainDeclarations(session.documentPrefix));
+  return ensureRootDeclarations(
+    `${XML_DECLARATION}${openTagXml(name, declarations === "" ? null : declarations)}${children}</${name}>`,
+    ENTRY_MARKUP
+  );
+}
+function planEntries(part, doc, session, context) {
+  const changes = storyChangesOf(doc, session, part.kind);
+  if (!changed(changes)) return null;
+  const refs = {
+    ...NO_EXPORT_REFS,
+    notes: context.notes,
+    session
+  };
+  const written = writtenStories(changes, part.frozenEntries(session));
+  const settled = withUniqueStoryIdentities(written);
+  const entries = written.map((entry, at) => ({
+    change: entry.change,
+    xml: entryXml(part, entry, settled[at] ?? entry.story, refs)
+  }));
+  const appended = entries.flatMap(({ change, xml }) => change.change === "added" ? [xml] : []).join("");
+  const related = relatedPartPath(
+    session.parts,
+    session.mainPartPath,
+    part.relType
+  );
+  const path = related ?? availablePartPath(session.parts, session.mainPartPath, part.stem);
+  const bytes = session.parts.get(path);
+  if (bytes !== void 0) {
+    const { text, hadBom } = decodeUtf8(bytes);
+    const arrived = new Map(
+      entries.flatMap(
+        ({ change, xml }) => change.change === "added" ? [] : [[change.imported.key, xml]]
+      )
+    );
+    return /* @__PURE__ */ new Map([
+      [path, encodeUtf8(rewrittenPart(part, text, arrived, appended), hadBom)]
+    ]);
+  }
+  if (related === null) {
+    context.relationships.add({
+      type: part.relType,
+      target: path.slice(directoryOf(session.mainPartPath).length)
+    });
+  }
+  context.contentTypes.addOverride(path, part.contentType);
+  const taken = /* @__PURE__ */ new Set([
+    ...changes.map(
+      (change) => change.change === "added" ? splitStoryKey(change.key).id : change.imported.id
+    ),
+    ...part.referencedIds(doc)
+  ]);
+  return /* @__PURE__ */ new Map([
+    [
+      path,
+      encodeUtf8(
+        createdPart(part, session, part.prelude(taken) + appended),
+        false
+      )
+    ]
+  ]);
+}
+function storyEntriesPlanner(part) {
+  return {
+    name: part.name,
+    plan: (doc, session, context) => planEntries(part, doc, session, context)
+  };
+}
+export {
+  EVERY_STORY_CHANGE,
+  rewrittenStories,
+  storyChangesOf,
+  storyEntriesOf,
+  storyEntriesPlanner,
+  storyEntriesProblems,
+  storyEntriesWriting,
+  storyWriting,
+  unwrittenStoryChanges
+};

package/dist/editor/clipboard/htmlReader.d.ts

@@ -2,9 +2,9 @@ import { Slice } from "prosemirror-model";
 import type { Transaction } from "prosemirror-state";
 import { type NewLists } from "../../numbering/listRegistry";
 import { type HtmlBlockReader } from "./blockReaders";
-import type { ListKinds } from "./internalChannel";
+import { type ListKinds, type NoteStories } from "./internalChannel";
 import type { HtmlReadContext } from "./readContext";
-/** What a paste puts in: the content, and the definitions of the lists it started */
+/** What a paste puts in: the content, the definitions of the lists it started, and its notes */
 export interface PastedContent {
     slice: Slice;
     newLists: NewLists;
@@ -14,13 +14,33 @@ export interface PastedContent {
      * which knows what kind each is from the markup it read them out of.
      */
     listKinds?: ListKinds;
+    /**
+     * What the notes this slice's references call said where it was copied (`./internalChannel`).
+     * Absent for a slice that arrived any other way, whose references this document drops.
+     */
+    noteStories?: NoteStories;
+    /**
+     * The notes the paste puts in, under the ids its references were given (`./normalizers`).
+     * Absent until the content has been normalized against the document it is going into.
+     */
+    newStories?: NoteStories;
 }
 /** The content one piece of already parsed markup reads as, or null when it reads as nothing */
 export declare function readHtml(root: ParentNode, context: HtmlReadContext, blockReaders?: readonly HtmlBlockReader[]): PastedContent | null;
 /** The same reading, for a caller holding the markup as a string rather than as elements */
 export declare function readHtmlSlice(context: HtmlReadContext, source: string): PastedContent | null;
 /**
- * The transaction a paste is put in with: the content, and the definitions of the lists it started
- * recorded on the document node so that the export writes them out and undo takes them back.
+ * The notes a paste brought, written under the ids its references were given.
+ *
+ * They go in the transaction the paste itself is in, so the export writes them out and one undo
+ * takes the text and its notes back together. A note whose reference did not land - a paste a
+ * table or a command turned into something else - would be an entry of the file nothing calls, so
+ * only the ones the document now refers to are written.
+ */
+export declare function withPastedStories(tr: Transaction, stories: NoteStories): Transaction;
+/**
+ * The transaction a paste is put in with: the content, the definitions of the lists it started
+ * recorded on the document node so that the export writes them out and undo takes them back, and
+ * the notes its references call.
  */
 export declare function withPastedContent(tr: Transaction, content: PastedContent): Transaction;