@stll/folio-core 0.62.0 → 0.63.0

package/dist/prosemirror/commands/formatPainter.d.ts

@@ -9,7 +9,7 @@ import { Command, EditorState } from "prosemirror-state";
  * `rtl` (run direction) and `hidden` are excluded too: painting them could flip
  * text direction or hide content, which is surprising for a formatting brush.
  */
-declare const PAINTABLE_MARK_NAMES: ReadonlySet<string>;
+export declare const PAINTABLE_MARK_NAMES: ReadonlySet<string>;
 type PaintableFormatting = {
   allCaps?: document_d_exports.TextFormatting["allCaps"];
   bold?: document_d_exports.TextFormatting["bold"];
@@ -39,7 +39,7 @@ type PaintableFormatting = {
   underline?: document_d_exports.TextFormatting["underline"];
   vertAlign?: document_d_exports.TextFormatting["vertAlign"];
 };
-type CapturedTextFormatting = Readonly<{
+export type CapturedTextFormatting = Readonly<{
   effectiveFormatting: Readonly<PaintableFormatting>;
   marks: readonly Mark[];
   type: "capturedTextFormatting";
@@ -50,7 +50,7 @@ type CapturedTextFormatting = Readonly<{
  * run. The discriminated result deliberately represents an effectively plain run:
  * `null` belongs to the host's “nothing captured” state, not this command.
  */
-declare function captureFormatMarks(state: EditorState): CapturedTextFormatting;
+export declare function captureFormatMarks(state: EditorState): CapturedTextFormatting;
 /**
  * Apply captured marks onto the current selection's range: clear every paintable
  * mark type first (replace, not merge — so painting Georgia-12-bold onto
@@ -60,6 +60,6 @@ declare function captureFormatMarks(state: EditorState): CapturedTextFormatting;
  * that cannot be represented without guessing document defaults is a no-op.
  * Returns false so a keymap binding stays unclaimed; never partially mutates.
  */
-declare function applyFormatMarks(captured: CapturedTextFormatting | null): Command;
+export declare function applyFormatMarks(captured: CapturedTextFormatting | null): Command;
 //#endregion
-export { CapturedTextFormatting, PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks };
+export {};

package/dist/prosemirror/commands/formatPainter.js

@@ -231,27 +231,30 @@ function resolveEffectiveFormatting({ context, marks, styleResolver }) {
 		marks,
 		styleResolver
 	});
-	const effectiveFormatting = mergeTextFormatting(resolveEffectiveRunStyleFormatting({
+	const paragraphFormatting = paragraphFormattingForRun({
+		context,
+		directFormatting: authoredFormatting,
+		marks
+	});
+	const inheritedFormatting = resolveEffectiveRunStyleFormatting({
 		marks,
-		paragraphFormatting: paragraphFormattingForRun({
-			context,
-			directFormatting: authoredFormatting,
-			marks
-		}),
+		paragraphFormatting,
 		styleResolver
-	}), authoredFormatting) ?? {};
+	});
+	const effectiveFormatting = mergeTextFormatting(inheritedFormatting, authoredFormatting) ?? {};
 	if (authoredFormatting.shading?.pattern === "nil") effectiveFormatting.shading = authoredFormatting.shading;
 	if (authoredFormatting.underline?.style === "none") effectiveFormatting.underline = authoredFormatting.underline;
 	return pickPaintableFormatting(effectiveFormatting);
 }
 function resolveCopiedStyleFormatting({ context, marks, styleResolver }) {
 	if (marks.some((mark) => mark.type.name === "characterStyle") && !styleResolver) return null;
+	const paragraphFormatting = paragraphFormattingForRun({
+		context,
+		marks
+	});
 	return pickPaintableFormatting(resolveEffectiveRunStyleFormatting({
 		marks,
-		paragraphFormatting: paragraphFormattingForRun({
-			context,
-			marks
-		}),
+		paragraphFormatting,
 		styleResolver
 	}));
 }

package/dist/prosemirror/commands/formatting.d.ts

@@ -9,24 +9,24 @@ import { Command } from "prosemirror-state";
 /**
  * textFormattingToMarks — wraps markUtils version to use singleton schema
  */
-declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting): Mark[];
-declare const toggleBold: Command;
-declare const toggleItalic: Command;
-declare const toggleUnderline: Command;
-declare const toggleStrike: Command;
-declare const toggleSuperscript: Command;
-declare const toggleSubscript: Command;
-declare function setTextColor(attrs: TextColorAttrs): Command;
-declare const clearTextColor: Command;
-declare function setHighlight(color: string): Command;
-declare const clearHighlight: Command;
-declare function setFontSize(size: number): Command;
-declare const clearFontSize: Command;
-declare function setFontFamily(fontName: string): Command;
-declare const clearFontFamily: Command;
-declare function setUnderlineStyle(style: string, color?: TextColorAttrs): Command;
-declare function setHyperlink(href: string, tooltip?: string): Command;
-declare const removeHyperlink: Command;
-declare function insertHyperlink(text: string, href: string, tooltip?: string): Command;
+export declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting): Mark[];
+export declare const toggleBold: Command;
+export declare const toggleItalic: Command;
+export declare const toggleUnderline: Command;
+export declare const toggleStrike: Command;
+export declare const toggleSuperscript: Command;
+export declare const toggleSubscript: Command;
+export declare function setTextColor(attrs: TextColorAttrs): Command;
+export declare const clearTextColor: Command;
+export declare function setHighlight(color: string): Command;
+export declare const clearHighlight: Command;
+export declare function setFontSize(size: number): Command;
+export declare const clearFontSize: Command;
+export declare function setFontFamily(fontName: string): Command;
+export declare const clearFontFamily: Command;
+export declare function setUnderlineStyle(style: string, color?: TextColorAttrs): Command;
+export declare function setHyperlink(href: string, tooltip?: string): Command;
+export declare const removeHyperlink: Command;
+export declare function insertHyperlink(text: string, href: string, tooltip?: string): Command;
 //#endregion
-export { clearFontFamily, clearFontSize, clearFormatting, clearHighlight, clearTextColor, createRemoveMarkCommand, createSetMarkCommand, getHyperlinkAttrs, getMarkAttr, getSelectedText, insertHyperlink, isHyperlinkActive, isMarkActive, removeHyperlink, setFontFamily, setFontSize, setHighlight, setHyperlink, setTextColor, setUnderlineStyle, textFormattingToMarks, toggleBold, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline };
+export { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getHyperlinkAttrs, getMarkAttr, getSelectedText, isHyperlinkActive, isMarkActive };

package/dist/prosemirror/commands/hyperlink.d.ts

@@ -1,6 +1,6 @@
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/commands/hyperlink.d.ts
-type EditHyperlinkInput = {
+export type EditHyperlinkInput = {
   displayText: string;
   href: string;
 };
@@ -12,8 +12,8 @@ type EditHyperlinkInput = {
  * to act on at the cursor; false only when a hyperlink mark is present but no
  * contiguous range contains the cursor (the original's silent bail).
  */
-declare const editHyperlinkAtCursor: (view: EditorView, { displayText, href }: EditHyperlinkInput) => boolean;
-type RemoveHyperlinkInput = {
+export declare const editHyperlinkAtCursor: (view: EditorView, { displayText, href }: EditHyperlinkInput) => boolean;
+export type RemoveHyperlinkInput = {
   /** href from the popup, used as a fallback when the cursor reports no mark. */
   popupHref: string | undefined;
 };
@@ -21,6 +21,5 @@ type RemoveHyperlinkInput = {
  * Remove the hyperlink mark from the contiguous run at the cursor. Returns
  * whether a link was actually removed (so the adapter can toast + refocus).
  */
-declare const removeHyperlinkAtCursor: (view: EditorView, { popupHref }: RemoveHyperlinkInput) => boolean;
-//#endregion
-export { EditHyperlinkInput, RemoveHyperlinkInput, editHyperlinkAtCursor, removeHyperlinkAtCursor };
+export declare const removeHyperlinkAtCursor: (view: EditorView, { popupHref }: RemoveHyperlinkInput) => boolean;
+//#endregion

package/dist/prosemirror/commands/hyperlink.js

@@ -26,12 +26,13 @@ const collectHyperlinkRanges = (parent, parentStart, hlType, href) => {
 	parent.forEach((node, offset) => {
 		const nodeStart = parentStart + offset;
 		const nodeEnd = nodeStart + node.nodeSize;
-		if (node.isText ? node.marks.some((m) => m.type === hlType && hyperlinkHref(m) === href) : false) if (current) current.end = nodeEnd;
-		else current = {
-			start: nodeStart,
-			end: nodeEnd
-		};
-		else if (current) {
+		if (node.isText ? node.marks.some((m) => m.type === hlType && hyperlinkHref(m) === href) : false) {
+			if (current) current.end = nodeEnd;
+			else current = {
+				start: nodeStart,
+				end: nodeEnd
+			};
+		} else if (current) {
 			ranges.push(current);
 			current = null;
 		}

package/dist/prosemirror/commands/image.d.ts

@@ -2,7 +2,7 @@ import { document_d_exports } from "../../types/document.js";
 import { ImageAttrs, ImagePositionAttrs } from "../schema/nodes.js";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/commands/image.d.ts
-type ImagePositionInput = {
+export type ImagePositionInput = {
   horizontal?: {
     relativeTo?: string;
     posOffset?: number;
@@ -18,20 +18,20 @@ type ImagePositionInput = {
   distLeft?: number;
   distRight?: number;
 };
-type ImagePropertiesInput = {
+export type ImagePropertiesInput = {
   alt?: string;
   borderWidth?: number;
   borderColor?: string;
   borderStyle?: string;
 };
-type ImageTransformAction = "rotateCW" | "rotateCCW" | "flipH" | "flipV";
+export type ImageTransformAction = "rotateCW" | "rotateCCW" | "flipH" | "flipV";
 type ResolvedImageWrap = {
   wrapType: NonNullable<ImageAttrs["wrapType"]>;
   displayMode: ImageAttrs["displayMode"];
   cssFloat: ImageAttrs["cssFloat"];
 };
 /** Map a toolbar wrap selection to the image's wrapType/displayMode/cssFloat, or null when unknown. */
-declare const resolveImageWrap: (wrapType: string) => ResolvedImageWrap | null;
+export declare const resolveImageWrap: (wrapType: string) => ResolvedImageWrap | null;
 /**
  * The authored transform after applying a rotate/flip action.
  *
@@ -39,27 +39,27 @@ declare const resolveImageWrap: (wrapType: string) => ResolvedImageWrap | null;
  * un-flipping states `false`. The editor is saying what the drawing is now, and
  * leaving the field absent would hand the decision back to the file.
  */
-declare const computeImageTransform: (current: document_d_exports.ImageTransform | undefined, action: ImageTransformAction) => document_d_exports.ImageTransform;
-declare const normalizeImageHorizontalPosition: (data: ImagePositionInput["horizontal"]) => ImagePositionAttrs["horizontal"] | undefined;
-declare const normalizeImageVerticalPosition: (data: ImagePositionInput["vertical"]) => ImagePositionAttrs["vertical"] | undefined;
+export declare const computeImageTransform: (current: document_d_exports.ImageTransform | undefined, action: ImageTransformAction) => document_d_exports.ImageTransform;
+export declare const normalizeImageHorizontalPosition: (data: ImagePositionInput["horizontal"]) => ImagePositionAttrs["horizontal"] | undefined;
+export declare const normalizeImageVerticalPosition: (data: ImagePositionInput["vertical"]) => ImagePositionAttrs["vertical"] | undefined;
 /** Clamp an image's intrinsic size to the page text width, preserving aspect ratio. */
-declare const constrainImageSize: (width: number, height: number) => {
+export declare const constrainImageSize: (width: number, height: number) => {
   width: number;
   height: number;
 };
 /** Change the wrap mode of the image at `pos`. Returns whether it applied. */
-declare const applyImageWrapType: (view: EditorView, pos: number, wrapType: string) => boolean;
+export declare const applyImageWrapType: (view: EditorView, pos: number, wrapType: string) => boolean;
 /** Rotate or flip the image at `pos`. Returns whether it applied. */
-declare const applyImageTransform: (view: EditorView, pos: number, action: ImageTransformAction) => boolean;
+export declare const applyImageTransform: (view: EditorView, pos: number, action: ImageTransformAction) => boolean;
 /** Apply position + text-wrap distances to the image at `pos`. Returns whether it applied. */
-declare const applyImagePosition: (view: EditorView, pos: number, data: ImagePositionInput) => boolean;
+export declare const applyImagePosition: (view: EditorView, pos: number, data: ImagePositionInput) => boolean;
 /** Apply alt text + border properties to the image at `pos`. Returns whether it applied. */
-declare const applyImageProperties: (view: EditorView, pos: number, data: ImagePropertiesInput) => boolean;
+export declare const applyImageProperties: (view: EditorView, pos: number, data: ImagePropertiesInput) => boolean;
 /**
  * Read an image file, then insert a constrained inline image node at the
  * current selection. `onInserted` runs after the image is dispatched. No-ops
  * when the file fails validation or the schema has no image node.
  */
-declare const insertImageFromFile: (view: EditorView, file: File, onInserted: () => void) => Promise<void>;
+export declare const insertImageFromFile: (view: EditorView, file: File, onInserted: () => void) => Promise<void>;
 //#endregion
-export { ImagePositionInput, ImagePropertiesInput, ImageTransformAction, applyImagePosition, applyImageProperties, applyImageTransform, applyImageWrapType, computeImageTransform, constrainImageSize, insertImageFromFile, normalizeImageHorizontalPosition, normalizeImageVerticalPosition, resolveImageWrap };
+export {};

package/dist/prosemirror/commands/pageBreak.d.ts

@@ -7,6 +7,5 @@ import { Command } from "prosemirror-state";
  * position among neighbouring run content. Block-level `pageBreak` remains a
  * legacy input boundary and is never emitted by this command.
  */
-declare const insertPageBreak: Command;
-//#endregion
-export { insertPageBreak };
+export declare const insertPageBreak: Command;
+//#endregion

package/dist/prosemirror/commands/pageBreak.js

@@ -1,6 +1,7 @@
 import { withCanonicalCommand } from "../canonicalCommands.js";
 import { canonicalSelectionRange } from "../canonicalSelectionRange.js";
 import { pageBreakRunParagraphProjectionDisposition } from "../pageBreakRunProjection.js";
+import { CellSelection } from "prosemirror-tables";
 //#region src/prosemirror/commands/pageBreak.ts
 const UNSUPPORTED_PAGE_BREAK_RUN_ANCESTORS = /* @__PURE__ */ new Set([
 	"tableCell",
@@ -45,7 +46,7 @@ const insertPageBreakCommand = (state, dispatch) => {
 * position among neighbouring run content. Block-level `pageBreak` remains a
 * legacy input boundary and is never emitted by this command.
 */
-const insertPageBreak = withCanonicalCommand(insertPageBreakCommand, (state) => insertPageBreakCommand(state) ? [{
+const insertPageBreak = withCanonicalCommand(insertPageBreakCommand, (state) => !(state.selection instanceof CellSelection) && insertPageBreakCommand(state) ? [{
 	type: "insertBreak",
 	...canonicalSelectionRange(state),
 	breakType: "page"

package/dist/prosemirror/commands/paragraph.d.ts

@@ -4,42 +4,42 @@ import { GenerateTableOfContentsOptions, ResolvedStyleAttrs, getParagraphAlignme
 import { getListInfo, isInList } from "../extensions/features/ListExtension.js";
 import { Command } from "prosemirror-state";
 //#region src/prosemirror/commands/paragraph.d.ts
-declare function setAlignment(alignment: document_d_exports.ParagraphAlignment): Command;
-declare const alignLeft: Command;
-declare const alignCenter: Command;
-declare const alignRight: Command;
-declare const alignJustify: Command;
-declare function setLineSpacing(value: number, rule?: document_d_exports.LineSpacingRule): Command;
-declare const singleSpacing: Command;
-declare const oneAndHalfSpacing: Command;
-declare const doubleSpacing: Command;
-declare function increaseIndent(amount?: number): Command;
-declare function decreaseIndent(amount?: number): Command;
-declare function setIndentLeft(twips: number): Command;
-declare function setIndentRight(twips: number): Command;
-declare function setIndentFirstLine(twips: number, hanging?: boolean): Command;
-declare const toggleBulletList: Command;
-declare const toggleNumberedList: Command;
-declare const increaseListLevel: Command;
-declare const decreaseListLevel: Command;
-declare const removeList: Command;
+export declare function setAlignment(alignment: document_d_exports.ParagraphAlignment): Command;
+export declare const alignLeft: Command;
+export declare const alignCenter: Command;
+export declare const alignRight: Command;
+export declare const alignJustify: Command;
+export declare function setLineSpacing(value: number, rule?: document_d_exports.LineSpacingRule): Command;
+export declare const singleSpacing: Command;
+export declare const oneAndHalfSpacing: Command;
+export declare const doubleSpacing: Command;
+export declare function increaseIndent(amount?: number): Command;
+export declare function decreaseIndent(amount?: number): Command;
+export declare function setIndentLeft(twips: number): Command;
+export declare function setIndentRight(twips: number): Command;
+export declare function setIndentFirstLine(twips: number, hanging?: boolean): Command;
+export declare const toggleBulletList: Command;
+export declare const toggleNumberedList: Command;
+export declare const increaseListLevel: Command;
+export declare const decreaseListLevel: Command;
+export declare const removeList: Command;
 /** *Restart at 1* on the selected list item. */
-declare const restartNumbering: Command;
+export declare const restartNumbering: Command;
 /** *Continue Numbering*: carry the selected list on from the previous one. */
-declare const continueNumbering: Command;
+export declare const continueNumbering: Command;
 /** *Set Numbering Value*: the selected item starts its list over at `value`. */
-declare function setNumberingValue(value: number): Command;
-declare function setSpaceBefore(twips: number): Command;
-declare function setSpaceAfter(twips: number): Command;
-declare function applyStyle(styleId: string, resolvedAttrs?: ResolvedStyleAttrs): Command;
-declare const clearStyle: Command;
-declare function insertSectionBreak(breakType: SectionBreakType): Command;
-declare const removeSectionBreak: Command;
-declare function addTabStop(position: number, alignment?: document_d_exports.TabStopAlignment, leader?: document_d_exports.TabLeader): Command;
-declare function removeTabStop(position: number): Command;
-declare const toggleBidi: Command;
-declare const setRtl: Command;
-declare const setLtr: Command;
-declare const generateTableOfContents: (options: GenerateTableOfContentsOptions) => Command;
+export declare function setNumberingValue(value: number): Command;
+export declare function setSpaceBefore(twips: number): Command;
+export declare function setSpaceAfter(twips: number): Command;
+export declare function applyStyle(styleId: string, resolvedAttrs?: ResolvedStyleAttrs): Command;
+export declare const clearStyle: Command;
+export declare function insertSectionBreak(breakType: SectionBreakType): Command;
+export declare const removeSectionBreak: Command;
+export declare function addTabStop(position: number, alignment?: document_d_exports.TabStopAlignment, leader?: document_d_exports.TabLeader): Command;
+export declare function removeTabStop(position: number): Command;
+export declare const toggleBidi: Command;
+export declare const setRtl: Command;
+export declare const setLtr: Command;
+export declare const generateTableOfContents: (options: GenerateTableOfContentsOptions) => Command;
 //#endregion
-export { type GenerateTableOfContentsOptions, type ResolvedStyleAttrs, addTabStop, alignCenter, alignJustify, alignLeft, alignRight, applyStyle, clearStyle, continueNumbering, decreaseIndent, decreaseListLevel, doubleSpacing, generateTableOfContents, getListInfo, getParagraphAlignment, getParagraphBidi, getParagraphTabs, getStyleId, increaseIndent, increaseListLevel, insertSectionBreak, isInList, oneAndHalfSpacing, removeList, removeSectionBreak, removeTabStop, restartNumbering, setAlignment, setIndentFirstLine, setIndentLeft, setIndentRight, setLineSpacing, setLtr, setNumberingValue, setRtl, setSpaceAfter, setSpaceBefore, singleSpacing, toggleBidi, toggleBulletList, toggleNumberedList };
+export { type GenerateTableOfContentsOptions, type ResolvedStyleAttrs, getListInfo, getParagraphAlignment, getParagraphBidi, getParagraphTabs, getStyleId, isInList };

package/dist/prosemirror/commands/paragraphBookmarkJoin.d.ts

@@ -6,14 +6,14 @@ type InlineBookmarksForParagraphJoinOptions = {
   second: Node;
 };
 /** The inline form of boundaries whose enclosing paragraph break was removed. */
-declare const inlineBookmarksOf: (boundaries: readonly Node[]) => Node[] | null;
+export declare const inlineBookmarksOf: (boundaries: readonly Node[]) => Node[] | null;
 /** Inline boundaries that can replace the paragraph break without replacing either paragraph's content. */
-declare const inlineBookmarksForParagraphJoin: ({ first, boundaries, second }: InlineBookmarksForParagraphJoinOptions) => Node[] | null;
-/** Paragraph siblings separated only by typed bookmark boundaries. */
-declare const paragraphJoinAfter: (doc: Node, position: number) => {
+export declare const inlineBookmarksForParagraphJoin: ({ first, boundaries, second }: InlineBookmarksForParagraphJoinOptions) => Node[] | null;
+/** Paragraph siblings separated only by typed range boundaries. */
+export declare const paragraphJoinAfter: (doc: Node, position: number) => {
   next: Node;
   nextPosition: number;
   inlineBookmarks: Node[];
 } | null;
 //#endregion
-export { inlineBookmarksForParagraphJoin, inlineBookmarksOf, paragraphJoinAfter };
+export {};

package/dist/prosemirror/commands/paragraphBookmarkJoin.js

@@ -1,12 +1,9 @@
+import { inlineBoundariesOf, isBlockBoundaryNode } from "../keptRangeBoundaries.js";
 import { Fragment } from "prosemirror-model";
 import { canJoin } from "prosemirror-transform";
 //#region src/prosemirror/commands/paragraphBookmarkJoin.ts
 /** The inline form of boundaries whose enclosing paragraph break was removed. */
-const inlineBookmarksOf = (boundaries) => {
-	const inlineType = boundaries.at(0)?.type.schema.nodes["bookmarkBoundary"];
-	if (!inlineType || boundaries.some((node) => node.type.name !== "blockBookmarkBoundary")) return null;
-	return boundaries.map((node) => inlineType.create(node.attrs));
-};
+const inlineBookmarksOf = (boundaries) => inlineBoundariesOf(boundaries);
 /** Inline boundaries that can replace the paragraph break without replacing either paragraph's content. */
 const inlineBookmarksForParagraphJoin = ({ first, boundaries, second }) => {
 	if (first.type.name !== "paragraph" || second.type !== first.type) return null;
@@ -19,7 +16,7 @@ const inlineBookmarksForParagraphJoin = ({ first, boundaries, second }) => {
 	]);
 	return first.type.validContent(content) ? inline : null;
 };
-/** Paragraph siblings separated only by typed bookmark boundaries. */
+/** Paragraph siblings separated only by typed range boundaries. */
 const paragraphJoinAfter = (doc, position) => {
 	const at = doc.resolve(position);
 	const first = at.nodeBefore;
@@ -29,7 +26,7 @@ const paragraphJoinAfter = (doc, position) => {
 	let index = at.index();
 	while (index < at.parent.childCount) {
 		const boundary = at.parent.child(index);
-		if (boundary.type.name !== "blockBookmarkBoundary") break;
+		if (!isBlockBoundaryNode(boundary)) break;
 		boundaries.push(boundary);
 		nextPosition += boundary.nodeSize;
 		index++;

package/dist/prosemirror/commands/pastePlainText.d.ts

@@ -8,7 +8,7 @@ import { Command } from "prosemirror-state";
  * event and decides how to surface it (toast, telemetry, or no-op) rather than
  * the keystroke silently doing nothing.
  */
-declare const CLIPBOARD_READ_ERROR_EVENT = "folio:clipboard-read-error";
+export declare const CLIPBOARD_READ_ERROR_EVENT = "folio:clipboard-read-error";
 /**
  * Build a mark-free slice from plain text, one paragraph per run of newlines.
  *
@@ -18,7 +18,7 @@ declare const CLIPBOARD_READ_ERROR_EVENT = "folio:clipboard-read-error";
  * surrounding block on {@link Transaction.replaceSelection}, matching how the
  * editor's default text paste flows into the current line.
  */
-declare function buildPlainTextSlice(text: string, schema: Schema): Slice;
+export declare function buildPlainTextSlice(text: string, schema: Schema): Slice;
 /**
  * Read the clipboard and insert it as unformatted text at the current selection.
  *
@@ -33,6 +33,5 @@ declare function buildPlainTextSlice(text: string, schema: Schema): Slice;
  * {@link CLIPBOARD_READ_ERROR_EVENT} on the view DOM so the keystroke is never a
  * silent no-op.
  */
-declare const pasteWithoutFormatting: Command;
-//#endregion
-export { CLIPBOARD_READ_ERROR_EVENT, buildPlainTextSlice, pasteWithoutFormatting };
+export declare const pasteWithoutFormatting: Command;
+//#endregion

package/dist/prosemirror/commands/propertyChangeScope.d.ts

@@ -3,10 +3,10 @@ import { ParagraphPropertyChangeAttrs } from "../schema/nodes.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/commands/propertyChangeScope.d.ts
 /** Editor-only suggestions are rebased away before save; every other entry emits `w:pPrChange`. */
-declare const hasSerializableParagraphPropertyChange: (changes: readonly ParagraphPropertyChangeAttrs[] | null | undefined) => boolean;
+export declare const hasSerializableParagraphPropertyChange: (changes: readonly ParagraphPropertyChangeAttrs[] | null | undefined) => boolean;
 type AttrPatch = Record<string, unknown>;
 type ParagraphPropertySnapshot = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
-type ParagraphPropertyChangeRemoval = {
+export type ParagraphPropertyChangeRemoval = {
   type: "unchanged";
 } | {
   type: "keep-live";
@@ -23,7 +23,7 @@ type ParagraphPropertyChangeRemoval = {
  * paragraph properties. This makes repeated scoped rejection independent of
  * the order in which revisions are resolved.
  */
-declare const removeParagraphPropertyChanges: (changes: readonly ParagraphPropertyChangeAttrs[], shouldRemove: (change: ParagraphPropertyChangeAttrs) => boolean) => ParagraphPropertyChangeRemoval;
+export declare const removeParagraphPropertyChanges: (changes: readonly ParagraphPropertyChangeAttrs[], shouldRemove: (change: ParagraphPropertyChangeAttrs) => boolean) => ParagraphPropertyChangeRemoval;
 /**
  * Paragraph attrs governed by a `w:pPrChange` — the attrs
  * `paragraphFormattingToAttrs` (conversion/toProseDoc.ts) can produce from a
@@ -43,9 +43,9 @@ declare const removeParagraphPropertyChanges: (changes: readonly ParagraphProper
  *   `alignmentFromStyle`, `spacingFromDocDefaults`, and resolved style-spacing
  *   provenance in `spacingFromImplicitDefaultStyle`
  */
-declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignment", "spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "lineSpacingExplicit", "snapToGrid", "spacingExplicit", "indentLeft", "indentRight", "indentFirstLine", "hangingIndent", "borders", "shading", "tabs", "pageBreakBefore", "keepNext", "keepLines", "widowControl", "contextualSpacing", "outlineLevel", "direction", "_autospacingBase"];
+export declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignment", "spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "lineSpacingExplicit", "snapToGrid", "spacingExplicit", "indentLeft", "indentRight", "indentFirstLine", "hangingIndent", "borders", "shading", "tabs", "pageBreakBefore", "keepNext", "keepLines", "widowControl", "contextualSpacing", "outlineLevel", "direction", "_autospacingBase"];
 /** The in-scope paragraph properties as they stand, for a `w:pPrChange` record. */
-declare const paragraphPropertiesSnapshot: (node: Node) => ParagraphPropertySnapshot;
+export declare const paragraphPropertiesSnapshot: (node: Node) => ParagraphPropertySnapshot;
 /**
  * Build the attr patch that rejecting one pPrChange applies to a paragraph:
  * every in-scope key set to the stored previous value, or to what the style
@@ -54,7 +54,7 @@ declare const paragraphPropertiesSnapshot: (node: Node) => ParagraphPropertySnap
  * the scoped set (editor-created list suggestions snapshot list-rendering
  * bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
  */
-declare function paragraphRejectAttrPatch(previousFormatting: ParagraphPropertySnapshot | null | undefined, inheritedFormatting?: document_d_exports.ParagraphFormatting): AttrPatch;
+export declare function paragraphRejectAttrPatch(previousFormatting: ParagraphPropertySnapshot | null | undefined, inheritedFormatting?: document_d_exports.ParagraphFormatting): AttrPatch;
 /**
  * Rebuild the paragraph's `_originalFormatting` (the serializer's pPr source)
  * after a reject: the stored old pPr wholesale within CT_PPrBase scope, with
@@ -62,7 +62,7 @@ declare function paragraphRejectAttrPatch(previousFormatting: ParagraphPropertyS
  * from the live original — a pPrChange cannot store them, so a reject must
  * not drop them.
  */
-declare function paragraphRejectOriginalFormatting(previousFormatting: ParagraphPropertySnapshot | null | undefined, liveOriginal: unknown): document_d_exports.ParagraphFormatting | null;
+export declare function paragraphRejectOriginalFormatting(previousFormatting: ParagraphPropertySnapshot | null | undefined, liveOriginal: unknown): document_d_exports.ParagraphFormatting | null;
 /**
  * Rejected section properties: the stored old sectPr wholesale, preserving
  * the live header/footer references — `EG_HdrFtrReferences` is not part of
@@ -76,14 +76,14 @@ type SectionRejectPropertiesOptions = {
   previousProperties: document_d_exports.SectionProperties | undefined;
   previousReferences?: document_d_exports.SectionPropertyChange["previousReferences"];
 };
-declare function sectionRejectProperties({ live, previousProperties, previousReferences }: SectionRejectPropertiesOptions): document_d_exports.SectionProperties;
+export declare function sectionRejectProperties({ live, previousProperties, previousReferences }: SectionRejectPropertiesOptions): document_d_exports.SectionProperties;
 /**
  * Attr patch for rejecting a `w:tblPrChange`: the stored old tblPr wholesale
  * (`w:tblPrChange` stores the complete previous tblPr, so every tblPr-derived
  * attr resets when absent). `columnWidths` comes from `w:tblGrid`, not tblPr,
  * and is untouched.
  */
-declare function tableRejectAttrPatch(previousFormatting: document_d_exports.TableFormatting | undefined): AttrPatch;
+export declare function tableRejectAttrPatch(previousFormatting: document_d_exports.TableFormatting | undefined): AttrPatch;
 /**
  * Attr patch for rejecting a `w:tblPrExChange`: the stored old `w:tblPrEx`
  * wholesale. The exceptions ride the row node whole rather than as attrs (the
@@ -91,9 +91,9 @@ declare function tableRejectAttrPatch(previousFormatting: document_d_exports.Tab
  * is restoring that one attr — and a record with no stored set says the row
  * overrode nothing, which is the element's absence, not an empty one.
  */
-declare function tablePropertyExceptionsRejectAttrPatch(previousFormatting: document_d_exports.TablePropertyExceptionFormatting | undefined): AttrPatch;
+export declare function tablePropertyExceptionsRejectAttrPatch(previousFormatting: document_d_exports.TablePropertyExceptionFormatting | undefined): AttrPatch;
 /** Attr patch for rejecting a `w:trPrChange`: the stored old trPr wholesale. */
-declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.TableRowFormatting | undefined): AttrPatch;
+export declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.TableRowFormatting | undefined): AttrPatch;
 /**
  * Attr patch for rejecting a `w:tcPrChange`: the stored old tcPr wholesale
  * for the non-structural attrs. `gridSpan` / `vMerge` are structural in
@@ -103,6 +103,6 @@ declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.
  * the live original's `gridSpan` / `vMerge` to stay consistent with it.
  * (Word would also restore tracked merges; folio deliberately does not.)
  */
-declare function tableCellRejectAttrPatch(previousFormatting: document_d_exports.TableCellFormatting | undefined, liveOriginalFormatting: document_d_exports.TableCellFormatting | null | undefined): AttrPatch;
+export declare function tableCellRejectAttrPatch(previousFormatting: document_d_exports.TableCellFormatting | undefined, liveOriginalFormatting: document_d_exports.TableCellFormatting | null | undefined): AttrPatch;
 //#endregion
-export { PPR_CHANGE_SCOPED_ATTR_KEYS, ParagraphPropertyChangeRemoval, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };
+export {};

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -174,6 +174,8 @@ const PPR_CHANGE_SCOPED_FORMATTING_KEYS = [
 	"numPr",
 	"alignment",
 	"bidi",
+	"autoSpaceDE",
+	"autoSpaceDN",
 	"spaceBefore",
 	"spaceAfter",
 	"lineSpacing",

package/dist/prosemirror/commands/resolveAllTableChanges.d.ts

@@ -9,7 +9,7 @@ type ResolveAllTableChangesOptions = {
   resolvedRows?: readonly Node[];
   mode: ResolveMode;
 };
-type ResolvedTableChanges = {
+export type ResolvedTableChanges = {
   /** Null means every row was removed; the caller owns the enclosing schema fallback. */
   node: Node | null;
   changed: boolean;
@@ -35,6 +35,6 @@ type ResolvedTableChanges = {
  * removed moves to the next retained row inside that rectangle. This is the
  * same topology operation as prosemirror-tables' removeRow.
  */
-declare const resolveAllTableChanges: ({ table, resolvedRows, mode }: ResolveAllTableChangesOptions) => ResolvedTableChanges;
+export declare const resolveAllTableChanges: ({ table, resolvedRows, mode }: ResolveAllTableChangesOptions) => ResolvedTableChanges;
 //#endregion
-export { ResolvedTableChanges, resolveAllTableChanges };
+export {};

package/dist/prosemirror/commands/resolveNodePropertyChangeAttrs.d.ts

@@ -8,8 +8,8 @@ type ResolveNodePropertyChangeAttrsOptions = {
   mode: "accept" | "reject";
   revisionSet: ReadonlySet<number> | null;
 };
-declare const resolveNodePropertyChangeAttrs: ({ node, site, mode, revisionSet }: ResolveNodePropertyChangeAttrsOptions) => Record<string, unknown> | null;
+export declare const resolveNodePropertyChangeAttrs: ({ node, site, mode, revisionSet }: ResolveNodePropertyChangeAttrsOptions) => Record<string, unknown> | null;
 /** Resolve every node-attr site, including both independent sites on a row. */
-declare const resolveAllNodePropertyChangeAttrs: (node: Node, mode: "accept" | "reject") => Node;
+export declare const resolveAllNodePropertyChangeAttrs: (node: Node, mode: "accept" | "reject") => Node;
 //#endregion
-export { resolveAllNodePropertyChangeAttrs, resolveNodePropertyChangeAttrs };
+export {};

package/dist/prosemirror/commands/resolveParagraphProperties.d.ts

@@ -1,5 +1,5 @@
-import { RunStyleResolver } from "../runStyleFormatting.js";
 import { NumberingMap } from "../../docx/numberingParser.js";
+import { RunStyleResolver } from "../runStyleFormatting.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/commands/resolveParagraphProperties.d.ts
 type ResolveParagraphPropertiesOptions = {
@@ -11,6 +11,6 @@ type ResolveParagraphPropertiesOptions = {
   numbering: NumberingMap | null;
 };
 /** Resolve paragraph and section property records before resolving their inline content. */
-declare const resolveParagraphChangeAttrs: ({ node, boundaryCovered, mode, revisionSet, styleResolver, numbering }: ResolveParagraphPropertiesOptions) => Record<string, unknown> | null;
+export declare const resolveParagraphChangeAttrs: ({ node, boundaryCovered, mode, revisionSet, styleResolver, numbering }: ResolveParagraphPropertiesOptions) => Record<string, unknown> | null;
 //#endregion
-export { resolveParagraphChangeAttrs };
+export {};

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -89,7 +89,7 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 			delete restored.propertyChanges;
 			if (remaining.length > 0) restored.propertyChanges = remaining;
 			nextAttrs = nextAttrs ?? { ...node.attrs };
-			nextAttrs["_sectionProperties"] = restored;
+			nextAttrs["_sectionProperties"] = mode === "reject" && Object.keys(restored).length === 0 ? null : restored;
 		}
 	}
 	return nextAttrs;