@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

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

@@ -0,0 +1,92 @@
+import { expectFootnoteRefMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/marks/FootnoteRefExtension.ts
+/**
+* Footnote Reference Mark Extension
+*
+* Provides footnoteRef mark + insert/delete commands for footnotes and endnotes.
+*/
+const noteRefAttrsFromDom = (dom, noteType, vertAlign) => ({
+	id: dom.dataset["id"] ?? "",
+	noteType: dom.dataset["noteType"] ?? noteType,
+	...vertAlign ? { vertAlign } : {}
+});
+const FootnoteRefExtension = createMarkExtension({
+	name: "footnoteRef",
+	schemaMarkName: "footnoteRef",
+	markSpec: {
+		attrs: {
+			id: {},
+			noteType: { default: "footnote" },
+			vertAlign: { default: null }
+		},
+		parseDOM: [
+			{
+				tag: "sup.docx-footnote-ref",
+				getAttrs: (dom) => noteRefAttrsFromDom(dom, "footnote", "superscript")
+			},
+			{
+				tag: "sup.docx-endnote-ref",
+				getAttrs: (dom) => noteRefAttrsFromDom(dom, "endnote", "superscript")
+			},
+			{
+				tag: "span.docx-footnote-ref",
+				getAttrs: (dom) => noteRefAttrsFromDom(dom, "footnote", "baseline")
+			},
+			{
+				tag: "span.docx-endnote-ref",
+				getAttrs: (dom) => noteRefAttrsFromDom(dom, "endnote", "baseline")
+			}
+		],
+		toDOM(mark) {
+			const attrs = expectFootnoteRefMarkAttrs(mark);
+			const id = String(attrs.id);
+			const noteType = attrs.noteType ?? "footnote";
+			const isSuperscript = attrs.vertAlign === "superscript";
+			return [
+				isSuperscript ? "sup" : "span",
+				{
+					class: `docx-${noteType}-ref ${isSuperscript ? "docx-note-ref-superscript" : "docx-note-ref-baseline"}`,
+					"data-id": id,
+					"data-note-type": noteType
+				},
+				0
+			];
+		}
+	},
+	onSchemaReady(ctx) {
+		const { schema } = ctx;
+		function makeInsertNote(noteType) {
+			return (id) => (state, dispatch) => {
+				if (!dispatch) return true;
+				const footnoteRefType = schema.marks["footnoteRef"];
+				if (!footnoteRefType) panic("Missing mark type: footnoteRef");
+				const mark = footnoteRefType.create({
+					id: String(id),
+					noteType,
+					vertAlign: "superscript"
+				});
+				const text = schema.text(String(id), [mark]);
+				dispatch(state.tr.replaceSelectionWith(text, false).scrollIntoView());
+				return true;
+			};
+		}
+		const deleteNoteRef = (state, dispatch) => {
+			const { $from, $to } = state.selection;
+			if (!dispatch) return true;
+			let tr = state.tr;
+			const markType = schema.marks["footnoteRef"];
+			tr = tr.removeMark($from.pos, $to.pos, markType);
+			dispatch(tr.scrollIntoView());
+			return true;
+		};
+		return { commands: {
+			insertFootnote: makeInsertNote("footnote"),
+			insertEndnote: makeInsertNote("endnote"),
+			deleteNoteRef: () => deleteNoteRef
+		} };
+	}
+});
+//#endregion
+export { FootnoteRefExtension };

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

@@ -0,0 +1,23 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/HiddenTextExtension.d.ts
+/**
+ * Hidden Text Mark Extension (w:vanish, OOXML §17.3.2.41)
+ *
+ * Word's editing view dims hidden text with a dotted underline so the
+ * author can navigate to and edit it; the print/normal view suppresses it
+ * entirely. The painter mirrors the editing-view treatment so PM cursor
+ * traversal stays correct across hidden ranges. The `docx-hidden` class
+ * hook lets host CSS opt into print-style suppression independently.
+ *
+ * The dotted-underline visual is delivered via `editor.css` (`.docx-hidden`
+ * rule), NOT inline `text-decoration`. Inline `text-decoration: underline`
+ * would be picked up by `UnderlineExtension`'s `style: "text-decoration"`
+ * parser on DOM/clipboard reparse and add a spurious `<w:u>` alongside
+ * `<w:vanish/>` on export.
+ *
+ * eigenpal #424 (w:vanish gap 9).
+ */
+declare const HiddenTextExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { HiddenTextExtension };

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

@@ -0,0 +1,35 @@
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/HiddenTextExtension.ts
+/**
+* Hidden Text Mark Extension (w:vanish, OOXML §17.3.2.41)
+*
+* Word's editing view dims hidden text with a dotted underline so the
+* author can navigate to and edit it; the print/normal view suppresses it
+* entirely. The painter mirrors the editing-view treatment so PM cursor
+* traversal stays correct across hidden ranges. The `docx-hidden` class
+* hook lets host CSS opt into print-style suppression independently.
+*
+* The dotted-underline visual is delivered via `editor.css` (`.docx-hidden`
+* rule), NOT inline `text-decoration`. Inline `text-decoration: underline`
+* would be picked up by `UnderlineExtension`'s `style: "text-decoration"`
+* parser on DOM/clipboard reparse and add a spurious `<w:u>` alongside
+* `<w:vanish/>` on export.
+*
+* eigenpal #424 (w:vanish gap 9).
+*/
+const HiddenTextExtension = createMarkExtension({
+	name: "hidden",
+	schemaMarkName: "hidden",
+	markSpec: {
+		parseDOM: [{ tag: "span.docx-hidden" }],
+		toDOM() {
+			return [
+				"span",
+				{ class: "docx-hidden" },
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { HiddenTextExtension };

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

@@ -0,0 +1,10 @@
+import { document_d_exports } from "../../../types/document.js";
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/HighlightExtension.d.ts
+type HighlightColor = NonNullable<document_d_exports.TextFormatting["highlight"]>;
+declare const normalizeCssColorKey: (value: string) => string;
+declare const parseDOMHighlightColor: (value: string) => HighlightColor | null;
+declare const HighlightExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { HighlightExtension, normalizeCssColorKey, parseDOMHighlightColor };

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

@@ -0,0 +1,115 @@
+import { HIGHLIGHT_COLOR_VALUES } from "../../../types/documentEnumValues.js";
+import { resolveHighlightToCss } from "../../../utils/colorResolver.js";
+import { expectHighlightMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { removeMark, setMark } from "./markUtils.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/marks/HighlightExtension.ts
+/**
+* Highlight/Background Color Mark Extension
+*/
+const CSS_HIGHLIGHT_TO_NAME = {
+	"#000000": "black",
+	"#00008b": "darkBlue",
+	"#0000ff": "blue",
+	"#006400": "darkGreen",
+	"#008000": "darkGreen",
+	"#008080": "darkCyan",
+	"#008b8b": "darkCyan",
+	"#00ff00": "green",
+	"#00ffff": "cyan",
+	"#800080": "darkMagenta",
+	"#808000": "darkYellow",
+	"#808080": "darkGray",
+	"#8b0000": "darkRed",
+	"#a9a9a9": "darkGray",
+	"#c0c0c0": "lightGray",
+	"#d3d3d3": "lightGray",
+	"#ff0000": "red",
+	"#ff00ff": "magenta",
+	"#ffff00": "yellow",
+	"#ffffff": "white",
+	aqua: "cyan",
+	black: "black",
+	blue: "blue",
+	cyan: "cyan",
+	darkblue: "darkBlue",
+	darkcyan: "darkCyan",
+	darkgray: "darkGray",
+	darkgreen: "darkGreen",
+	darkgrey: "darkGray",
+	darkmagenta: "darkMagenta",
+	darkred: "darkRed",
+	fuchsia: "magenta",
+	gray: "darkGray",
+	green: "green",
+	grey: "darkGray",
+	lightgray: "lightGray",
+	lightgrey: "lightGray",
+	lime: "green",
+	magenta: "magenta",
+	red: "red",
+	white: "white",
+	yellow: "yellow"
+};
+const readHighlightName = (value) => {
+	for (const color of HIGHLIGHT_COLOR_VALUES) if (color === value) return color;
+	return null;
+};
+const normalizeCssColorKey = (value) => {
+	const compact = value.trim().toLowerCase().replace(/\s+/gu, "");
+	const hex = /^#(?<hex>[0-9a-f]{3}|[0-9a-f]{6})$/u.exec(compact)?.groups?.["hex"];
+	if (hex) return hex.length === 3 ? `#${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}` : `#${hex}`;
+	const rgbMatch = /^rgba?\((?<red>\d{1,3}),(?<green>\d{1,3}),(?<blue>\d{1,3})(?:,[^)]+)?\)$/u.exec(compact);
+	if (!rgbMatch?.groups) return compact;
+	const { red, green, blue } = rgbMatch.groups;
+	return `#${cssColorComponentToHex(red)}${cssColorComponentToHex(green)}${cssColorComponentToHex(blue)}`;
+};
+const cssColorComponentToHex = (value) => {
+	const component = Number(value);
+	if (!Number.isFinite(component)) return "00";
+	return Math.min(255, Math.max(0, component)).toString(16).padStart(2, "0");
+};
+const parseDOMHighlightColor = (value) => {
+	const trimmed = value.trim();
+	if (trimmed === "" || trimmed === "inherit" || trimmed === "initial" || trimmed === "none" || trimmed === "transparent" || trimmed === "unset") return null;
+	const namedColor = readHighlightName(trimmed);
+	if (namedColor && namedColor !== "none") return namedColor;
+	return CSS_HIGHLIGHT_TO_NAME[normalizeCssColorKey(trimmed)] ?? null;
+};
+const HighlightExtension = createMarkExtension({
+	name: "highlight",
+	schemaMarkName: "highlight",
+	markSpec: {
+		attrs: { color: { default: "yellow" } },
+		parseDOM: [{ tag: "mark" }, {
+			style: "background-color",
+			getAttrs: (value) => {
+				const color = parseDOMHighlightColor(value);
+				if (color) return { color };
+				return false;
+			}
+		}],
+		toDOM(mark) {
+			const { color } = expectHighlightMarkAttrs(mark);
+			return [
+				"mark",
+				{ style: `background-color: ${resolveHighlightToCss(color)}` },
+				0
+			];
+		}
+	},
+	onSchemaReady(ctx) {
+		const highlightType = ctx.schema.marks["highlight"];
+		if (!highlightType) panic("Missing mark type: highlight");
+		return { commands: {
+			setHighlight: (color) => {
+				if (!color || color === "none") return removeMark(highlightType);
+				return setMark(highlightType, { color: parseDOMHighlightColor(color) ?? "yellow" });
+			},
+			clearHighlight: () => removeMark(highlightType)
+		} };
+	}
+});
+//#endregion
+export { HighlightExtension, normalizeCssColorKey, parseDOMHighlightColor };

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

@@ -0,0 +1,13 @@
+import { MarkExtension } from "../types.js";
+import { EditorState } from "prosemirror-state";
+
+//#region src/prosemirror/extensions/marks/HyperlinkExtension.d.ts
+declare function isHyperlinkActive(state: EditorState): boolean;
+declare function getHyperlinkAttrs(state: EditorState): {
+  href: string;
+  tooltip?: string;
+} | null;
+declare function getSelectedText(state: EditorState): string;
+declare const HyperlinkExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { HyperlinkExtension, getHyperlinkAttrs, getSelectedText, isHyperlinkActive };

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

@@ -0,0 +1,146 @@
+import { expectHyperlinkMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { isMarkActive } from "./markUtils.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/marks/HyperlinkExtension.ts
+/**
+* Hyperlink Mark Extension
+*/
+function isHyperlinkActive(state) {
+	const hlType = state.schema.marks["hyperlink"];
+	if (!hlType) return false;
+	return isMarkActive(state, hlType);
+}
+function getHyperlinkAttrs(state) {
+	const hlType = state.schema.marks["hyperlink"];
+	if (!hlType) return null;
+	const { empty, $from, from, to } = state.selection;
+	if (empty) {
+		const marks = state.storedMarks ?? $from.marks();
+		for (const mark of marks) if (mark.type === hlType) {
+			const { href, tooltip } = expectHyperlinkMarkAttrs(mark);
+			return {
+				href,
+				...tooltip !== void 0 ? { tooltip } : {}
+			};
+		}
+		return null;
+	}
+	let attrs = null;
+	state.doc.nodesBetween(from, to, (node) => {
+		if (node.isText && attrs === null) {
+			const mark = hlType.isInSet(node.marks);
+			if (mark) {
+				const { href, tooltip } = expectHyperlinkMarkAttrs(mark);
+				attrs = {
+					href,
+					...tooltip !== void 0 ? { tooltip } : {}
+				};
+				return false;
+			}
+		}
+		return true;
+	});
+	return attrs;
+}
+function getSelectedText(state) {
+	const { from, to, empty } = state.selection;
+	if (empty) return "";
+	return state.doc.textBetween(from, to, "");
+}
+const HyperlinkExtension = createMarkExtension({
+	name: "hyperlink",
+	schemaMarkName: "hyperlink",
+	markSpec: {
+		attrs: {
+			href: {},
+			tooltip: { default: null },
+			rId: { default: null },
+			_docxHyperlinkIndex: { default: null }
+		},
+		inclusive: false,
+		parseDOM: [{
+			tag: "a[href]",
+			getAttrs: (dom) => ({
+				href: dom.getAttribute("href") ?? "",
+				tooltip: dom.getAttribute("title") ?? void 0
+			})
+		}],
+		toDOM(mark) {
+			const { href, tooltip } = expectHyperlinkMarkAttrs(mark);
+			const domAttrs = {
+				href,
+				target: "_blank",
+				rel: "noopener noreferrer"
+			};
+			if (tooltip) domAttrs["title"] = tooltip;
+			return [
+				"a",
+				domAttrs,
+				0
+			];
+		}
+	},
+	onSchemaReady(ctx) {
+		const hlType = ctx.schema.marks["hyperlink"];
+		if (!hlType) panic("Missing mark type: hyperlink");
+		const setHyperlink = (href, tooltip) => (state, dispatch) => {
+			const { from, to, empty } = state.selection;
+			if (empty) return false;
+			if (dispatch) {
+				const mark = hlType.create({
+					href,
+					tooltip: tooltip || null
+				});
+				let tr = state.tr.addMark(from, to, mark);
+				const textColorType = state.schema.marks["textColor"];
+				if (textColorType) tr = tr.removeMark(from, to, textColorType);
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		};
+		const removeHyperlink = (state, dispatch) => {
+			const { from, to, empty } = state.selection;
+			if (empty) {
+				const $pos = state.selection.$from;
+				if (!$pos.marks().find((m) => m.type === hlType)) return false;
+				let start = $pos.pos;
+				let end = $pos.pos;
+				$pos.parent.forEach((node, offset) => {
+					if (node.isText) {
+						const nodeStart = $pos.start() + offset;
+						const nodeEnd = nodeStart + node.nodeSize;
+						if (nodeStart <= $pos.pos && $pos.pos <= nodeEnd) {
+							if (node.marks.some((m) => m.type === hlType)) {
+								start = Math.min(start, nodeStart);
+								end = Math.max(end, nodeEnd);
+							}
+						}
+					}
+				});
+				if (dispatch) dispatch(state.tr.removeMark(start, end, hlType).scrollIntoView());
+				return true;
+			}
+			if (dispatch) dispatch(state.tr.removeMark(from, to, hlType).scrollIntoView());
+			return true;
+		};
+		const insertHyperlink = (text, href, tooltip) => (state, dispatch) => {
+			if (dispatch) {
+				const mark = hlType.create({
+					href,
+					tooltip: tooltip || null
+				});
+				const textNode = state.schema.text(text, [mark]);
+				dispatch(state.tr.replaceSelectionWith(textNode, false).scrollIntoView());
+			}
+			return true;
+		};
+		return { commands: {
+			setHyperlink,
+			removeHyperlink: () => removeHyperlink,
+			insertHyperlink
+		} };
+	}
+});
+//#endregion
+export { HyperlinkExtension, getHyperlinkAttrs, getSelectedText, isHyperlinkActive };

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

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/ItalicExtension.d.ts
+/**
+ * Italic Mark Extension
+ */
+declare const ItalicExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { ItalicExtension };

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

@@ -0,0 +1,34 @@
+import { createMarkExtension } from "../create.js";
+import { panic } from "better-result";
+import { toggleMark } from "prosemirror-commands";
+//#region src/prosemirror/extensions/marks/ItalicExtension.ts
+/**
+* Italic Mark Extension
+*/
+const ItalicExtension = createMarkExtension({
+	name: "italic",
+	schemaMarkName: "italic",
+	markSpec: {
+		parseDOM: [
+			{ tag: "i" },
+			{ tag: "em" },
+			{
+				style: "font-style",
+				getAttrs: (value) => value === "italic" ? null : false
+			}
+		],
+		toDOM() {
+			return ["em", 0];
+		}
+	},
+	onSchemaReady(ctx) {
+		const italicType = ctx.schema.marks["italic"];
+		if (!italicType) panic("Missing mark type: italic");
+		return {
+			commands: { toggleItalic: () => toggleMark(italicType) },
+			keyboardShortcuts: { "Mod-i": toggleMark(italicType) }
+		};
+	}
+});
+//#endregion
+export { ItalicExtension };

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

@@ -0,0 +1,6 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/RtlExtension.d.ts
+declare const RtlExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { RtlExtension };

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

@@ -0,0 +1,21 @@
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/RtlExtension.ts
+const RtlExtension = createMarkExtension({
+	name: "rtl",
+	schemaMarkName: "rtl",
+	markSpec: {
+		parseDOM: [{
+			tag: "span[dir=rtl]",
+			getAttrs: (dom) => typeof dom !== "string" && dom.getAttribute("dir")?.toLowerCase() === "rtl" ? {} : false
+		}],
+		toDOM() {
+			return [
+				"span",
+				{ dir: "rtl" },
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { RtlExtension };

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

@@ -0,0 +1,11 @@
+import { document_d_exports } from "../../../types/document.js";
+import { MarkExtension } from "../types.js";
+import { Mark } from "prosemirror-model";
+
+//#region src/prosemirror/extensions/marks/RunFormattingOverrideExtension.d.ts
+type RunFormattingOverrideAttrs = Record<string, false | "none">;
+declare function buildRunFormattingOverrideAttrs(formatting: document_d_exports.TextFormatting | undefined): RunFormattingOverrideAttrs | undefined;
+declare function applyRunFormattingOverrideMark(formatting: document_d_exports.TextFormatting, mark: Mark): void;
+declare const RunFormattingOverrideExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { RunFormattingOverrideExtension, applyRunFormattingOverrideMark, buildRunFormattingOverrideAttrs };

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

@@ -0,0 +1,75 @@
+import { expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/RunFormattingOverrideExtension.ts
+function buildRunFormattingOverrideAttrs(formatting) {
+	if (!formatting) return;
+	const attrs = {};
+	if (formatting.bold === false) attrs["bold"] = false;
+	if (formatting.italic === false) attrs["italic"] = false;
+	if (formatting.underline?.style === "none") attrs["underline"] = "none";
+	if (formatting.strike === false) attrs["strike"] = false;
+	if (formatting.doubleStrike === false) attrs["doubleStrike"] = false;
+	if (formatting.allCaps === false) attrs["allCaps"] = false;
+	if (formatting.smallCaps === false) attrs["smallCaps"] = false;
+	if (formatting.hidden === false) attrs["hidden"] = false;
+	if (formatting.emboss === false) attrs["emboss"] = false;
+	if (formatting.imprint === false) attrs["imprint"] = false;
+	if (formatting.shadow === false) attrs["shadow"] = false;
+	if (formatting.outline === false) attrs["outline"] = false;
+	if (formatting.rtl === false) attrs["rtl"] = false;
+	return Object.keys(attrs).length > 0 ? attrs : void 0;
+}
+function applyRunFormattingOverrideMark(formatting, mark) {
+	const attrs = expectRunFormattingOverrideMarkAttrs(mark);
+	if (attrs.bold === false) formatting.bold = false;
+	if (attrs.italic === false) formatting.italic = false;
+	if (attrs.underline === "none") formatting.underline = { style: "none" };
+	if (attrs.strike === false) formatting.strike = false;
+	if (attrs.doubleStrike === false) formatting.doubleStrike = false;
+	if (attrs.allCaps === false) formatting.allCaps = false;
+	if (attrs.smallCaps === false) formatting.smallCaps = false;
+	if (attrs.hidden === false) formatting.hidden = false;
+	if (attrs.emboss === false) formatting.emboss = false;
+	if (attrs.imprint === false) formatting.imprint = false;
+	if (attrs.shadow === false) formatting.shadow = false;
+	if (attrs.outline === false) formatting.outline = false;
+	if (attrs.rtl === false) formatting.rtl = false;
+}
+const RunFormattingOverrideExtension = createMarkExtension({
+	name: "runFormattingOverride",
+	schemaMarkName: "runFormattingOverride",
+	markSpec: {
+		attrs: {
+			bold: { default: null },
+			italic: { default: null },
+			underline: { default: null },
+			strike: { default: null },
+			doubleStrike: { default: null },
+			allCaps: { default: null },
+			smallCaps: { default: null },
+			hidden: { default: null },
+			emboss: { default: null },
+			imprint: { default: null },
+			shadow: { default: null },
+			outline: { default: null },
+			rtl: { default: null }
+		},
+		toDOM(mark) {
+			const attrs = expectRunFormattingOverrideMarkAttrs(mark);
+			const styles = [];
+			if (attrs.bold === false) styles.push("font-weight: normal");
+			if (attrs.italic === false) styles.push("font-style: normal");
+			if (attrs.underline === "none" || attrs.strike === false) styles.push("text-decoration: none");
+			if (attrs.allCaps === false) styles.push("text-transform: none");
+			if (attrs.smallCaps === false) styles.push("font-variant-caps: normal");
+			if (attrs.hidden === false) styles.push("visibility: visible");
+			return [
+				"span",
+				styles.length > 0 ? { style: styles.join("; ") } : {},
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { RunFormattingOverrideExtension, applyRunFormattingOverrideMark, buildRunFormattingOverrideAttrs };

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

@@ -0,0 +1,6 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/RunShadingExtension.d.ts
+declare const RunShadingExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { RunShadingExtension };

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

@@ -0,0 +1,38 @@
+import { ensureHexPrefix } from "../../../utils/colorResolver.js";
+import { expectRunShadingMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { normalizeCssColorKey, parseDOMHighlightColor } from "./HighlightExtension.js";
+//#region src/prosemirror/extensions/marks/RunShadingExtension.ts
+const RunShadingExtension = createMarkExtension({
+	name: "runShading",
+	schemaMarkName: "runShading",
+	markSpec: {
+		attrs: {
+			rgb: { default: null },
+			themeColor: { default: null },
+			themeTint: { default: null },
+			themeShade: { default: null },
+			pattern: { default: null },
+			patternColor: { default: null }
+		},
+		parseDOM: [{
+			style: "background-color",
+			getAttrs: (value) => {
+				if (parseDOMHighlightColor(value)) return false;
+				const hex = /^#(?<hex>[0-9a-fA-F]{6})$/u.exec(normalizeCssColorKey(value))?.groups?.["hex"];
+				return hex ? { rgb: hex.toUpperCase() } : false;
+			}
+		}],
+		toDOM(mark) {
+			const { rgb } = expectRunShadingMarkAttrs(mark);
+			const background = rgb ? ensureHexPrefix(rgb) : "";
+			return [
+				"span",
+				background ? { style: `background-color: ${background}` } : {},
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { RunShadingExtension };

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

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/SmallCapsExtension.d.ts
+/**
+ * Small Caps Mark Extension (w:smallCaps)
+ */
+declare const SmallCapsExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { SmallCapsExtension };