@portone/docx-editor 0.5.1 → 0.6.1

package/dist/docx/storyParts.js

@@ -0,0 +1,289 @@
+// 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,
+  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 storyIdOf(key, kind) {
+  return key.slice(kind.length + 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(storyIdOf(a, kind), storyIdOf(b, kind))).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 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 [];
+    return [
+      {
+        change,
+        story,
+        frozen: change.change !== "added" && frozen.has(change.imported.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) => change.change === "added" && ST_DecimalNumber.parse(storyIdOf(change.key, part.kind)) === null ? [
+      {
+        code: "unsupported-content",
+        message: `the ${change.key} story is named by no whole number, and a ${wName(part.entry)} is identified by one`
+      }
+    ] : []
+  );
+}
+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 }];
+  }
+  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}`
+    }
+  ];
+}
+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, storyIdOf(change.key, part.kind)),
+      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" ? storyIdOf(change.key, part.kind) : 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,
+  storyChangesOf,
+  storyEntriesOf,
+  storyEntriesPlanner,
+  storyEntriesProblems,
+  storyEntriesWriting,
+  storyIdOf,
+  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;

package/dist/editor/clipboard/htmlReader.js

@@ -7,6 +7,7 @@ import {
   withListNumbering,
   withParagraphStyle
 } from "../../docx/paraProps.js";
+import { setStory } from "../../docx/story.js";
 import {
   listsWorn,
   NEW_LISTS_ATTR,
@@ -20,6 +21,10 @@ import {
 import { styleIdOf } from "../../ooxml/props.js";
 import { docxSchema } from "../../schema/index.js";
 import { COPIED_STYLE_ATTRIBUTE } from "../../schema/clipboard.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey
+} from "../../schema/stories.js";
 import { editorClassNames } from "../../styles/classNames.js";
 import { numIdsIn } from "../commands/listCommands.js";
 import {
@@ -32,6 +37,9 @@ import {
   marksFor,
   withInlineStyle
 } from "./inlineFormatting.js";
+import {
+  NO_NOTE_STORIES
+} from "./internalChannel.js";
 import { detectHtmlSource } from "./source.js";
 var BLOCK_TAGS = /* @__PURE__ */ new Set([
   "ADDRESS",
@@ -363,14 +371,41 @@ function readHtmlSlice(context, source) {
   template.innerHTML = source;
   return readHtml(template.content, context);
 }
+function notesCalledIn(doc) {
+  const keys = /* @__PURE__ */ new Set();
+  doc.descendants((node) => {
+    if (node.type !== docxSchema.nodes.noteReference) return true;
+    const kind = EDITABLE_NOTE_KINDS.find(
+      (candidate) => candidate === node.attrs.kind
+    );
+    const id = node.attrs.id;
+    if (kind !== void 0 && typeof id === "string") {
+      keys.add(storyKey(kind, id));
+    }
+    return true;
+  });
+  return keys;
+}
+function withPastedStories(tr, stories) {
+  if (stories.size === 0) return tr;
+  const called = notesCalledIn(tr.doc);
+  for (const [key, story] of stories) {
+    if (called.has(key)) setStory(tr, key, story);
+  }
+  return tr;
+}
 function withPastedContent(tr, content) {
-  return tr.setDocAttribute(
-    NEW_LISTS_ATTR,
-    newListsValue(listsWorn(content.newLists, numIdsIn(tr.doc)))
+  return withPastedStories(
+    tr.setDocAttribute(
+      NEW_LISTS_ATTR,
+      newListsValue(listsWorn(content.newLists, numIdsIn(tr.doc)))
+    ),
+    content.newStories ?? NO_NOTE_STORIES
   );
 }
 export {
   readHtml,
   readHtmlSlice,
-  withPastedContent
+  withPastedContent,
+  withPastedStories
 };

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

@@ -16,15 +16,23 @@
  * about the copy that only the editor it was copied from can answer: a number says nothing about
  * whether it counted or bulleted, and the definition that said so is the source document's. It is
  * read here because this is where both ends are the same session.
+ *
+ * The note each reference in it calls is kept the same way, and for a stronger reason: a cut takes
+ * a footnote away together with its last reference (`editor/plugins/noteLifecycle`), so by the time
+ * the paste happens the document no longer holds what the copy was pointing at.
  */
-import type { Slice } from "prosemirror-model";
+import type { Node as PMNode, Slice } from "prosemirror-model";
 import type { ListKind } from "../../numbering/listTemplate";
 import type { Numbering } from "../../numbering/parseNumbering";
+import { type NoteKey, type StoryKey } from "../../schema/stories";
 /** Where the copied HTML carries the name of the slice this editor kept */
 export declare const INTERNAL_TOKEN_ATTRIBUTE = "data-docx-clip";
 /** The kind of list each numbering id of a slice stood for where the slice was copied */
 export type ListKinds = ReadonlyMap<number, ListKind>;
 export declare const NO_LIST_KINDS: ListKinds;
+/** The story of each note the slice refers to, as the document copied from held it */
+export type NoteStories = ReadonlyMap<NoteKey, PMNode>;
+export declare const NO_NOTE_STORIES: NoteStories;
 /**
  * The two ways a copy leaves the editor.
  *
@@ -34,19 +42,38 @@ export declare const NO_LIST_KINDS: ListKinds;
  * replaced only by the next copy made the same way.
  */
 export type CopyRoute = "clipboard" | "drag";
-/** What one name stands for: the slice that was copied, and what its list numbers meant there */
+/** What one name stands for: the slice that was copied, and what it named where it was copied */
 export interface RecalledCopy {
     readonly slice: Slice;
     readonly listKinds: ListKinds;
+    readonly noteStories: NoteStories;
+}
+/** The document a copy is made from, which is the only one that can answer what it carries */
+export interface CopySource {
+    /** Null for a state built without a document, which has no session to bind a name to */
+    readonly sessionId: string | null;
+    readonly doc: PMNode;
+    readonly numbering: Numbering;
+    /** The notes laying a part out rather than saying something, which are never copied */
+    readonly specialNotes: ReadonlySet<StoryKey>;
 }
 /**
  * Keeps the copied slice under a fresh name, and answers with the name to write into the markup.
  * Null for a state built without a document: with no session to bind the name to there is nothing
  * to tell this editor's copy from another's, and the copy travels as markup alone.
  */
-export declare function rememberCopied(route: CopyRoute, slice: Slice, sessionId: string | null, numbering: Numbering): string | null;
+export declare function rememberCopied(route: CopyRoute, slice: Slice, source: CopySource): string | null;
 /** The copy that name stands for, and only when the session asking is the one that copied it */
 export declare function recallCopied(token: string | null, sessionId: string | null): RecalledCopy | null;
+/**
+ * The notes the last drag out of this editor carried.
+ *
+ * A drop is handed the slice itself rather than markup (`prosemirror-view`), so it carries no name
+ * to look a copy up by; the drag is the one route whose last copy is the copy being dropped. The
+ * session must still be the one that dragged, since a drop from another editor arrives as the
+ * markup its own reader answers for.
+ */
+export declare function draggedNotes(sessionId: string | null): NoteStories;
 /**
  * The name the pasted markup carries, if it carries one.
  *

package/dist/editor/clipboard/internalChannel.js

@@ -1,31 +1,50 @@
 // src/editor/clipboard/internalChannel.ts
 import { docxSchema } from "../../schema/index.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey,
+  storyNodeOf
+} from "../../schema/stories.js";
 import { listKindOf, listRefOf } from "../commands/listCommands.js";
 var INTERNAL_TOKEN_ATTRIBUTE = "data-docx-clip";
 var NO_LIST_KINDS = /* @__PURE__ */ new Map();
+var NO_NOTE_STORIES = /* @__PURE__ */ new Map();
 var copied = /* @__PURE__ */ new Map();
 var copies = 0;
 function nextToken() {
   copies += 1;
   return `c${copies}-${Math.random().toString(36).slice(2, 10)}`;
 }
-function rememberCopied(route, slice, sessionId, numbering) {
+function rememberCopied(route, slice, source) {
+  const { sessionId } = source;
   if (sessionId === null) return null;
   const token = nextToken();
   copied.set(route, {
     token,
     sessionId,
     slice,
-    listKinds: listKindsIn(slice, numbering)
+    listKinds: listKindsIn(slice, source.numbering),
+    noteStories: noteStoriesIn(slice, source)
   });
   return token;
 }
+function recalled(copy) {
+  return {
+    slice: copy.slice,
+    listKinds: copy.listKinds,
+    noteStories: copy.noteStories
+  };
+}
 function recallCopied(token, sessionId) {
   if (token === null || sessionId === null) return null;
   const found = [...copied.values()].find(
     (copy) => copy.token === token && copy.sessionId === sessionId
   );
-  return found === void 0 ? null : { slice: found.slice, listKinds: found.listKinds };
+  return found === void 0 ? null : recalled(found);
+}
+function draggedNotes(sessionId) {
+  const found = copied.get("drag");
+  return found === void 0 || sessionId === null || found.sessionId !== sessionId ? NO_NOTE_STORIES : found.noteStories;
 }
 function listKindsIn(slice, numbering) {
   const kinds = /* @__PURE__ */ new Map();
@@ -41,6 +60,25 @@ function listKindsIn(slice, numbering) {
   slice.content.forEach(read);
   return kinds.size === 0 ? NO_LIST_KINDS : kinds;
 }
+function noteStoriesIn(slice, source) {
+  const stories = /* @__PURE__ */ new Map();
+  const read = (node) => {
+    if (node.type === docxSchema.nodes.noteReference) {
+      const kind = EDITABLE_NOTE_KINDS.find(
+        (candidate) => candidate === node.attrs.kind
+      );
+      const id = node.attrs.id;
+      if (kind === void 0 || typeof id !== "string") return;
+      const key = storyKey(kind, id);
+      const story = source.specialNotes.has(key) ? null : storyNodeOf(source.doc, key);
+      if (story !== null) stories.set(key, story);
+      return;
+    }
+    node.forEach(read);
+  };
+  slice.content.forEach(read);
+  return stories.size === 0 ? NO_NOTE_STORIES : stories;
+}
 function internalTokenOf(dom) {
   if (dom instanceof Element) {
     const own = dom.getAttribute(INTERNAL_TOKEN_ATTRIBUTE);
@@ -52,6 +90,8 @@ function internalTokenOf(dom) {
 export {
   INTERNAL_TOKEN_ATTRIBUTE,
   NO_LIST_KINDS,
+  NO_NOTE_STORIES,
+  draggedNotes,
   internalTokenOf,
   recallCopied,
   rememberCopied

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

@@ -16,8 +16,9 @@
 import { type Node as PMNode, Slice } from "prosemirror-model";
 import type { EditorState } from "prosemirror-state";
 import { type ListKind } from "../../numbering/listTemplate";
+import { type NoteKind } from "../../schema/stories";
 import type { PastedContent } from "./htmlReader";
-import { type ListKinds } from "./internalChannel";
+import { type ListKinds, type NoteStories } from "./internalChannel";
 /** What one normalizer answers about the document the slice is going into */
 export interface NormalizeContext {
     readonly state: EditorState;
@@ -40,6 +41,17 @@ export interface NormalizeContext {
      * the list button starts one. Null in a document with nowhere to write a definition.
      */
     startList(kind: ListKind): number | null;
+    /**
+     * What the notes the slice's references call said where it was copied
+     * (`./internalChannel`). Empty for a slice that arrived any other way, whose references name
+     * notes of a document this one knows nothing about.
+     */
+    readonly noteStories: NoteStories;
+    /**
+     * A note this paste puts in, under an id no note of this document answers to, registered in
+     * `PastedContent.newStories`. It answers with the id the reference is pasted under.
+     */
+    startNote(kind: NoteKind, story: PMNode): string;
 }
 export type SliceNormalizer = (slice: Slice, context: NormalizeContext) => Slice;
 /** The slice with every node rewritten depth first, and the ones mapped to null taken out */
@@ -71,17 +83,31 @@ export declare const rekeyNumbering: SliceNormalizer;
 /**
  * Takes the anchors off what is pasted.
  *
- * A comment marker, a bookmark and a note reference all point at something written elsewhere in
- * the package: the comment, the bookmark's other end, the note's body. A copy of the marker alone
- * points at the same thing a second time, which is a duplicate identifier the file may not hold
- * and a range the reader cannot close. Nothing here duplicates what they point at, so the anchor
- * goes and the text it stood in stays, which is what Word does with a note it has no body for.
+ * A comment marker and a bookmark both point at something written elsewhere in the package: the
+ * comment, the bookmark's other end. A copy of the marker alone points at the same thing a second
+ * time, which is a duplicate identifier the file may not hold and a range the reader cannot close.
+ * Nothing here duplicates what they point at, so the anchor goes and the text it stood in stays,
+ * which is what Word does with a note it has no body for.
  *
  * A move drop duplicates nothing: the source goes as the drop lands, so the one anchor there was
  * travels with the text it opened. Taking it off would delete a marker the document has no way to
  * write back, which is a change the preserved guard refuses whole, and the drag would do nothing.
  */
 export declare const detachAnchors: SliceNormalizer;
+/**
+ * Gives a pasted note reference a note of its own.
+ *
+ * A note is written once and called from the text by its id, so a second reference naming that id
+ * is one note drawn with one number where the reader made two. The note each reference called was
+ * remembered as the slice was copied (`./internalChannel`) - a cut deletes a footnote together
+ * with its last reference, so the document no longer holds it by the time the paste lands - and
+ * each reference is pasted under a fresh id with a copy of that note beside it.
+ *
+ * A reference no remembered note answers for points at nothing here: a copy from another editor or
+ * another document numbers its notes against its own file, and markup naming one says nothing
+ * about what it said. It goes the way the other anchors do.
+ */
+export declare const duplicateNotes: SliceNormalizer;
 /**
  * Works out again what the pasted paragraphs are drawn with.
  *
@@ -93,7 +119,8 @@ export declare const detachAnchors: SliceNormalizer;
 export declare const rederiveDisplay: SliceNormalizer;
 export declare const DEFAULT_NORMALIZERS: readonly SliceNormalizer[];
 /**
- * The pasted content as this document may hold it, and the definitions of the lists the paste
- * starts - the ones a reading started, and the ones a reissued number was taken for.
+ * The pasted content as this document may hold it, the definitions of the lists the paste starts -
+ * the ones a reading started, and the ones a reissued number was taken for - and the notes it puts
+ * in beside the references calling them.
  */
 export declare function normalizePasted(content: PastedContent, state: EditorState, move: boolean, normalizers?: readonly SliceNormalizer[]): PastedContent;