@portone/docx-editor 0.6.0 → 0.6.1

package/dist/editor/editorDocument.d.ts

@@ -10,9 +10,11 @@
 import type { Node as PMNode } from "prosemirror-model";
 import { type EditorState, Plugin } from "prosemirror-state";
 import { type FormattingContext, type ParagraphStyleOption } from "../docx/formatting";
+import { type NoteNumbering } from "../docx/notes/reading";
 import { type PageGeometry } from "../docx/pageGeometry";
 import type { SessionStore } from "../docx/session";
 import type { DocumentDefaults } from "../model/format";
+import { type StoryKey } from "../schema/stories";
 /** The document-level values one editing state is built on */
 export interface EditorDocument {
     /** The document these values were read from. Null for a state built without one */
@@ -30,12 +32,26 @@ export interface EditorDocument {
     readonly canStartNewList: boolean;
     /** The paper the document is written on, which decides the width a new table is fitted to */
     readonly geometry: PageGeometry;
+    /**
+     * Whether these values stand for a side story rather than for the body, whose paper is then the
+     * geometry above rather than anything the story's own blocks say (`editor/documentStyles`).
+     */
+    readonly sideStory: boolean;
     /** The distance between automatic tab stops when no custom stop applies */
     readonly defaultTabStopPt: number;
     /** Every id already present in the opened Comments part, including unreferenced entries */
     readonly reservedCommentIds: ReadonlySet<string>;
     /** Every paragraph id present in the opened comment parts, including orphan extension entries */
     readonly reservedCommentParaIds: ReadonlySet<string>;
+    /** How the document counts its footnotes and endnotes, which the note labels are spelled in */
+    readonly noteNumbering: NoteNumbering;
+    /** The note entries that lay out the page rather than number a note: separators and the continuation notice */
+    readonly specialNotes: ReadonlySet<StoryKey>;
+    /**
+     * Every entry of an editable kind the opened notes parts hold, separators and entries no
+     * reference names included, which a new note may not take the id of
+     */
+    readonly reservedNoteKeys: ReadonlySet<StoryKey>;
 }
 /** What a state built without an opened document answers: the same as nothing being written down */
 export declare const NO_DOCUMENT: EditorDocument;
@@ -51,6 +67,14 @@ export declare function documentOf(state: EditorState): EditorDocument;
  * both leave the same object behind, allowing the sheet's style to be cached against that identity.
  */
 export declare function editorDocument(document: EditorDocument): Plugin<EditorDocument>;
+/**
+ * The snapshot one side story is edited against: the document's own values, with the two a story
+ * answers differently.
+ *
+ * A story has nowhere of its own to write a list definition, and the paper its text wraps at is
+ * the paper of the place it is called from rather than anything the story says.
+ */
+export declare function storyDocument(document: EditorDocument, geometry: PageGeometry): EditorDocument;
 /** The comment ids the opened document already spent, which a new comment may not take */
 export declare function reservedCommentIds(state: EditorState): ReadonlySet<string>;
 /** The paragraph ids the opened comment parts already spent */

package/dist/editor/editorDocument.js

@@ -6,9 +6,17 @@ import {
   NO_FORMATTING
 } from "../docx/formatting.js";
 import { canDefineNewList } from "../docx/newLists.js";
+import {
+  DEFAULT_NOTE_NUMBERING
+} from "../docx/notes/reading.js";
 import { A4_PORTRAIT } from "../docx/pageGeometry.js";
 import { NEW_LISTS_ATTR, newListsOf } from "../numbering/listRegistry.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  STORIES_ATTR
+} from "../schema/stories.js";
 var NO_IDS = /* @__PURE__ */ new Set();
+var NO_NOTE_KEYS = /* @__PURE__ */ new Set();
 var NO_PARAGRAPH_STYLES = [];
 var NO_DOCUMENT = {
   session: null,
@@ -17,9 +25,13 @@ var NO_DOCUMENT = {
   paragraphStyles: NO_PARAGRAPH_STYLES,
   canStartNewList: true,
   geometry: A4_PORTRAIT,
+  sideStory: false,
   defaultTabStopPt: DEFAULT_TAB_STOP_PT,
   reservedCommentIds: NO_IDS,
-  reservedCommentParaIds: NO_IDS
+  reservedCommentParaIds: NO_IDS,
+  noteNumbering: DEFAULT_NOTE_NUMBERING,
+  specialNotes: NO_NOTE_KEYS,
+  reservedNoteKeys: NO_NOTE_KEYS
 };
 function reservedParaIds(session) {
   const paraIds = /* @__PURE__ */ new Set();
@@ -46,9 +58,17 @@ function editorDocumentOf(session, doc) {
     paragraphStyles: session.paragraphStyles,
     canStartNewList: canDefineNewList(session),
     geometry: session.geometry,
+    sideStory: false,
     defaultTabStopPt: session.defaultTabStopPt,
     reservedCommentIds: new Set(session.comments.byId.keys()),
-    reservedCommentParaIds: reservedParaIds(session)
+    reservedCommentParaIds: reservedParaIds(session),
+    noteNumbering: session.noteNumbering,
+    specialNotes: session.specialNotes,
+    reservedNoteKeys: new Set(
+      Array.from(session.stories.values()).flatMap(
+        (story) => EDITABLE_NOTE_KINDS.some((kind) => kind === story.kind) ? [story.key] : []
+      )
+    )
   };
 }
 var editorDocumentKey = new PluginKey("docxEditorDocument");
@@ -61,15 +81,24 @@ function derived(current, doc) {
     formatting: formattingWithNewLists(current.formatting, doc)
   } : editorDocumentOf(current.session, doc);
 }
+function onlyStoriesMoved(next, before) {
+  const names = Object.keys(next.attrs);
+  return next.attrs[STORIES_ATTR] !== before.attrs[STORIES_ATTR] && names.length === Object.keys(before.attrs).length && names.every(
+    (name) => name === STORIES_ATTR || next.attrs[name] === before.attrs[name]
+  );
+}
 function editorDocument(document) {
   return new Plugin({
     key: editorDocumentKey,
     state: {
       init: () => document,
-      apply: (tr, current, old) => tr.doc.attrs === old.doc.attrs ? current : derived(current, tr.doc)
+      apply: (tr, current, old) => tr.doc.attrs === old.doc.attrs || onlyStoriesMoved(tr.doc, old.doc) ? current : derived(current, tr.doc)
     }
   });
 }
+function storyDocument(document, geometry) {
+  return { ...document, sideStory: true, canStartNewList: false, geometry };
+}
 function reservedCommentIds(state) {
   return documentOf(state).reservedCommentIds;
 }
@@ -82,5 +111,6 @@ export {
   editorDocument,
   editorDocumentOf,
   reservedCommentIds,
-  reservedCommentParaIds
+  reservedCommentParaIds,
+  storyDocument
 };

package/dist/editor/notes/noteSurface.d.ts

@@ -0,0 +1,53 @@
+/**
+ * What a footnote or an endnote draws and does differently from any other story.
+ *
+ * A note's story opens with a mark of its own (`w:footnoteRef`, `w:endnoteRef`), which the file
+ * keeps as a preserved chip. Word draws that mark as the number the reference carries, so it is
+ * drawn here as that label in superscript, the way the reference in the body is.
+ *
+ * The rest is what the story view asks a kind of story for (`editor/stories`): the host every
+ * edit leaves through, and the extensions that give a note its chip, its key rule, the number it
+ * keeps through an edit, and what a paste into one may carry.
+ */
+import type { EditorView } from "prosemirror-view";
+import { type StoryKey } from "../../schema/stories";
+import { type SliceNormalizer } from "../clipboard/normalizers";
+import type { StoryNodeSpecs } from "../stories/storyMarkup";
+import { type StoryExtensions, type StoryHost } from "../stories/storyView";
+/** The node specs a note's story is drawn with, its own reference mark drawn as `labelOf` answers */
+export declare function noteNodeSpecs(labelOf: () => string): StoryNodeSpecs;
+/**
+ * Takes out of a paste what the notes part cannot be written with: an image, and a link.
+ *
+ * Either needs a relationship of the part it stands in, and the notes part writer writes none, so
+ * both would go out naming a relationship the file does not hold. A link or an image the file
+ * itself wrote inside a note stays; this is about what a paste would add.
+ */
+export declare const dropUnwritableContent: SliceNormalizer;
+/**
+ * Takes a note reference out of a paste: a note may not hold a note.
+ *
+ * The lifecycle, the numbering and the writer all walk the body alone, so a reference inside a
+ * story would call a note nothing numbers, counts or settles, and one copied from beside the note
+ * it was pasted into would have that note calling itself. The text it stood in stays, the way the
+ * other anchors leave theirs (`editor/clipboard/normalizers`).
+ */
+export declare const dropNoteReferences: SliceNormalizer;
+/**
+ * Puts the caret back just after the reference that calls this note and takes the body's focus,
+ * which is what leaves the note: Escape and a press on the note's own number both run it.
+ */
+export declare function returnToReference(main: EditorView, key: StoryKey): void;
+/**
+ * The host a note's editing view writes through, whichever kind of note stands under the key.
+ *
+ * Every edit leaves as that kind's own body command, so a lock around the reference and the
+ * editing protection judge a note edit where they judge a body edit, and the main document keeps
+ * the one history both share.
+ */
+export declare function noteHost(main: EditorView, activate: StoryHost["activate"]): StoryHost;
+/**
+ * What a note adds to the story view: its chip, the number it keeps first, its key rule, and what
+ * a paste may bring in
+ */
+export declare function noteExtensions(main: EditorView, key: StoryKey, labelOf: () => string): StoryExtensions;

package/dist/editor/notes/noteSurface.js

@@ -0,0 +1,246 @@
+// src/editor/notes/noteSurface.ts
+import { keymap } from "prosemirror-keymap";
+import {
+  DOMSerializer,
+  Mark
+} from "prosemirror-model";
+import { Plugin, TextSelection } from "prosemirror-state";
+import { NOTE_NUMBER_ELEMENTS } from "../../docx/notes/newNote.js";
+import { docxSchema } from "../../schema/index.js";
+import { editShut, transactionAllowed } from "../../schema/guards.js";
+import { editsShut } from "../../schema/protectionState.js";
+import { noteKeyOf } from "../../schema/stories.js";
+import { editorClassNames } from "../../styles/classNames.js";
+import {
+  detachAnchors,
+  dropSourceIdentity,
+  mapSliceNodes,
+  rederiveDisplay,
+  rekeyNumbering
+} from "../clipboard/normalizers.js";
+import { redo, undo } from "../commands/historyCommands.js";
+import { noteBodyCommand } from "../commands/noteCommands.js";
+import { onMac } from "../plugins/keymap.js";
+import { noteReferenceAt } from "../plugins/noteNavigation.js";
+import {
+  NO_CAPABILITY
+} from "../stories/storyView.js";
+function isOwnMark(node) {
+  const element = node.attrs.element;
+  return node.type === docxSchema.nodes.rawRunContent && typeof element === "string" && NOTE_NUMBER_ELEMENTS.includes(element);
+}
+function drawnBySchema(node) {
+  return docxSchema.nodes.rawRunContent.spec.toDOM?.(node) ?? ["span"];
+}
+function markSpec(node, labelOf) {
+  return isOwnMark(node) ? ["sup", { class: editorClassNames.noteMark }, labelOf()] : drawnBySchema(node);
+}
+function noteNodeSpecs(labelOf) {
+  return { rawRunContent: (node) => markSpec(node, labelOf) };
+}
+function noteMarkView(labelOf, back) {
+  return (node) => {
+    const { dom } = DOMSerializer.renderSpec(document, markSpec(node, labelOf));
+    if (isOwnMark(node) && dom instanceof HTMLElement) {
+      dom.addEventListener("mousedown", (event) => {
+        event.preventDefault();
+        back();
+      });
+    }
+    return { dom };
+  };
+}
+var dropUnwritableContent = (slice) => mapSliceNodes(slice, (node) => {
+  if (node.type === docxSchema.nodes.image) return null;
+  const marks = node.marks.filter(
+    (mark) => mark.type !== docxSchema.marks.link
+  );
+  return Mark.sameSet(marks, node.marks) ? node : node.mark(marks);
+});
+var dropNoteReferences = (slice, { move }) => move ? slice : mapSliceNodes(
+  slice,
+  (node) => node.type === docxSchema.nodes.noteReference ? null : node
+);
+var NOTE_TAKES = NO_CAPABILITY;
+var NOTE_NORMALIZERS = [
+  dropSourceIdentity,
+  detachAnchors,
+  dropNoteReferences,
+  dropUnwritableContent,
+  rekeyNumbering,
+  rederiveDisplay
+];
+function runOn(main, command) {
+  return command(main.state, (tr) => main.dispatch(tr), main);
+}
+function referenceOf(main, key) {
+  const note = noteKeyOf(key);
+  return note === null ? null : noteReferenceAt(main.state.doc, note.kind, note.id);
+}
+function returnToReference(main, key) {
+  const found = referenceOf(main, key);
+  if (found !== null) {
+    const after = found.pos + found.node.nodeSize;
+    main.dispatch(
+      main.state.tr.setSelection(TextSelection.near(main.state.doc.resolve(after))).scrollIntoView()
+    );
+  }
+  main.focus();
+}
+function leadingChipSize(story) {
+  const first = story.firstChild?.firstChild ?? null;
+  return first !== null && isOwnMark(first) ? first.nodeSize : 0;
+}
+function ownMarkIn(story) {
+  let found = null;
+  story.descendants((node, pos) => {
+    if (found === null && isOwnMark(node)) found = { pos, node };
+    return found === null;
+  });
+  return found;
+}
+function caretFloor(story) {
+  const held = ownMarkIn(story);
+  return held === null || held.pos !== markHome(story) ? null : held.pos + held.node.nodeSize;
+}
+function markHome(story) {
+  const type = docxSchema.nodes.rawRunContent;
+  let at = null;
+  story.descendants((node, pos) => {
+    if (at !== null) return false;
+    if (!node.isTextblock) return true;
+    if (node.type.contentMatch.matchType(type) !== null) at = pos + 1;
+    return false;
+  });
+  return at;
+}
+function pressesTowardsTheNumber() {
+  return [
+    "ArrowLeft",
+    "ArrowUp",
+    "Home",
+    "PageUp",
+    "Mod-ArrowLeft",
+    "Mod-ArrowUp",
+    "Mod-Home",
+    ...onMac() ? ["Ctrl-a"] : []
+  ];
+}
+function holdAtTheNumber(extend) {
+  return (state, dispatch) => {
+    const floor = caretFloor(state.doc);
+    const home = markHome(state.doc);
+    if (floor === null || home === null) return false;
+    const { selection } = state;
+    if (extend ? selection.head > home : selection.from > floor) return false;
+    if (dispatch && !extend) {
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, floor)));
+    }
+    return true;
+  };
+}
+function keysOffTheNumber() {
+  return Object.fromEntries(
+    pressesTowardsTheNumber().flatMap((press) => [
+      [press, holdAtTheNumber(false)],
+      [`Shift-${press}`, holdAtTheNumber(true)]
+    ])
+  );
+}
+function ownMarkFirst() {
+  return new Plugin({
+    appendTransaction(transactions, oldState, newState) {
+      const tr = newState.tr;
+      const home = markHome(newState.doc);
+      if (transactions.some((changed) => changed.docChanged) && home !== null) {
+        const held = ownMarkIn(newState.doc);
+        const lost = ownMarkIn(oldState.doc);
+        if (held === null) {
+          if (lost !== null) tr.insert(home, lost.node);
+        } else if (held.pos !== home) {
+          tr.delete(held.pos, held.pos + held.node.nodeSize).insert(
+            home,
+            held.node
+          );
+        }
+      }
+      const floor = caretFloor(tr.doc);
+      if (floor !== null && tr.selection.empty && tr.selection.from < floor) {
+        tr.setSelection(
+          TextSelection.create(tr.doc, Math.min(floor, tr.doc.content.size))
+        );
+      }
+      return tr.docChanged || tr.selectionSet ? tr : null;
+    }
+  });
+}
+function holdsNothing(story) {
+  const only = story.childCount === 1 ? story.firstChild : null;
+  return only !== null && only.type === docxSchema.nodes.paragraph && only.content.size === leadingChipSize(story);
+}
+function deleteEmptyNote(main, key) {
+  return (state, dispatch) => {
+    if (!state.selection.empty) return false;
+    if (!holdsNothing(state.doc)) return false;
+    const $at = state.selection.$from;
+    if ($at.index(0) !== 0 || $at.parentOffset > leadingChipSize(state.doc)) {
+      return false;
+    }
+    const found = referenceOf(main, key);
+    if (found === null) return false;
+    const tr = main.state.tr.delete(found.pos, found.pos + found.node.nodeSize);
+    if (!transactionAllowed(tr, main.state)) return false;
+    if (dispatch) {
+      main.dispatch(
+        tr.setSelection(TextSelection.near(tr.doc.resolve(found.pos))).scrollIntoView()
+      );
+      main.focus();
+    }
+    return true;
+  };
+}
+function noteHost(main, activate) {
+  return {
+    state: () => main.state,
+    write(key, story) {
+      const note = noteKeyOf(key);
+      return note !== null && runOn(main, noteBodyCommand(note.kind, note.id, story));
+    },
+    undo: () => runOn(main, undo),
+    redo: () => runOn(main, redo),
+    leave: (key) => returnToReference(main, key),
+    shut(key) {
+      if (editsShut(main.state)) return true;
+      const found = referenceOf(main, key);
+      if (found === null) return true;
+      return editShut(main.state, {
+        kind: "replace",
+        from: found.pos,
+        to: found.pos + found.node.nodeSize
+      });
+    },
+    activate
+  };
+}
+function noteExtensions(main, key, labelOf) {
+  return {
+    plugins: [
+      ownMarkFirst(),
+      keymap(keysOffTheNumber()),
+      keymap({ Backspace: deleteEmptyNote(main, key) })
+    ],
+    nodeViews: {
+      rawRunContent: noteMarkView(labelOf, () => returnToReference(main, key))
+    },
+    normalizers: NOTE_NORMALIZERS,
+    takes: NOTE_TAKES
+  };
+}
+export {
+  dropNoteReferences,
+  dropUnwritableContent,
+  noteExtensions,
+  noteHost,
+  noteNodeSpecs,
+  returnToReference
+};

package/dist/editor/plugins/compositionSelection.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Takes the selected text away before a composition opens over it.
+ *
+ * A composition normally replaces what is selected because the browser does the replacing and
+ * ProseMirror reads the result back. Chrome will not touch a selection that begins at an element
+ * it may not edit - the number a note is drawn by, a note reference - and does not say so: the
+ * composition lands beside the words it was meant to replace, or nothing happens at all. A note
+ * meets it every time, since its first paragraph opens with its number and selecting the whole of
+ * a note to write it again is an ordinary thing to do.
+ *
+ * So the selection is deleted here, in the frame the composition opens in and before ProseMirror
+ * marks the view as composing, which leaves the composition starting from a caret with nothing
+ * for the browser to refuse. ProseMirror does the same for a selection spanning whole blocks
+ * (`endComposition`).
+ *
+ * The deletion is an edit like any other, so the guards judge it: across a bookmark marker it is
+ * refused, and the composition is left to the browser where it stood.
+ */
+import { Plugin } from "prosemirror-state";
+export declare function compositionSelection(): Plugin;

package/dist/editor/plugins/compositionSelection.js

@@ -0,0 +1,19 @@
+// src/editor/plugins/compositionSelection.ts
+import { deleteSelection } from "prosemirror-commands";
+import { Plugin } from "prosemirror-state";
+function compositionSelection() {
+  return new Plugin({
+    props: {
+      handleDOMEvents: {
+        compositionstart(view) {
+          if (view.state.selection.empty) return false;
+          deleteSelection(view.state, (tr) => view.dispatch(tr));
+          return false;
+        }
+      }
+    }
+  });
+}
+export {
+  compositionSelection
+};

package/dist/editor/plugins/keymap.d.ts

@@ -2,6 +2,7 @@
  * Keys not handled here are taken by ProseMirror's base keymap.
  */
 import { type Command, Plugin } from "prosemirror-state";
+import type { NoteKind } from "../../schema/stories";
 /**
  * Keeps undo and redo on their keys where the keymap above cannot reach them.
  *
@@ -12,4 +13,17 @@ import { type Command, Plugin } from "prosemirror-state";
  * second time.
  */
 export declare function historyKeys(): Plugin;
+/**
+ * Whether the editor is running on a Mac, which decides the Mod key and what the system takes
+ * before a page sees it.
+ */
+export declare function onMac(): boolean;
+/**
+ * The key each kind of note is put in on.
+ *
+ * They are Word's own, except that Word for Windows' endnote key is the system's on a Mac:
+ * Cmd+Option+D hides the Dock, so the editor is never asked about it, and Word for Mac puts an
+ * endnote on Cmd+Option+E. The footnote key is the same on both, which is Google Docs' as well.
+ */
+export declare const NOTE_KEYS: Readonly<Record<NoteKind, string>>;
 export declare const docxKeymap: Record<string, Command>;

package/dist/editor/plugins/keymap.js

@@ -22,6 +22,7 @@ import {
   increaseListLevel,
   leaveEmptyListItem
 } from "../commands/listCommands.js";
+import { insertEndnote, insertFootnote } from "../commands/noteCommands.js";
 import { insertTab, moveAcrossTab } from "../commands/tabCommands.js";
 import { openLinkPanel } from "./linkPanel.js";
 var insertTabFromKeyboard = (state, dispatch, view) => {
@@ -91,6 +92,13 @@ function historyKeys() {
     }
   });
 }
+function onMac() {
+  return typeof navigator !== "undefined" && navigator.platform.includes("Mac");
+}
+var NOTE_KEYS = {
+  footnote: "Mod-Alt-f",
+  endnote: onMac() ? "Mod-Alt-e" : "Mod-Alt-d"
+};
 var docxKeymap = {
   Enter: chainCommands(leaveEmptyListItem, splitParagraph),
   "Shift-Enter": insertLineBreak,
@@ -107,6 +115,8 @@ var docxKeymap = {
   // The link key Word and Google Docs share. It opens the panel over the selection, and with
   // nothing there to link it reports that it did nothing, so the browser keeps its own Cmd+K
   "Mod-k": openLinkPanel,
+  [NOTE_KEYS.footnote]: insertFootnote,
+  [NOTE_KEYS.endnote]: insertEndnote,
   // Inside a table, moving between cells comes first (Word does the same).
   // In a list paragraph outside a table it shifts the level; an ordinary paragraph gets a document tab.
   Tab: chainCommands(
@@ -124,6 +134,8 @@ var docxKeymap = {
   "Shift-ArrowRight": moveAcrossTab("right", true)
 };
 export {
+  NOTE_KEYS,
   docxKeymap,
-  historyKeys
+  historyKeys,
+  onMac
 };

package/dist/editor/plugins/noteLifecycle.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Keeps each note of an editable kind in step with the references that call it.
+ *
+ * A note is written once and called from the text by its id, so what an edit does to the text
+ * decides what becomes of the note. An edit that takes away the last reference to a note takes the
+ * note away with it. An edit that copies a reference gives the copy a new id and a copy of the
+ * note, since two references naming one id are one note drawn with one number where the reader
+ * made two. A reference moved whole keeps its id and its note. Either change goes in a transaction
+ * appended to the edit, so it lands in the edit's history event and one undo takes both back.
+ *
+ * Only what the edit did is read. An entry the file arrived with and no reference to is never
+ * reached, a reference naming no note is left naming none, and the separators a notes part lays
+ * the page out with are left as they are. The notes part writer relies on the first of these: a
+ * note disappears only together with its last reference (`docx/storyParts`).
+ */
+import { Plugin } from "prosemirror-state";
+import { type NoteKind } from "../../schema/stories";
+export declare function noteLifecycle(kinds?: readonly NoteKind[]): Plugin;

package/dist/editor/plugins/noteLifecycle.js

@@ -0,0 +1,117 @@
+// src/editor/plugins/noteLifecycle.ts
+import { Plugin } from "prosemirror-state";
+import { DocAttrStep, Mapping } from "prosemirror-transform";
+import {
+  copiedNoteStory,
+  nextNoteId,
+  takenNoteIds
+} from "../../docx/notes/newNote.js";
+import { setStory, withoutStories } from "../../docx/story.js";
+import { displayOnly } from "../../schema/displayDerivation.js";
+import { stepReaches } from "../../schema/guards.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey,
+  storyNodeOf
+} from "../../schema/stories.js";
+import { documentOf } from "../editorDocument.js";
+function kindOf(node, kinds) {
+  if (node.type.name !== "noteReference") return null;
+  return kinds.find((kind) => kind === node.attrs.kind) ?? null;
+}
+function referencesIn(doc, kinds) {
+  const found = [];
+  doc.descendants((node, pos) => {
+    const kind = kindOf(node, kinds);
+    const id = node.attrs.id;
+    if (kind !== null && typeof id === "string") {
+      found.push({ kind, key: storyKey(kind, id), pos });
+    }
+    return true;
+  });
+  return found;
+}
+function countsOf(references) {
+  return references.reduce(
+    (counts, { key }) => counts.set(key, (counts.get(key) ?? 0) + 1),
+    /* @__PURE__ */ new Map()
+  );
+}
+function reachesReferences(tr, kinds) {
+  if (!tr.docChanged || tr.getMeta(displayOnly) === true) return false;
+  return tr.steps.some(
+    (step, index) => !(step instanceof DocAttrStep) && stepReaches(
+      step,
+      tr.docs[index],
+      tr.docs[index + 1] ?? tr.doc,
+      (node) => kindOf(node, kinds) !== null
+    )
+  );
+}
+function copiedReferences(transactions, before, after) {
+  const found = countsOf(before);
+  const left = countsOf(after);
+  const mapping = new Mapping(transactions.flatMap((tr) => tr.mapping.maps));
+  const carried = new Set(
+    before.flatMap(({ key, pos }) => {
+      const mapped = mapping.mapResult(pos, 1);
+      return mapped.deletedAfter ? [] : [`${key}@${mapped.pos}`];
+    })
+  );
+  const wasCarried = ({ key, pos }) => carried.has(`${key}@${pos}`);
+  return [...left].flatMap(([key, count]) => {
+    const kept = found.get(key) ?? 0;
+    if (kept === 0 || count <= kept) return [];
+    const standing = after.filter((reference) => reference.key === key);
+    return [
+      ...standing.filter(wasCarried),
+      ...standing.filter((reference) => !wasCarried(reference))
+    ].slice(kept);
+  });
+}
+function settled(transactions, oldState, newState, kinds) {
+  const document = documentOf(newState);
+  const isNote = (key) => !document.specialNotes.has(key) && storyNodeOf(newState.doc, key) !== null;
+  const before = referencesIn(oldState.doc, kinds);
+  const after = referencesIn(newState.doc, kinds);
+  const left = countsOf(after);
+  const gone = [...countsOf(before).keys()].filter(
+    (key) => !left.has(key) && isNote(key)
+  );
+  const copies = copiedReferences(transactions, before, after).filter(({ key }) => isNote(key)).sort((a, b) => a.pos - b.pos);
+  if (gone.length === 0 && copies.length === 0) return null;
+  const tr = withoutStories(newState.tr, gone);
+  const taken = /* @__PURE__ */ new Map();
+  for (const copy of copies) {
+    const story = storyNodeOf(newState.doc, copy.key);
+    if (story === null) continue;
+    const ids = taken.get(copy.kind) ?? takenNoteIds(newState.doc, copy.kind, document.reservedNoteKeys);
+    taken.set(copy.kind, ids);
+    const id = nextNoteId(ids);
+    ids.add(id);
+    tr.setNodeAttribute(copy.pos, "id", id).setNodeAttribute(
+      copy.pos,
+      "referenceXml",
+      null
+    );
+    setStory(
+      tr,
+      storyKey(copy.kind, id),
+      copiedNoteStory(story, document.session)
+    );
+  }
+  return tr;
+}
+function noteLifecycle(kinds = EDITABLE_NOTE_KINDS) {
+  return new Plugin({
+    appendTransaction(transactions, oldState, newState) {
+      if (!transactions.some((tr) => reachesReferences(tr, kinds))) {
+        return null;
+      }
+      return settled(transactions, oldState, newState, kinds);
+    }
+  });
+}
+export {
+  noteLifecycle
+};