@portone/docx-editor 0.4.0 → 0.5.0

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

@@ -0,0 +1,30 @@
+import { Slice } from "prosemirror-model";
+import type { Transaction } from "prosemirror-state";
+import { type NewLists } from "../../numbering/listRegistry";
+import type { ListKinds } from "./internalChannel";
+import type { HtmlReadContext } from "./readContext";
+/**
+ * The paragraph style a copy carries, which is the one thing a paste needs that the drawing does
+ * not already say. It is the style's id alone, where the editor draws the whole `w:pPr`.
+ */
+export declare const COPIED_STYLE_ATTRIBUTE = "data-style";
+/** 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): 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/{externalClipboard.js → clipboard/htmlReader.js}

@@ -1,43 +1,33 @@
-// src/editor/externalClipboard.ts
-import {
-  DOMSerializer,
-  Fragment,
-  Slice
-} from "prosemirror-model";
-import { Plugin } from "prosemirror-state";
+// src/editor/clipboard/htmlReader.ts
+import { Fragment, Slice } from "prosemirror-model";
 import {
   paragraphAttrsFor,
   styleIdOf
-} from "../docx/formatting.js";
+} from "../../docx/formatting.js";
 import {
   withListNumbering,
   withParagraphStyle
-} from "../docx/paraProps.js";
+} from "../../docx/paraProps.js";
 import {
   listsWorn,
   NEW_LISTS_ATTR,
   newListsValue
-} from "../numbering/listRegistry.js";
+} from "../../numbering/listRegistry.js";
 import {
   allocateList,
   MAX_ILVL,
   templateList
-} from "../numbering/listTemplate.js";
-import { docxSchema, isPageBreak } from "../schema/index.js";
-import { editorClassNames } from "../styles/classNames.js";
-import { PASTED_IMAGE_ATTRIBUTE } from "./clipboard/images.js";
+} from "../../numbering/listTemplate.js";
+import { docxSchema } from "../../schema/index.js";
+import { editorClassNames } from "../../styles/classNames.js";
+import { numIdsIn } from "../commands/listCommands.js";
+import { PASTED_IMAGE_ATTRIBUTE } from "./images.js";
 import {
   appendInline,
   contextFor,
   marksFor,
-  safeHref,
   withInlineStyle
-} from "./clipboard/inlineFormatting.js";
-import { numIdsIn } from "./commands/listCommands.js";
-import { documentFormatting, documentParagraphStyles } from "./documentStyles.js";
-import { insertPlainText } from "./plainText.js";
-import { moveCaretToDrop } from "./plugins/dropCaret.js";
-import { canStartNewList } from "./plugins/numberingDecorations.js";
+} from "./inlineFormatting.js";
 var BLOCK_TAGS = /* @__PURE__ */ new Set([
   "ADDRESS",
   "ARTICLE",
@@ -71,143 +61,7 @@ var HEADING_FALLBACKS = {
   5: { bold: true, fontSizePt: 10 },
   6: { bold: true, fontSizePt: 8 }
 };
-var PUBLIC_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "alt",
-  "aria-label",
-  "class",
-  "colspan",
-  "height",
-  "href",
-  "lang",
-  "rowspan",
-  "src",
-  "style",
-  "width"
-]);
 var COPIED_STYLE_ATTRIBUTE = "data-style";
-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 clipboardSerializer() {
-  const drawn = DOMSerializer.fromSchema(docxSchema);
-  const nodes = Object.fromEntries(
-    Object.entries(drawn.nodes).map(([name, toDOM]) => [
-      name,
-      (node) => copiedNodeSpec(node, toDOM(node))
-    ])
-  );
-  const marks = Object.fromEntries(
-    Object.entries(drawn.marks).map(([name, toDOM]) => [
-      name,
-      (mark, inline) => copiedMarkSpec(mark, toDOM(mark, inline))
-    ])
-  );
-  return new DOMSerializer(nodes, marks);
-}
-var UNREADABLE_BLOCKS = /* @__PURE__ */ new Set([
-  "bookmarkBlock",
-  "docxRaw",
-  "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 normalizedStyleName(value) {
   return value.toLowerCase().replace(/[\s_-]+/g, "");
 }
@@ -223,8 +77,7 @@ function headingLevel(element, sourceStyleId) {
   );
   return match ? Number.parseInt(match[1] ?? "", 10) : null;
 }
-function destinationStyleId(state, sourceStyleId, level) {
-  const styles = documentParagraphStyles(state);
+function destinationStyleId(styles, sourceStyleId, level) {
   if (sourceStyleId && styles.some((style) => style.id === sourceStyleId)) {
     return sourceStyleId;
   }
@@ -234,7 +87,7 @@ function destinationStyleId(state, sourceStyleId, level) {
     (style) => normalizedStyleName(style.id) === wanted || normalizedStyleName(style.name) === wanted
   )?.id ?? null;
 }
-function blockContext(state, parent, element, preserveParagraphStyle) {
+function blockContext(context, parent, element, preserveParagraphStyle) {
   const editorParagraph = element.classList.contains(
     editorClassNames.paragraph
   );
@@ -246,7 +99,11 @@ function blockContext(state, parent, element, preserveParagraphStyle) {
       paragraph: null
     };
   }
-  const styleId = destinationStyleId(state, sourceStyleId, level);
+  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;
@@ -270,17 +127,15 @@ function paragraphAttrs(formatting, list, paragraph) {
   return props ? { pPr: props.pPr, ...paragraphAttrsFor(props.pPr, formatting) } : null;
 }
 var HtmlReader = class {
-  constructor(state, preserveParagraphStyles, images) {
-    this.state = state;
+  constructor(context, preserveParagraphStyles) {
+    this.context = context;
     this.preserveParagraphStyles = preserveParagraphStyles;
-    this.images = images;
-    this.formatting = documentFormatting(state);
-    this.used = numIdsIn(state.doc);
-    this.canCreateLists = canStartNewList(state);
+    this.formatting = context.formatting;
+    this.used = new Set(context.numbering.used);
+    this.canCreateLists = context.numbering.canCreate;
   }
-  state;
+  context;
   preserveParagraphStyles;
-  images;
   blocks = [];
   used;
   canCreateLists;
@@ -302,7 +157,7 @@ var HtmlReader = class {
     appendInline(target, node, context, (content, element, inline) => {
       if (element.tagName !== "IMG") return false;
       const token = element.getAttribute(PASTED_IMAGE_ATTRIBUTE);
-      const image = token === null ? void 0 : this.images.get(token);
+      const image = token === null ? void 0 : this.context.images.get(token);
       if (!image) return true;
       content.push(
         docxSchema.nodes.image.create(
@@ -346,7 +201,7 @@ var HtmlReader = class {
         flush();
         const before = this.blocks.length;
         const block = blockContext(
-          this.state,
+          this.context,
           context,
           element,
           this.preserveParagraphStyles
@@ -418,69 +273,30 @@ function sliceDepth(root) {
   const blocks = [...BLOCK_TAGS, "OL", "UL"].map((tag) => tag.toLowerCase());
   return root.querySelector(blocks.join(",")) ? 0 : 1;
 }
-function richHtmlSlice(state, document, source, images = /* @__PURE__ */ new Map()) {
-  if (source.trim() === "") return null;
-  const template = document.createElement("template");
-  template.innerHTML = source;
-  const open = sliceDepth(template.content);
-  const reader = new HtmlReader(state, open === 0, images);
-  const blocks = reader.read(template.content);
+function readHtml(root, context) {
+  const open = sliceDepth(root);
+  const reader = new HtmlReader(context, open === 0);
+  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)))
   );
 }
-function insertRichHtml(view, source) {
-  const content = richHtmlSlice(view.state, view.dom.ownerDocument, source);
-  if (content === null) return false;
-  view.dispatch(
-    withPastedContent(
-      view.state.tr.replaceSelection(content.slice),
-      content
-    ).scrollIntoView()
-  );
-  return true;
-}
-function insertClipboardData(view, data) {
-  if (insertRichHtml(view, data.html ?? "")) return;
-  insertPlainText(view, data.text ?? "");
-}
-function externalClipboard() {
-  const serializer = clipboardSerializer();
-  return new Plugin({
-    props: {
-      clipboardSerializer: serializer,
-      clipboardTextSerializer: clipboardText,
-      transformCopied: copiedSlice,
-      handlePaste(view, event) {
-        insertClipboardData(view, {
-          html: event.clipboardData?.getData("text/html"),
-          text: event.clipboardData?.getData("text/plain")
-        });
-        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 {
-  externalClipboard,
-  insertClipboardData,
-  insertRichHtml,
-  richHtmlSlice,
+  COPIED_STYLE_ATTRIBUTE,
+  readHtml,
+  readHtmlSlice,
   withPastedContent
 };

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;

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;