@portone/docx-editor 0.2.0 → 0.3.0

package/dist/editor/editorDocument.js

@@ -0,0 +1,74 @@
+// src/editor/editorDocument.ts
+import { Plugin, PluginKey } from "prosemirror-state";
+import { DEFAULT_TAB_STOP_PT } from "../docx/documentSettings.js";
+import {
+  NO_DOCUMENT_DEFAULTS,
+  NO_FORMATTING
+} from "../docx/formatting.js";
+import { A4_PORTRAIT } from "../docx/pageGeometry.js";
+var NO_IDS = /* @__PURE__ */ new Set();
+var NO_PARAGRAPH_STYLES = [];
+var NO_DOCUMENT = {
+  session: null,
+  formatting: NO_FORMATTING,
+  defaults: NO_DOCUMENT_DEFAULTS,
+  paragraphStyles: NO_PARAGRAPH_STYLES,
+  canStartNewList: true,
+  geometry: A4_PORTRAIT,
+  defaultTabStopPt: DEFAULT_TAB_STOP_PT,
+  reservedCommentIds: NO_IDS,
+  reservedCommentParaIds: NO_IDS
+};
+function reservedParaIds(session) {
+  const paraIds = /* @__PURE__ */ new Set();
+  for (const comment of session.comments.ordered) {
+    if (comment.paraId !== null) paraIds.add(comment.paraId);
+  }
+  for (const extension of session.comments.extendedOrdered) {
+    paraIds.add(extension.paraId);
+  }
+  return paraIds;
+}
+function editorDocumentOf(session) {
+  return {
+    session,
+    formatting: session.formatting,
+    defaults: session.defaults,
+    paragraphStyles: session.paragraphStyles,
+    canStartNewList: session.numberingPartPath !== null,
+    geometry: session.geometry,
+    defaultTabStopPt: session.defaultTabStopPt,
+    reservedCommentIds: new Set(session.comments.byId.keys()),
+    reservedCommentParaIds: reservedParaIds(session)
+  };
+}
+var editorDocumentKey = new PluginKey("docxEditorDocument");
+function documentOf(state) {
+  return editorDocumentKey.getState(state) ?? NO_DOCUMENT;
+}
+function derive(session, _doc) {
+  return editorDocumentOf(session);
+}
+function editorDocument(document) {
+  return new Plugin({
+    key: editorDocumentKey,
+    state: {
+      init: () => document,
+      apply: (tr, current, old) => current.session === null || tr.doc.attrs === old.doc.attrs ? current : derive(current.session, tr.doc)
+    }
+  });
+}
+function reservedCommentIds(state) {
+  return documentOf(state).reservedCommentIds;
+}
+function reservedCommentParaIds(state) {
+  return documentOf(state).reservedCommentParaIds;
+}
+export {
+  NO_DOCUMENT,
+  documentOf,
+  editorDocument,
+  editorDocumentOf,
+  reservedCommentIds,
+  reservedCommentParaIds
+};

package/dist/editor/externalClipboard.js

@@ -1,25 +1,28 @@
 // src/editor/externalClipboard.ts
-import { Fragment, Slice } from "prosemirror-model";
+import {
+  DOMSerializer,
+  Fragment,
+  Slice
+} from "prosemirror-model";
 import { Plugin } from "prosemirror-state";
-import { effectiveParagraphFormat, styleIdOf } from "../docx/formatting.js";
-import { withParagraphStyle } from "../docx/paraProps.js";
+import { paragraphAttrsFor, styleIdOf } from "../docx/formatting.js";
+import {
+  withListNumbering,
+  withParagraphStyle
+} from "../docx/paraProps.js";
 import { MAX_ILVL, nextNumId } from "../numbering/listTemplate.js";
-import { docxSchema } from "../schema/index.js";
+import { docxSchema, isPageBreak } from "../schema/index.js";
 import { editorClassNames } from "../styles/classNames.js";
 import { PASTED_IMAGE_ATTRIBUTE } from "./clipboard/images.js";
 import {
   appendInline,
   contextFor,
   marksFor,
+  safeHref,
   withInlineStyle
 } from "./clipboard/inlineFormatting.js";
 import { listRefOf } from "./commands/listCommands.js";
-import {
-  defaultParagraphStyleId,
-  documentParagraphFormatting,
-  documentParagraphStyles,
-  documentStyles
-} from "./documentStyles.js";
+import { documentFormatting, documentParagraphStyles } from "./documentStyles.js";
 import { insertPlainText } from "./plainText.js";
 import { moveCaretToDrop } from "./plugins/dropCaret.js";
 import {
@@ -59,11 +62,149 @@ 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, "");
 }
 function copiedStyleId(element) {
-  return element.classList.contains(editorClassNames.paragraph) ? styleIdOf(element.getAttribute("data-ppr")) : null;
+  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];
@@ -97,12 +238,7 @@ function blockContext(state, parent, element, preserveParagraphStyle) {
     };
   }
   const styleId = destinationStyleId(state, sourceStyleId, level);
-  const paragraph = styleId === null ? null : withParagraphStyle(
-    null,
-    styleId,
-    documentStyles(state),
-    defaultParagraphStyleId(state)
-  );
+  const paragraph = styleId === null ? null : withParagraphStyle(null, styleId);
   const usesDestinationStyle = editorParagraph && (sourceStyleId === null || paragraph !== null);
   let inline = parent;
   if (paragraph === null && level !== null) {
@@ -113,25 +249,18 @@ function blockContext(state, parent, element, preserveParagraphStyle) {
     paragraph
   };
 }
-function listParagraphAttrs(state, list) {
+function listParagraphProps(list) {
   if (!list || list.numId === null) return null;
-  const ilvl = Math.min(MAX_ILVL, list.level);
-  const pPr = `<w:pPr><w:numPr><w:ilvl w:val="${ilvl}"/><w:numId w:val="${list.numId}"/></w:numPr></w:pPr>`;
-  return {
-    pPr,
-    format: effectiveParagraphFormat(pPr, documentParagraphFormatting(state))
-  };
+  return withListNumbering(null, {
+    numbering: { numId: list.numId, ilvl: Math.min(MAX_ILVL, list.level) },
+    indent: { kind: "keep" }
+  });
 }
 function paragraphAttrs(state, list, paragraph) {
-  const listed = listParagraphAttrs(state, list);
-  if (listed) return listed;
-  return paragraph ? {
-    pPr: paragraph.pPr,
-    format: effectiveParagraphFormat(
-      paragraph.pPr,
-      documentParagraphFormatting(state)
-    ),
-    styleRun: paragraph.styleRun
+  const props = listParagraphProps(list) ?? paragraph;
+  return props ? {
+    pPr: props.pPr,
+    ...paragraphAttrsFor(props.pPr, documentFormatting(state))
   } : null;
 }
 function usedNumIds(state) {
@@ -294,8 +423,12 @@ function insertClipboardData(view, data) {
   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"),

package/dist/editor/insertImage.js

@@ -2,10 +2,11 @@
 import { insertPoint } from "prosemirror-transform";
 import { toImageExtent, toImageSrc } from "../ooxml/image.js";
 import { docxSchema } from "../schema/index.js";
-import { replacementShut } from "../schema/locks.js";
-import { editsShut } from "../schema/protectionState.js";
+import { editShut, selectionIntents } from "../schema/guards.js";
 function insertPosition(state) {
-  if (editsShut(state) || replacementShut(state.selection, state.doc)) {
+  if (selectionIntents(state.selection, "replace").some(
+    (intent) => editShut(state, intent)
+  )) {
     return null;
   }
   return insertPoint(state.doc, state.selection.from, docxSchema.nodes.image);

package/dist/editor/insertTable.js

@@ -4,7 +4,7 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { createTableNode, isTableSide } from "../docx/tableTemplate.js";
-import { editsShut } from "../schema/protectionState.js";
+import { editShut } from "../schema/guards.js";
 import { documentGeometry } from "./documentStyles.js";
 function isInTable($pos) {
   for (let depth = $pos.depth; depth > 0; depth -= 1) {
@@ -14,8 +14,9 @@ function isInTable($pos) {
 }
 function insertPosition(state) {
   const $from = state.selection.$from;
-  if (editsShut(state) || $from.depth === 0 || isInTable($from)) return null;
-  return $from.after(1);
+  if ($from.depth === 0 || isInTable($from)) return null;
+  const at = $from.after(1);
+  return editShut(state, { kind: "insert", at }) ? null : at;
 }
 function canInsertTable(state) {
   return insertPosition(state) !== null;

package/dist/editor/paragraphEdits.d.ts

@@ -8,7 +8,6 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { EditorState, Transaction } from "prosemirror-state";
-import { type StyleTable } from "../docx/formatting";
 import type { ParagraphProps } from "../docx/paraProps";
 export interface ParagraphSpot {
     pos: number;
@@ -17,28 +16,22 @@ export interface ParagraphSpot {
 /** The paragraphs the selection spans. Selections covering several table cells are handled too */
 export declare function selectedParagraphs(state: EditorState): ParagraphSpot[];
 /**
- * The selected paragraphs a lock leaves editable, which is what every paragraph edit works on.
+ * The selected paragraphs the guards leave editable, which is what every paragraph edit works on.
  *
- * A locked stretch is left out rather than the whole edit refused, the policy character formatting
- * already follows (`commands/formattingCommands`): the guard turns down a whole transaction, so
- * asking for it would leave the rest of the selection unedited too. A selection the lock leaves
- * nothing of edits nothing, and the command reports that of its own accord, which is the disabled
- * state of the control that runs it.
+ * A shut paragraph is left out rather than the whole edit refused, the policy character formatting
+ * already follows (`schema/guards`): the guard turns down a whole transaction, so asking for it
+ * would leave the rest of the selection unedited too. A selection the guards leave nothing of edits
+ * nothing, and the command reports that of its own accord, which is the disabled state of the
+ * control that runs it.
  *
- * Only the paragraphs of a locked cell are shut. A paragraph merely holding a locked control keeps
- * its own alignment, indent and style, which is what `insideLockedCell` says and
- * `rangeTouchesLocked` would not (`schema/locks`).
- *
- * A protection that shuts the body leaves no paragraph editable (`schema/protection`).
+ * A paragraph is rewritten around its content, which is the block intent: only the paragraphs of a
+ * locked cell are shut, and a paragraph merely holding a locked control keeps its own alignment,
+ * indent and style. A protection that shuts the body shuts every one of them.
  */
 export declare function editableParagraphs(state: EditorState): ParagraphSpot[];
 /** The original formatting XML this paragraph holds. Null when there is none */
 export declare function paragraphPPr(node: PMNode): string | null;
-/**
- * How to edit a single paragraph. Null skips that paragraph.
- * The style table and the document's default paragraph style come along, because the display values
- * of the edited fragment are read back with the style the paragraph wears laid underneath.
- */
-export type ParagraphSurgery = (node: PMNode, styles: StyleTable, defaultStyleId: string | null) => ParagraphProps | null;
+/** How to edit a single paragraph. Null skips that paragraph */
+export type ParagraphSurgery = (node: PMNode) => ParagraphProps | null;
 /** Edits the selected paragraphs in a single transaction. Does nothing when there is nothing to edit */
 export declare function editParagraphs(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, surgery: ParagraphSurgery): boolean;

package/dist/editor/paragraphEdits.js

@@ -1,13 +1,8 @@
 // src/editor/paragraphEdits.ts
-import { effectiveParagraphFormat } from "../docx/formatting.js";
+import { paragraphAttrsFor } from "../docx/formatting.js";
 import { docxSchema } from "../schema/index.js";
-import { insideLockedCell } from "../schema/locks.js";
-import { editsShut } from "../schema/protectionState.js";
-import {
-  defaultParagraphStyleId,
-  documentParagraphFormatting,
-  documentStyles
-} from "./documentStyles.js";
+import { editShut } from "../schema/guards.js";
+import { documentFormatting } from "./documentStyles.js";
 function selectedParagraphs(state) {
   const spots = /* @__PURE__ */ new Map();
   for (const range of state.selection.ranges) {
@@ -20,9 +15,8 @@ function selectedParagraphs(state) {
   return Array.from(spots, ([pos, node]) => ({ pos, node }));
 }
 function editableParagraphs(state) {
-  if (editsShut(state)) return [];
   return selectedParagraphs(state).filter(
-    (spot) => !insideLockedCell(state.doc, spot.pos)
+    (spot) => !editShut(state, { kind: "block", at: spot.pos })
   );
 }
 function paragraphPPr(node) {
@@ -31,22 +25,19 @@ function paragraphPPr(node) {
 }
 function writeChanges(state, changed) {
   const tr = state.tr;
-  const formatting = documentParagraphFormatting(state);
+  const formatting = documentFormatting(state);
   for (const { spot, props } of changed) {
     tr.setNodeMarkup(tr.mapping.map(spot.pos), void 0, {
       ...spot.node.attrs,
       pPr: props.pPr,
-      format: effectiveParagraphFormat(props.pPr, formatting),
-      styleRun: props.styleRun
+      ...paragraphAttrsFor(props.pPr, formatting)
     });
   }
   return tr;
 }
 function editParagraphs(state, dispatch, surgery) {
-  const styles = documentStyles(state);
-  const defaultStyleId = defaultParagraphStyleId(state);
   const changed = editableParagraphs(state).flatMap((spot) => {
-    const props = surgery(spot.node, styles, defaultStyleId);
+    const props = surgery(spot.node);
     return props ? [{ spot, props }] : [];
   });
   if (changed.length === 0) return false;

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

@@ -0,0 +1,47 @@
+/**
+ * Keeps every display value of the document current: the ones an edit moved, after that edit, and
+ * every one at once when the document snapshot the values are resolved against is replaced.
+ *
+ * The derivers are registered here and run through the one walk `schema/displayDerivation`
+ * defines. What a node maps back to is settled here as well, from the mapping of the transactions
+ * that changed the document: a node whose content survived those transactions is the node that
+ * stood where its opening maps back to, and one whose content did not is new. A node rewritten
+ * where it stands (`setNodeMarkup`) therefore still maps back to itself, which is what lets a
+ * table resized or a paragraph re-aligned be told from a table or a paragraph put in.
+ *
+ * The transaction this appends carries the display-only pass (`schema/guards`), since it changes
+ * nothing a lock or a protection answers for, and goes to the history as part of the edit it
+ * follows, so that one undo takes the edit and its values back together. The re-derivation after
+ * a snapshot change follows no edit and goes to the history not at all: the values follow the
+ * snapshot, and undoing whatever replaced the snapshot derives them again.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { type DisplayDeriver } from "../../schema/displayDerivation";
+import { type EditorDocument } from "../editorDocument";
+/** What a deriver of this editor resolves against */
+export interface DerivationContext {
+    readonly document: EditorDocument;
+    /**
+     * Where the composition the browser holds open stands, which a deriver leaves alone: rewriting
+     * the node it stands in redraws it, and a redraw under an open composition is what the browser
+     * answers by taking the composition down. Null while nothing is being composed, and while every
+     * value is being worked out again from nothing, when nothing may be left standing.
+     */
+    readonly composingAt: number | null;
+}
+export type DocumentDeriver = DisplayDeriver<DerivationContext>;
+export declare const DISPLAY_DERIVERS: readonly DocumentDeriver[];
+/**
+ * The document with every display value worked out against this snapshot, which is what a state
+ * is built over: the values a document arrived with were worked out against whatever opened it.
+ */
+export declare function withDerivedDisplay(doc: PMNode, document: EditorDocument, derivers?: readonly DocumentDeriver[]): PMNode;
+/**
+ * Derives the display values again after every change: for the nodes an edit moved, and for every
+ * node when the snapshot was replaced.
+ *
+ * An appended transaction is handed nothing but states, so the view an open composition is read
+ * from is the one the plugin is given when it mounts.
+ */
+export declare function displayDerivation(derivers?: readonly DocumentDeriver[]): Plugin;

package/dist/editor/plugins/displayDerivation.js

@@ -0,0 +1,78 @@
+// src/editor/plugins/displayDerivation.ts
+import { Plugin } from "prosemirror-state";
+import { Mapping, Transform } from "prosemirror-transform";
+import {
+  deriveDisplay,
+  displayOnly
+} from "../../schema/displayDerivation.js";
+import { documentOf } from "../editorDocument.js";
+import { paragraphDisplay } from "./paragraphDisplay.js";
+import { tableDisplay } from "./tableDisplay.js";
+var DISPLAY_DERIVERS = [
+  tableDisplay,
+  paragraphDisplay
+];
+var nothingBefore = () => null;
+function withDerivedDisplay(doc, document, derivers = DISPLAY_DERIVERS) {
+  const transform = new Transform(doc);
+  deriveDisplay(
+    transform,
+    { document, composingAt: null },
+    derivers,
+    nothingBefore
+  );
+  return transform.doc;
+}
+function previousIn(before, transactions) {
+  const mapping = new Mapping();
+  for (const transaction of transactions) {
+    mapping.appendMapping(transaction.mapping);
+  }
+  const back = mapping.invert();
+  return (node, pos) => {
+    const inside = node.isLeaf ? pos : pos + 1;
+    if (back.mapResult(inside, 1).deleted) return null;
+    const was = before.nodeAt(back.map(pos, 1));
+    return was !== null && was.type === node.type ? was : null;
+  };
+}
+function composingAt(view, state) {
+  return view?.composing === true ? state.selection.from : null;
+}
+function displayDerivation(derivers = DISPLAY_DERIVERS) {
+  let live = null;
+  return new Plugin({
+    view(view) {
+      live = view;
+      return {
+        destroy() {
+          live = null;
+        }
+      };
+    },
+    appendTransaction(transactions, oldState, newState) {
+      const document = documentOf(newState);
+      const replaced = document !== documentOf(oldState);
+      if (!replaced && !transactions.some((transaction) => transaction.docChanged)) {
+        return null;
+      }
+      const tr = newState.tr.setMeta(displayOnly, true);
+      if (replaced) tr.setMeta("addToHistory", false);
+      deriveDisplay(
+        tr,
+        {
+          document,
+          composingAt: replaced ? null : composingAt(live, newState)
+        },
+        derivers,
+        replaced ? nothingBefore : previousIn(oldState.doc, transactions)
+      );
+      return tr.docChanged ? tr : null;
+    }
+  });
+}
+export {
+  DISPLAY_DERIVERS,
+  displayDerivation,
+  withDerivedDisplay
+};

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

@@ -1,7 +1,7 @@
 /**
- * Holds the protection the editor runs under (`schema/protection`) in the state, where the guard
- * and the commands read it. The guard itself stands in `lockedContent`, which enforces
- * `transactionAllowed` for locks and protection in one pass.
+ * Holds the protection the editor runs under (`schema/protection`) in the state, where the guards
+ * and the commands read it. The runtime filter stands in `lockedContent`, which enforces every
+ * guard `schema/guards` registers, the protection among them, in one pass.
  */
 import { Plugin, type Transaction } from "prosemirror-state";
 import type { EditableComments, EditingProtection, ProtectionState } from "../../schema/protection";

package/dist/editor/plugins/imagePaste.js

@@ -2,8 +2,7 @@
 import { isHistoryTransaction } from "prosemirror-history";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { replacementShut } from "../../schema/locks.js";
-import { editsShut } from "../../schema/protectionState.js";
+import { editShut, selectionIntents } from "../../schema/guards.js";
 import {
   hasResolvableClipboardImages,
   resolveClipboardImages
@@ -223,7 +222,9 @@ function imagePaste() {
     props: {
       decorations: (state) => imagePasteKey.getState(state)?.decorations,
       handlePaste(view, event) {
-        if (editsShut(view.state) || replacementShut(view.state.selection, view.state.doc)) {
+        if (selectionIntents(view.state.selection, "replace").some(
+          (intent) => editShut(view.state, intent)
+        )) {
           return false;
         }
         if (view.state.selection.ranges.length > 1) return false;

package/dist/editor/plugins/keymap.js

@@ -5,6 +5,7 @@ import { keydownHandler } from "prosemirror-keymap";
 import { Plugin } from "prosemirror-state";
 import { goToNextCell } from "prosemirror-tables";
 import { canSplit } from "prosemirror-transform";
+import { splitParagraphAttrs } from "../../docx/cloning.js";
 import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
 import { insertLineBreak, insertPageBreak } from "../commands/breakCommands.js";
@@ -42,13 +43,27 @@ var splitParagraph = (state, dispatch) => {
   const tr = state.tr;
   if (!state.selection.empty) tr.deleteSelection();
   const at = tr.mapping.map(state.selection.$from.pos);
-  const parent = tr.doc.resolve(at).parent;
+  const $at = tr.doc.resolve(at);
+  const parent = $at.parent;
   if (parent.type !== docxSchema.nodes.paragraph) return false;
-  const types = [{ type: docxSchema.nodes.paragraph, attrs: parent.attrs }];
+  const { before, after } = splitParagraphAttrs(parent);
+  const types = [{ type: docxSchema.nodes.paragraph, attrs: after }];
   if (!canSplit(tr.doc, at, 1, types)) return false;
-  if (dispatch) dispatch(tr.split(at, 1, types).scrollIntoView());
+  if (dispatch) {
+    const beforePos = $at.before();
+    tr.split(at, 1, types);
+    if (!keptEveryAttr(parent, before)) {
+      tr.setNodeMarkup(beforePos, null, before);
+    }
+    dispatch(tr.scrollIntoView());
+  }
   return true;
 };
+function keptEveryAttr(paragraph, attrs) {
+  return Object.keys(paragraph.attrs).every(
+    (name) => attrs[name] === paragraph.attrs[name]
+  );
+}
 var preserveTableFollowingParagraph = (state) => {
   const { $from } = state.selection;
   if (!state.selection.empty || $from.depth !== 1 || $from.parent.type !== docxSchema.nodes.paragraph || $from.parent.content.size !== 0 || $from.parentOffset !== 0) {