@stll/folio-core 0.47.7 → 0.48.0

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -228,6 +228,7 @@ const paragraphNodeSpec = {
 		listMarkerSecondSlotOffsetTwips: { default: null },
 		listLevelNumFmts: { default: null },
 		listLevelStarts: { default: null },
+		listLevelTabs: { default: null },
 		listAbstractNumId: { default: null },
 		listStartOverride: { default: null },
 		styleId: { default: null },

package/dist/prosemirror/extensions/marks/markUtils.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../../../types/document.js";
 import { Command, EditorState } from "prosemirror-state";
-import { Mark, MarkType, Schema } from "prosemirror-model";
+import { Attrs, Mark, MarkType, Schema } from "prosemirror-model";
 //#region src/prosemirror/extensions/marks/markUtils.d.ts
 type MarkAttrs = Record<string, unknown>;
 declare function marksToTextFormatting(marks: readonly Mark[]): document_d_exports.TextFormatting;
@@ -23,6 +23,8 @@ declare function isMarkActive(state: EditorState, markType: MarkType, attrs?: Re
  */
 declare function getMarkAttr(state: EditorState, markType: MarkType, attr: string): unknown;
 type AuthoredRunFormattingCarrier = "preserve" | "reconstruct";
+/** Builds a mark by type name; a conversion passes one that shares equal marks. */
+type MarkFactory = (type: string, attrs?: Attrs | null) => Mark;
 /**
  * Convert TextFormatting to ProseMirror marks
  */
@@ -32,6 +34,8 @@ type TextFormattingToMarksOptions = {
   directFormatting?: document_d_exports.TextFormatting | undefined;
   /** Whether direct authorship is reconstructible from structural marks and the style context. */
   authoredCarrier?: AuthoredRunFormattingCarrier;
+  /** Builds each mark; defaults to `schema.mark`. */
+  createMark?: MarkFactory;
 };
 declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting | undefined, schema: Schema, options?: TextFormattingToMarksOptions): Mark[];
 /**
@@ -47,4 +51,4 @@ declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string,
  */
 declare function createRemoveMarkCommand(markType: MarkType): Command;
 //#endregion
-export { AuthoredRunFormattingCarrier, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };
+export { AuthoredRunFormattingCarrier, MarkFactory, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };

package/dist/prosemirror/extensions/marks/markUtils.js

@@ -375,23 +375,16 @@ function getMarkAttr(state, markType, attr) {
 	});
 	return value;
 }
-const addDirectFontProvenance = (marks, schema, directFormatting) => {
+const withDirectFontProvenance = (attrs, directFormatting) => {
 	const directFontProperties = [];
 	if (directFormatting?.fontFamily !== void 0) directFontProperties.push("fontFamily");
 	if (directFormatting?.fontSize !== void 0) directFontProperties.push("fontSize");
 	if (directFormatting?.color !== void 0) directFontProperties.push("color");
-	if (directFontProperties.length === 0) return;
-	const index = marks.findIndex(({ type }) => type.name === "runFormattingOverride");
-	const existing = index >= 0 ? marks.at(index) : void 0;
-	const override = schema.mark("runFormattingOverride", {
-		...existing?.attrs,
+	if (directFontProperties.length === 0) return attrs;
+	return {
+		...attrs,
 		directFontProperties
-	});
-	if (index >= 0) {
-		marks[index] = override;
-		return;
-	}
-	marks.push(override);
+	};
 };
 const COMPLEX_SCRIPT_MIRRORS = [
 	{
@@ -407,25 +400,19 @@ const COMPLEX_SCRIPT_MIRRORS = [
 		complex: "fontSizeCs"
 	}
 ];
-const addComplexScriptAbsenceProvenance = (marks, schema, directFormatting) => {
+const withComplexScriptAbsenceProvenance = (attrs, directFormatting) => {
 	const absent = COMPLEX_SCRIPT_MIRRORS.filter(({ ordinary, complex }) => directFormatting?.[ordinary] !== void 0 && directFormatting[complex] === void 0).map(({ complex }) => complex);
-	if (absent.length === 0) return;
-	const index = marks.findIndex(({ type }) => type.name === "runFormattingOverride");
-	const existing = index >= 0 ? marks.at(index) : void 0;
-	const existingAbsences = new Set(existing?.attrs["complexScriptPropertyAbsences"] ?? []);
+	if (absent.length === 0) return attrs;
+	const existingAbsences = new Set(attrs?.complexScriptPropertyAbsences ?? []);
 	for (const property of absent) existingAbsences.add(property);
-	const override = schema.mark("runFormattingOverride", {
-		...existing?.attrs,
+	return {
+		...attrs,
 		complexScriptPropertyAbsences: COMPLEX_SCRIPT_RUN_PROPERTY_KEYS.filter((property) => existingAbsences.has(property))
-	});
-	if (index >= 0) {
-		marks[index] = override;
-		return;
-	}
-	marks.push(override);
+	};
 };
 function textFormattingToMarks(formatting, schema, options) {
 	if (!formatting) return [];
+	const createMark = options?.createMark ?? ((type, attrs) => schema.mark(type, attrs));
 	const marks = [];
 	const overrideFormatting = options ? options.overrideFormatting : formatting;
 	let overrideAttrs;
@@ -435,25 +422,24 @@ function textFormattingToMarks(formatting, schema, options) {
 		formatting: options.directFormatting
 	});
 	else overrideAttrs = buildRunFormattingOverrideAttrs(overrideFormatting);
-	if (overrideAttrs) marks.push(schema.mark("runFormattingOverride", overrideAttrs));
-	if (formatting.bold) marks.push(schema.mark("bold"));
-	if (formatting.italic) marks.push(schema.mark("italic"));
-	if (formatting.underline && formatting.underline.style !== "none") marks.push(schema.mark("underline", {
+	if (formatting.bold) marks.push(createMark("bold"));
+	if (formatting.italic) marks.push(createMark("italic"));
+	if (formatting.underline && formatting.underline.style !== "none") marks.push(createMark("underline", {
 		style: formatting.underline.style,
 		color: formatting.underline.color
 	}));
-	if (formatting.strike || formatting.doubleStrike) marks.push(schema.mark("strike", { double: formatting.doubleStrike || false }));
-	if (formatting.color && !formatting.color.auto) marks.push(schema.mark("textColor", {
+	if (formatting.strike || formatting.doubleStrike) marks.push(createMark("strike", { double: formatting.doubleStrike || false }));
+	if (formatting.color && !formatting.color.auto) marks.push(createMark("textColor", {
 		rgb: formatting.color.rgb,
 		themeColor: formatting.color.themeColor,
 		themeTint: formatting.color.themeTint,
 		themeShade: formatting.color.themeShade
 	}));
-	if (formatting.highlight && formatting.highlight !== "none") marks.push(schema.mark("highlight", { color: formatting.highlight }));
+	if (formatting.highlight && formatting.highlight !== "none") marks.push(createMark("highlight", { color: formatting.highlight }));
 	const runShadingMarkAttrs = shadingToRunShadingAttrs(formatting.shading);
-	if (runShadingMarkAttrs) marks.push(schema.mark("runShading", runShadingMarkAttrs));
-	if (formatting.fontSize) marks.push(schema.mark("fontSize", { size: formatting.fontSize }));
-	if (formatting.fontFamily) marks.push(schema.mark("fontFamily", {
+	if (runShadingMarkAttrs) marks.push(createMark("runShading", runShadingMarkAttrs));
+	if (formatting.fontSize) marks.push(createMark("fontSize", { size: formatting.fontSize }));
+	if (formatting.fontFamily) marks.push(createMark("fontFamily", {
 		ascii: formatting.fontFamily.ascii,
 		hAnsi: formatting.fontFamily.hAnsi,
 		eastAsia: formatting.fontFamily.eastAsia,
@@ -464,31 +450,33 @@ function textFormattingToMarks(formatting, schema, options) {
 		eastAsiaTheme: formatting.fontFamily.eastAsiaTheme,
 		csTheme: formatting.fontFamily.csTheme
 	}));
-	if (formatting.language) marks.push(schema.mark("language", formatting.language));
-	if (formatting.vertAlign === "superscript") marks.push(schema.mark("superscript"));
-	else if (formatting.vertAlign === "subscript") marks.push(schema.mark("subscript"));
-	if (formatting.allCaps) marks.push(schema.mark("allCaps"));
-	if (formatting.smallCaps) marks.push(schema.mark("smallCaps"));
+	if (formatting.language) marks.push(createMark("language", formatting.language));
+	if (formatting.vertAlign === "superscript") marks.push(createMark("superscript"));
+	else if (formatting.vertAlign === "subscript") marks.push(createMark("subscript"));
+	if (formatting.allCaps) marks.push(createMark("allCaps"));
+	if (formatting.smallCaps) marks.push(createMark("smallCaps"));
 	const spacing = typeof formatting.spacing === "number" ? formatting.spacing : null;
 	const position = typeof formatting.position === "number" ? formatting.position : null;
 	const scale = normalizeHorizontalScalePercent(formatting.scale) ?? null;
 	const kerning = typeof formatting.kerning === "number" ? formatting.kerning : null;
-	if (spacing !== null || position !== null || scale !== null || kerning !== null) marks.push(schema.mark("characterSpacing", {
+	if (spacing !== null || position !== null || scale !== null || kerning !== null) marks.push(createMark("characterSpacing", {
 		spacing,
 		position,
 		scale,
 		kerning
 	}));
-	if (formatting.hidden === true) marks.push(schema.mark("hidden"));
-	if (formatting.emboss) marks.push(schema.mark("emboss"));
-	if (formatting.imprint) marks.push(schema.mark("imprint"));
-	if (formatting.shadow) marks.push(schema.mark("textShadow"));
-	if (formatting.emphasisMark && formatting.emphasisMark !== "none") marks.push(schema.mark("emphasisMark", { type: formatting.emphasisMark }));
-	if (formatting.outline) marks.push(schema.mark("textOutline"));
-	if (formatting.rtl) marks.push(schema.mark("rtl"));
-	if (formatting.effect && formatting.effect !== "none") marks.push(schema.mark("textEffect", { effect: formatting.effect }));
-	addDirectFontProvenance(marks, schema, options?.directFormatting);
-	if (options?.authoredCarrier === "preserve") addComplexScriptAbsenceProvenance(marks, schema, options.directFormatting);
+	if (formatting.hidden === true) marks.push(createMark("hidden"));
+	if (formatting.emboss) marks.push(createMark("emboss"));
+	if (formatting.imprint) marks.push(createMark("imprint"));
+	if (formatting.shadow) marks.push(createMark("textShadow"));
+	if (formatting.emphasisMark && formatting.emphasisMark !== "none") marks.push(createMark("emphasisMark", { type: formatting.emphasisMark }));
+	if (formatting.outline) marks.push(createMark("textOutline"));
+	if (formatting.rtl) marks.push(createMark("rtl"));
+	if (formatting.effect && formatting.effect !== "none") marks.push(createMark("textEffect", { effect: formatting.effect }));
+	let provenanceAttrs = withDirectFontProvenance(overrideAttrs, options?.directFormatting);
+	if (options?.authoredCarrier === "preserve") provenanceAttrs = withComplexScriptAbsenceProvenance(provenanceAttrs, options.directFormatting);
+	if (overrideAttrs) marks.unshift(createMark("runFormattingOverride", provenanceAttrs));
+	else if (provenanceAttrs) marks.push(createMark("runFormattingOverride", provenanceAttrs));
 	return marks;
 }
 /**

package/dist/prosemirror/extensions/nodes/TextBoxExtension.js

@@ -117,7 +117,8 @@ const TextBoxExtension = createNodeExtension({
 			_docxTextBodyContentState: { default: { type: "authored" } },
 			_docxTrackedChange: { default: null },
 			_docxInlineSdts: { default: null },
-			_preservedAttributes: { default: null }
+			_preservedAttributes: { default: null },
+			_docxHostParagraph: { default: null }
 		},
 		parseDOM: [{
 			tag: "div.docx-textbox",

package/dist/prosemirror/listMarker.d.ts

@@ -58,6 +58,7 @@ declare const CLEARED_LIST_RENDERING_ATTRS: Readonly<{
   listMarkerSecondSlotOffsetTwips: null;
   listLevelNumFmts: null;
   listLevelStarts: null;
+  listLevelTabs: null;
   listAbstractNumId: null;
   listStartOverride: null;
 }>;

package/dist/prosemirror/listMarker.js

@@ -20,6 +20,7 @@ const CLEARED_LIST_RENDERING_ATTRS = Object.freeze({
 	listMarkerSecondSlotOffsetTwips: null,
 	listLevelNumFmts: null,
 	listLevelStarts: null,
+	listLevelTabs: null,
 	listAbstractNumId: null,
 	listStartOverride: null
 });
@@ -84,6 +85,7 @@ function previousListAttrs(attrs) {
 		...previous.listMarkerSecondSlotOffsetTwips !== void 0 ? { listMarkerSecondSlotOffsetTwips: previous.listMarkerSecondSlotOffsetTwips } : {},
 		...previous.listLevelNumFmts !== void 0 ? { listLevelNumFmts: previous.listLevelNumFmts } : {},
 		...previous.listLevelStarts !== void 0 ? { listLevelStarts: previous.listLevelStarts } : {},
+		...previous.listLevelTabs !== void 0 ? { listLevelTabs: previous.listLevelTabs } : {},
 		...previous.listAbstractNumId !== void 0 ? { listAbstractNumId: previous.listAbstractNumId } : {},
 		...previous.listStartOverride !== void 0 ? { listStartOverride: previous.listStartOverride } : {}
 	};

package/dist/prosemirror/listRenderingAttrs.d.ts

@@ -14,6 +14,7 @@ declare const LIST_RENDERING_ATTR_BY_FIELD: {
   readonly markerAlignment: "listMarkerAlignment";
   readonly markerAllCaps: "listMarkerAllCaps";
   readonly markerSuffix: "listMarkerSuffix";
+  readonly levelTabs: "listLevelTabs";
   readonly levelNumFmts: "listLevelNumFmts";
   readonly levelStarts: "listLevelStarts";
   readonly abstractNumId: "listAbstractNumId";

package/dist/prosemirror/listRenderingAttrs.js

@@ -20,6 +20,7 @@ const LIST_RENDERING_ATTR_BY_FIELD = {
 	markerAlignment: "listMarkerAlignment",
 	markerAllCaps: "listMarkerAllCaps",
 	markerSuffix: "listMarkerSuffix",
+	levelTabs: "listLevelTabs",
 	levelNumFmts: "listLevelNumFmts",
 	levelStarts: "listLevelStarts",
 	abstractNumId: "listAbstractNumId",
@@ -48,6 +49,7 @@ const listRenderingAttrPatch = (rendering) => {
 		listMarkerAlignment: rendering.markerAlignment || void 0,
 		listMarkerAllCaps: rendering.markerAllCaps || void 0,
 		listMarkerSuffix: rendering.markerSuffix || void 0,
+		listLevelTabs: rendering.levelTabs?.length ? rendering.levelTabs : void 0,
 		listLevelNumFmts: rendering.levelNumFmts || void 0,
 		listLevelStarts: rendering.levelStarts || void 0,
 		listAbstractNumId: rendering.abstractNumId,
@@ -71,6 +73,7 @@ const listRenderingFromAttrs = ({ attrs, numId }) => {
 		markerAlignment: attrs.listMarkerAlignment ?? void 0,
 		markerAllCaps: attrs.listMarkerAllCaps ?? void 0,
 		markerSuffix: attrs.listMarkerSuffix ?? void 0,
+		levelTabs: attrs.listLevelTabs ?? void 0,
 		levelNumFmts: attrs.listLevelNumFmts ?? void 0,
 		levelStarts: attrs.listLevelStarts ?? void 0,
 		abstractNumId: attrs.listAbstractNumId ?? void 0,

package/dist/prosemirror/schema/nodes.d.ts

@@ -167,6 +167,8 @@ type ParagraphAttrs = {
   listLevelNumFmts?: document_d_exports.CounterFormat[];
   /** Initial counter for each level used by multi-level marker templates. */
   listLevelStarts?: number[];
+  /** Custom tab stops of the numbering level (`w:lvl/w:pPr/w:tabs`). */
+  listLevelTabs?: document_d_exports.TabStop[];
   /** Abstract numbering ID shared by numbering instances. */
   listAbstractNumId?: number;
   /** Numbering start override for this numId/level. */
@@ -325,7 +327,7 @@ type ParagraphPropertyChangeAttrs = Omit<document_d_exports.ParagraphPropertyCha
   };
   previousFormatting?: Omit<document_d_exports.ParagraphFormatting, "numPr"> & {
     numPr?: ParagraphAttrs["numPr"] | null;
-  } & Partial<Pick<ParagraphAttrs, "listIsBullet" | "listIsLegal" | "listNumFmt" | "listMarker" | "listMarkerTemplate" | "listMarkerHidden" | "listMarkerFormatting" | "listMarkerAlignment" | "listMarkerSuffix" | "listMarkerAllCaps" | "listImplicitChildLevelAdvances" | "listMarkerSecondSlotOffsetTwips" | "listLevelNumFmts" | "listLevelStarts" | "listAbstractNumId" | "listStartOverride" | "lineSpacingExplicit" | "direction" | "_autospacingBase">>;
+  } & Partial<Pick<ParagraphAttrs, "listIsBullet" | "listIsLegal" | "listNumFmt" | "listMarker" | "listMarkerTemplate" | "listMarkerHidden" | "listMarkerFormatting" | "listMarkerAlignment" | "listMarkerSuffix" | "listMarkerAllCaps" | "listImplicitChildLevelAdvances" | "listMarkerSecondSlotOffsetTwips" | "listLevelNumFmts" | "listLevelStarts" | "listLevelTabs" | "listAbstractNumId" | "listStartOverride" | "lineSpacingExplicit" | "direction" | "_autospacingBase">>;
   currentFormatting?: document_d_exports.ParagraphFormatting;
 };
 /**
@@ -878,6 +880,16 @@ type TextBoxAttrs = {
    * itself and keeps its own.
    */
   _preservedAttributes?: document_d_exports.PreservedAttribute[];
+  /**
+   * The paragraph properties of the `w:p` this node was lifted out of.
+   *
+   * An inline drawing is run content of its paragraph, so that paragraph's
+   * spacing, indentation and alignment still place the box and must be
+   * written back around it. Only a `"standalone"` placement has a host to
+   * speak for. The host's identity (`paraId`, source token, attribute
+   * remainder) is not carried here: a copied node must not duplicate it.
+   */
+  _docxHostParagraph?: Omit<ParagraphAttrs, "paraId" | "textId" | "_preservedAttributes">;
 };
 /** Internal inline position marker for an extracted text box block. */
 type TextBoxAnchorAttrs = {

package/dist/prosemirror/textBoxHostParagraph.d.ts

@@ -0,0 +1,13 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/textBoxHostParagraph.d.ts
+/**
+ * The `w:p` a standalone text box was lifted out of, as a childless paragraph
+ * node over the host's paragraph attributes, or `undefined` when the box
+ * carries none.
+ *
+ * Building the node runs the carried attributes through the paragraph schema,
+ * so every consumer reads them with the validation any paragraph's get.
+ */
+declare const textBoxHostParagraph: (textBox: Node) => Node | undefined;
+//#endregion
+export { textBoxHostParagraph };

package/dist/prosemirror/textBoxHostParagraph.js

@@ -0,0 +1,21 @@
+import { expectTextBoxAttrs } from "./attrs/index.js";
+//#region src/prosemirror/textBoxHostParagraph.ts
+const hostParagraphs = /* @__PURE__ */ new WeakMap();
+/**
+* The `w:p` a standalone text box was lifted out of, as a childless paragraph
+* node over the host's paragraph attributes, or `undefined` when the box
+* carries none.
+*
+* Building the node runs the carried attributes through the paragraph schema,
+* so every consumer reads them with the validation any paragraph's get.
+*/
+const textBoxHostParagraph = (textBox) => {
+	const cached = hostParagraphs.get(textBox);
+	if (cached !== void 0) return cached ?? void 0;
+	const host = expectTextBoxAttrs(textBox)._docxHostParagraph;
+	const paragraph = host ? textBox.type.schema.nodes["paragraph"]?.create(host) : void 0;
+	hostParagraphs.set(textBox, paragraph ?? null);
+	return paragraph;
+};
+//#endregion
+export { textBoxHostParagraph };

package/dist/prosemirror/validation.js

@@ -303,88 +303,99 @@ const validateNodeAttrs = (node, path, issues) => {
 		});
 	}
 };
+/**
+* Marks already validated with no issues. A mark's attrs never change, and a
+* conversion shares one instance per distinct mark across thousands of runs,
+* so each distinct mark is validated once.
+*/
+const validMarks = /* @__PURE__ */ new WeakSet();
 const validateMarks = (marks, path, issues) => {
 	for (const [index, mark] of marks.entries()) {
-		const markPath = `${path}.marks[${index}]`;
-		switch (mark.type.name) {
-			case "bold":
-			case "italic":
-			case "subscript":
-			case "superscript":
-			case "allCaps":
-			case "smallCaps":
-			case "emboss":
-			case "imprint":
-			case "hidden":
-			case "textShadow":
-			case "textOutline":
-			case "rtl": continue;
-			case "textEffect":
-				appendAttrIssues(markPath, readTextEffectMarkAttrs(mark), issues);
-				continue;
-			case "underline":
-				appendAttrIssues(markPath, readUnderlineMarkAttrs(mark), issues);
-				continue;
-			case "strike":
-				appendAttrIssues(markPath, readStrikeMarkAttrs(mark), issues);
-				continue;
-			case "textColor":
-				appendAttrIssues(markPath, readTextColorMarkAttrs(mark), issues);
-				continue;
-			case "highlight":
-				appendAttrIssues(markPath, readHighlightMarkAttrs(mark), issues);
-				continue;
-			case "runShading":
-				appendAttrIssues(markPath, readRunShadingMarkAttrs(mark), issues);
-				continue;
-			case "fontSize":
-				appendAttrIssues(markPath, readFontSizeMarkAttrs(mark), issues);
-				continue;
-			case "fontFamily":
-				appendAttrIssues(markPath, readFontFamilyMarkAttrs(mark), issues);
-				continue;
-			case "language":
-				appendAttrIssues(markPath, readLanguageMarkAttrs(mark), issues);
-				continue;
-			case "characterSpacing":
-				appendAttrIssues(markPath, readCharacterSpacingMarkAttrs(mark), issues);
-				continue;
-			case "characterStyle":
-				appendAttrIssues(markPath, readCharacterStyleMarkAttrs(mark), issues);
-				continue;
-			case "emphasisMark":
-				appendAttrIssues(markPath, readEmphasisMarkAttrs(mark), issues);
-				continue;
-			case "footnoteRef":
-				appendAttrIssues(markPath, readFootnoteRefMarkAttrs(mark), issues);
-				continue;
-			case "comment":
-				appendAttrIssues(markPath, readCommentMarkAttrs(mark), issues);
-				continue;
-			case "insertion":
-			case "deletion":
-				appendAttrIssues(markPath, readTrackedChangeMarkAttrs(mark), issues);
-				continue;
-			case "runPropertyChange":
-				appendAttrIssues(markPath, readRunPropertyChangeMarkAttrs(mark), issues);
-				continue;
-			case "runIdentity":
-				appendAttrIssues(markPath, readRunIdentityMarkAttrs(mark), issues);
-				continue;
-			case "runFormattingOverride":
-				appendAttrIssues(markPath, readRunFormattingOverrideMarkAttrs(mark), issues);
-				continue;
-			case "hyperlink":
-				appendAttrIssues(markPath, readHyperlinkMarkAttrs(mark), issues);
-				continue;
-			case "inlineWrapper":
-				appendAttrIssues(markPath, readInlineWrapperMarkAttrs(mark), issues);
-				continue;
-			default: issues.push({
-				path: `${markPath}.type.name`,
-				message: `Unsupported ProseMirror mark type ${mark.type.name}.`
-			});
-		}
+		if (validMarks.has(mark)) continue;
+		const issueCount = issues.length;
+		validateMark(mark, `${path}.marks[${index}]`, issues);
+		if (issues.length === issueCount) validMarks.add(mark);
+	}
+};
+const validateMark = (mark, markPath, issues) => {
+	switch (mark.type.name) {
+		case "bold":
+		case "italic":
+		case "subscript":
+		case "superscript":
+		case "allCaps":
+		case "smallCaps":
+		case "emboss":
+		case "imprint":
+		case "hidden":
+		case "textShadow":
+		case "textOutline":
+		case "rtl": return;
+		case "textEffect":
+			appendAttrIssues(markPath, readTextEffectMarkAttrs(mark), issues);
+			return;
+		case "underline":
+			appendAttrIssues(markPath, readUnderlineMarkAttrs(mark), issues);
+			return;
+		case "strike":
+			appendAttrIssues(markPath, readStrikeMarkAttrs(mark), issues);
+			return;
+		case "textColor":
+			appendAttrIssues(markPath, readTextColorMarkAttrs(mark), issues);
+			return;
+		case "highlight":
+			appendAttrIssues(markPath, readHighlightMarkAttrs(mark), issues);
+			return;
+		case "runShading":
+			appendAttrIssues(markPath, readRunShadingMarkAttrs(mark), issues);
+			return;
+		case "fontSize":
+			appendAttrIssues(markPath, readFontSizeMarkAttrs(mark), issues);
+			return;
+		case "fontFamily":
+			appendAttrIssues(markPath, readFontFamilyMarkAttrs(mark), issues);
+			return;
+		case "language":
+			appendAttrIssues(markPath, readLanguageMarkAttrs(mark), issues);
+			return;
+		case "characterSpacing":
+			appendAttrIssues(markPath, readCharacterSpacingMarkAttrs(mark), issues);
+			return;
+		case "characterStyle":
+			appendAttrIssues(markPath, readCharacterStyleMarkAttrs(mark), issues);
+			return;
+		case "emphasisMark":
+			appendAttrIssues(markPath, readEmphasisMarkAttrs(mark), issues);
+			return;
+		case "footnoteRef":
+			appendAttrIssues(markPath, readFootnoteRefMarkAttrs(mark), issues);
+			return;
+		case "comment":
+			appendAttrIssues(markPath, readCommentMarkAttrs(mark), issues);
+			return;
+		case "insertion":
+		case "deletion":
+			appendAttrIssues(markPath, readTrackedChangeMarkAttrs(mark), issues);
+			return;
+		case "runPropertyChange":
+			appendAttrIssues(markPath, readRunPropertyChangeMarkAttrs(mark), issues);
+			return;
+		case "runIdentity":
+			appendAttrIssues(markPath, readRunIdentityMarkAttrs(mark), issues);
+			return;
+		case "runFormattingOverride":
+			appendAttrIssues(markPath, readRunFormattingOverrideMarkAttrs(mark), issues);
+			return;
+		case "hyperlink":
+			appendAttrIssues(markPath, readHyperlinkMarkAttrs(mark), issues);
+			return;
+		case "inlineWrapper":
+			appendAttrIssues(markPath, readInlineWrapperMarkAttrs(mark), issues);
+			return;
+		default: issues.push({
+			path: `${markPath}.type.name`,
+			message: `Unsupported ProseMirror mark type ${mark.type.name}.`
+		});
 	}
 };
 const appendAttrIssues = (path, result, issues) => {

package/dist/utils/createDocument.js

@@ -2,6 +2,7 @@ import { BUILT_IN_STYLE_NAME, builtInHeadingStyleName } from "../docx/builtInSty
 import "../docx/defaultParagraphStyle.js";
 import { createParseWarningCollector } from "../docx/parseContext.js";
 import { formatParseWarnings } from "../docx/parseWarningMessage.js";
+import "../docx/settingsParser.js";
 import { STYLE_SET_PART, normalizeDocumentStyleSet } from "../style-sets/styleSetNormalization.js";
 import "../style-sets/types.js";
 import { panic } from "better-result";
@@ -13,6 +14,12 @@ import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 * Provides functions to create new documents programmatically.
 */
 /**
+* `compatibilityMode` a new document declares, so it is laid out, and read
+* back, with the current rules rather than the oldest ones a package without
+* the setting gets.
+*/
+const NEW_DOCUMENT_COMPATIBILITY_MODE = 15;
+/**
 * Get default paragraph styles (matching Google Docs defaults)
 *
 * Font sizes are in half-points (e.g., 22 = 11pt, 40 = 20pt)
@@ -398,7 +405,9 @@ function createEmptyDocument(options = {}) {
 	if (styleSet?.numbering) docxPackage.numbering = structuredClone(styleSet.numbering);
 	if (styleSet?.theme) docxPackage.theme = structuredClone(styleSet.theme);
 	if (styleSet?.fontTable) docxPackage.fontTable = structuredClone(styleSet.fontTable);
-	if (styleSet?.settings) docxPackage.settings = structuredClone(styleSet.settings);
+	const settings = styleSet?.settings ? structuredClone(styleSet.settings) : { defaultTabStop: 720 };
+	settings.compatibilityMode ??= NEW_DOCUMENT_COMPATIBILITY_MODE;
+	docxPackage.settings = settings;
 	const parseWarnings = styleSetWarnings();
 	const document = {
 		package: docxPackage,

package/dist/utils/scriptSegments.d.ts

@@ -50,8 +50,31 @@ declare function hasCjk(text: string): boolean;
  * overlap the presentation forms below.
  */
 declare function isComplexScriptCodePoint(cp: number): boolean;
-/** Which font slot a single code point selects. CJK wins where ranges meet. */
-declare function scriptClassOf(cp: number): ScriptClass;
+/**
+ * True when `w:rFonts/@w:hint="eastAsia"` moves a code point from the
+ * `w:hAnsi` slot to the `w:eastAsia` slot (ECMA-376 §17.3.2.26): the ranges
+ * the font-slot table resolves to the East Asian font whenever the hint is
+ * `eastAsia`. Basic Latin never moves, and neither do the accented letters of
+ * Latin-1 Supplement and the Latin Extended blocks, whose move the table also
+ * conditions on the run's East Asian language.
+ */
+declare function isEastAsiaHintCodePoint(cp: number): boolean;
+/**
+ * Whether a run's `w:hint="eastAsia"` takes effect. A run under `w:cs` or
+ * `w:rtl` formats every character with the complex-script slot, which the
+ * hint does not override.
+ */
+declare function eastAsiaHintApplies(run: {
+  readonly eastAsiaHint?: boolean | undefined;
+  readonly forceComplexScript?: boolean | undefined;
+  readonly rtl?: boolean | undefined;
+}): boolean;
+/**
+ * Which font slot a single code point selects. CJK wins where ranges meet.
+ * `eastAsiaHint` is the run's effective `w:hint="eastAsia"`
+ * (see {@link eastAsiaHintApplies}).
+ */
+declare function scriptClassOf(cp: number, eastAsiaHint?: boolean): ScriptClass;
 /**
  * True when the text contains at least one complex-script code point. Callers
  * use this to skip segmentation entirely on the common all-Latin path.
@@ -68,11 +91,17 @@ declare function isRightToLeftCodePoint(cp: number): boolean;
 /** True when the text contains at least one right-to-left code point. */
 declare function hasRightToLeft(text: string): boolean;
 declare function hasComplexScript(text: string): boolean;
+/**
+ * True when some code point of the text selects the `w:eastAsia` slot: a CJK
+ * code point, or under an effective `w:hint="eastAsia"` one the hint moves.
+ */
+declare function hasEastAsiaSlotText(text: string, eastAsiaHint?: boolean): boolean;
 /**
  * Split text into maximal runs of one script class (CJK vs. non-CJK). Iterates
  * by code point so astral ideographs (surrogate pairs) are never split between
  * fonts. Empty input yields no segments; single-class input yields one.
+ * `eastAsiaHint` is the run's effective `w:hint="eastAsia"`.
  */
-declare function segmentByScript(text: string): ScriptSegment[];
+declare function segmentByScript(text: string, eastAsiaHint?: boolean): ScriptSegment[];
 //#endregion
-export { SCRIPT_CLASS, ScriptClass, ScriptSegment, hasCjk, hasComplexScript, hasRightToLeft, isCjkCodePoint, isComplexScriptCodePoint, isRightToLeftCodePoint, scriptClassOf, segmentByScript };
+export { SCRIPT_CLASS, ScriptClass, ScriptSegment, eastAsiaHintApplies, hasCjk, hasComplexScript, hasEastAsiaSlotText, hasRightToLeft, isCjkCodePoint, isComplexScriptCodePoint, isEastAsiaHintCodePoint, isRightToLeftCodePoint, scriptClassOf, segmentByScript };