superdoc 2.30.0-next.4 → 2.30.0-next.9

package/dist/chunks/{create-super-doc-ui-CbEDXtpm.es.js → create-super-doc-ui-Cq8trPVC.es.js}

@@ -1410,6 +1410,9 @@ new Set(INLINE_PROPERTY_REGISTRY.map((entry) => entry.key));
 var INLINE_PROPERTY_BY_KEY = Object.fromEntries(INLINE_PROPERTY_REGISTRY.map((entry) => [entry.key, entry]));
 INLINE_PROPERTY_REGISTRY.filter((entry) => entry.storage === "mark").map((entry) => entry.key), INLINE_PROPERTY_REGISTRY.filter((entry) => entry.storage === "runAttribute").map((entry) => entry.key);
 //#endregion
+//#region ../document-api/src/paragraphs/paragraphs.types.ts
+var PARAGRAPH_BATCH_MAX_TARGETS = 1e3;
+//#endregion
 //#region src/helpers/tracked-change-comment-lane.ts
 var TRACKED_CHANGE_COMMENT_LANE_ID_PREFIX = "tc-comment:";
 function isSyntheticTrackedChangeCommentLaneItem(item) {
@@ -2971,6 +2974,213 @@ function fontsValue(value) {
 	return Object.keys(result).length > 0 ? result : null;
 }
 //#endregion
+//#region src/public/ui/format-painter-paragraph.ts
+var BORDER_SIDES = /* @__PURE__ */ new Set([
+	"top",
+	"bottom",
+	"left",
+	"right",
+	"between",
+	"bar"
+]);
+function isBorderSide(side) {
+	return BORDER_SIDES.has(side);
+}
+var TAB_ALIGNMENTS = /* @__PURE__ */ new Set([
+	"left",
+	"center",
+	"right",
+	"decimal",
+	"bar",
+	"clear"
+]);
+var TAB_LEADERS = /* @__PURE__ */ new Set([
+	"none",
+	"dot",
+	"hyphen",
+	"underscore",
+	"heavy",
+	"middleDot"
+]);
+function colorValue(value) {
+	if (value == null) return void 0;
+	if (typeof value === "string") return /^(?:#?[\da-f]{6}|auto)$/i.test(value) ? value.replace(/^#/, "") : void 0;
+	if (typeof value !== "object" || !("model" in value)) return void 0;
+	const color = value;
+	if (color.model === "auto") return "auto";
+	return color.model === "rgb" && "value" in color && typeof color.value === "string" && /^[\da-f]{6}$/i.test(color.value) ? color.value : void 0;
+}
+function hasOnlyKeys(value, keys) {
+	return Object.keys(value).every((key) => keys.includes(key));
+}
+function captureParagraphPaintOperations(props, supports = () => true) {
+	const operations = [];
+	if (props.bidi == null) operations.push({
+		operationId: "format.paragraph.clearDirection",
+		input: {}
+	});
+	else operations.push({
+		operationId: "format.paragraph.setDirection",
+		input: {
+			direction: props.bidi ? "rtl" : "ltr",
+			alignmentPolicy: "preserve"
+		}
+	});
+	const alignment = props.alignment;
+	if (alignment == null) operations.push({
+		operationId: "format.paragraph.clearAlignment",
+		input: {}
+	});
+	else if (alignment === "left" || alignment === "right" || alignment === "center" || alignment === "justify") operations.push({
+		operationId: "format.paragraph.setAlignment",
+		input: { alignment }
+	});
+	const spacing = props.spacing;
+	if (!spacing || hasOnlyKeys(spacing, [
+		"before",
+		"after",
+		"line",
+		"lineRule"
+	])) {
+		operations.push({
+			operationId: "format.paragraph.clearSpacing",
+			input: {}
+		});
+		if (spacing && [
+			"before",
+			"after",
+			"line",
+			"lineRule"
+		].some((key) => spacing[key] != null)) {
+			const lineRule = spacing.lineRule === "multiple" ? "auto" : spacing.lineRule ?? "auto";
+			operations.push({
+				operationId: "format.paragraph.setSpacing",
+				input: {
+					...spacing.before != null ? { before: Math.round(Number(spacing.before) * 20) } : {},
+					...spacing.after != null ? { after: Math.round(Number(spacing.after) * 20) } : {},
+					...spacing.line != null ? { line: Math.round(Number(spacing.line) * (lineRule === "auto" ? 240 : 20)) } : {},
+					...spacing.line != null || spacing.lineRule != null ? { lineRule } : {}
+				}
+			});
+		}
+	}
+	const indent = props.indent;
+	if (!indent || hasOnlyKeys(indent, [
+		"left",
+		"right",
+		"firstLine",
+		"hanging"
+	]) && !(indent.firstLine != null && indent.hanging != null)) {
+		operations.push({
+			operationId: "format.paragraph.clearIndentation",
+			input: {}
+		});
+		if (indent && Object.keys(indent).length) operations.push({
+			operationId: "format.paragraph.setIndentation",
+			input: Object.fromEntries(Object.entries(indent).filter(([, value]) => value != null).map(([key, value]) => [key, Math.round(Number(value) * 20)]))
+		});
+	}
+	operations.push({
+		operationId: "format.paragraph.setKeepOptions",
+		input: {
+			keepNext: props.keepWithNext ?? null,
+			keepLines: props.keepLines ?? null,
+			widowControl: props.widowControl ?? null
+		}
+	});
+	operations.push({
+		operationId: "format.paragraph.setFlowOptions",
+		input: {
+			contextualSpacing: props.contextualSpacing ?? null,
+			pageBreakBefore: props.pageBreakBefore ?? null
+		}
+	});
+	operations.push({
+		operationId: "format.paragraph.setOutlineLevel",
+		input: { outlineLevel: props.outlineLevel ?? null }
+	});
+	const borders = props.borders;
+	if (!borders || Object.entries(borders).every(([side, border]) => BORDER_SIDES.has(side) && hasOnlyKeys(border, [
+		"style",
+		"color",
+		"width",
+		"space"
+	]) && typeof border.style === "string" && (border.color == null || colorValue(border.color) !== void 0))) {
+		operations.push({
+			operationId: "format.paragraph.clearBorder",
+			input: { side: "all" }
+		});
+		for (const side of Object.keys(borders ?? {})) {
+			if (!isBorderSide(side)) continue;
+			const border = borders?.[side];
+			if (!border || typeof border.style !== "string") continue;
+			operations.push({
+				operationId: "format.paragraph.setBorder",
+				input: {
+					side,
+					style: border.style,
+					...border.color != null ? { color: colorValue(border.color) } : {},
+					...border.width != null ? { size: Math.round(Number(border.width) * 8) } : {},
+					...border.space != null ? { space: border.space } : {}
+				}
+			});
+		}
+	}
+	const shading = props.shading;
+	if (!shading || hasOnlyKeys(shading, [
+		"fill",
+		"color",
+		"pattern"
+	]) && ["fill", "color"].every((key) => shading[key] == null || colorValue(shading[key]) !== void 0)) {
+		operations.push({
+			operationId: "format.paragraph.clearShading",
+			input: {}
+		});
+		if (shading && Object.keys(shading).length) operations.push({
+			operationId: "format.paragraph.setShading",
+			input: {
+				...shading.fill != null ? { fill: colorValue(shading.fill) } : {},
+				...shading.color != null ? { color: colorValue(shading.color) } : {},
+				...shading.pattern != null ? { pattern: shading.pattern } : {}
+			}
+		});
+	}
+	const tabs = props.tabs;
+	if (!tabs || tabs.every((tab) => hasOnlyKeys(tab, [
+		"kind",
+		"position",
+		"alignment",
+		"leader"
+	]) && (tab.kind === "clear" || TAB_ALIGNMENTS.has(String(tab.alignment ?? "left"))) && (tab.leader == null || TAB_LEADERS.has(String(tab.leader))))) {
+		operations.push({
+			operationId: "format.paragraph.clearAllTabStops",
+			input: {}
+		});
+		for (const tab of tabs ?? []) {
+			const alignment = tab.kind === "clear" ? "clear" : tab.alignment ?? "left";
+			const leader = tab.leader;
+			if (alignment === "num" || leader === "line") continue;
+			operations.push({
+				operationId: "format.paragraph.setTabStop",
+				input: {
+					position: Math.round(Number(tab.position) * 20),
+					alignment,
+					...leader != null ? { leader } : {}
+				}
+			});
+		}
+	}
+	const replacementGroups = [
+		["clearSpacing", "setSpacing"],
+		["clearIndentation", "setIndentation"],
+		["clearBorder", "setBorder"],
+		["clearShading", "setShading"],
+		["clearAllTabStops", "setTabStop"]
+	].map((group) => group.map((name) => `format.paragraph.${name}`));
+	const unavailable = new Set(replacementGroups.filter((group) => operations.some((entry) => group.includes(entry.operationId) && !supports(entry.operationId))).flat());
+	return operations.filter((entry) => supports(entry.operationId) && !unavailable.has(entry.operationId));
+}
+//#endregion
 //#region src/public/ui/format-painter-helpers.ts
 /**
 * Maps SDRunProps field names to InlineRunPatch field names.
@@ -3332,6 +3542,7 @@ var SUPERDOC_UI_REASONS = {
 	* are never gated by this reason.
 	*/
 	contentControlLocked: "content-control-locked",
+	deletedTextFormattingUnsupported: "deleted-text-formatting-unsupported",
 	/**
 	* The current user is not allowed to run this command under the product
 	* permissionResolver / role matrix (SD-3845). Distinct from document
@@ -4350,6 +4561,10 @@ function getParagraphInlineDirection(attrs) {
 	if (ppRtl === false) return "ltr";
 }
 //#endregion
+//#region ../layout-engine/contracts/src/table-cell-vector-overlay.ts
+var svgNumber = String.raw`[-+]?(?:\d*\.?\d+)(?:e[-+]?\d+)?`;
+new RegExp(String.raw`^M\s+${svgNumber}\s+${svgNumber}\s+L\s+${svgNumber}\s+${svgNumber}\s*$`, "iu");
+//#endregion
 //#region ../layout-engine/contracts/src/drawing-taxonomy.ts
 /**
 * Frozen canonical diagnostic codes for drawing rendering.
@@ -4649,7 +4864,7 @@ function readEffectiveInlineUniformityStates(raw) {
 		states[key] = isPlainObject(entry) && entry.state === "uniform" && typeof entry.value === "string" ? {
 			state: "uniform",
 			value: entry.value
-		} : { state: isPlainObject(entry) && entry.state === "mixed" ? "mixed" : "unresolvable" };
+		} : { state: isPlainObject(entry) && (entry.state === "mixed" || entry.state === "absent") ? entry.state : "unresolvable" };
 	}
 	return states;
 }
@@ -5750,6 +5965,19 @@ function resolveInlineSelectionTarget(selection) {
 	if (fallback && fallback.start.kind === "text" && fallback.end.kind === "text" && fallback.start.blockId !== fallback.end.blockId) return null;
 	return fallback;
 }
+function selectionHasOnlyDeletedText(selection) {
+	const target = selection.target;
+	const selected = selection.selectionTarget;
+	return !selection.empty && selected?.kind === "selection" && selected.coordinateSpace === "tracked" && target?.kind === "text" && target.segments.length > 0 && target.segments.every((segment) => segment.range.start === segment.range.end);
+}
+function selectionTouchesDeletedText(selection) {
+	const target = selection.target;
+	if (selection.empty || target?.kind !== "text" || !Array.isArray(target.segments) || target.segments.length === 0) return false;
+	const visibleLength = target.segments.reduce((length, segment) => length + Math.abs(segment.range.end - segment.range.start), 0);
+	const selected = selection.selectionTarget;
+	const trackedSegments = selection.trackedTarget?.segments;
+	return ((Array.isArray(trackedSegments) ? trackedSegments.reduce((length, segment) => length + Math.abs(segment.range.end - segment.range.start), 0) : void 0) ?? (selected?.coordinateSpace === "tracked" && selected.start.kind === "text" && selected.end.kind === "text" && selected.start.blockId === selected.end.blockId ? Math.abs(selected.end.offset - selected.start.offset) : 0)) > visibleLength;
+}
 //#endregion
 //#region src/public/ui/tracked-change-ids.ts
 function identityText(value) {
@@ -8944,6 +9172,11 @@ function createSuperDocUI(options) {
 		const scope = listSelectionScope(selection);
 		return [...pendingListRequests].some((request) => !request.cancelled && request.editor === getEditor() && request.doc === getEditor()?.doc && request.mode === readDocumentMode() && request.kind === kind && (request.scope == null || scope == null || request.scope === scope));
 	};
+	const inlineFormattingRefused = (descriptor, selection) => {
+		if (!descriptor.inline) return false;
+		if (selectionHasOnlyDeletedText(selection)) return true;
+		return descriptor.inline.kind === "clear" && selectionTouchesDeletedText(selection);
+	};
 	const computeCommandState = (id, doc, selection, projectedInlineValues, lockModesById = /* @__PURE__ */ new Map()) => {
 		if (customCommands.has(id)) return normalizeCommandState({
 			supported: true,
@@ -9020,6 +9253,12 @@ function createSuperDocUI(options) {
 			supported: false,
 			reason: descriptor.reason ?? SUPERDOC_UI_REASONS.commandUnsupported
 		}, descriptor.disposition === "unsupported" ? "unsupported" : "builtin");
+		if (inlineFormattingRefused(descriptor, selection)) return normalizeCommandState({
+			enabled: false,
+			active: false,
+			supported: true,
+			reason: readonly ? SUPERDOC_UI_REASONS.documentReadonly : SUPERDOC_UI_REASONS.deletedTextFormattingUnsupported
+		}, "builtin");
 		if (descriptor.instanceRoute) return computeInstanceCommandState(descriptor);
 		if (descriptor.table) return computeTableCommandState(descriptor, doc, readonly);
 		if (descriptor.inline?.kind === "clear") {
@@ -11459,27 +11698,26 @@ function createSuperDocUI(options) {
 		setPendingInlineFormatOnHost(method, value);
 		return true;
 	};
-	const executeClearFormattingCommand = () => {
-		const doc = getDoc();
-		const { lockModesById } = computeActiveContentControlLockModes(doc?.contentControls, state.selection);
-		if (contentControlLockReason(lockModesById)) return false;
+	const acceptUnchangedReset = (result) => isPlainObject(result) && result.success === false && isPlainObject(result.failure) && result.failure.code === "NO_OP" ? true : result;
+	const applyClearFormattingCommand = (doc) => {
 		const immediateResults = [];
 		const settledResults = [];
-		const record = (result) => {
+		const record = (result, unchangedResetIsSuccess = false) => {
 			const settled = settleOperationResult(result);
-			immediateResults.push(settled.immediate);
-			settledResults.push(settled.settled);
+			immediateResults.push(unchangedResetIsSuccess ? acceptUnchangedReset(settled.immediate) : settled.immediate);
+			settledResults.push(unchangedResetIsSuccess ? settled.settled.then(acceptUnchangedReset) : settled.settled);
 		};
-		const run = (op, input, options) => {
+		const run = (op, input, unchangedResetIsSuccess = false) => {
 			try {
-				record(options ? op(input, options) : op(input));
+				record(op(input), unchangedResetIsSuccess);
 			} catch {
 				immediateResults.push(false);
 				settledResults.push(Promise.resolve(false));
 			}
 		};
 		const defaultStyleId = getStyleCatalog().cache?.full.defaults.paragraphStyleId ?? DEFAULT_PARAGRAPH_STYLE_ID;
-		const rangeTarget = resolveInlineCommandTarget(state.selection);
+		const selectedTarget = resolveInlineCommandTarget(state.selection);
+		const rangeTarget = selectedTarget?.coordinateSpace === "tracked" && !currentCellSelectionTarget() && !selectionTouchesDeletedText(state.selection) ? selectionTargetFromTextTarget(state.selection.target) ?? selectedTarget : selectedTarget;
 		if (rangeTarget) {
 			const inlineOp = resolveDocOperation(doc, "format.apply");
 			if (inlineOp) try {
@@ -11499,7 +11737,7 @@ function createSuperDocUI(options) {
 		const listsRemoveOp = resolveDocOperation(doc, isBodyStory ? "lists.remove" : "lists.removeInStory");
 		for (const blockId of selectionBlockIds(state.selection)) {
 			const target = paragraphTarget(blockId, story);
-			if (resetOp) run(resetOp, { target });
+			if (resetOp) run(resetOp, { target }, true);
 			if (listsRemoveOp) try {
 				const listTarget = listsBlockTarget(blockId);
 				const r = settleOperationResult(listsRemoveOp(isBodyStory ? { target: listTarget } : {
@@ -11531,6 +11769,47 @@ function createSuperDocUI(options) {
 		pendingCommandSettlement = settledResults.length ? Promise.all(settledResults).then((results) => combineCommandResults(results)) : null;
 		return combineCommandResults(immediateResults.length ? immediateResults : [false]);
 	};
+	const executeClearFormattingCommand = () => {
+		const doc = getDoc();
+		const { lockModesById } = computeActiveContentControlLockModes(doc?.contentControls, state.selection);
+		if (contentControlLockReason(lockModesById)) return false;
+		const editor = getEditor();
+		const sourceDoc = editor?.doc;
+		const reset = resolveDocOperation(doc, "format.paragraph.resetDirectFormatting");
+		const blockIds = selectionBlockIds(state.selection);
+		if (editor?.editorVersion !== 2 || !reset || blockIds.length === 0) return applyClearFormattingCommand(doc);
+		const sourceToken = contentToken(), mode = readDocumentMode(), selectionToken = selectionKey(state.selection);
+		const story = selectionStoryLocator(state.selection);
+		const normalize = (result) => acceptUnchangedReset(commandResultFromOperationResult(result));
+		const checks = blockIds.map((blockId) => {
+			try {
+				const result = reset({ target: paragraphTarget(blockId, story) }, { dryRun: true });
+				return isPromiseLike(result) ? Promise.resolve(result).then(normalize, () => false) : normalize(result);
+			} catch {
+				return false;
+			}
+		});
+		const isCurrent = () => !disposed && getEditor() === editor && editor?.doc === sourceDoc && contentToken() === sourceToken && readDocumentMode() === mode && selectionKey(state.selection) === selectionToken;
+		if (!checks.some(isPromiseLike)) {
+			const result = combineCommandResults(checks.map(commandResultFromOperationResult));
+			if (!commandResultSucceeded(result)) return result;
+			return isCurrent() ? applyClearFormattingCommand(doc) : false;
+		}
+		pendingCommandSettlement = Promise.all(checks).then((results) => {
+			const result = combineCommandResults(results);
+			if (!commandResultSucceeded(result)) return result;
+			if (!isCurrent()) return false;
+			const previousSettlement = pendingCommandSettlement;
+			pendingCommandSettlement = null;
+			try {
+				const immediate = applyClearFormattingCommand(doc);
+				return pendingCommandSettlement ?? immediate;
+			} finally {
+				pendingCommandSettlement = previousSettlement;
+			}
+		});
+		return true;
+	};
 	/** Route a block-level paragraph command (`format.paragraph.*` / `styles.paragraph.*`). */
 	const executeBlockParagraph = (descriptor, op, payload) => {
 		const blockIds = selectionBlockIds(state.selection);
@@ -12219,6 +12498,7 @@ function createSuperDocUI(options) {
 		if (id === "copy-format") return documentIsReadOnly() ? false : settleCommandExecution(executeCopyFormat());
 		const descriptor = getCommandDescriptor(id);
 		if (!descriptor || descriptor.disposition !== "routed") return false;
+		if (inlineFormattingRefused(descriptor, preparedSelection ?? state.selection)) return false;
 		const normalized = descriptor.normalizePayload ? descriptor.normalizePayload(payload) : payload;
 		if (descriptor.instanceRoute) {
 			if (!getEditor()) return false;
@@ -12512,11 +12792,20 @@ function createSuperDocUI(options) {
 		}
 		let paragraphSnapshot = null;
 		const paragraphSegments = formatPainterParagraphSegments(segments, sourceWholeCells);
-		if (paragraphSegments.length === 1) {
+		if (paragraphSegments.length > 0) {
 			const segment = paragraphSegments[0];
 			const node = (await readBlockNode(paragraphTarget(segment.blockId, sourceStory)))?.["node"] ?? null;
 			if (node && getParagraphLikeData(node)) paragraphSnapshot = await extractParagraphSnapshot(node, segment.blockId, doc, sourceStory);
 		}
+		if (paragraphSnapshot?.styleId && effectiveInput) {
+			const authored = await readEffectiveInlineUniformityNow({
+				...effectiveInput,
+				keys: ["fontFamily", "fontSize"],
+				includeCaret: true,
+				includeDefaultFloor: false
+			});
+			paragraphSnapshot.inheritedFontKeys = ["fontFamily", "fontSize"].filter((key) => authored?.[key]?.state === "absent");
+		}
 		return {
 			story: sourceStory ?? null,
 			inline: inlinePatch,
@@ -12569,15 +12858,7 @@ function createSuperDocUI(options) {
 		const para = getParagraphLikeData(node);
 		const props = para["props"] ?? {};
 		const styleId = para["styleRef"] ?? null;
-		const alignment = props["alignment"] ?? null;
-		const spacing = props["spacing"] ?? null;
-		const indent = props["indent"] ?? null;
-		const indentation = indent ? {
-			...indent["left"] != null ? { left: indent["left"] } : {},
-			...indent["right"] != null ? { right: indent["right"] } : {},
-			...indent["firstLine"] != null ? { firstLine: indent["firstLine"] } : {},
-			...indent["hanging"] != null ? { hanging: indent["hanging"] } : {}
-		} : null;
+		const operations = captureParagraphPaintOperations(props, (operationId) => Boolean(resolveDocOperation(doc, operationId)));
 		const markRunProps = props["markRunProps"] ?? null;
 		const rawNumId = props["numbering"]?.["numId"];
 		const numId = typeof rawNumId === "string" ? parseInt(rawNumId, 10) : typeof rawNumId === "number" ? rawNumId : NaN;
@@ -12595,9 +12876,7 @@ function createSuperDocUI(options) {
 		} catch {}
 		return {
 			styleId,
-			alignment,
-			spacing,
-			indentation,
+			operations,
 			markRunProps,
 			numbering,
 			listStyle
@@ -12679,11 +12958,13 @@ function createSuperDocUI(options) {
 		const segments = Array.isArray(selTarget?.segments) ? selTarget.segments : [];
 		const targetStory = selTarget?.story;
 		const inline = { ...snap.inline };
+		const contiguousTextLengths = /* @__PURE__ */ new Map();
 		if (!selectionIsEmpty) {
 			for (const segment of formatPainterTextSegments(segments)) {
 				const node = (await readBlockNode(paragraphTarget(segment.blockId, targetStory)))?.node;
 				const para = node ? getParagraphLikeData(node) : null;
 				const runs = Array.isArray(para?.inlines) ? para.inlines : [];
+				if (runs.every((run) => typeof run.run?.text === "string")) contiguousTextLengths.set(segment.blockId, runs.reduce((length, run) => length + run.run.text.length, 0));
 				for (const props of sliceRunProps(runs, segment.range)) for (const key of Object.keys(sdRunPropsToInlineRunPatch(props))) {
 					const fontAlias = key === "rFonts" ? "fontFamily" : key === "fontFamily" ? "rFonts" : null;
 					const capturedFontAlias = fontAlias && (fontAlias in inline || snap.mixedInlineKeys.includes(fontAlias));
@@ -12692,99 +12973,205 @@ function createSuperDocUI(options) {
 			}
 			if (disposed || painter.snapshot !== snap || getEditor() !== ownerEditor || ownerEditor?.doc !== ownerDoc || readDocumentMode() !== ownerMode) return;
 		}
-		if (!selectionIsEmpty && Object.keys(inline).length > 0) {
-			const inlineOp = resolveDocOperation(doc, "format.apply");
-			if (inlineOp && selectionTarget) try {
-				if (!commandResultSucceeded(commandResultFromOperationResult(await Promise.resolve(callInlineFormatMutation("format.apply", inlineOp, {
+		const entries = [];
+		const options = editorMutationOptionsForRoute("format.apply");
+		if (options?.success === false) return;
+		const inlineOptions = {
+			...options,
+			...tableCellSelection || paintedTarget || selectionTarget?.coordinateSpace === "tracked" ? { offsetSpace: "selection" } : selection.selectionTarget ? { offsetSpace: "kernel" } : {},
+			...tableCellSelection ? { tableCellSelection } : {}
+		};
+		const add = (operationId, input, entryOptions = options) => {
+			entries.push({
+				operationId,
+				input,
+				...entryOptions ? { options: entryOptions } : {}
+			});
+		};
+		if (!selectionIsEmpty && Object.keys(inline).length > 0 && selectionTarget && resolveDocOperation(doc, "format.apply")) {
+			const inheritedFontKeys = snap.paragraph?.inheritedFontKeys ?? [];
+			const styledBlocks = new Set(formatPainterParagraphSegments(segments, Boolean(tableCellSelection)).map((segment) => segment.blockId));
+			if (inheritedFontKeys.length > 0 && styledBlocks.size > 0 && !tableCellSelection) {
+				const textSegments = formatPainterTextSegments(segments);
+				const original = selectionTarget;
+				const start = original.start;
+				const end = original.end;
+				const first = segments[0];
+				const last = segments.at(-1);
+				if (original.kind === "selection" && start?.kind === "text" && end?.kind === "text" && start.blockId === first?.blockId && start.offset === first?.range.start && end.blockId === last?.blockId && end.offset === last?.range.end && JSON.stringify(original.story ?? null) === JSON.stringify(targetStory ?? null) && new Set(segments.map((segment) => segment.blockId)).size === segments.length && segments.every((segment, index) => segment.range.start >= 0 && segment.range.end >= segment.range.start && (index === 0 || segment.range.start === 0) && (index === segments.length - 1 || contiguousTextLengths.get(segment.blockId) === segment.range.end))) {
+					const styledInline = { ...inline };
+					for (const key of inheritedFontKeys) styledInline[key] = null;
+					const partial = textSegments.at(-1);
+					if (partial && !styledBlocks.has(partial.blockId)) {
+						const markedEnd = textSegments.slice(0, -1).at(-1);
+						if (markedEnd) add("format.apply", {
+							target: {
+								...original,
+								end: {
+									...end,
+									blockId: markedEnd.blockId,
+									offset: markedEnd.range.end
+								}
+							},
+							inline: styledInline
+						}, inlineOptions);
+						add("format.apply", {
+							target: {
+								...original,
+								start: {
+									...start,
+									blockId: partial.blockId,
+									offset: partial.range.start
+								}
+							},
+							inline
+						}, inlineOptions);
+					} else add("format.apply", {
+						target: selectionTarget,
+						inline: styledInline
+					}, inlineOptions);
+				} else for (const segment of textSegments) {
+					const segmentInline = { ...inline };
+					if (styledBlocks.has(segment.blockId)) for (const key of inheritedFontKeys) segmentInline[key] = null;
+					add("format.apply", {
+						target: {
+							kind: "selection",
+							...targetStory ? { story: targetStory } : {},
+							start: {
+								kind: "text",
+								blockId: segment.blockId,
+								offset: segment.range.start
+							},
+							end: {
+								kind: "text",
+								blockId: segment.blockId,
+								offset: segment.range.end
+							}
+						},
+						inline: segmentInline
+					}, {
+						...options,
+						offsetSpace: "kernel"
+					});
+				}
+			} else {
+				if (tableCellSelection && styledBlocks.size > 0) for (const key of inheritedFontKeys) inline[key] = null;
+				add("format.apply", {
 					target: selectionTarget,
 					inline
-				}, selection, tableCellSelection))))) {
-					recompute();
-					return;
-				}
-			} catch {
-				recompute();
-				return;
-			}
-		}
-		if (snap.paragraph) for (const segment of formatPainterParagraphSegments(segments, Boolean(tableCellSelection))) {
-			const blockAddress = paragraphTarget(segment.blockId, targetStory);
-			const nodeResult = await readBlockNode(blockAddress);
-			const node = nodeResult?.["node"] ?? null;
-			const nodeAddress = nodeResult?.["address"] ?? null;
-			if (!node) continue;
-			const target = {
-				kind: "block",
-				nodeType: nodeAddress?.["nodeType"] ?? node["kind"] ?? "paragraph",
-				nodeId: segment.blockId,
-				...targetStory && typeof targetStory === "object" ? { story: targetStory } : {}
-			};
-			const { styleId, alignment, spacing, indentation, markRunProps, numbering, listStyle } = snap.paragraph;
-			const targetProps = getParagraphLikeData(node)?.props;
-			if (styleId) await resolveDocOperation(doc, "styles.paragraph.setStyle")?.({
-				target,
-				styleId
-			});
-			else if (getParagraphLikeData(node)?.styleRef) await resolveDocOperation(doc, "styles.paragraph.clearStyle")?.({ target });
-			if (alignment) await resolveDocOperation(doc, "format.paragraph.setAlignment")?.({
-				target,
-				alignment
-			});
-			else if (targetProps?.alignment != null) await resolveDocOperation(doc, "format.paragraph.clearAlignment")?.({ target });
-			if (targetProps?.spacing != null) await resolveDocOperation(doc, "format.paragraph.clearSpacing")?.({ target });
-			if (targetProps?.indent != null) await resolveDocOperation(doc, "format.paragraph.clearIndentation")?.({ target });
-			if (spacing) {
-				const sp = spacing;
-				const rawLr = sp["lineRule"] ?? "auto";
-				const lr = (/* @__PURE__ */ new Set([
-					"auto",
-					"exact",
-					"atLeast"
-				])).has(rawLr) ? rawLr : "auto";
-				const rawSpacing = {
-					...sp["before"] != null ? { before: Math.round(sp["before"] * 20) } : {},
-					...sp["after"] != null ? { after: Math.round(sp["after"] * 20) } : {},
-					...sp["line"] != null ? {
-						line: Math.round(lr === "auto" ? sp["line"] * 240 : sp["line"] * 20),
-						lineRule: lr
-					} : {}
-				};
-				await resolveDocOperation(doc, "format.paragraph.setSpacing")?.({
-					target,
-					...rawSpacing
-				});
-			}
-			if (indentation) {
-				const rawIndentation = {
-					...indentation.left != null ? { left: pointsToTwips(indentation.left) } : {},
-					...indentation.right != null ? { right: pointsToTwips(indentation.right) } : {},
-					...indentation.firstLine != null ? { firstLine: pointsToTwips(indentation.firstLine) } : {},
-					...indentation.hanging != null ? { hanging: pointsToTwips(indentation.hanging) } : {}
+				}, inlineOptions);
+			}
+		}
+		if (snap.paragraph) {
+			const batchSupported = (await resolveDocOperation(doc, "capabilities.get")?.())?.operations?.["format.paragraph.applyBatch"]?.available === true && Boolean(resolveDocOperation(doc, "format.paragraph.applyBatch"));
+			const batchTargets = [];
+			const { styleId, operations, markRunProps, numbering, listStyle } = snap.paragraph;
+			const batchOperations = [
+				...styleId ? [{
+					operationId: "styles.paragraph.setStyleRef",
+					input: { styleId }
+				}] : [{
+					operationId: "styles.paragraph.clearStyle",
+					input: {}
+				}],
+				...operations,
+				...markRunProps ? [{
+					operationId: "format.paragraph.setMarkRunProps",
+					input: { markRunProps }
+				}] : []
+			];
+			for (const segment of formatPainterParagraphSegments(segments, Boolean(tableCellSelection))) {
+				const blockAddress = paragraphTarget(segment.blockId, targetStory);
+				const nodeResult = await readBlockNode(blockAddress);
+				const node = nodeResult?.node;
+				const para = node ? getParagraphLikeData(node) : null;
+				if (!para) continue;
+				const target = {
+					...blockAddress,
+					nodeType: (nodeResult?.address)?.nodeType ?? node?.kind ?? "paragraph"
 				};
-				await resolveDocOperation(doc, "format.paragraph.setIndentation")?.({
+				if (batchSupported) batchTargets.push(target);
+				else {
+					if (styleId) add("styles.paragraph.setStyleRef", {
+						target,
+						styleId
+					});
+					else if (para.styleRef) add("styles.paragraph.clearStyle", { target });
+					for (const operation of operations) add(operation.operationId, {
+						target,
+						...operation.input
+					});
+					if (markRunProps) add("format.paragraph.setMarkRunProps", {
+						target,
+						markRunProps
+					});
+				}
+				if (numbering) add("format.paragraph.setNumbering", {
 					target,
-					...rawIndentation
+					...numbering
 				});
-			}
-			if (markRunProps) await resolveDocOperation(doc, "format.paragraph.setMarkRunProps")?.({
-				target,
-				markRunProps
-			});
-			if (numbering) await resolveDocOperation(doc, "format.paragraph.setNumbering")?.({
-				target,
-				...numbering
-			});
-			if (listStyle) {
-				if (((await readBlockNode(blockAddress))?.["address"])?.["nodeType"] === "listItem") await resolveDocOperation(doc, "lists.applyStyle")?.({
+				if (listStyle && target.nodeType === "listItem") add("lists.applyStyle", {
 					target: listItemTarget(segment.blockId, targetStory),
 					style: listStyle
 				});
-				else if (numbering) await resolveDocOperation(doc, "format.paragraph.setNumbering")?.({
-					target,
-					...numbering
+			}
+			if (batchSupported) {
+				if (batchTargets.length * batchOperations.length > 32e3) {
+					recompute();
+					return;
+				}
+				let payloadBytes = 0;
+				for (let index = 0; index < batchTargets.length; index += PARAGRAPH_BATCH_MAX_TARGETS) {
+					const input = {
+						targets: batchTargets.slice(index, index + PARAGRAPH_BATCH_MAX_TARGETS),
+						operations: batchOperations
+					};
+					payloadBytes += new TextEncoder().encode(JSON.stringify(input)).length;
+					if (payloadBytes > 1048576) {
+						recompute();
+						return;
+					}
+					add("format.paragraph.applyBatch", input);
+				}
+			}
+		}
+		if (disposed || painter.snapshot !== snap || getEditor() !== ownerEditor || ownerEditor?.doc !== ownerDoc || readDocumentMode() !== ownerMode || readDocumentMode() === "viewing") return;
+		const currentLocks = computeActiveContentControlLockModes(doc.contentControls, targetSelection);
+		if (contentControlLockReason(currentLocks.lockModesById)) return;
+		try {
+			const execute = resolveDocOperation(doc, "plan.execute");
+			if (entries.length === 1 && entries[0].operationId === "format.apply") {
+				const apply = resolveDocOperation(doc, "format.apply");
+				if (!apply) return;
+				if (!commandResultSucceeded(commandResultFromOperationResult(await apply(entries[0].input, entries[0].options)))) {
+					recompute();
+					return;
+				}
+			} else if (execute) {
+				const result = await execute({
+					atomic: true,
+					entries
 				});
+				if (!result || result.failure || result.success === false) {
+					recompute();
+					return;
+				}
+			} else {
+				if (ownerEditor?.editorVersion === 2) return;
+				for (const entry of entries) {
+					const operation = resolveDocOperation(doc, entry.operationId);
+					if (!operation) continue;
+					if (!commandResultSucceeded(commandResultFromOperationResult(entry.options ? await operation(entry.input, entry.options) : await operation(entry.input)))) {
+						recompute();
+						return;
+					}
+				}
 			}
+		} catch {
+			recompute();
+			return;
 		}
+		if (disposed || painter.snapshot !== snap || getEditor() !== ownerEditor || ownerEditor?.doc !== ownerDoc || readDocumentMode() !== ownerMode) return;
 		if (painter.mode === "armed") exitFormatPainter();
 		recompute();
 	};