@portone/docx-editor 0.4.0 → 0.5.1

package/dist/editor/clipboard/internalChannel.js

@@ -0,0 +1,58 @@
+// src/editor/clipboard/internalChannel.ts
+import { docxSchema } from "../../schema/index.js";
+import { listKindOf, listRefOf } from "../commands/listCommands.js";
+var INTERNAL_TOKEN_ATTRIBUTE = "data-docx-clip";
+var NO_LIST_KINDS = /* @__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) {
+  if (sessionId === null) return null;
+  const token = nextToken();
+  copied.set(route, {
+    token,
+    sessionId,
+    slice,
+    listKinds: listKindsIn(slice, numbering)
+  });
+  return token;
+}
+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 };
+}
+function listKindsIn(slice, numbering) {
+  const kinds = /* @__PURE__ */ new Map();
+  const read = (node) => {
+    if (node.type === docxSchema.nodes.paragraph) {
+      const ref = listRefOf(node);
+      const kind = ref === null ? null : listKindOf(numbering, ref);
+      if (ref !== null && kind !== null) kinds.set(ref.numId, kind);
+      return;
+    }
+    node.forEach(read);
+  };
+  slice.content.forEach(read);
+  return kinds.size === 0 ? NO_LIST_KINDS : kinds;
+}
+function internalTokenOf(dom) {
+  if (dom instanceof Element) {
+    const own = dom.getAttribute(INTERNAL_TOKEN_ATTRIBUTE);
+    if (own !== null) return own;
+  }
+  const first = dom instanceof Element || dom instanceof DocumentFragment ? dom.firstElementChild : null;
+  return first?.getAttribute(INTERNAL_TOKEN_ATTRIBUTE) ?? null;
+}
+export {
+  INTERNAL_TOKEN_ATTRIBUTE,
+  NO_LIST_KINDS,
+  internalTokenOf,
+  recallCopied,
+  rememberCopied
+};

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

@@ -0,0 +1,99 @@
+/**
+ * What a slice has to obey before it may be put into this document.
+ *
+ * A slice reaching a paste says where its blocks came from, which list its paragraphs belong to,
+ * which comment its markers open, and what everything is drawn with. None of those mean anything
+ * outside the document that wrote them: a block naming a fragment of the file would be written
+ * from that fragment a second time, a list number naming no definition here would be exported
+ * bare, and a comment marker copied along would open a range the comment part never opens. So a
+ * paste is a normalization rather than an insertion, and each rule stands as one normalizer over
+ * the whole slice, in the order they are declared.
+ *
+ * A move drop is the exception the first two rules read: content dragged from one place in this
+ * very document to another is the same content, so it keeps the identity it had and the anchors it
+ * stood in. The source of a move is deleted along with the drop, so nothing is duplicated.
+ */
+import { type Node as PMNode, Slice } from "prosemirror-model";
+import type { EditorState } from "prosemirror-state";
+import { type ListKind } from "../../numbering/listTemplate";
+import type { PastedContent } from "./htmlReader";
+import { type ListKinds } from "./internalChannel";
+/** What one normalizer answers about the document the slice is going into */
+export interface NormalizeContext {
+    readonly state: EditorState;
+    /** A drop that moves what it carries rather than copying it, which keeps its source identity */
+    readonly move: boolean;
+    /**
+     * The list numbers this document answers for: the ones it defines, the ones a list started
+     * while editing was registered under, the ones its paragraphs wear, and the ones this very
+     * paste has started.
+     */
+    readonly knownLists: ReadonlySet<number>;
+    /**
+     * What the numbers the slice names meant where it was copied, for the numbers this document
+     * cannot answer for. Empty for a slice that came in as markup, whose lists were given numbers
+     * of this document as they were read.
+     */
+    readonly listKinds: ListKinds;
+    /**
+     * A number for a list this slice starts, registered with the definition it is started with, as
+     * the list button starts one. Null in a document with nowhere to write a definition.
+     */
+    startList(kind: ListKind): number | null;
+}
+export type SliceNormalizer = (slice: Slice, context: NormalizeContext) => Slice;
+/** The slice with every node rewritten depth first, and the ones mapped to null taken out */
+export declare function mapSliceNodes(slice: Slice, f: (node: PMNode) => PMNode | null): Slice;
+/**
+ * Takes the source identity off what is pasted.
+ *
+ * A block names the fragment of the opened file it came from, and the export writes that fragment
+ * back verbatim rather than building one. Two blocks naming the same fragment would therefore go
+ * out as the same bytes twice, identifiers and all, so a pasted copy names none and is written
+ * from the model instead. A preserved block holding its own XML is that XML wherever it stands and
+ * travels whole; one that only names a fragment has nothing of its own to travel with, so it goes.
+ */
+export declare const dropSourceIdentity: SliceNormalizer;
+/**
+ * Gives a pasted list a number this document defines.
+ *
+ * A number the destination knows nothing about is exported as a list nothing defines, which the
+ * export invariants refuse. The paragraphs that shared such a number still share the one they are
+ * given, so a pasted list stays one list, started the way the list button starts one and drawn and
+ * written from the destination's own definition from here on.
+ *
+ * Which of the two kinds it is started as is the one thing the number alone does not say. A copy
+ * made in this same session was remembered alongside what its numbers meant there
+ * (`./internalChannel`), so a bulleted list comes back bulleted; a number arriving any other way
+ * has no kind to be read off it and counts.
+ */
+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 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;
+/**
+ * Works out again what the pasted paragraphs are drawn with.
+ *
+ * The values a paragraph and the runs in it carry were resolved against the styles, the defaults
+ * and the list definitions of wherever the slice came from, this document's own list definitions
+ * after the numbers have just been reissued among them. Resolving them here is what makes the
+ * numbering the paste registers the numbering the document is then found to wear.
+ */
+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.
+ */
+export declare function normalizePasted(content: PastedContent, state: EditorState, move: boolean, normalizers?: readonly SliceNormalizer[]): PastedContent;

package/dist/editor/clipboard/normalizers.js

@@ -0,0 +1,199 @@
+// src/editor/clipboard/normalizers.ts
+import {
+  Fragment,
+  Mark,
+  Slice
+} from "prosemirror-model";
+import {
+  paragraphAttrsOf,
+  resolveParagraph,
+  resolveRun
+} from "../../docx/formatting.js";
+import { withListNumbering } from "../../docx/paraProps.js";
+import {
+  allocateList,
+  templateList
+} from "../../numbering/listTemplate.js";
+import {
+  COMMENT_RANGE_MARKERS,
+  PERMISSION_MARKERS,
+  RANGE_MARKERS
+} from "../../ooxml/rangeMarkers.js";
+import { docxSchema } from "../../schema/index.js";
+import { listRefOf, numIdsIn } from "../commands/listCommands.js";
+import { documentFormatting } from "../documentStyles.js";
+import {
+  canStartNewList,
+  documentNumbering
+} from "../plugins/numberingDecorations.js";
+import { NO_LIST_KINDS } from "./internalChannel.js";
+function xmlAttr(value) {
+  return typeof value === "string" ? value : null;
+}
+function withAttrs(node, attrs) {
+  return node.type.create(attrs, node.content, node.marks);
+}
+function mapFragment(fragment, openStart, openEnd, f) {
+  const mapped = [];
+  fragment.forEach((child, _offset, index) => {
+    const first = index === 0;
+    const last = index === fragment.childCount - 1;
+    const inside = child.isText ? child : child.type.create(
+      child.attrs,
+      mapFragment(
+        child.content,
+        first ? openStart - 1 : 0,
+        last ? openEnd - 1 : 0,
+        f
+      ),
+      child.marks
+    );
+    const next = f(inside);
+    if (next !== null) mapped.push(next);
+    else if (first && openStart > 0 || last && openEnd > 0) {
+      mapped.push(docxSchema.nodes.paragraph.create());
+    }
+  });
+  return Fragment.fromArray(mapped);
+}
+function mapSliceNodes(slice, f) {
+  return new Slice(
+    mapFragment(slice.content, slice.openStart, slice.openEnd, f),
+    slice.openStart,
+    slice.openEnd
+  );
+}
+var dropSourceIdentity = (slice, { move }) => move ? slice : mapSliceNodes(slice, (node) => {
+  if (node.type === docxSchema.nodes.rawBlock) {
+    return node.attrs.xml === null ? null : withAttrs(node, { ...node.attrs, srcId: null });
+  }
+  if (node.type !== docxSchema.nodes.paragraph && node.type !== docxSchema.nodes.table) {
+    return node;
+  }
+  return node.attrs.srcId === null ? node : withAttrs(node, { ...node.attrs, srcId: null });
+});
+var rekeyNumbering = (slice, context) => {
+  const given = /* @__PURE__ */ new Map();
+  return mapSliceNodes(slice, (node) => {
+    if (node.type !== docxSchema.nodes.paragraph) return node;
+    const ref = listRefOf(node);
+    if (ref === null || context.knownLists.has(ref.numId)) return node;
+    const taken = given.has(ref.numId) ? given.get(ref.numId) ?? null : context.startList(context.listKinds.get(ref.numId) ?? "numbered");
+    given.set(ref.numId, taken);
+    const props = taken === null ? withListNumbering(node.attrs.pPr, {
+      numbering: null,
+      indent: { kind: "clearHanging" }
+    }) : withListNumbering(node.attrs.pPr, {
+      numbering: { numId: taken, ilvl: ref.ilvl },
+      indent: { kind: "keep" }
+    });
+    return props === null ? node : withAttrs(node, { ...node.attrs, pPr: props.pPr });
+  });
+};
+var ANCHOR_NODES = /* @__PURE__ */ new Set([
+  "commentStart",
+  "commentEnd",
+  "commentReference",
+  "noteReference"
+]);
+var REFERENCE_ELEMENTS = [
+  "commentReference",
+  "footnoteReference",
+  "endnoteReference"
+];
+var ANCHOR_ELEMENTS = /* @__PURE__ */ new Set([
+  ...RANGE_MARKERS,
+  ...PERMISSION_MARKERS,
+  ...COMMENT_RANGE_MARKERS,
+  ...REFERENCE_ELEMENTS
+]);
+var PRESERVED_INLINE = /* @__PURE__ */ new Set([
+  "rawInline",
+  "rawRunContent"
+]);
+function preservedName(node) {
+  const xml = node.attrs.xml;
+  const opening = typeof xml === "string" ? /^<\s*(?:[^\s:>/]+:)?([^\s>/]+)/.exec(xml) : null;
+  if (opening?.[1] !== void 0) return opening[1];
+  const element = node.attrs.element;
+  return typeof element === "string" ? element : null;
+}
+var detachAnchors = (slice, { move }) => move ? slice : mapSliceNodes(slice, (node) => {
+  if (ANCHOR_NODES.has(node.type.name)) return null;
+  if (!PRESERVED_INLINE.has(node.type.name)) return node;
+  const name = preservedName(node);
+  return name !== null && ANCHOR_ELEMENTS.has(name) ? null : node;
+});
+var rederiveDisplay = (slice, { state }) => {
+  const formatting = documentFormatting(state);
+  return mapSliceNodes(slice, (node) => {
+    if (node.type !== docxSchema.nodes.paragraph) return node;
+    const paragraph = resolveParagraph(xmlAttr(node.attrs.pPr), formatting);
+    const inline = node.children.map((child) => {
+      const marks = child.marks.map(
+        (mark) => mark.type === docxSchema.marks.run ? mark.type.create({
+          ...mark.attrs,
+          format: resolveRun(
+            xmlAttr(mark.attrs.rPr),
+            paragraph,
+            formatting
+          )
+        }) : mark
+      );
+      return Mark.sameSet(marks, child.marks) ? child : child.mark(marks);
+    });
+    return node.type.create(
+      { ...node.attrs, ...paragraphAttrsOf(paragraph) },
+      Fragment.fromArray(inline),
+      node.marks
+    );
+  });
+};
+var DEFAULT_NORMALIZERS = [
+  dropSourceIdentity,
+  detachAnchors,
+  rekeyNumbering,
+  rederiveDisplay
+];
+function normalizePasted(content, state, move, normalizers = DEFAULT_NORMALIZERS) {
+  let numbering = documentNumbering(state);
+  const known = /* @__PURE__ */ new Set([
+    ...numbering.lists.keys(),
+    ...numbering.added.keys(),
+    ...numIdsIn(state.doc),
+    ...content.newLists.keys()
+  ]);
+  const started = /* @__PURE__ */ new Map();
+  const context = {
+    state,
+    move,
+    knownLists: known,
+    listKinds: content.listKinds ?? NO_LIST_KINDS,
+    startList(kind) {
+      if (!canStartNewList(state)) return null;
+      const list = templateList(kind);
+      const taken = allocateList(numbering, known, list);
+      numbering = taken.numbering;
+      known.add(taken.numId);
+      started.set(taken.numId, list);
+      return taken.numId;
+    }
+  };
+  const slice = normalizers.reduce(
+    (current, normalize) => normalize(current, context),
+    content.slice
+  );
+  return {
+    slice,
+    newLists: started.size === 0 ? content.newLists : new Map([...content.newLists, ...started])
+  };
+}
+export {
+  DEFAULT_NORMALIZERS,
+  detachAnchors,
+  dropSourceIdentity,
+  mapSliceNodes,
+  normalizePasted,
+  rederiveDisplay,
+  rekeyNumbering
+};

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

@@ -0,0 +1,34 @@
+import { DOMParser, Slice } from "prosemirror-model";
+import type { EditorView } from "prosemirror-view";
+import type { PastedContent } from "./htmlReader";
+import type { ClipboardInput, ClipboardReader } from "./readers";
+/**
+ * The parser ProseMirror hands the clipboard to.
+ *
+ * It is a `DOMParser` because that is what the `clipboardParser` prop is, but it holds no rules:
+ * clipboard markup is read by the reader chain alone, so a `parseDOM` rule of the schema - which
+ * would take the document's own XML back out of a private attribute - never sees it.
+ */
+export declare class DocxClipboardParser extends DOMParser {
+    private readonly readers;
+    private readonly inputOf;
+    private read;
+    private textOnly;
+    private pasteEvent;
+    constructor(readers: readonly ClipboardReader[], inputOf: (dom: Node) => ClipboardInput | null);
+    parseSlice(dom: Node): Slice;
+    /**
+     * What the last parse read, given up as it is taken.
+     *
+     * ProseMirror widens whatever a parser returns to the openness the surrounding markup implies
+     * and wraps it in the nodes a `data-pm-slice` context names, neither of which the reader asked
+     * for. The plugin puts this back in `transformPasted`, and takes it so that a later drag - which
+     * reaches `transformPasted` without a parse - never picks up a stale reading.
+     */
+    takeRead(): PastedContent | null;
+    /** A new reading replaces the mode left by the previous clipboard event */
+    setPlainText(plain: boolean): void;
+    isPlainText(event: ClipboardEvent): boolean;
+}
+/** Whether the current paste chose text, so image handlers must leave its HTML and files alone */
+export declare function plainTextPaste(view: EditorView, event: ClipboardEvent): boolean;

package/dist/editor/clipboard/parser.js

@@ -0,0 +1,58 @@
+// src/editor/clipboard/parser.ts
+import { DOMParser, Slice } from "prosemirror-model";
+import { docxSchema } from "../../schema/index.js";
+var DocxClipboardParser = class extends DOMParser {
+  constructor(readers, inputOf) {
+    super(docxSchema, []);
+    this.readers = readers;
+    this.inputOf = inputOf;
+  }
+  readers;
+  inputOf;
+  read = null;
+  textOnly = false;
+  pasteEvent = null;
+  parseSlice(dom) {
+    this.read = null;
+    this.setPlainText(false);
+    const input = this.inputOf(dom);
+    if (input === null) return Slice.empty;
+    for (const reader of this.readers) {
+      const content = reader(input);
+      if (content === null) continue;
+      this.read = content;
+      return content.slice;
+    }
+    return Slice.empty;
+  }
+  /**
+   * What the last parse read, given up as it is taken.
+   *
+   * ProseMirror widens whatever a parser returns to the openness the surrounding markup implies
+   * and wraps it in the nodes a `data-pm-slice` context names, neither of which the reader asked
+   * for. The plugin puts this back in `transformPasted`, and takes it so that a later drag - which
+   * reaches `transformPasted` without a parse - never picks up a stale reading.
+   */
+  takeRead() {
+    const read = this.read;
+    this.read = null;
+    return read;
+  }
+  /** A new reading replaces the mode left by the previous clipboard event */
+  setPlainText(plain) {
+    this.textOnly = plain;
+    this.pasteEvent = null;
+  }
+  isPlainText(event) {
+    if (this.pasteEvent === null) this.pasteEvent = event;
+    return this.pasteEvent === event && this.textOnly;
+  }
+};
+function plainTextPaste(view, event) {
+  const parser = view.someProp("clipboardParser");
+  return parser instanceof DocxClipboardParser && parser.isPlainText(event);
+}
+export {
+  DocxClipboardParser,
+  plainTextPaste
+};

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

@@ -0,0 +1,21 @@
+/**
+ * The one plugin holding the editor's clipboard.
+ *
+ * Everything the clipboard carries in or out passes through the props declared here: what a copy
+ * is written as, what a paste is read as, and what a drop from outside becomes. ProseMirror asks
+ * these before it asks any `handlePaste`. This plugin handles only an empty reading, preserving
+ * the selection or retrying the text fallback. Content goes in through ProseMirror's insertion
+ * with the `paste` and `uiEvent` meta a plugin
+ * watching for one reads (`prosemirror-view`'s `doPaste`), and a table decides for itself what a
+ * paste over a cell selection means (`prosemirror-tables`).
+ */
+import { Plugin } from "prosemirror-state";
+import { type SliceNormalizer } from "./normalizers";
+import { type ClipboardReader } from "./readers";
+export interface ClipboardOptions {
+    /** Tried from the front. The first reader to answer decides what a paste puts in */
+    readers?: readonly ClipboardReader[];
+    /** Run in order over every pasted and dropped slice before it is put in */
+    normalizers?: readonly SliceNormalizer[];
+}
+export declare function docxClipboard(options?: ClipboardOptions): Plugin;

package/dist/editor/clipboard/plugin.js

@@ -0,0 +1,188 @@
+// src/editor/clipboard/plugin.ts
+import { Fragment, Slice } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import {
+  NEW_LISTS_ATTR,
+  NO_NEW_LISTS,
+  newListsOf,
+  newListsValue
+} from "../../numbering/listRegistry.js";
+import { clipboardSerializer, clipboardText } from "../../schema/clipboard.js";
+import { numIdsIn } from "../commands/listCommands.js";
+import { documentOf } from "../editorDocument.js";
+import { insertPlainText } from "../plainText.js";
+import { moveCaretToDrop } from "../plugins/dropCaret.js";
+import { documentNumbering } from "../plugins/numberingDecorations.js";
+import {
+  INTERNAL_TOKEN_ATTRIBUTE,
+  internalTokenOf,
+  rememberCopied
+} from "./internalChannel.js";
+import {
+  DEFAULT_NORMALIZERS,
+  normalizePasted
+} from "./normalizers.js";
+import { DocxClipboardParser } from "./parser.js";
+import { readContextOf } from "./readContext.js";
+import {
+  DEFAULT_READERS,
+  plainTextSlice
+} from "./readers.js";
+function bareWrappers(content, openStart, openEnd) {
+  const wrapper = content.firstChild;
+  if (openStart <= 1 || openEnd <= 1 || content.childCount !== 1)
+    return content;
+  if (wrapper === null || wrapper.childCount !== 1) return content;
+  return Fragment.from(
+    wrapper.type.create(
+      null,
+      bareWrappers(wrapper.content, openStart - 1, openEnd - 1),
+      wrapper.marks
+    )
+  );
+}
+function copiedSlice(slice) {
+  return new Slice(
+    bareWrappers(slice.content, slice.openStart, slice.openEnd),
+    slice.openStart,
+    slice.openEnd
+  );
+}
+function dragCopyModifier() {
+  return /Mac|iP(hone|[oa]d)/.test(navigator.platform) ? "altKey" : "ctrlKey";
+}
+function dropMoves(view, event) {
+  if (view.dragging === null) return false;
+  let copies;
+  view.someProp("dragCopies", (test) => {
+    copies = copies === true || test(event);
+  });
+  return copies === void 0 ? !event[dragCopyModifier()] : !copies;
+}
+function docxClipboard(options = {}) {
+  const normalizers = options.normalizers ?? DEFAULT_NORMALIZERS;
+  let copyToken = null;
+  const serializer = clipboardSerializer((copy) => {
+    if (copyToken !== null) {
+      copy.firstElementChild?.setAttribute(INTERNAL_TOKEN_ATTRIBUTE, copyToken);
+    }
+  });
+  let host = null;
+  const parser = new DocxClipboardParser(
+    options.readers ?? DEFAULT_READERS,
+    (dom) => host === null ? null : {
+      dom,
+      token: internalTokenOf(dom),
+      sessionId: documentOf(host.state).session?.sessionId ?? null,
+      context: readContextOf(host.state, host.dom.ownerDocument)
+    }
+  );
+  let started = null;
+  let dropMove = false;
+  let draggingOut = false;
+  return new Plugin({
+    view(view) {
+      host = view;
+      return {
+        destroy() {
+          if (host === view) host = null;
+        }
+      };
+    },
+    /**
+     * The definitions of the lists a paste began, registered on the document once the paste is
+     * in. A list the pasted markup started is numbered as it is read, and only the edit that
+     * lands says whether that number is worn in the end.
+     */
+    appendTransaction(transactions, _before, after) {
+      const lists = started;
+      started = null;
+      if (lists === null || lists.size === 0 || !transactions.some((tr) => tr.docChanged)) {
+        return null;
+      }
+      const worn = numIdsIn(after.doc);
+      const registered = newListsOf(after.doc.attrs[NEW_LISTS_ATTR]);
+      const missing = [...lists].filter(
+        ([numId]) => worn.has(numId) && !registered.has(numId)
+      );
+      if (missing.length === 0) return null;
+      return after.tr.setDocAttribute(
+        NEW_LISTS_ATTR,
+        newListsValue(new Map([...registered, ...missing]))
+      );
+    },
+    props: {
+      handleDOMEvents: {
+        paste() {
+          parser.setPlainText(false);
+          return false;
+        },
+        // ProseMirror writes and reads the dragged slice inside the very event the two below
+        // answer for, through props it hands the view and not the event, and it runs these first.
+        // A microtask is the first thing to run once the event is over, so neither answer is left
+        // standing for whatever comes next
+        dragstart() {
+          draggingOut = true;
+          queueMicrotask(() => {
+            draggingOut = false;
+          });
+          return false;
+        },
+        drop(view, event) {
+          dropMove = dropMoves(view, event);
+          queueMicrotask(() => {
+            dropMove = false;
+          });
+          return false;
+        }
+      },
+      clipboardParser: parser,
+      clipboardSerializer: serializer,
+      clipboardTextParser(text, context, plain) {
+        parser.setPlainText(plain);
+        return plainTextSlice(text, context);
+      },
+      clipboardTextSerializer: clipboardText,
+      transformCopied(slice, view) {
+        const route = draggingOut ? "drag" : "clipboard";
+        copyToken = rememberCopied(
+          route,
+          slice,
+          documentOf(view.state).session?.sessionId ?? null,
+          documentNumbering(view.state)
+        );
+        return copiedSlice(slice);
+      },
+      transformPasted(slice, view, plain) {
+        if (!plain) parser.setPlainText(false);
+        const read = parser.takeRead();
+        const content = normalizePasted(
+          read ?? { slice, newLists: NO_NEW_LISTS },
+          view.state,
+          dropMove,
+          normalizers
+        );
+        started = content.newLists;
+        return content.slice;
+      },
+      handlePaste(view, event, slice) {
+        if (slice.content.size > 0) return false;
+        const text = event.clipboardData?.getData("text/plain") ?? "";
+        if (!parser.isPlainText(event) && text) view.pasteText(text, event);
+        return true;
+      },
+      handleDrop(view, event) {
+        if (view.dragging) return false;
+        const text = event.dataTransfer?.getData("text/plain") ?? "";
+        if (text) {
+          moveCaretToDrop(view, event);
+          insertPlainText(view, text);
+        }
+        return true;
+      }
+    }
+  });
+}
+export {
+  docxClipboard
+};