@portone/docx-editor 0.4.0 → 0.5.1

package/dist/editor/clipboard/blockReaders.js

@@ -0,0 +1,193 @@
+// src/editor/clipboard/blockReaders.ts
+import {
+  createTableNodeFrom,
+  isTableSide,
+  MAX_TABLE_SIDE
+} from "../../docx/tableTemplate.js";
+import { MAX_ILVL } from "../../numbering/listTemplate.js";
+import { docxSchema } from "../../schema/index.js";
+import { contextFor } from "./inlineFormatting.js";
+var CELL_TAGS = /* @__PURE__ */ new Set(["TD", "TH"]);
+var ROW_GROUP_TAGS = /* @__PURE__ */ new Set(["THEAD", "TBODY", "TFOOT"]);
+function rowsOf(table) {
+  return [...table.children].flatMap((child) => {
+    if (!(child instanceof HTMLElement)) return [];
+    if (child.tagName === "TR") return [child];
+    if (!ROW_GROUP_TAGS.has(child.tagName)) return [];
+    return [...child.children].flatMap(
+      (row) => row instanceof HTMLElement && row.tagName === "TR" ? [row] : []
+    );
+  });
+}
+function cellsOf(row) {
+  return [...row.children].flatMap(
+    (cell) => cell instanceof HTMLElement && CELL_TAGS.has(cell.tagName) ? [cell] : []
+  );
+}
+function spanOf(element, name, limit) {
+  const value = Number.parseInt(element.getAttribute(name) ?? "", 10);
+  return Number.isFinite(value) && value > 1 ? Math.min(value, limit) : 1;
+}
+function gridOf(table) {
+  const rows = rowsOf(table).filter((row) => cellsOf(row).length > 0);
+  if (!isTableSide(rows.length)) return null;
+  const covered = rows.map(() => /* @__PURE__ */ new Set());
+  const cells = rows.map(() => []);
+  let cols = 0;
+  rows.forEach((row, top) => {
+    let left = 0;
+    for (const element of cellsOf(row)) {
+      while (covered[top]?.has(left)) left += 1;
+      const colspan = spanOf(element, "colspan", MAX_TABLE_SIDE);
+      const rowspan = Math.min(
+        spanOf(element, "rowspan", MAX_TABLE_SIDE),
+        rows.length - top
+      );
+      for (let covering = top; covering < top + rowspan; covering += 1) {
+        for (let column = left; column < left + colspan; column += 1) {
+          covered[covering]?.add(column);
+        }
+      }
+      cells[top]?.push({
+        element,
+        rect: { top, bottom: top + rowspan, left, right: left + colspan }
+      });
+      left += colspan;
+      cols = Math.max(cols, left);
+    }
+  });
+  return isTableSide(cols) ? cells : null;
+}
+function captionOf(table) {
+  for (const child of table.children) {
+    if (child instanceof HTMLElement && child.tagName === "CAPTION") {
+      return child;
+    }
+  }
+  return null;
+}
+function rowParagraphs(table, inline, host) {
+  return rowsOf(table).filter((row) => cellsOf(row).length > 0).map(
+    (row) => host.paragraph(
+      cellsOf(row).flatMap((cell, index) => [
+        ...index === 0 ? [] : [docxSchema.text("	", [docxSchema.marks.tab.create()])],
+        ...host.readInline(cell.childNodes, contextFor(inline, cell))
+      ])
+    )
+  );
+}
+var tableBlockReader = {
+  read: (element, inline, host) => {
+    if (element.tagName !== "TABLE") return null;
+    const inside = contextFor(inline, element);
+    const caption = captionOf(element);
+    const above = caption === null ? [] : [
+      host.paragraph(
+        host.readInline(caption.childNodes, contextFor(inside, caption))
+      )
+    ];
+    const grid = host.inTable ? null : gridOf(element);
+    if (grid === null) {
+      return [...above, ...rowParagraphs(element, inside, host)];
+    }
+    const cells = grid.map(
+      (row) => row.map(({ element: cell, rect }) => ({
+        rect,
+        content: host.readCell(cell, contextFor(inside, cell))
+      }))
+    );
+    return [...above, createTableNodeFrom(cells, host.context.geometry)];
+  }
+};
+var WORD_LIST = /mso-list:\s*l(?<list>\d+)\s+level(?<level>\d+)\s+lfo(?<applied>\d+)/i;
+var IGNORED_MARKER = /mso-list:\s*Ignore/i;
+var MARKER_START = /^\[if\s+!supportLists\]/i;
+var MARKER_END = /^\[endif\]/i;
+var COUNTED_MARKER = /^\s*(?:\d+|[A-Za-z]+)\s*[.)]\s*/;
+function wordListItemOf(element) {
+  const found = WORD_LIST.exec(element.getAttribute("style") ?? "")?.groups;
+  if (found === void 0) return null;
+  const level = Number.parseInt(found.level ?? "", 10);
+  return {
+    key: `${found.list}/${found.applied}`,
+    // Word counts its levels from one, and no document has more levels than the model holds
+    level: Number.isFinite(level) ? Math.min(Math.max(level, 1), MAX_ILVL + 1) - 1 : 0
+  };
+}
+function withoutMarker(element) {
+  const content = [];
+  let marker = "";
+  let inMarker = false;
+  for (const child of element.childNodes) {
+    if (child.nodeType === child.COMMENT_NODE) {
+      const data = child.nodeValue ?? "";
+      if (MARKER_START.test(data)) inMarker = true;
+      else if (MARKER_END.test(data)) inMarker = false;
+      continue;
+    }
+    const ignored = child instanceof HTMLElement && IGNORED_MARKER.test(child.getAttribute("style") ?? "");
+    if (inMarker || ignored) marker += child.textContent ?? "";
+    else content.push(child);
+  }
+  return { marker, content };
+}
+var SYMBOL_FONTS = /symbol|wingdings|webdings/i;
+function leadingNode(element) {
+  for (const child of element.childNodes) {
+    const blank = child.nodeType === child.TEXT_NODE && (child.nodeValue ?? "").trim() === "";
+    if (!blank) return child;
+  }
+  return null;
+}
+function firstText(element) {
+  for (const child of element.childNodes) {
+    if (child.nodeType === child.TEXT_NODE) {
+      if ((child.nodeValue ?? "").trim() !== "") return child;
+    } else if (child instanceof HTMLElement) {
+      const found = firstText(child);
+      if (found !== null) return found;
+    }
+  }
+  return null;
+}
+function leadingMarker(element) {
+  const copy = element.cloneNode(true);
+  if (!(copy instanceof HTMLElement)) return null;
+  const lead = leadingNode(copy);
+  if (lead instanceof HTMLElement && SYMBOL_FONTS.test(lead.getAttribute("style") ?? "")) {
+    const marker = lead.textContent ?? "";
+    lead.remove();
+    return { marker, content: [...copy.childNodes] };
+  }
+  const text = firstText(copy);
+  const counted = COUNTED_MARKER.exec(text?.nodeValue ?? "");
+  if (text === null || counted === null) return null;
+  text.nodeValue = (text.nodeValue ?? "").slice(counted[0].length);
+  return { marker: counted[0], content: [...copy.childNodes] };
+}
+var wordListReader = {
+  read: (element, inline, host) => {
+    if (host.context.source !== "word") return null;
+    const item = wordListItemOf(element);
+    if (item === null) return null;
+    const marked = withoutMarker(element);
+    const { marker, content } = marked.marker === "" ? leadingMarker(element) ?? marked : marked;
+    const kind = COUNTED_MARKER.test(marker) ? "numbered" : "bullet";
+    return [
+      host.paragraph(host.readInline(content, contextFor(inline, element)), {
+        kind,
+        numId: host.listNumber(item.key, kind),
+        level: item.level
+      })
+    ];
+  }
+};
+var DEFAULT_BLOCK_READERS = [
+  tableBlockReader,
+  wordListReader
+];
+export {
+  DEFAULT_BLOCK_READERS,
+  tableBlockReader,
+  wordListReader
+};

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

@@ -0,0 +1,26 @@
+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 { HtmlReadContext } from "./readContext";
+/** What a paste puts in: the content, and the definitions of the lists it started */
+export interface PastedContent {
+    slice: Slice;
+    newLists: NewLists;
+    /**
+     * What the numbers this slice's paragraphs name meant where it was copied
+     * (`./internalChannel`). Absent for a reading that gave the lists it read numbers of its own,
+     * which knows what kind each is from the markup it read them out of.
+     */
+    listKinds?: ListKinds;
+}
+/** 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.
+ */
+export declare function withPastedContent(tr: Transaction, content: PastedContent): Transaction;

package/dist/editor/clipboard/htmlReader.js

@@ -0,0 +1,376 @@
+// src/editor/clipboard/htmlReader.ts
+import { Fragment, Slice } from "prosemirror-model";
+import {
+  paragraphAttrsFor
+} from "../../docx/formatting.js";
+import {
+  withListNumbering,
+  withParagraphStyle
+} from "../../docx/paraProps.js";
+import {
+  listsWorn,
+  NEW_LISTS_ATTR,
+  newListsValue
+} from "../../numbering/listRegistry.js";
+import {
+  allocateList,
+  MAX_ILVL,
+  templateList
+} from "../../numbering/listTemplate.js";
+import { styleIdOf } from "../../ooxml/props.js";
+import { docxSchema } from "../../schema/index.js";
+import { COPIED_STYLE_ATTRIBUTE } from "../../schema/clipboard.js";
+import { editorClassNames } from "../../styles/classNames.js";
+import { numIdsIn } from "../commands/listCommands.js";
+import {
+  DEFAULT_BLOCK_READERS
+} from "./blockReaders.js";
+import { PASTED_IMAGE_ATTRIBUTE } from "./images.js";
+import {
+  appendInline,
+  contextFor,
+  marksFor,
+  withInlineStyle
+} from "./inlineFormatting.js";
+import { detectHtmlSource } from "./source.js";
+var BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "ADDRESS",
+  "ARTICLE",
+  "ASIDE",
+  "BLOCKQUOTE",
+  "DIV",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "LI",
+  "P",
+  "PRE",
+  "SECTION"
+]);
+var BLOCK_SELECTOR = [...BLOCK_TAGS, "OL", "UL", "TABLE"].map((tag) => tag.toLowerCase()).join(",");
+var HEADING_LEVELS = {
+  H1: 1,
+  H2: 2,
+  H3: 3,
+  H4: 4,
+  H5: 5,
+  H6: 6
+};
+var HEADING_FALLBACKS = {
+  1: { bold: true, fontSizePt: 24 },
+  2: { bold: true, fontSizePt: 18 },
+  3: { bold: true, fontSizePt: 14 },
+  4: { bold: true, fontSizePt: 12 },
+  5: { bold: true, fontSizePt: 10 },
+  6: { bold: true, fontSizePt: 8 }
+};
+function normalizedStyleName(value) {
+  return value.toLowerCase().replace(/[\s_-]+/g, "");
+}
+function copiedStyleId(element) {
+  if (!element.classList.contains(editorClassNames.paragraph)) return null;
+  return element.getAttribute(COPIED_STYLE_ATTRIBUTE) ?? styleIdOf(element.getAttribute("data-ppr"));
+}
+function headingLevel(element, sourceStyleId) {
+  const direct = HEADING_LEVELS[element.tagName];
+  if (direct !== void 0) return direct;
+  const match = /^heading([1-6])$/.exec(
+    normalizedStyleName(sourceStyleId ?? "")
+  );
+  return match ? Number.parseInt(match[1] ?? "", 10) : null;
+}
+function destinationStyleId(styles, sourceStyleId, level) {
+  if (sourceStyleId && styles.some((style) => style.id === sourceStyleId)) {
+    return sourceStyleId;
+  }
+  if (level === null) return null;
+  const wanted = `heading${level}`;
+  return styles.find(
+    (style) => normalizedStyleName(style.id) === wanted || normalizedStyleName(style.name) === wanted
+  )?.id ?? null;
+}
+function blockContext(context, parent, element, preserveParagraphStyle) {
+  const editorParagraph = element.classList.contains(
+    editorClassNames.paragraph
+  );
+  const sourceStyleId = copiedStyleId(element);
+  const level = headingLevel(element, sourceStyleId);
+  if (!preserveParagraphStyle && editorParagraph) {
+    return {
+      inline: contextFor(parent, element),
+      paragraph: null
+    };
+  }
+  const styleId = destinationStyleId(
+    context.paragraphStyles,
+    sourceStyleId,
+    level
+  );
+  const paragraph = styleId === null ? null : withParagraphStyle(null, styleId);
+  const usesDestinationStyle = editorParagraph && (sourceStyleId === null || paragraph !== null);
+  let inline = parent;
+  if (paragraph === null && level !== null) {
+    inline = withInlineStyle(inline, HEADING_FALLBACKS[level] ?? {});
+  }
+  return {
+    inline: contextFor(inline, element, !usesDestinationStyle),
+    paragraph
+  };
+}
+function listParagraphProps(list) {
+  if (!list || list.numId === null) return null;
+  return withListNumbering(null, {
+    numbering: { numId: list.numId, ilvl: Math.min(MAX_ILVL, list.level) },
+    indent: { kind: "keep" }
+  });
+}
+function paragraphAttrs(formatting, list, paragraph) {
+  const props = listParagraphProps(list) ?? paragraph;
+  return props ? { pPr: props.pPr, ...paragraphAttrsFor(props.pPr, formatting) } : null;
+}
+var HtmlReader = class {
+  constructor(context, preserveParagraphStyles, blockReaders) {
+    this.context = context;
+    this.preserveParagraphStyles = preserveParagraphStyles;
+    this.blockReaders = blockReaders;
+    this.formatting = context.formatting;
+    this.used = new Set(context.numbering.used);
+    this.canCreateLists = context.numbering.canCreate;
+  }
+  context;
+  preserveParagraphStyles;
+  blockReaders;
+  blocks = [];
+  used;
+  canCreateLists;
+  /** How deep the reading stands inside the tables it is reading */
+  tableDepth = 0;
+  /** The number each list a block reader named has taken, so its items join one list */
+  listNumbers = /* @__PURE__ */ new Map();
+  /**
+   * What the pasted paragraphs are resolved against: the document's context, holding the
+   * definition of each pasted list as it is read, so that an item is drawn against the list it
+   * is joining rather than against a list nothing yet defines.
+   */
+  formatting;
+  /** The definitions of every list started while editing, the pasted ones among them */
+  get newLists() {
+    return this.formatting.numbering.added;
+  }
+  read(root) {
+    this.readFlow(root, { style: {}, href: null, preserveWhitespace: false });
+    return this.blocks;
+  }
+  appendInline(target, node, context) {
+    appendInline(target, node, context, (content, element, inline) => {
+      if (this.context.source === "word" && element.tagName === "O:P") {
+        return true;
+      }
+      if (element.tagName !== "IMG") return false;
+      const token = element.getAttribute(PASTED_IMAGE_ATTRIBUTE);
+      const image = token === null ? void 0 : this.context.images.get(token);
+      if (!image) return true;
+      content.push(
+        docxSchema.nodes.image.create(
+          {
+            ...image,
+            // The source drawing may point at a relationship in another package.
+            xml: null
+          },
+          null,
+          marksFor(inline)
+        )
+      );
+      return true;
+    });
+  }
+  /**
+   * One paragraph of the reading. An item of a list this document may not start keeps its marker
+   * as text, since the list it names is one the document will not be numbering.
+   */
+  paragraphNode(content, list = null, paragraph = null) {
+    const marker = list && list.numId === null ? [docxSchema.text(list.kind === "bullet" ? "\u2022 " : "1. ")] : [];
+    return docxSchema.nodes.paragraph.create(
+      paragraphAttrs(this.formatting, list, paragraph),
+      [...marker, ...content]
+    );
+  }
+  addParagraph(content, list = null, paragraph = null) {
+    this.blocks.push(this.paragraphNode(content, list, paragraph));
+  }
+  /** The blocks a nested reading produces, kept apart from the ones read so far */
+  collect(read) {
+    const outer = this.blocks;
+    this.blocks = [];
+    read();
+    const inner = this.blocks;
+    this.blocks = outer;
+    return inner;
+  }
+  /** What the first reader to answer for this element reads it as, or null where none does */
+  readBlock(element, context, host) {
+    for (const reader of this.blockReaders) {
+      const read = reader.read(element, context, host);
+      if (read !== null) return read;
+    }
+    return null;
+  }
+  /**
+   * What a block reader may ask of this reading. One is made per level of the reading, since a
+   * reader asks whether it stands inside a table and that answer is the level's own.
+   */
+  hostView() {
+    return {
+      context: this.context,
+      inTable: this.tableDepth > 0,
+      readCell: (cell, inline) => {
+        this.tableDepth += 1;
+        const blocks = this.collect(() => this.readFlow(cell, inline));
+        this.tableDepth -= 1;
+        return blocks;
+      },
+      readInline: (nodes, inline) => {
+        const target = [];
+        for (const node of nodes) this.appendInline(target, node, inline);
+        return target;
+      },
+      paragraph: (content, list) => this.paragraphNode(content, list ?? null),
+      listNumber: (key, kind) => {
+        const known = this.listNumbers.get(key);
+        if (known !== void 0) return known;
+        const numId = this.takeNumId(kind);
+        this.listNumbers.set(key, numId);
+        return numId;
+      }
+    };
+  }
+  readFlow(parent, context, paragraph = null) {
+    let inline = [];
+    const flush = () => {
+      if (inline.length === 0) return;
+      this.addParagraph(inline, null, paragraph);
+      inline = [];
+    };
+    const host = this.hostView();
+    for (const child of parent.childNodes) {
+      const element = child.nodeType === child.ELEMENT_NODE ? child : null;
+      const read = element && this.readBlock(element, context, host);
+      if (read) {
+        flush();
+        this.blocks.push(...read);
+      } else if (element?.tagName === "UL" || element?.tagName === "OL") {
+        flush();
+        this.readList(element, context, 0, null);
+      } else if (element && (BLOCK_TAGS.has(element.tagName) || element.querySelector(BLOCK_SELECTOR) !== null)) {
+        flush();
+        const before = this.blocks.length;
+        const block = blockContext(
+          this.context,
+          context,
+          element,
+          this.preserveParagraphStyles
+        );
+        this.readFlow(element, block.inline, block.paragraph);
+        if (this.blocks.length === before) {
+          this.addParagraph([], null, block.paragraph);
+        }
+      } else {
+        this.appendInline(inline, child, context);
+      }
+    }
+    flush();
+  }
+  /**
+   * The number a pasted list takes, registered with the definition that list is drawn and written
+   * with. A pasted list is started here just as the list button starts one.
+   */
+  takeNumId(kind) {
+    if (!this.canCreateLists) return null;
+    const started = allocateList(
+      this.formatting.numbering,
+      this.used,
+      templateList(kind)
+    );
+    this.formatting = { ...this.formatting, numbering: started.numbering };
+    this.used.add(started.numId);
+    return started.numId;
+  }
+  readList(list, context, level, inherited) {
+    const kind = list.tagName === "UL" ? "bullet" : "numbered";
+    const listContext = {
+      kind,
+      numId: inherited?.kind === kind ? inherited.numId : this.takeNumId(kind),
+      level
+    };
+    const items = [...list.children].flatMap(
+      (child) => child instanceof HTMLElement && child.tagName === "LI" ? [child] : []
+    );
+    const host = this.hostView();
+    for (const item of items) {
+      const itemContext = contextFor(context, item);
+      const content = [];
+      const after = [];
+      for (const child of item.childNodes) {
+        const nested = child instanceof HTMLElement ? child : null;
+        if (nested?.tagName === "UL" || nested?.tagName === "OL") continue;
+        const read = nested && this.readBlock(nested, itemContext, host);
+        if (read) after.push(...read);
+        else this.appendInline(content, child, itemContext);
+      }
+      this.addParagraph(content, listContext);
+      this.blocks.push(...after);
+      for (const nested of Array.from(item.children)) {
+        if (nested.tagName === "UL" || nested.tagName === "OL") {
+          this.readList(
+            nested,
+            itemContext,
+            level + 1,
+            listContext
+          );
+        }
+      }
+    }
+  }
+};
+function sliceDepth(root) {
+  const marker = root.querySelector("[data-pm-slice]");
+  const openStart = Number.parseInt(
+    marker?.getAttribute("data-pm-slice")?.split(/\s+/, 1)[0] ?? "",
+    10
+  );
+  if (Number.isFinite(openStart)) return openStart === 0 ? 0 : 1;
+  return root.querySelector(BLOCK_SELECTOR) ? 0 : 1;
+}
+function readHtml(root, context, blockReaders = DEFAULT_BLOCK_READERS) {
+  const open = sliceDepth(root);
+  const reader = new HtmlReader(
+    { ...context, source: detectHtmlSource(root) },
+    open === 0,
+    blockReaders
+  );
+  const blocks = reader.read(root);
+  return blocks.length === 0 ? null : {
+    slice: new Slice(Fragment.fromArray([...blocks]), open, open),
+    newLists: reader.newLists
+  };
+}
+function readHtmlSlice(context, source) {
+  if (source.trim() === "") return null;
+  const template = context.document.createElement("template");
+  template.innerHTML = source;
+  return readHtml(template.content, context);
+}
+function withPastedContent(tr, content) {
+  return tr.setDocAttribute(
+    NEW_LISTS_ATTR,
+    newListsValue(listsWorn(content.newLists, numIdsIn(tr.doc)))
+  );
+}
+export {
+  readHtml,
+  readHtmlSlice,
+  withPastedContent
+};

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

@@ -15,13 +15,6 @@ export interface InlineContext {
     preserveWhitespace: boolean;
 }
 export type InlineElementReader = (target: PMNode[], element: HTMLElement, context: InlineContext) => boolean;
-/**
- * The address a link may carry, whichever way it travels.
- *
- * A copy writes one out and a paste reads one in, and an address this rule turns down is one
- * neither end should act on, so both ask here.
- */
-export declare function safeHref(value: string | null): string | null;
 export declare function contextFor(parent: InlineContext, element: HTMLElement, readElementStyle?: boolean): InlineContext;
 export declare function withInlineStyle(context: InlineContext, style: InlineStyle): InlineContext;
 export declare function marksFor(context: InlineContext): Mark[];

package/dist/editor/clipboard/inlineFormatting.js

@@ -3,6 +3,7 @@ import { rPrOf } from "../../docx/formatting.js";
 import { readRunProps } from "../../docx/runProps.js";
 import { HALF_POINTS_PER_PT, ST_HpsMeasure } from "../../ooxml/simpleTypes.js";
 import { docxSchema } from "../../schema/index.js";
+import { safeHref } from "../../schema/clipboard.js";
 import { editorClassNames } from "../../styles/classNames.js";
 var IGNORED_TAGS = /* @__PURE__ */ new Set([
   "HEAD",
@@ -135,12 +136,6 @@ function styleOf(parent, element) {
   if (background !== null) style.background = background;
   return style;
 }
-function safeHref(value) {
-  const href = value?.trim() ?? "";
-  if (href === "") return null;
-  if (/^(?:https?|mailto|tel):/i.test(href)) return href;
-  return /^(?:[./]|#)/.test(href) ? href : null;
-}
 function contextFor(parent, element, readElementStyle = true) {
   const copiedEditorLink = element.classList.contains(editorClassNames.link) ? element.getAttribute("data-href") : null;
   return {
@@ -217,6 +212,5 @@ export {
   appendInline,
   contextFor,
   marksFor,
-  safeHref,
   withInlineStyle
 };

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

@@ -0,0 +1,57 @@
+/**
+ * The channel a copy made in this editor comes back through.
+ *
+ * What leaves for the clipboard is HTML, and HTML carries only what a reader can make out of it:
+ * a paragraph's own properties, a table's grid, the relationship a link hung off are none of them
+ * writable there without publishing the document's insides. So the slice itself stays here, under
+ * a name the copied HTML carries, and a paste that hands that name back is given what was copied.
+ *
+ * The name is trusted only alongside the session it was copied from: another open document -
+ * a second editor on the same page among them - numbers its lists and relates its images against
+ * its own file, so a slice of it means something else here, and such a paste falls to the reader
+ * that reads the markup instead. A token nothing kept, a token from a copy since replaced, and a
+ * token invented by whoever wrote the markup all miss the same way.
+ *
+ * The slice is kept alongside the kind of each list its paragraphs name, which is the one thing
+ * 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.
+ */
+import type { Slice } from "prosemirror-model";
+import type { ListKind } from "../../numbering/listTemplate";
+import type { Numbering } from "../../numbering/parseNumbering";
+/** 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 two ways a copy leaves the editor.
+ *
+ * A drag is serialized through the very same path a copy takes, so the one the drag wrote would
+ * replace the one the clipboard still holds, and a drag begun and let go would send the next paste
+ * of that clipboard to the reader that reads markup. They are kept apart instead, and each is
+ * 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 */
+export interface RecalledCopy {
+    readonly slice: Slice;
+    readonly listKinds: ListKinds;
+}
+/**
+ * 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;
+/** 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 name the pasted markup carries, if it carries one.
+ *
+ * The copy writes it on the first element it draws. `prosemirror-view` may wrap that element in
+ * the parents its tag needs (a row in a table) and descends back through them before parsing, so
+ * the element handed here is either the one carrying the name or its parent.
+ */
+export declare function internalTokenOf(dom: Node): string | null;