@stll/folio-core 0.22.3 → 0.23.1

package/dist/managers/autoSaveCodec.js

@@ -0,0 +1,109 @@
+import { validateFolioDocumentModel } from "../docx/modelValidation.js";
+//#region src/managers/autoSaveCodec.ts
+const AUTOSAVE_FORMAT_VERSION = 2;
+const BASE64_CHUNK_BYTES = 32768;
+const encodeBase64 = (buffer) => {
+	const bytes = new Uint8Array(buffer);
+	const chunks = [];
+	for (let offset = 0; offset < bytes.length; offset += BASE64_CHUNK_BYTES) chunks.push(String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK_BYTES)));
+	return btoa(chunks.join(""));
+};
+const decodeBase64 = (value) => {
+	const binary = atob(value);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+	return bytes.buffer;
+};
+const encodeValue = (value) => {
+	if (value === void 0) return { type: "undefined" };
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value instanceof Date) return {
+		type: "date",
+		value: value.toISOString()
+	};
+	if (value instanceof ArrayBuffer) return {
+		type: "arrayBuffer",
+		value: encodeBase64(value)
+	};
+	if (value instanceof Map) return {
+		type: "map",
+		value: [...value.entries()].map(([key, entry]) => [encodeValue(key), encodeValue(entry)])
+	};
+	if (Array.isArray(value)) return {
+		type: "array",
+		value: value.map(encodeValue)
+	};
+	if (typeof value === "object") {
+		const encoded = {};
+		for (const [key, entry] of Object.entries(value)) encoded[key] = encodeValue(entry);
+		return {
+			type: "object",
+			value: encoded
+		};
+	}
+	throw new TypeError(`Unsupported auto-save value: ${typeof value}`);
+};
+const decodeValue = (value) => {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value !== "object" || !value || !("type" in value)) throw new TypeError("Invalid auto-save encoded value");
+	const type = value.type;
+	if (type === "undefined") return;
+	if (type === "date") {
+		if (!("value" in value) || typeof value.value !== "string" || !Number.isFinite(Date.parse(value.value))) throw new TypeError("Invalid auto-save date");
+		return new Date(value.value);
+	}
+	if (type === "arrayBuffer") {
+		if (!("value" in value) || typeof value.value !== "string") throw new TypeError("Invalid auto-save binary data");
+		return decodeBase64(value.value);
+	}
+	if (type === "array") {
+		if (!("value" in value) || !Array.isArray(value.value)) throw new TypeError("Invalid auto-save array");
+		return value.value.map(decodeValue);
+	}
+	if (type === "map") {
+		if (!("value" in value) || !Array.isArray(value.value)) throw new TypeError("Invalid auto-save map");
+		return new Map(value.value.map((entry) => {
+			if (!Array.isArray(entry) || entry.length !== 2) throw new TypeError("Invalid auto-save map entry");
+			return [decodeValue(entry[0]), decodeValue(entry[1])];
+		}));
+	}
+	if (type === "object") {
+		if (!("value" in value) || typeof value.value !== "object" || !value.value) throw new TypeError("Invalid auto-save object");
+		const decoded = Object.create(null);
+		for (const [key, entry] of Object.entries(value.value)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") throw new TypeError("Invalid auto-save object key");
+			const decodedEntry = decodeValue(entry);
+			if (decodedEntry !== void 0) decoded[key] = decodedEntry;
+		}
+		return decoded;
+	}
+	throw new TypeError("Unknown auto-save encoded value");
+};
+const encodeAutoSaveDocument = (document) => {
+	const snapshot = {
+		...document,
+		originalBuffer: null
+	};
+	return { json: JSON.stringify(encodeValue(snapshot)) };
+};
+const encodeAutoSaveEnvelopeFromDocument = (document, savedAt) => `{"document":${document.json},"savedAt":${JSON.stringify(savedAt)},"version":2}`;
+const encodeAutoSaveEnvelope = (document, savedAt) => encodeAutoSaveEnvelopeFromDocument(encodeAutoSaveDocument(document), savedAt);
+const decodeAutoSaveEnvelope = (json) => {
+	try {
+		const parsed = JSON.parse(json);
+		if (typeof parsed !== "object" || !parsed || !("document" in parsed) || !("savedAt" in parsed) || !("version" in parsed)) return null;
+		if (parsed.version !== 2 || typeof parsed.savedAt !== "string" || !Number.isFinite(Date.parse(parsed.savedAt))) return null;
+		const document = decodeValue(parsed.document);
+		if (typeof document !== "object" || !document) return null;
+		if (!validateFolioDocumentModel(document).valid) return null;
+		return {
+			document,
+			savedAt: parsed.savedAt,
+			version: 2
+		};
+	} catch {
+		return null;
+	}
+};
+//#endregion
+export { AUTOSAVE_FORMAT_VERSION, decodeAutoSaveEnvelope, encodeAutoSaveDocument, encodeAutoSaveEnvelope, encodeAutoSaveEnvelopeFromDocument };

package/dist/paged-layout/sectionGeometry.d.ts

@@ -1,5 +1,5 @@
 import { document_d_exports } from "../types/document.js";
-import { PageMargins } from "../layout-engine/types.js";
+import { PageMargins, SectionPageNumbering } from "../layout-engine/types.js";
 //#region src/paged-layout/sectionGeometry.d.ts
 declare const DEFAULT_PAGE_WIDTH_PX = 816;
 declare const DEFAULT_PAGE_HEIGHT_PX = 1056;
@@ -16,5 +16,6 @@ declare const getPageSize: (sectionProps: document_d_exports.SectionProperties |
   h: number;
 };
 declare const getMargins: (sectionProps: document_d_exports.SectionProperties | null | undefined) => PageMargins;
+declare const getPageNumbering: (sectionProps: document_d_exports.SectionProperties | null | undefined) => SectionPageNumbering;
 //#endregion
-export { DEFAULT_BODY_MARGIN_PX, DEFAULT_HEADER_FOOTER_DISTANCE_PX, DEFAULT_PAGE_HEIGHT_PX, DEFAULT_PAGE_WIDTH_PX, getMargins, getPageSize, twipsToPixels, twipsToPxOr };
+export { DEFAULT_BODY_MARGIN_PX, DEFAULT_HEADER_FOOTER_DISTANCE_PX, DEFAULT_PAGE_HEIGHT_PX, DEFAULT_PAGE_WIDTH_PX, getMargins, getPageNumbering, getPageSize, twipsToPixels, twipsToPxOr };

package/dist/paged-layout/sectionGeometry.js

@@ -32,5 +32,21 @@ const getMargins = (sectionProps) => ({
 	header: twipsToPxOr(sectionProps?.headerDistance, 48),
 	footer: twipsToPxOr(sectionProps?.footerDistance, 48)
 });
+const getPageNumbering = (sectionProps) => {
+	const pageNumbering = sectionProps?.pageNumbering;
+	const format = pageNumbering?.format;
+	if (pageNumbering?.start === void 0) return format === void 0 ? { type: "continue" } : {
+		type: "continue",
+		format
+	};
+	return format === void 0 ? {
+		type: "restart",
+		start: pageNumbering.start
+	} : {
+		type: "restart",
+		start: pageNumbering.start,
+		format
+	};
+};
 //#endregion
-export { DEFAULT_BODY_MARGIN_PX, DEFAULT_HEADER_FOOTER_DISTANCE_PX, DEFAULT_PAGE_HEIGHT_PX, DEFAULT_PAGE_WIDTH_PX, getMargins, getPageSize, twipsToPixels, twipsToPxOr };
+export { DEFAULT_BODY_MARGIN_PX, DEFAULT_HEADER_FOOTER_DISTANCE_PX, DEFAULT_PAGE_HEIGHT_PX, DEFAULT_PAGE_WIDTH_PX, getMargins, getPageNumbering, getPageSize, twipsToPixels, twipsToPxOr };

package/dist/prosemirror/attrs/index.js

@@ -1,4 +1,4 @@
-import { FIELD_TYPE_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_TEXT_DIRECTION_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_EFFECT_VALUES, THEME_COLOR_SLOT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
+import { EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, NUMBER_FORMAT_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_TEXT_DIRECTION_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_EFFECT_VALUES, THEME_COLOR_SLOT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
 import { TRACKED_CHANGE_PROVENANCE_VALUES } from "../schema/marks.js";
 import { panic } from "better-result";
@@ -89,21 +89,6 @@ const RUN_FORMATTING_OVERRIDE_FALSE_KEYS = [
 	"shadow",
 	"outline"
 ];
-const TEXT_FORMATTING_BOOLEAN_KEYS = [
-	"bold",
-	"boldCs",
-	"italic",
-	"italicCs",
-	"strike",
-	"doubleStrike",
-	"smallCaps",
-	"allCaps",
-	"hidden",
-	"emboss",
-	"imprint",
-	"shadow",
-	"outline"
-];
 const SECTION_ORIENTATIONS = ["portrait", "landscape"];
 const SECTION_START_TYPES = [
 	"continuous",
@@ -160,6 +145,7 @@ const readParagraphAttrs = (node) => {
 	optionalBoolean(attrs, "kinsoku", "paragraph.attrs.kinsoku", issues);
 	optionalBoolean(attrs, "overflowPunctuation", "paragraph.attrs.overflowPunctuation", issues);
 	optionalBoolean(attrs, "suppressAutoHyphens", "paragraph.attrs.suppressAutoHyphens", issues);
+	optionalBoolean(attrs, "suppressLineNumbers", "paragraph.attrs.suppressLineNumbers", issues);
 	optionalNumber(attrs, "spaceBefore", "paragraph.attrs.spaceBefore", issues);
 	optionalNumber(attrs, "spaceAfter", "paragraph.attrs.spaceAfter", issues);
 	optionalNumber(attrs, "lineSpacing", "paragraph.attrs.lineSpacing", issues);
@@ -192,9 +178,11 @@ const readParagraphAttrs = (node) => {
 	optionalBoolean(attrs, "pageBreakBefore", "paragraph.attrs.pageBreakBefore", issues);
 	optionalBoolean(attrs, "renderedPageBreakBefore", "paragraph.attrs.renderedPageBreakBefore", issues);
 	optionalBoolean(attrs, "_trailingPageBreak", "paragraph.attrs._trailingPageBreak", issues);
+	optionalBoolean(attrs, "_pageBreakCarrier", "paragraph.attrs._pageBreakCarrier", issues);
 	optionalBoolean(attrs, "runInWithNext", "paragraph.attrs.runInWithNext", issues);
 	optionalBoolean(attrs, "keepNext", "paragraph.attrs.keepNext", issues);
 	optionalBoolean(attrs, "keepLines", "paragraph.attrs.keepLines", issues);
+	optionalBoolean(attrs, "widowControl", "paragraph.attrs.widowControl", issues);
 	optionalBoolean(attrs, "contextualSpacing", "paragraph.attrs.contextualSpacing", issues);
 	const direction = attrs["direction"];
 	if (direction !== void 0 && direction !== null && !isParagraphDirection(direction)) issues.push({
@@ -223,7 +211,7 @@ const readParagraphAttrs = (node) => {
 	validateNumPr(attrs["numPr"], issues);
 	optionalBookmarkArray(attrs["bookmarks"], issues);
 	optionalEmptyHyperlinkArray(attrs["_emptyHyperlinks"], issues);
-	optionalAutospacingBase(attrs, issues);
+	optionalAutospacingBase(attrs, "paragraph.attrs._autospacingBase", issues);
 	optionalSectionProperties(attrs, "_sectionProperties", "paragraph.attrs._sectionProperties", issues);
 	optionalPropertyChanges(attrs, "_propertyChanges", "paragraph.attrs._propertyChanges", issues, ["paragraphPropertyChange"]);
 	return attrsResult(attrs, issues);
@@ -288,6 +276,7 @@ const readTableAttrs = (node) => {
 		"insideH",
 		"insideV"
 	]);
+	optionalBoolean(attrs, "_resolvedBidi", "table.attrs._resolvedBidi", issues);
 	optionalRecord(attrs, "_originalFormatting", "table.attrs._originalFormatting", issues);
 	return attrsResult(attrs, issues);
 };
@@ -663,6 +652,10 @@ const readRunFormattingOverrideMarkAttrs = (mark) => {
 	const issues = [];
 	expectMarkType(mark, "runFormattingOverride", issues);
 	for (const key of RUN_FORMATTING_OVERRIDE_FALSE_KEYS) optionalFalse(attrs, key, `runFormattingOverride.attrs.${key}`, issues);
+	optionalBoolean(attrs, "boldCs", "runFormattingOverride.attrs.boldCs", issues);
+	optionalBoolean(attrs, "italicCs", "runFormattingOverride.attrs.italicCs", issues);
+	optionalNumber(attrs, "fontSizeCs", "runFormattingOverride.attrs.fontSizeCs", issues);
+	optionalBoolean(attrs, "cs", "runFormattingOverride.attrs.cs", issues);
 	optionalOneOf(attrs, "underline", "runFormattingOverride.attrs.underline", issues, ["none"]);
 	return attrsResult(attrs, issues);
 };
@@ -1089,18 +1082,18 @@ const validateSdtAttrsRecord = (attrs, path, issues) => {
 	optionalString(attrs, "rawPropertiesXml", `${path}.rawPropertiesXml`, issues);
 	optionalString(attrs, "rawEndPropertiesXml", `${path}.rawEndPropertiesXml`, issues);
 };
-const optionalAutospacingBase = (attrs, issues) => {
+const optionalAutospacingBase = (attrs, path, issues) => {
 	const value = attrs["_autospacingBase"];
 	if (value === void 0 || value === null) return;
 	if (!isRecord(value)) {
 		issues.push({
-			path: "paragraph.attrs._autospacingBase",
+			path,
 			message: "Expected an object."
 		});
 		return;
 	}
-	optionalNumber(value, "before", "paragraph.attrs._autospacingBase.before", issues);
-	optionalNumber(value, "after", "paragraph.attrs._autospacingBase.after", issues);
+	optionalNumber(value, "before", `${path}.before`, issues);
+	optionalNumber(value, "after", `${path}.after`, issues);
 };
 const optionalArray = (attrs, key, path, issues) => {
 	const value = attrs[key];
@@ -1201,11 +1194,42 @@ const optionalTextFormatting = (attrs, key, path, issues) => {
 		});
 		return;
 	}
-	for (const booleanKey of TEXT_FORMATTING_BOOLEAN_KEYS) optionalBoolean(value, booleanKey, `${path}.${booleanKey}`, issues);
+	validateTextFormatting(value, path, issues);
+};
+const validateTextFormatting = (value, path, issues) => {
+	for (const booleanKey of [
+		"bold",
+		"boldCs",
+		"italic",
+		"italicCs",
+		"strike",
+		"doubleStrike",
+		"smallCaps",
+		"allCaps",
+		"hidden",
+		"emboss",
+		"imprint",
+		"outline",
+		"shadow",
+		"rtl",
+		"cs"
+	]) optionalBoolean(value, booleanKey, `${path}.${booleanKey}`, issues);
+	optionalOneOf(value, "vertAlign", `${path}.vertAlign`, issues, [
+		"baseline",
+		"superscript",
+		"subscript"
+	]);
 	optionalNumber(value, "fontSize", `${path}.fontSize`, issues);
 	optionalNumber(value, "fontSizeCs", `${path}.fontSizeCs`, issues);
-	optionalOneOf(value, "highlight", `${path}.highlight`, issues, HIGHLIGHT_COLOR_VALUES);
+	optionalNumber(value, "spacing", `${path}.spacing`, issues);
+	optionalNumber(value, "position", `${path}.position`, issues);
+	optionalNumber(value, "scale", `${path}.scale`, issues);
+	optionalNumber(value, "kerning", `${path}.kerning`, issues);
+	optionalString(value, "styleId", `${path}.styleId`, issues);
+	optionalOneOf(value, "effect", `${path}.effect`, issues, TEXT_EFFECT_VALUES);
+	optionalOneOf(value, "emphasisMark", `${path}.emphasisMark`, issues, EMPHASIS_MARK_VALUES);
 	optionalColorValue(value, "color", `${path}.color`, 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({
@@ -1216,6 +1240,36 @@ const optionalTextFormatting = (attrs, key, path, issues) => {
 		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);
+	}
+	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);
 };
 const optionalInsetMap = (attrs, key, path, issues) => {
 	const value = attrs[key];
@@ -1285,8 +1339,192 @@ const optionalPropertyChanges = (attrs, key, path, issues, allowedTypes) => {
 		}
 		requiredOneOf(item, "type", `${itemPath}.type`, issues, allowedTypes);
 		validatePropertyChangeInfo(item["info"], `${itemPath}.info`, issues);
-		optionalRecord(item, "previousFormatting", `${itemPath}.previousFormatting`, issues);
-		optionalRecord(item, "currentFormatting", `${itemPath}.currentFormatting`, issues);
+		let validateFormatting;
+		if (allowedTypes.includes("paragraphPropertyChange")) validateFormatting = validateParagraphFormatting;
+		else if (allowedTypes.includes("runPropertyChange")) validateFormatting = validateTextFormatting;
+		if (validateFormatting) {
+			optionalNestedRecord(item, "previousFormatting", `${itemPath}.previousFormatting`, issues, validateFormatting);
+			optionalNestedRecord(item, "currentFormatting", `${itemPath}.currentFormatting`, issues, validateFormatting);
+		} else {
+			optionalRecord(item, "previousFormatting", `${itemPath}.previousFormatting`, issues);
+			optionalRecord(item, "currentFormatting", `${itemPath}.currentFormatting`, issues);
+		}
+	}
+};
+const optionalNestedRecord = (attrs, key, path, issues, validate) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	validate(value, path, issues);
+};
+const PARAGRAPH_FORMATTING_BOOLEAN_KEYS = [
+	"bidi",
+	"kinsoku",
+	"overflowPunctuation",
+	"suppressAutoHyphens",
+	"suppressLineNumbers",
+	"snapToGrid",
+	"beforeAutospacing",
+	"afterAutospacing",
+	"hangingIndent",
+	"keepNext",
+	"keepLines",
+	"widowControl",
+	"pageBreakBefore",
+	"contextualSpacing",
+	"runInWithNext"
+];
+const PARAGRAPH_FORMATTING_NUMBER_KEYS = [
+	"spaceBefore",
+	"spaceAfter",
+	"lineSpacing",
+	"indentLeft",
+	"indentRight",
+	"indentFirstLine",
+	"outlineLevel"
+];
+const validateParagraphFormatting = (value, path, issues) => {
+	optionalOneOf(value, "alignment", `${path}.alignment`, issues, PARAGRAPH_ALIGNMENT_VALUES);
+	for (const key of PARAGRAPH_FORMATTING_BOOLEAN_KEYS) optionalBoolean(value, key, `${path}.${key}`, issues);
+	for (const key of [
+		"lineSpacingExplicit",
+		"listIsBullet",
+		"listIsLegal",
+		"listMarkerHidden",
+		"listMarkerBold",
+		"listMarkerAllCaps"
+	]) optionalBoolean(value, key, `${path}.${key}`, issues);
+	for (const key of PARAGRAPH_FORMATTING_NUMBER_KEYS) optionalNumber(value, key, `${path}.${key}`, issues);
+	for (const key of [
+		"listMarkerFontSize",
+		"listImplicitChildLevelAdvances",
+		"listMarkerSecondSlotOffsetTwips",
+		"listAbstractNumId",
+		"listStartOverride"
+	]) optionalNumber(value, key, `${path}.${key}`, issues);
+	optionalOneOf(value, "lineSpacingRule", `${path}.lineSpacingRule`, issues, LINE_SPACING_RULE_VALUES);
+	optionalString(value, "styleId", `${path}.styleId`, issues);
+	optionalOneOf(value, "listNumFmt", `${path}.listNumFmt`, issues, NUMBER_FORMAT_VALUES);
+	optionalString(value, "listMarker", `${path}.listMarker`, issues);
+	optionalString(value, "listMarkerFontFamily", `${path}.listMarkerFontFamily`, issues);
+	optionalOneOf(value, "listMarkerAlignment", `${path}.listMarkerAlignment`, issues, [
+		"left",
+		"center",
+		"right"
+	]);
+	optionalOneOf(value, "listMarkerSuffix", `${path}.listMarkerSuffix`, issues, [
+		"tab",
+		"space",
+		"nothing"
+	]);
+	optionalOneOfArray(value, "listLevelNumFmts", `${path}.listLevelNumFmts`, issues, NUMBER_FORMAT_VALUES);
+	optionalNumberArray(value, "listLevelStarts", `${path}.listLevelStarts`, issues);
+	optionalAutospacingBase(value, `${path}._autospacingBase`, issues);
+	for (const key of ["numPr", "numPrFromStyle"]) {
+		const nested = value[key];
+		if (nested === void 0 || nested === null) continue;
+		if (!isRecord(nested)) {
+			issues.push({
+				path: `${path}.${key}`,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		optionalNumber(nested, "numId", `${path}.${key}.numId`, issues);
+		optionalNumber(nested, "ilvl", `${path}.${key}.ilvl`, issues);
+	}
+	const direction = value["direction"];
+	if (direction !== void 0 && direction !== null && !isParagraphDirection(direction)) issues.push({
+		path: `${path}.direction`,
+		message: "Expected a ParagraphDirection."
+	});
+	for (const key of [
+		"spacingExplicit",
+		"spacingFromDocDefaults",
+		"spacingFromImplicitDefaultStyle"
+	]) {
+		const nested = value[key];
+		if (nested === void 0 || nested === null) continue;
+		if (!isRecord(nested)) {
+			issues.push({
+				path: `${path}.${key}`,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		optionalBoolean(nested, "before", `${path}.${key}.before`, issues);
+		optionalBoolean(nested, "after", `${path}.${key}.after`, issues);
+	}
+	optionalBorderMap(value, "borders", `${path}.borders`, issues, [
+		"top",
+		"bottom",
+		"left",
+		"right",
+		"between",
+		"bar"
+	]);
+	optionalShading(value, "shading", `${path}.shading`, issues);
+	optionalTabStops(value, "tabs", `${path}.tabs`, 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);
 	}
 };
 const validatePropertyChangeInfo = (value, path, issues) => {
@@ -1373,6 +1611,21 @@ const optionalStringArray = (attrs, key, path, issues) => {
 		message: "Expected a string."
 	});
 };
+const optionalOneOfArray = (attrs, key, path, issues, allowed) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, item] of value.entries()) if (typeof item !== "string" || !allowed.includes(item)) issues.push({
+		path: `${path}[${index}]`,
+		message: `Expected one of ${allowed.join(", ")}.`
+	});
+};
 const validateNumPr = (value, issues) => {
 	if (value === void 0 || value === null || !isRecord(value)) return;
 	validateNonNegativeInteger(value["numId"], "paragraph.attrs.numPr.numId", issues);

package/dist/prosemirror/commands/comments.js

@@ -1,4 +1,4 @@
-import { expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
+import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
 import { textFormattingToMarks } from "../conversion/toProseDoc.js";
 import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
@@ -72,7 +72,7 @@ function resolveChange(from, to, mode, revisionIds) {
 					if (op) pPrMarkOps.push(op);
 					const boundaryCovered = rangeCoversParagraphBoundary(from, to, pos, node);
 					let nextAttrs = null;
-					const propertyChanges = node.attrs["_propertyChanges"];
+					const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
 					if (Array.isArray(propertyChanges) && propertyChanges.length > 0 && boundaryCovered) {
 						const matches = propertyChanges.filter((c) => revisionSet === null || c.info && revisionSet.has(c.info.id));
 						if (matches.length > 0) {
@@ -418,7 +418,7 @@ function findParagraphBoundaryChangeAtPosition(state, pos) {
 	const paragraphPos = $pos.before($pos.depth);
 	const pPrMark = node.attrs["pPrMark"];
 	if (isPPrMarkAttr(pPrMark)) return toParagraphBoundaryChange(node, paragraphPos, pPrMark.kind === "ins" ? "insertion" : "deletion", pPrMark.info);
-	const propertyChanges = node.attrs["_propertyChanges"];
+	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
 	if (!Array.isArray(propertyChanges)) return null;
 	for (const change of propertyChanges) {
 		const type = getListPropertyChangeType(node.attrs, change);

package/dist/prosemirror/commands/formatting.js

@@ -8,38 +8,38 @@ import { schema, singletonManager } from "../schema/index.js";
 function textFormattingToMarks(formatting) {
 	return textFormattingToMarks$1(formatting, schema);
 }
-const cmds = singletonManager.getCommands();
-const toggleBold = cmds["toggleBold"]();
-const toggleItalic = cmds["toggleItalic"]();
-const toggleUnderline = cmds["toggleUnderline"]();
-const toggleStrike = cmds["toggleStrike"]();
-const toggleSuperscript = cmds["toggleSuperscript"]();
-const toggleSubscript = cmds["toggleSubscript"]();
+const cmds = singletonManager;
+const toggleBold = cmds.requireCommand("toggleBold")();
+const toggleItalic = cmds.requireCommand("toggleItalic")();
+const toggleUnderline = cmds.requireCommand("toggleUnderline")();
+const toggleStrike = cmds.requireCommand("toggleStrike")();
+const toggleSuperscript = cmds.requireCommand("toggleSuperscript")();
+const toggleSubscript = cmds.requireCommand("toggleSubscript")();
 function setTextColor(attrs) {
-	return cmds["setTextColor"](attrs);
+	return cmds.requireCommand("setTextColor")(attrs);
 }
-const clearTextColor = cmds["clearTextColor"]();
+const clearTextColor = cmds.requireCommand("clearTextColor")();
 function setHighlight(color) {
-	return cmds["setHighlight"](color);
+	return cmds.requireCommand("setHighlight")(color);
 }
-const clearHighlight = cmds["clearHighlight"]();
+const clearHighlight = cmds.requireCommand("clearHighlight")();
 function setFontSize(size) {
-	return cmds["setFontSize"](size);
+	return cmds.requireCommand("setFontSize")(size);
 }
-const clearFontSize = cmds["clearFontSize"]();
+const clearFontSize = cmds.requireCommand("clearFontSize")();
 function setFontFamily(fontName) {
-	return cmds["setFontFamily"](fontName);
+	return cmds.requireCommand("setFontFamily")(fontName);
 }
-const clearFontFamily = cmds["clearFontFamily"]();
+const clearFontFamily = cmds.requireCommand("clearFontFamily")();
 function setUnderlineStyle(style, color) {
-	return cmds["setUnderlineStyle"](style, color);
+	return cmds.requireCommand("setUnderlineStyle")(style, color);
 }
 function setHyperlink(href, tooltip) {
-	return cmds["setHyperlink"](href, tooltip);
+	return cmds.requireCommand("setHyperlink")(href, tooltip);
 }
-const removeHyperlink = cmds["removeHyperlink"]();
+const removeHyperlink = cmds.requireCommand("removeHyperlink")();
 function insertHyperlink(text, href, tooltip) {
-	return cmds["insertHyperlink"](text, href, tooltip);
+	return cmds.requireCommand("insertHyperlink")(text, href, tooltip);
 }
 //#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 };

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

@@ -1,12 +1,12 @@
+import { ResolvedStyleAttrs, getParagraphAlignment, getParagraphBidi, getStyleId } from "../extensions/core/ParagraphExtension.js";
+import { BorderPreset, TableBorderPreset, TableContextInfo, getTableContext, isInTable as isInTableCell } from "../extensions/nodes/TableExtension.js";
 import { AcceptSuggestionOptions, FolioSuggestion, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findNextChange, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark } from "./comments.js";
 import { PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks } from "./formatPainter.js";
 import { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive } from "../extensions/marks/markUtils.js";
 import { getHyperlinkAttrs, getSelectedText, isHyperlinkActive } from "../extensions/marks/HyperlinkExtension.js";
 import { clearFontFamily, clearFontSize, clearHighlight, clearTextColor, insertHyperlink, removeHyperlink, setFontFamily, setFontSize, setHighlight, setHyperlink, setTextColor, setUnderlineStyle, toggleBold, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline } from "./formatting.js";
-import { ResolvedStyleAttrs, getParagraphAlignment, getParagraphBidi, getStyleId } from "../extensions/core/ParagraphExtension.js";
 import { getListInfo, isInList } from "../extensions/features/ListExtension.js";
 import { addTabStop, alignCenter, alignJustify, alignLeft, alignRight, applyStyle, clearStyle, decreaseIndent, decreaseListLevel, doubleSpacing, generateTOC, increaseIndent, increaseListLevel, oneAndHalfSpacing, removeList, removeTabStop, setAlignment, setIndentFirstLine, setIndentLeft, setIndentRight, setLineSpacing, setLtr, setRtl, setSpaceAfter, setSpaceBefore, singleSpacing, toggleBidi, toggleBulletList, toggleNumberedList } from "./paragraph.js";
-import { BorderPreset, TableBorderPreset, TableContextInfo, getTableContext, isInTable as isInTableCell } from "../extensions/nodes/TableExtension.js";
 import { addColumnLeft, addColumnRight, addRowAbove, addRowBelow, applyTableStyle, autoFitContents, deleteColumn, deleteRow, deleteTable, distributeColumns, insertTable, mergeCells, removeTableBorders, selectColumn, selectRow, selectTable, setAllTableBorders, setCellBorder, setCellFillColor, setCellMargins, setCellTextDirection, setCellVerticalAlign, setInsideTableBorders, setOutsideTableBorders, setRowHeight, setTableBorderColor, setTableBorderPreset, setTableBorderWidth, setTableBorders, setTableProperties, splitCell, toggleHeaderRow, toggleNoWrap } from "./table.js";
 import { insertPageBreak } from "./pageBreak.js";
 import { CLIPBOARD_READ_ERROR_EVENT, buildPlainTextSlice, pasteWithoutFormatting } from "./pastePlainText.js";