@stll/folio-core 0.62.0 → 0.63.1

package/dist/prosemirror/attrs/index.js

@@ -16,6 +16,7 @@ import { isParagraphDirection } from "../paragraphDirection.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_VALUE_PROPERTIES, TRACKED_CHANGE_PROVENANCE_VALUES } from "../schema/marks.js";
 import { PRESERVED_XML_LEVELS, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES } from "../schema/nodes.js";
 import { DRAWING_RAW_XML_MODES, THEME_COLORS, isOoxmlSymbolCharacter } from "@stll/docx-core/model";
+import { isCopyOriginAncestors } from "@stll/docx-core/ops";
 import { isSafePreservedChildXml, isWithinPreservedMarkupBudget } from "@stll/docx-core/schema";
 //#region src/prosemirror/attrs/index.ts
 const RUN_FORMATTING_VALUE_PROPERTY_SET = new Set(RUN_FORMATTING_VALUE_PROPERTIES);
@@ -233,6 +234,8 @@ const readParagraphAttrsUncached = (node) => {
 	optionalString(attrs, "styleId", "paragraph.attrs.styleId", issues);
 	optionalNumber(attrs, "_tableOfContentsLevel", "paragraph.attrs._tableOfContentsLevel", issues);
 	optionalBoolean(attrs, "kinsoku", "paragraph.attrs.kinsoku", issues);
+	optionalBoolean(attrs, "autoSpaceDE", "paragraph.attrs.autoSpaceDE", issues);
+	optionalBoolean(attrs, "autoSpaceDN", "paragraph.attrs.autoSpaceDN", issues);
 	optionalBoolean(attrs, "overflowPunctuation", "paragraph.attrs.overflowPunctuation", issues);
 	optionalBoolean(attrs, "suppressAutoHyphens", "paragraph.attrs.suppressAutoHyphens", issues);
 	optionalBoolean(attrs, "suppressLineNumbers", "paragraph.attrs.suppressLineNumbers", issues);
@@ -574,11 +577,13 @@ const validateEmptyFieldResultRuns = (value, issues) => {
 			message: "Expected only empty text."
 		});
 		const formatting = run["formatting"];
-		if (formatting !== void 0) if (!isRecord(formatting)) issues.push({
-			path: `${path}.formatting`,
-			message: "Expected formatting object."
-		});
-		else validateTextFormatting(formatting, `${path}.formatting`, issues);
+		if (formatting !== void 0) {
+			if (!isRecord(formatting)) issues.push({
+				path: `${path}.formatting`,
+				message: "Expected formatting object."
+			});
+			else validateTextFormatting(formatting, `${path}.formatting`, issues);
+		}
 		optionalPropertyChanges(run, "propertyChanges", `${path}.propertyChanges`, issues, ["runPropertyChange"]);
 		optionalPreservedAttributes(run, "preservedAttributes", `${path}.preservedAttributes`, issues);
 	}
@@ -993,6 +998,11 @@ const readTrackedChangeMarkAttrs = (mark) => {
 	});
 	const ancestors = attrs["_docxRevisionAncestors"];
 	const resolutionJoins = attrs["_docxResolutionJoins"];
+	const commentRangeBoundaries = attrs["_docxCommentRangeBoundaries"];
+	if (commentRangeBoundaries !== void 0 && commentRangeBoundaries !== null && (!Array.isArray(commentRangeBoundaries) || commentRangeBoundaries.some((boundary) => typeof boundary !== "object" || boundary === null || boundary["type"] !== "start" && boundary["type"] !== "end" || boundary["owner"] !== "revision" && boundary["owner"] !== "parent" || typeof boundary["commentId"] !== "number" || !Number.isSafeInteger(boundary["commentId"]) || boundary["commentId"] < 0))) issues.push({
+		path: `${mark.type.name}.attrs._docxCommentRangeBoundaries`,
+		message: "Expected valid tracked comment boundary ownership."
+	});
 	if (resolutionJoins !== void 0 && resolutionJoins !== null && !isResolutionJoins(resolutionJoins)) issues.push({
 		path: `${mark.type.name}.attrs._docxResolutionJoins`,
 		message: "Expected valid tracked-resolution provenance."
@@ -1270,6 +1280,7 @@ const readHyperlinkMarkAttrs = (mark) => {
 	const issues = [];
 	expectMarkType(mark, "hyperlink", issues);
 	requiredString(attrs, "href", "hyperlink.attrs.href", issues);
+	optionalString(attrs, "anchor", "hyperlink.attrs.anchor", issues);
 	optionalString(attrs, "tooltip", "hyperlink.attrs.tooltip", issues);
 	optionalString(attrs, "rId", "hyperlink.attrs.rId", issues);
 	optionalString(attrs, "target", "hyperlink.attrs.target", issues);
@@ -2026,6 +2037,11 @@ const optionalPositionedBookmarks = (attrs, path, issues) => {
 		}
 		validateNonNegativeSafeInteger(marker["id"], `${entryPath}.marker.id`, issues);
 		if (type === "bookmarkStart") requiredString(marker, "name", `${entryPath}.marker.name`, issues);
+		const copyOriginAncestors = marker["copyOriginAncestors"];
+		if (copyOriginAncestors !== void 0 && !isCopyOriginAncestors(copyOriginAncestors)) issues.push({
+			path: `${entryPath}.marker.copyOriginAncestors`,
+			message: "Expected a sorted, unique list of safe non-negative ordinals."
+		});
 		optionalContentControls(entry, `${entryPath}.contentControls`, issues);
 	}
 };
@@ -2175,44 +2191,50 @@ const validateTextFormatting = (value, path, issues) => {
 	optionalOneOf(value, "highlight", `${path}.highlight`, issues, HIGHLIGHT_COLOR_VALUES);
 	optionalShading(value, "shading", `${path}.shading`, issues);
 	const underline = value["underline"];
-	if (underline !== void 0 && underline !== null) if (!isRecord(underline)) issues.push({
-		path: `${path}.underline`,
-		message: "Expected an object."
-	});
-	else {
-		requiredOneOf(underline, "style", `${path}.underline.style`, issues, UNDERLINE_STYLE_VALUES);
-		optionalColorValue(underline, "color", `${path}.underline.color`, issues);
+	if (underline !== void 0 && underline !== null) {
+		if (!isRecord(underline)) issues.push({
+			path: `${path}.underline`,
+			message: "Expected an object."
+		});
+		else {
+			requiredOneOf(underline, "style", `${path}.underline.style`, issues, UNDERLINE_STYLE_VALUES);
+			optionalColorValue(underline, "color", `${path}.underline.color`, issues);
+		}
 	}
 	const fontFamily = value["fontFamily"];
-	if (fontFamily !== void 0 && fontFamily !== null) if (!isRecord(fontFamily)) issues.push({
-		path: `${path}.fontFamily`,
-		message: "Expected an object."
-	});
-	else {
-		for (const key of [
-			"ascii",
-			"hAnsi",
-			"eastAsia",
-			"cs"
-		]) optionalString(fontFamily, key, `${path}.fontFamily.${key}`, issues);
-		optionalOneOf(fontFamily, "hint", `${path}.fontFamily.hint`, issues, FONT_HINT_VALUES);
-		for (const key of [
-			"asciiTheme",
-			"hAnsiTheme",
-			"eastAsiaTheme",
-			"csTheme"
-		]) optionalOneOf(fontFamily, key, `${path}.fontFamily.${key}`, issues, FONT_THEME_VALUES);
+	if (fontFamily !== void 0 && fontFamily !== null) {
+		if (!isRecord(fontFamily)) issues.push({
+			path: `${path}.fontFamily`,
+			message: "Expected an object."
+		});
+		else {
+			for (const key of [
+				"ascii",
+				"hAnsi",
+				"eastAsia",
+				"cs"
+			]) optionalString(fontFamily, key, `${path}.fontFamily.${key}`, issues);
+			optionalOneOf(fontFamily, "hint", `${path}.fontFamily.hint`, issues, FONT_HINT_VALUES);
+			for (const key of [
+				"asciiTheme",
+				"hAnsiTheme",
+				"eastAsiaTheme",
+				"csTheme"
+			]) optionalOneOf(fontFamily, key, `${path}.fontFamily.${key}`, issues, FONT_THEME_VALUES);
+		}
 	}
 	const language = value["language"];
-	if (language !== void 0 && language !== null) if (!isRecord(language)) issues.push({
-		path: `${path}.language`,
-		message: "Expected an object."
-	});
-	else for (const key of [
-		"val",
-		"eastAsia",
-		"bidi"
-	]) optionalString(language, key, `${path}.language.${key}`, issues);
+	if (language !== void 0 && language !== null) {
+		if (!isRecord(language)) issues.push({
+			path: `${path}.language`,
+			message: "Expected an object."
+		});
+		else for (const key of [
+			"val",
+			"eastAsia",
+			"bidi"
+		]) optionalString(language, key, `${path}.language.${key}`, issues);
+	}
 };
 const optionalInsetMap = (attrs, key, path, issues) => {
 	const value = attrs[key];
@@ -2343,6 +2365,8 @@ const optionalWordArt = (attrs, key, path, issues) => {
 const PARAGRAPH_FORMATTING_BOOLEAN_KEYS = [
 	"bidi",
 	"kinsoku",
+	"autoSpaceDE",
+	"autoSpaceDN",
 	"overflowPunctuation",
 	"suppressAutoHyphens",
 	"suppressLineNumbers",
@@ -2443,59 +2467,61 @@ const validateParagraphFormatting = (value, path, issues) => {
 	for (const key of ["indentPreservedAttributes", "spacingPreservedAttributes"]) optionalPreservedAttributes(value, key, `${path}.${key}`, issues);
 	optionalNestedRecord(value, "runProperties", `${path}.runProperties`, issues, validateTextFormatting);
 	const frame = value["frame"];
-	if (frame !== void 0 && frame !== null) if (!isRecord(frame)) issues.push({
-		path: `${path}.frame`,
-		message: "Expected an object."
-	});
-	else {
-		optionalOneOf(frame, "dropCap", `${path}.frame.dropCap`, issues, [
-			"none",
-			"drop",
-			"margin"
-		]);
-		optionalOneOf(frame, "hAnchor", `${path}.frame.hAnchor`, issues, [
-			"text",
-			"margin",
-			"page"
-		]);
-		optionalOneOf(frame, "vAnchor", `${path}.frame.vAnchor`, issues, [
-			"text",
-			"margin",
-			"page"
-		]);
-		optionalOneOf(frame, "xAlign", `${path}.frame.xAlign`, issues, [
-			"left",
-			"center",
-			"right",
-			"inside",
-			"outside"
-		]);
-		optionalOneOf(frame, "yAlign", `${path}.frame.yAlign`, issues, [
-			"top",
-			"center",
-			"bottom",
-			"inside",
-			"outside",
-			"inline"
-		]);
-		optionalOneOf(frame, "wrap", `${path}.frame.wrap`, issues, [
-			"around",
-			"auto",
-			"none",
-			"notBeside",
-			"through",
-			"tight"
-		]);
-		for (const key of [
-			"lines",
-			"width",
-			"height",
-			"hSpace",
-			"vSpace",
-			"x",
-			"y"
-		]) optionalNumber(frame, key, `${path}.frame.${key}`, issues);
-		optionalPreservedAttributes(frame, "preservedAttributes", `${path}.frame.preservedAttributes`, issues);
+	if (frame !== void 0 && frame !== null) {
+		if (!isRecord(frame)) issues.push({
+			path: `${path}.frame`,
+			message: "Expected an object."
+		});
+		else {
+			optionalOneOf(frame, "dropCap", `${path}.frame.dropCap`, issues, [
+				"none",
+				"drop",
+				"margin"
+			]);
+			optionalOneOf(frame, "hAnchor", `${path}.frame.hAnchor`, issues, [
+				"text",
+				"margin",
+				"page"
+			]);
+			optionalOneOf(frame, "vAnchor", `${path}.frame.vAnchor`, issues, [
+				"text",
+				"margin",
+				"page"
+			]);
+			optionalOneOf(frame, "xAlign", `${path}.frame.xAlign`, issues, [
+				"left",
+				"center",
+				"right",
+				"inside",
+				"outside"
+			]);
+			optionalOneOf(frame, "yAlign", `${path}.frame.yAlign`, issues, [
+				"top",
+				"center",
+				"bottom",
+				"inside",
+				"outside",
+				"inline"
+			]);
+			optionalOneOf(frame, "wrap", `${path}.frame.wrap`, issues, [
+				"around",
+				"auto",
+				"none",
+				"notBeside",
+				"through",
+				"tight"
+			]);
+			for (const key of [
+				"lines",
+				"width",
+				"height",
+				"hSpace",
+				"vSpace",
+				"x",
+				"y"
+			]) optionalNumber(frame, key, `${path}.frame.${key}`, issues);
+			optionalPreservedAttributes(frame, "preservedAttributes", `${path}.frame.preservedAttributes`, issues);
+		}
 	}
 };
 const validatePropertyChangeInfo = (value, path, issues) => {
@@ -2510,13 +2536,15 @@ const validatePropertyChangeInfo = (value, path, issues) => {
 	requiredString(value, "author", `${path}.author`, issues);
 	optionalString(value, "date", `${path}.date`, issues);
 	const utcDate = value["utcDate"];
-	if (utcDate !== void 0) if (!isRecord(utcDate)) issues.push({
-		path: `${path}.utcDate`,
-		message: "Expected an object."
-	});
-	else {
-		requiredString(utcDate, "attribute", `${path}.utcDate.attribute`, issues);
-		requiredString(utcDate, "value", `${path}.utcDate.value`, issues);
+	if (utcDate !== void 0) {
+		if (!isRecord(utcDate)) issues.push({
+			path: `${path}.utcDate`,
+			message: "Expected an object."
+		});
+		else {
+			requiredString(utcDate, "attribute", `${path}.utcDate.attribute`, issues);
+			requiredString(utcDate, "value", `${path}.utcDate.value`, issues);
+		}
 	}
 	optionalString(value, "rsid", `${path}.rsid`, issues);
 	optionalOneOf(value, "provenance", `${path}.provenance`, issues, TRACKED_CHANGE_PROVENANCE_VALUES);

package/dist/prosemirror/authoredTransformAttrs.d.ts

@@ -16,13 +16,13 @@ type ReadableTransformAttrs = {
   transform?: string;
 };
 /** Project a model transform onto a drawing node's attrs. */
-declare const authoredTransformAttrs: (transform: document_d_exports.ImageTransform | undefined) => AuthoredTransformAttrs;
+export declare const authoredTransformAttrs: (transform: document_d_exports.ImageTransform | undefined) => AuthoredTransformAttrs;
 /**
  * Read a drawing node's authored transform back.
  *
  * The attrs are the record; the CSS string answers only for a node that states
  * none of them, which is how a node persisted before they existed arrives.
  */
-declare const readAuthoredTransform: (attrs: ReadableTransformAttrs) => document_d_exports.ImageTransform | undefined;
+export declare const readAuthoredTransform: (attrs: ReadableTransformAttrs) => document_d_exports.ImageTransform | undefined;
 //#endregion
-export { authoredTransformAttrs, readAuthoredTransform };
+export {};

package/dist/prosemirror/autospacingBase.d.ts

@@ -2,9 +2,9 @@ import { ParagraphAttrs } from "./schema/nodes.js";
 //#region src/prosemirror/autospacingBase.d.ts
 type AutospacingBase = NonNullable<ParagraphAttrs["_autospacingBase"]>;
 type AutospacingSide = "before" | "after";
-declare function normalizeAutospacingBaseValue(value: unknown): number | null;
-declare function setAutospacingBaseValue(base: AutospacingBase, side: AutospacingSide, value: unknown): void;
-declare function hasAutospacingBaseSide(base: ParagraphAttrs["_autospacingBase"] | null | undefined, side: AutospacingSide): boolean;
-declare function autospacingMatchesBase(base: ParagraphAttrs["_autospacingBase"] | null | undefined, side: AutospacingSide, currentValue: unknown): boolean;
+export declare function normalizeAutospacingBaseValue(value: unknown): number | null;
+export declare function setAutospacingBaseValue(base: AutospacingBase, side: AutospacingSide, value: unknown): void;
+export declare function hasAutospacingBaseSide(base: ParagraphAttrs["_autospacingBase"] | null | undefined, side: AutospacingSide): boolean;
+export declare function autospacingMatchesBase(base: ParagraphAttrs["_autospacingBase"] | null | undefined, side: AutospacingSide, currentValue: unknown): boolean;
 //#endregion
-export { autospacingMatchesBase, hasAutospacingBaseSide, normalizeAutospacingBaseValue, setAutospacingBaseValue };
+export {};

package/dist/prosemirror/bookmarkBoundaryAttrs.d.ts

@@ -4,13 +4,13 @@ import { ReadProseMirrorAttrsResult } from "../internal/prosemirrorAttrBoundary.
 import "./attrs/index.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/bookmarkBoundaryAttrs.d.ts
-declare const isDisplacedByCustomXml: (value: unknown) => value is document_d_exports.DisplacedByCustomXml;
+export declare const isDisplacedByCustomXml: (value: unknown) => value is document_d_exports.DisplacedByCustomXml;
 /**
  * A boundary's `w:displacedByCustomXml`, as a fragment to spread into the model
  * content it rebuilds. Both a start and an end may carry it, so the callers
  * that build either one share this rather than each remembering the attribute.
  */
-declare const bookmarkBoundaryDisplacement: (attrs: BookmarkBoundaryAttrs) => {
+export declare const bookmarkBoundaryDisplacement: (attrs: BookmarkBoundaryAttrs) => {
   displacedByCustomXml?: document_d_exports.DisplacedByCustomXml;
 };
 /**
@@ -20,8 +20,8 @@ declare const bookmarkBoundaryDisplacement: (attrs: BookmarkBoundaryAttrs) => {
  * rebuild the same two elements from the same attributes; spelling that out
  * per caller is how one of them comes to forget `w:colFirst`.
  */
-declare const bookmarkMarkerFromAttrs: (attrs: BookmarkBoundaryAttrs) => document_d_exports.BookmarkStart | document_d_exports.BookmarkEnd;
-declare const readBookmarkBoundaryAttrs: (node: Node) => ReadProseMirrorAttrsResult<BookmarkBoundaryAttrs>;
-declare const expectBookmarkBoundaryAttrs: (node: Node) => BookmarkBoundaryAttrs;
-//#endregion
-export { bookmarkBoundaryDisplacement, bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };
+export declare const bookmarkMarkerFromAttrs: (attrs: BookmarkBoundaryAttrs) => document_d_exports.BookmarkStart | document_d_exports.BookmarkEnd;
+export declare const bookmarkBoundaryAttrsFromMarker: (marker: document_d_exports.BookmarkStart | document_d_exports.BookmarkEnd) => BookmarkBoundaryAttrs;
+export declare const readBookmarkBoundaryAttrs: (node: Node) => ReadProseMirrorAttrsResult<BookmarkBoundaryAttrs>;
+export declare const expectBookmarkBoundaryAttrs: (node: Node) => BookmarkBoundaryAttrs;
+//#endregion

package/dist/prosemirror/bookmarkBoundaryAttrs.js

@@ -1,4 +1,5 @@
 import { panic } from "better-result";
+import { isCopyOriginAncestors } from "@stll/docx-core/ops";
 //#region src/prosemirror/bookmarkBoundaryAttrs.ts
 const isDisplacedByCustomXml = (value) => value === "next" || value === "prev";
 const attrsCache = /* @__PURE__ */ new WeakMap();
@@ -8,6 +9,7 @@ const attrsCache = /* @__PURE__ */ new WeakMap();
 * that build either one share this rather than each remembering the attribute.
 */
 const bookmarkBoundaryDisplacement = (attrs) => attrs.displacedByCustomXml === void 0 ? {} : { displacedByCustomXml: attrs.displacedByCustomXml };
+const bookmarkBoundaryCopyOrigin = (attrs) => attrs.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: attrs.copyOriginAncestors };
 /**
 * The model marker a boundary node carries, at either level.
 *
@@ -19,14 +21,30 @@ const bookmarkMarkerFromAttrs = (attrs) => attrs.type === "start" ? {
 	type: "bookmarkStart",
 	id: attrs.id,
 	name: attrs.name,
+	...bookmarkBoundaryCopyOrigin(attrs),
 	...attrs.colFirst !== void 0 ? { colFirst: attrs.colFirst } : {},
 	...attrs.colLast !== void 0 ? { colLast: attrs.colLast } : {},
 	...bookmarkBoundaryDisplacement(attrs)
 } : {
 	type: "bookmarkEnd",
 	id: attrs.id,
+	...bookmarkBoundaryCopyOrigin(attrs),
 	...bookmarkBoundaryDisplacement(attrs)
 };
+const bookmarkBoundaryAttrsFromMarker = (marker) => marker.type === "bookmarkStart" ? {
+	type: "start",
+	id: marker.id,
+	name: marker.name,
+	...marker.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: marker.copyOriginAncestors },
+	...marker.colFirst === void 0 ? {} : { colFirst: marker.colFirst },
+	...marker.colLast === void 0 ? {} : { colLast: marker.colLast },
+	...marker.displacedByCustomXml === void 0 ? {} : { displacedByCustomXml: marker.displacedByCustomXml }
+} : {
+	type: "end",
+	id: marker.id,
+	...marker.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: marker.copyOriginAncestors },
+	...marker.displacedByCustomXml === void 0 ? {} : { displacedByCustomXml: marker.displacedByCustomXml }
+};
 const readBookmarkBoundaryAttrs = (node) => {
 	const issues = [];
 	if (node.type.name !== "bookmarkBoundary" && node.type.name !== "blockBookmarkBoundary") issues.push({
@@ -63,17 +81,24 @@ const readBookmarkBoundaryAttrs = (node) => {
 		path: "bookmarkBoundary.attrs.displacedByCustomXml",
 		message: "Expected \"next\" or \"prev\"."
 	});
+	const copyOriginAncestors = node.attrs["copyOriginAncestors"];
+	if (copyOriginAncestors !== void 0 && copyOriginAncestors !== null && !isCopyOriginAncestors(copyOriginAncestors)) issues.push({
+		path: "bookmarkBoundary.attrs.copyOriginAncestors",
+		message: "Expected a sorted, unique list of safe non-negative ordinals."
+	});
 	if (issues.length > 0 || typeof id !== "number") return {
 		ok: false,
 		issues
 	};
 	const displacement = isDisplacedByCustomXml(displaced) ? { displacedByCustomXml: displaced } : {};
+	const copyOrigin = copyOriginAncestors === void 0 || copyOriginAncestors === null || !isCopyOriginAncestors(copyOriginAncestors) ? {} : { copyOriginAncestors };
 	if (type === "start" && typeof name === "string") return {
 		ok: true,
 		value: {
 			type,
 			id,
 			name,
+			...copyOrigin,
 			...typeof colFirst === "number" ? { colFirst } : {},
 			...typeof colLast === "number" ? { colLast } : {},
 			...displacement
@@ -84,6 +109,7 @@ const readBookmarkBoundaryAttrs = (node) => {
 		value: {
 			type: "end",
 			id,
+			...copyOrigin,
 			...displacement
 		}
 	};
@@ -92,9 +118,12 @@ const expectBookmarkBoundaryAttrs = (node) => {
 	const cached = attrsCache.get(node);
 	if (cached) return cached;
 	const result = readBookmarkBoundaryAttrs(node);
-	if (!result.ok) panic(`Invalid ProseMirror bookmark boundary attrs:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+	if (!result.ok) {
+		const details = result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n");
+		panic(`Invalid ProseMirror bookmark boundary attrs:\n${details}`);
+	}
 	attrsCache.set(node, result.value);
 	return result.value;
 };
 //#endregion
-export { bookmarkBoundaryDisplacement, bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };
+export { bookmarkBoundaryAttrsFromMarker, bookmarkBoundaryDisplacement, bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };

package/dist/prosemirror/bookmarkBoundaryIntegrity.d.ts

@@ -1,9 +1,8 @@
 //#region src/prosemirror/bookmarkBoundaryIntegrity.d.ts
-type BookmarkBoundaryOccurrence = {
+export type BookmarkBoundaryOccurrence = {
   id: number;
   type: "start" | "end";
   position: number;
 };
-declare const findInvalidBookmarkBoundaryIds: (occurrences: readonly BookmarkBoundaryOccurrence[], reservedIds?: ReadonlySet<number>) => ReadonlySet<number>;
-//#endregion
-export { BookmarkBoundaryOccurrence, findInvalidBookmarkBoundaryIds };
+export declare const findInvalidBookmarkBoundaryIds: (occurrences: readonly BookmarkBoundaryOccurrence[], reservedIds?: ReadonlySet<number>) => ReadonlySet<number>;
+//#endregion

package/dist/prosemirror/canonicalCommands.d.ts

@@ -1,9 +1,10 @@
+import { document_d_exports } from "../types/document.js";
 import { Node } from "prosemirror-model";
 import { Command, EditorState } from "prosemirror-state";
-import { ParagraphPropsPatch, RunPropsPatch } from "@stll/docx-core/ops";
+import { FormattingPatch, ParagraphPropsPatch, RunPropsPatch } from "@stll/docx-core/ops";
 //#region src/prosemirror/canonicalCommands.d.ts
 /** Command meaning before canonical positions are resolved by the session. */
-type CanonicalCommandIntent = {
+export type CanonicalCommandIntent = {
   type: "generateTOC";
   at: number;
   title: string;
@@ -47,25 +48,44 @@ type CanonicalCommandIntent = {
   start?: number;
 } | {
   type: "continueNumbering";
+} | {
+  type: "setSectionBreak";
+  breakType: "nextPage" | "nextColumn" | "continuous" | "evenPage" | "oddPage";
+} | {
+  type: "removeSectionBreak";
+} | {
+  type: "insertNote";
+  at: number;
+  kind: "footnote" | "endnote";
+  id: number;
+  content: document_d_exports.BlockContent[];
+} | {
+  type: "deleteNote";
+  from: number;
+  kind: "footnote" | "endnote";
+  id: number;
 } | {
   type: "insertBreak";
   from: number;
   to: number;
   breakType: "page" | "textWrapping";
 };
-type CanonicalCommandDescriptor = (state: EditorState) => readonly CanonicalCommandIntent[];
+type CanonicalCommandDescriptor = (state: EditorState) => readonly CanonicalCommandIntent[] | undefined;
 /** Registration leaves execution and side-effect-free command probes unchanged. */
-declare const withCanonicalCommand: (command: Command, descriptor: CanonicalCommandDescriptor) => Command;
-declare const getCanonicalCommandIntents: (command: Command, state: EditorState) => readonly CanonicalCommandIntent[] | undefined;
-declare const canonicalRunFormatting: (state: EditorState, patch: RunPropsPatch) => readonly [{
-  readonly patch: import("@stll/docx-core/ops").FormattingPatch<{
+export declare const withCanonicalCommand: (command: Command, descriptor: CanonicalCommandDescriptor) => Command;
+export declare const getCanonicalCommandIntents: (command: Command, state: EditorState) => readonly CanonicalCommandIntent[] | undefined;
+export declare const canonicalRunFormatting: (state: EditorState, patch: RunPropsPatch) => {
+  type: "formatRun";
+  from: number;
+  to: number;
+  patch: FormattingPatch<{
     bold?: boolean | undefined;
     boldCs?: boolean | undefined;
     italic?: boolean | undefined;
     italicCs?: boolean | undefined;
     underline?: {
-      style: import("@stll/docx-core/model").UnderlineStyle;
-      color?: import("@stll/docx-core/model").ColorValue;
+      style: document_d_exports.UnderlineStyle;
+      color?: document_d_exports.ColorValue;
     } | undefined;
     strike?: boolean | undefined;
     doubleStrike?: boolean | undefined;
@@ -74,9 +94,9 @@ declare const canonicalRunFormatting: (state: EditorState, patch: RunPropsPatch)
     allCaps?: boolean | undefined;
     hidden?: boolean | undefined;
     noProof?: boolean | undefined;
-    color?: import("@stll/docx-core/model").ColorValue | undefined;
+    color?: document_d_exports.ColorValue | undefined;
     highlight?: "black" | "blue" | "cyan" | "darkBlue" | "darkCyan" | "darkGray" | "darkGreen" | "darkMagenta" | "darkRed" | "darkYellow" | "green" | "lightGray" | "magenta" | "none" | "red" | "white" | "yellow" | undefined;
-    shading?: import("@stll/docx-core/model").ShadingProperties | undefined;
+    shading?: document_d_exports.ShadingProperties | undefined;
     fontSize?: number | undefined;
     fontSizeCs?: number | undefined;
     fontFamily?: {
@@ -99,8 +119,8 @@ declare const canonicalRunFormatting: (state: EditorState, patch: RunPropsPatch)
     position?: number | undefined;
     scale?: number | undefined;
     kerning?: number | undefined;
-    effect?: import("@stll/docx-core/model").TextEffect | undefined;
-    emphasisMark?: import("@stll/docx-core/model").EmphasisMark | undefined;
+    effect?: document_d_exports.TextEffect | undefined;
+    emphasisMark?: document_d_exports.EmphasisMark | undefined;
     emboss?: boolean | undefined;
     imprint?: boolean | undefined;
     outline?: boolean | undefined;
@@ -108,14 +128,11 @@ declare const canonicalRunFormatting: (state: EditorState, patch: RunPropsPatch)
     rtl?: boolean | undefined;
     cs?: boolean | undefined;
     styleId?: string | undefined;
-    preserved?: import("@stll/docx-core/model").PreservedMarkup | undefined;
+    preserved?: document_d_exports.PreservedMarkup | undefined;
   }>;
-  readonly from: number;
-  readonly to: number;
-  readonly type: "formatRun";
-}];
-declare const withCanonicalParagraphFormatting: (command: Command, patch: ParagraphPropsPatch | ((paragraph: Node) => ParagraphPropsPatch)) => Command;
+}[];
+export declare const withCanonicalParagraphFormatting: (command: Command, patch: ParagraphPropsPatch | ((paragraph: Node) => ParagraphPropsPatch)) => Command;
 /** Commands that read the selection start apply that same patch across selected paragraphs. */
-declare const withCanonicalStartParagraphFormatting: (command: Command, patch: (paragraph: Node) => ParagraphPropsPatch) => Command;
+export declare const withCanonicalStartParagraphFormatting: (command: Command, patch: (paragraph: Node) => ParagraphPropsPatch) => Command;
 //#endregion
-export { CanonicalCommandIntent, canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting, withCanonicalStartParagraphFormatting };
+export {};

package/dist/prosemirror/canonicalCommands.js

@@ -1,4 +1,4 @@
-import { canonicalSelectionRange } from "./canonicalSelectionRange.js";
+import { canonicalSelectionRanges } from "./canonicalSelectionRange.js";
 //#region src/prosemirror/canonicalCommands.ts
 const descriptors = /* @__PURE__ */ new WeakMap();
 /** Registration leaves execution and side-effect-free command probes unchanged. */
@@ -7,11 +7,12 @@ const withCanonicalCommand = (command, descriptor) => {
 	return command;
 };
 const getCanonicalCommandIntents = (command, state) => descriptors.get(command)?.(state);
-const canonicalRunFormatting = (state, patch) => [{
+const canonicalRunFormatting = (state, patch) => canonicalSelectionRanges(state).map(({ from, to }) => ({
 	type: "formatRun",
-	...canonicalSelectionRange(state),
+	from,
+	to,
 	patch
-}];
+}));
 const canonicalParagraphFormatting = (state, patch) => {
 	const intents = [];
 	state.doc.nodesBetween(state.selection.from, state.selection.to, (node, position) => {

package/dist/prosemirror/canonicalSelectionRange.d.ts

@@ -1,12 +1,22 @@
 import { Node } from "prosemirror-model";
 import { EditorState } from "prosemirror-state";
+import { CellSelection } from "prosemirror-tables";
 //#region src/prosemirror/canonicalSelectionRange.d.ts
 /** Document edges denote the first and last editable content gaps. */
-declare const canonicalContentPosition: (doc: Node, position: number) => number;
+export declare const canonicalContentPosition: (doc: Node, position: number) => number;
 /** Whole-document selection addresses paragraph content rather than document edges. */
-declare const canonicalSelectionRange: ({ doc, selection }: EditorState) => {
+export declare const canonicalSelectionRange: ({ doc, selection }: EditorState) => {
   from: number;
   to: number;
 };
-//#endregion
-export { canonicalContentPosition, canonicalSelectionRange };
+/** Cell selections address each selected cell independently, in document order. */
+export declare const canonicalCellSelectionRanges: (selection: CellSelection) => {
+  from: number;
+  to: number;
+}[];
+/** A selection is either one linear range or a document-ordered set of cell ranges. */
+export declare const canonicalSelectionRanges: (state: EditorState) => {
+  from: number;
+  to: number;
+}[];
+//#endregion