@portone/docx-editor 0.4.0 → 0.5.0

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,320 @@
+// src/editor/clipboard/plugin.ts
+import {
+  DOMSerializer,
+  Fragment,
+  Slice
+} from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { styleIdOf } from "../../docx/formatting.js";
+import {
+  NEW_LISTS_ATTR,
+  NO_NEW_LISTS,
+  newListsOf,
+  newListsValue
+} from "../../numbering/listRegistry.js";
+import { docxSchema, isPageBreak } from "../../schema/index.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 { COPIED_STYLE_ATTRIBUTE } from "./htmlReader.js";
+import { safeHref } from "./inlineFormatting.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";
+var PUBLIC_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "alt",
+  "aria-label",
+  "class",
+  "colspan",
+  "height",
+  "href",
+  "lang",
+  "rowspan",
+  "src",
+  "style",
+  "width"
+]);
+function isAttributes(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Node);
+}
+function publicAttributes(attrs) {
+  return Object.fromEntries(
+    Object.entries(attrs).filter(([name]) => PUBLIC_ATTRIBUTES.has(name))
+  );
+}
+function isSpecArray(value) {
+  return Array.isArray(value) && typeof value[0] === "string";
+}
+function stripPrivateAttributes(spec) {
+  if (!isSpecArray(spec)) return spec;
+  const [tag, ...rest] = spec;
+  const attrs = isAttributes(rest[0]) ? publicAttributes(rest[0]) : null;
+  const children = (attrs === null ? rest : rest.slice(1)).map(
+    (child) => isSpecArray(child) ? stripPrivateAttributes(child) : child
+  );
+  return attrs === null ? [tag, ...children] : [tag, attrs, ...children];
+}
+function withDomAttribute(spec, name, value) {
+  if (!isSpecArray(spec)) return spec;
+  const [tag, ...rest] = spec;
+  return isAttributes(rest[0]) ? [tag, { ...rest[0], [name]: value }, ...rest.slice(1)] : [tag, { [name]: value }, ...rest];
+}
+function asTag(spec, tag) {
+  return isSpecArray(spec) ? [tag, ...spec.slice(1)] : spec;
+}
+function copiedMarkSpec(mark, spec) {
+  const stripped = stripPrivateAttributes(spec);
+  if (mark.type !== docxSchema.marks.link) return stripped;
+  const href = safeHref(
+    typeof mark.attrs.href === "string" ? mark.attrs.href : null
+  );
+  return href === null ? stripped : asTag(withDomAttribute(stripped, "href", href), "a");
+}
+function copiedNodeSpec(node, spec) {
+  const stripped = stripPrivateAttributes(spec);
+  if (node.type !== docxSchema.nodes.paragraph) return stripped;
+  const styleId = styleIdOf(node.attrs.pPr);
+  return styleId === null ? stripped : withDomAttribute(stripped, COPIED_STYLE_ATTRIBUTE, styleId);
+}
+function copiedNodes() {
+  const drawn = DOMSerializer.fromSchema(docxSchema);
+  return Object.fromEntries(
+    Object.entries(drawn.nodes).map(([name, toDOM]) => [
+      name,
+      (node) => copiedNodeSpec(node, toDOM(node))
+    ])
+  );
+}
+function copiedMarks() {
+  const drawn = DOMSerializer.fromSchema(docxSchema);
+  return Object.fromEntries(
+    Object.entries(drawn.marks).map(([name, toDOM]) => [
+      name,
+      (mark, inline) => copiedMarkSpec(mark, toDOM(mark, inline))
+    ])
+  );
+}
+var ClipboardSerializer = class extends DOMSerializer {
+  constructor(tokenOf) {
+    super(copiedNodes(), copiedMarks());
+    this.tokenOf = tokenOf;
+  }
+  tokenOf;
+  serializeFragment(fragment, options, target) {
+    const dom = super.serializeFragment(fragment, options, target);
+    const token = target === void 0 ? this.tokenOf() : null;
+    if (token !== null) {
+      dom.firstElementChild?.setAttribute(INTERNAL_TOKEN_ATTRIBUTE, token);
+    }
+    return dom;
+  }
+};
+var UNREADABLE_BLOCKS = /* @__PURE__ */ new Set(["rawBlock"]);
+function stringAttr(value) {
+  return typeof value === "string" ? value : "";
+}
+function inlineText(node) {
+  if (node.isText) return node.text ?? "";
+  if (node.type === docxSchema.nodes.hardBreak) {
+    return isPageBreak(node.attrs.brAttrs) ? "\f" : "\n";
+  }
+  if (node.type === docxSchema.nodes.image) return stringAttr(node.attrs.alt);
+  if (node.type === docxSchema.nodes.noteReference) {
+    return node.attrs.customMarkFollows === true ? "" : stringAttr(node.attrs.label);
+  }
+  return "";
+}
+function rowsText(table) {
+  const rows = [];
+  table.forEach((row) => {
+    const cells = [];
+    row.forEach((cell) => {
+      cells.push(fragmentText(cell.content));
+    });
+    rows.push(cells.join("	"));
+  });
+  return rows.join("\n");
+}
+function blockText(node) {
+  if (node.type === docxSchema.nodes.table) return rowsText(node);
+  if (UNREADABLE_BLOCKS.has(node.type.name)) return "";
+  return fragmentText(node.content);
+}
+function fragmentText(fragment) {
+  const pieces = [];
+  fragment.forEach((child) => {
+    pieces.push(child.isInline ? inlineText(child) : blockText(child));
+  });
+  return pieces.join(fragment.firstChild?.isInline === true ? "" : "\n");
+}
+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 clipboardText(slice) {
+  return fragmentText(slice.content);
+}
+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 = new ClipboardSerializer(() => 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
+};

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

@@ -0,0 +1,24 @@
+import type { EditorState } from "prosemirror-state";
+import type { FormattingContext, ParagraphStyleOption } from "../../docx/formatting";
+import type { ImageToInsert } from "../insertImage";
+/**
+ * Everything a piece of HTML is read against.
+ *
+ * The reader answers about the document it is read into - which styles it may name, which list
+ * numbers are taken, whether a list may be started at all - and nothing about the editor holding
+ * it. Gathering those in one place is what keeps the reader off the editing state, so the same
+ * reading can be asked for from a paste, from a drop, and from a test.
+ */
+export interface HtmlReadContext {
+    /** The document the markup is read into an element of */
+    document: Document;
+    formatting: FormattingContext;
+    paragraphStyles: readonly ParagraphStyleOption[];
+    numbering: {
+        used: ReadonlySet<number>;
+        canCreate: boolean;
+    };
+    /** The images already loaded for this read, by the token the markup carries */
+    images: ReadonlyMap<string, ImageToInsert>;
+}
+export declare function readContextOf(state: EditorState, document: Document, images?: ReadonlyMap<string, ImageToInsert>): HtmlReadContext;

package/dist/editor/clipboard/readContext.js

@@ -0,0 +1,19 @@
+// src/editor/clipboard/readContext.ts
+import { numIdsIn } from "../commands/listCommands.js";
+import { documentFormatting, documentParagraphStyles } from "../documentStyles.js";
+import { canStartNewList } from "../plugins/numberingDecorations.js";
+function readContextOf(state, document, images = /* @__PURE__ */ new Map()) {
+  return {
+    document,
+    formatting: documentFormatting(state),
+    paragraphStyles: documentParagraphStyles(state),
+    numbering: {
+      used: numIdsIn(state.doc),
+      canCreate: canStartNewList(state)
+    },
+    images
+  };
+}
+export {
+  readContextOf
+};