@office-kit/xlsx 0.8.0

package/dist/cell-style-BEDjMX1y.mjs

@@ -0,0 +1,1579 @@
+import { o as OpenXmlSchemaError } from "./exceptions-D-CFwxgm.mjs";
+import { Cn as parseRange, bt as setCell, ln as makeColor, nn as colorToHex } from "./worksheet-CmCNoIgD.mjs";
+//#region src/utils/stable-stringify.ts
+const sortKeysReplacer = (_key, value) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+	const obj = value;
+	const keys = Object.keys(obj).sort();
+	const out = {};
+	for (const k of keys) out[k] = obj[k];
+	return out;
+};
+/**
+* Stringify `value` with object keys sorted recursively. Equal logical
+* values produce the same string regardless of insertion order; arrays
+* preserve their element order. Circular references throw (the error
+* comes straight from JSON.stringify's stack-overflow check).
+*/
+function stableStringify(value) {
+	return JSON.stringify(value, sortKeysReplacer);
+}
+//#endregion
+//#region src/styles/alignment.ts
+const HORIZONTAL_ALIGNMENTS = Object.freeze([
+	"general",
+	"left",
+	"center",
+	"right",
+	"fill",
+	"justify",
+	"centerContinuous",
+	"distributed"
+]);
+const VERTICAL_ALIGNMENTS = Object.freeze([
+	"top",
+	"center",
+	"bottom",
+	"justify",
+	"distributed"
+]);
+const HORIZONTAL_SET = new Set(HORIZONTAL_ALIGNMENTS);
+const VERTICAL_SET = new Set(VERTICAL_ALIGNMENTS);
+function makeAlignment(opts = {}) {
+	const out = {};
+	if (opts.horizontal !== void 0) {
+		if (!HORIZONTAL_SET.has(opts.horizontal)) throw new OpenXmlSchemaError(`Alignment horizontal must be one of [${HORIZONTAL_ALIGNMENTS.join(", ")}]; got "${opts.horizontal}"`);
+		out.horizontal = opts.horizontal;
+	}
+	if (opts.vertical !== void 0) {
+		if (!VERTICAL_SET.has(opts.vertical)) throw new OpenXmlSchemaError(`Alignment vertical must be one of [${VERTICAL_ALIGNMENTS.join(", ")}]; got "${opts.vertical}"`);
+		out.vertical = opts.vertical;
+	}
+	if (opts.textRotation !== void 0) {
+		const r = opts.textRotation;
+		if (!Number.isInteger(r) || r < 0 || r > 180 && r !== 255) throw new OpenXmlSchemaError(`Alignment textRotation must be 0..180 or 255; got ${r}`);
+		out.textRotation = r;
+	}
+	if (opts.wrapText !== void 0) out.wrapText = opts.wrapText;
+	if (opts.shrinkToFit !== void 0) out.shrinkToFit = opts.shrinkToFit;
+	if (opts.indent !== void 0) {
+		if (!Number.isFinite(opts.indent) || opts.indent < 0 || opts.indent > 255) throw new OpenXmlSchemaError(`Alignment indent must be 0..255; got ${opts.indent}`);
+		out.indent = opts.indent;
+	}
+	if (opts.relativeIndent !== void 0) {
+		const r = opts.relativeIndent;
+		if (!Number.isFinite(r) || r < -255 || r > 255) throw new OpenXmlSchemaError(`Alignment relativeIndent must be -255..255; got ${r}`);
+		out.relativeIndent = r;
+	}
+	if (opts.justifyLastLine !== void 0) out.justifyLastLine = opts.justifyLastLine;
+	if (opts.readingOrder !== void 0) {
+		if (!Number.isFinite(opts.readingOrder) || opts.readingOrder < 0) throw new OpenXmlSchemaError(`Alignment readingOrder must be >= 0; got ${opts.readingOrder}`);
+		out.readingOrder = opts.readingOrder;
+	}
+	return Object.freeze(out);
+}
+makeAlignment();
+const HORIZONTAL_TO_TEXT_ALIGN = {
+	general: void 0,
+	left: "left",
+	center: "center",
+	right: "right",
+	fill: "left",
+	justify: "justify",
+	centerContinuous: "center",
+	distributed: "justify"
+};
+const VERTICAL_TO_VERTICAL_ALIGN = {
+	top: "top",
+	center: "middle",
+	bottom: "bottom",
+	justify: "middle",
+	distributed: "middle"
+};
+/**
+* Translate an {@link Alignment} to a CSS-property record suitable for
+* HTML preview. `horizontal` → `text-align`, `vertical` →
+* `vertical-align` (table-cell semantics), `wrapText` → `white-space:
+* pre-wrap`, `textRotation` → `transform: rotate(<-deg>)` (Excel rotates
+* counter-clockwise relative to CSS) plus `transform-origin` to keep
+* the text anchored, and `indent` → `padding-left: <n>em`. `255`
+* stacked-text rotation maps to a 180° flip with `writing-mode`.
+*
+* Empty / undefined Alignment returns `{}`.
+*/
+function alignmentToCss(alignment) {
+	const css = {};
+	if (!alignment) return css;
+	if (alignment.horizontal !== void 0) {
+		const ta = HORIZONTAL_TO_TEXT_ALIGN[alignment.horizontal];
+		if (ta !== void 0) css["text-align"] = ta;
+	}
+	if (alignment.vertical !== void 0) {
+		const va = VERTICAL_TO_VERTICAL_ALIGN[alignment.vertical];
+		if (va !== void 0) css["vertical-align"] = va;
+	}
+	if (alignment.wrapText) css["white-space"] = "pre-wrap";
+	if (alignment.textRotation !== void 0) {
+		if (alignment.textRotation === 255) css["writing-mode"] = "vertical-rl";
+		else if (alignment.textRotation !== 0) {
+			css["transform"] = `rotate(-${alignment.textRotation}deg)`;
+			css["transform-origin"] = "center center";
+		}
+	}
+	if (alignment.indent !== void 0 && alignment.indent > 0) css["padding-left"] = `${alignment.indent}em`;
+	return css;
+}
+//#endregion
+//#region src/styles/borders.ts
+const SIDE_STYLES = Object.freeze([
+	"thin",
+	"medium",
+	"thick",
+	"double",
+	"hair",
+	"dotted",
+	"dashed",
+	"dashDot",
+	"dashDotDot",
+	"mediumDashed",
+	"mediumDashDot",
+	"mediumDashDotDot",
+	"slantDashDot"
+]);
+const SIDE_STYLE_SET = new Set(SIDE_STYLES);
+/** Build an immutable {@link Side}. */
+function makeSide(opts = {}) {
+	const out = {};
+	if (opts.style !== void 0) {
+		if (!SIDE_STYLE_SET.has(opts.style)) throw new OpenXmlSchemaError(`Side style must be one of [${SIDE_STYLES.join(", ")}]; got "${opts.style}"`);
+		out.style = opts.style;
+	}
+	if (opts.color !== void 0) out.color = Object.isFrozen(opts.color) ? opts.color : makeColor(opts.color);
+	return Object.freeze(out);
+}
+/** Build an immutable {@link Border}. */
+function makeBorder(opts = {}) {
+	const out = {};
+	if (opts.left !== void 0) out.left = freezeSide(opts.left);
+	if (opts.right !== void 0) out.right = freezeSide(opts.right);
+	if (opts.top !== void 0) out.top = freezeSide(opts.top);
+	if (opts.bottom !== void 0) out.bottom = freezeSide(opts.bottom);
+	if (opts.diagonal !== void 0) out.diagonal = freezeSide(opts.diagonal);
+	if (opts.vertical !== void 0) out.vertical = freezeSide(opts.vertical);
+	if (opts.horizontal !== void 0) out.horizontal = freezeSide(opts.horizontal);
+	if (opts.diagonalUp !== void 0) out.diagonalUp = opts.diagonalUp;
+	if (opts.diagonalDown !== void 0) out.diagonalDown = opts.diagonalDown;
+	if (opts.outline !== void 0) out.outline = opts.outline;
+	return Object.freeze(out);
+}
+const freezeSide = (s) => Object.isFrozen(s) ? s : makeSide(s);
+makeSide();
+/** Default empty border — every cell starts here until styled otherwise. */
+const DEFAULT_BORDER = makeBorder();
+/**
+* Map an Excel {@link SideStyle} to a CSS `border` shorthand fragment (`<width>
+* <style>`). Returns `undefined` for unmappable styles or a missing/no-style
+* side. Colour is appended by the caller.
+*/
+function sideStyleToCss(style) {
+	switch (style) {
+		case "thin":
+		case "hair": return "1px solid";
+		case "medium": return "2px solid";
+		case "thick": return "3px solid";
+		case "double": return "3px double";
+		case "dotted": return "1px dotted";
+		case "dashed":
+		case "dashDot":
+		case "dashDotDot": return "1px dashed";
+		case "mediumDashed":
+		case "mediumDashDot":
+		case "mediumDashDotDot":
+		case "slantDashDot": return "2px dashed";
+		default: return;
+	}
+}
+/**
+* Translate a {@link Border} to a CSS-property record suitable for HTML
+* preview. Each present side becomes `border-<edge>: <width> <style> <#color>`.
+* Theme/auto/missing colours fall back to `currentColor`. Diagonal / vertical /
+* horizontal sides are skipped (CSS has no native equivalent for in-cell
+* strokes). Empty Border returns `{}`.
+*/
+function borderToCss(border) {
+	const css = {};
+	if (!border) return css;
+	const sides = [
+		["top", border.top],
+		["right", border.right],
+		["bottom", border.bottom],
+		["left", border.left]
+	];
+	for (const [edge, side] of sides) {
+		if (!side) continue;
+		const stroke = sideStyleToCss(side.style);
+		if (stroke === void 0) continue;
+		const argb = colorToHex(side.color);
+		const colour = argb !== void 0 ? `#${argb.slice(2)}` : "currentColor";
+		css[`border-${edge}`] = `${stroke} ${colour}`;
+	}
+	return css;
+}
+//#endregion
+//#region src/styles/fills.ts
+const PATTERN_TYPES = Object.freeze([
+	"none",
+	"solid",
+	"darkDown",
+	"darkGray",
+	"darkGrid",
+	"darkHorizontal",
+	"darkTrellis",
+	"darkUp",
+	"darkVertical",
+	"gray0625",
+	"gray125",
+	"lightDown",
+	"lightGray",
+	"lightGrid",
+	"lightHorizontal",
+	"lightTrellis",
+	"lightUp",
+	"lightVertical",
+	"mediumGray"
+]);
+const PATTERN_TYPE_SET = new Set(PATTERN_TYPES);
+function makePatternFill(opts = {}) {
+	const out = { kind: "pattern" };
+	if (opts.patternType !== void 0) {
+		if (!PATTERN_TYPE_SET.has(opts.patternType)) throw new OpenXmlSchemaError(`PatternFill patternType must be one of [${PATTERN_TYPES.join(", ")}]; got "${opts.patternType}"`);
+		out.patternType = opts.patternType;
+	}
+	if (opts.fgColor !== void 0) out.fgColor = freezeColor(opts.fgColor);
+	if (opts.bgColor !== void 0) out.bgColor = freezeColor(opts.bgColor);
+	return Object.freeze(out);
+}
+function makeGradientStop(position, color) {
+	if (!Number.isFinite(position) || position < 0 || position > 1) throw new OpenXmlSchemaError(`GradientStop position must be in [0, 1]; got ${position}`);
+	return Object.freeze({
+		position,
+		color: freezeColor(color)
+	});
+}
+function makeGradientFill(opts = {}) {
+	const out = {
+		kind: "gradient",
+		type: opts.type ?? "linear",
+		stops: opts.stops?.map((s) => freezeStop(s)) ?? []
+	};
+	if (out.type !== "linear" && out.type !== "path") throw new OpenXmlSchemaError(`GradientFill type must be "linear" or "path"; got "${String(out.type)}"`);
+	if (opts.degree !== void 0) out.degree = opts.degree;
+	if (opts.left !== void 0) out.left = opts.left;
+	if (opts.right !== void 0) out.right = opts.right;
+	if (opts.top !== void 0) out.top = opts.top;
+	if (opts.bottom !== void 0) out.bottom = opts.bottom;
+	Object.freeze(out.stops);
+	return Object.freeze(out);
+}
+/**
+* Single-arg constructor that defers to the variant-specific maker based on
+* `kind`. Useful when the caller has a plain object in hand and wants the
+* freeze invariant applied uniformly.
+*/
+function makeFill(opts) {
+	if (opts.kind === "gradient") return makeGradientFill(opts);
+	return makePatternFill(opts);
+}
+/** The empty PatternFill — Excel's default cellXf[0] points here. */
+const DEFAULT_EMPTY_FILL = makePatternFill();
+/** The 'gray125' PatternFill — Excel's default cellXf[1]. */
+const DEFAULT_GRAY_FILL = makePatternFill({ patternType: "gray125" });
+const freezeColor = (c) => Object.isFrozen(c) ? c : makeColor(c);
+const freezeStop = (s) => Object.isFrozen(s) ? s : makeGradientStop(s.position, s.color);
+const argbToCssHex = (color) => {
+	const argb = colorToHex(color);
+	return argb ? `#${argb.slice(2)}` : void 0;
+};
+/**
+* Translate a {@link Fill} to a CSS-property record suitable for HTML preview.
+* `'solid'` PatternFill renders as `background-color`, other pattern types
+* collapse to bgColor (CSS has no built-in equivalent of Excel hatch patterns).
+* GradientFill emits a CSS `background-image` with `linear-gradient(<angle>,
+* …)` for `type='linear'` or `radial-gradient(circle, …)` for `type='path'`.
+*
+* theme/auto colours and unresolvable inputs are skipped (returns `{}`) so
+* callers can spread without overwriting upstream defaults.
+*/
+function fillToCss(fill) {
+	const css = {};
+	if (!fill) return css;
+	if (fill.kind === "pattern") {
+		if (fill.patternType === "none" || fill.patternType === void 0) return css;
+		if (fill.patternType === "solid") {
+			const fg = argbToCssHex(fill.fgColor);
+			if (fg !== void 0) css["background-color"] = fg;
+			return css;
+		}
+		const bg = argbToCssHex(fill.bgColor) ?? argbToCssHex(fill.fgColor);
+		if (bg !== void 0) css["background-color"] = bg;
+		return css;
+	}
+	const stopParts = [];
+	for (const s of fill.stops) {
+		const hex = argbToCssHex(s.color);
+		if (hex === void 0) continue;
+		stopParts.push(`${hex} ${(s.position * 100).toFixed(2)}%`);
+	}
+	if (stopParts.length === 0) return css;
+	if (fill.type === "linear") css["background-image"] = `linear-gradient(${fill.degree ?? 0}deg, ${stopParts.join(", ")})`;
+	else css["background-image"] = `radial-gradient(circle, ${stopParts.join(", ")})`;
+	return css;
+}
+//#endregion
+//#region src/styles/fonts.ts
+const UNDERLINE_STYLES = Object.freeze([
+	"single",
+	"double",
+	"singleAccounting",
+	"doubleAccounting"
+]);
+const VERT_ALIGNS = Object.freeze([
+	"baseline",
+	"superscript",
+	"subscript"
+]);
+const FONT_SCHEMES = Object.freeze(["major", "minor"]);
+const UNDERLINE_SET = new Set(UNDERLINE_STYLES);
+const VERT_SET = new Set(VERT_ALIGNS);
+const SCHEME_SET = new Set(FONT_SCHEMES);
+function makeFont(opts = {}) {
+	const out = {};
+	if (opts.name !== void 0) {
+		if (typeof opts.name !== "string") throw new OpenXmlSchemaError(`Font name must be a string; got ${typeof opts.name}`);
+		out.name = opts.name;
+	}
+	if (opts.charset !== void 0) {
+		if (!Number.isInteger(opts.charset)) throw new OpenXmlSchemaError(`Font charset must be an integer; got ${opts.charset}`);
+		out.charset = opts.charset;
+	}
+	if (opts.family !== void 0) {
+		if (!Number.isInteger(opts.family) || opts.family < 0 || opts.family > 14) throw new OpenXmlSchemaError(`Font family must be 0..14; got ${opts.family}`);
+		out.family = opts.family;
+	}
+	if (opts.size !== void 0) {
+		if (!Number.isFinite(opts.size) || opts.size <= 0) throw new OpenXmlSchemaError(`Font size must be positive; got ${opts.size}`);
+		out.size = opts.size;
+	}
+	if (opts.color !== void 0) out.color = Object.isFrozen(opts.color) ? opts.color : makeColor(opts.color);
+	if (opts.bold !== void 0) out.bold = opts.bold;
+	if (opts.italic !== void 0) out.italic = opts.italic;
+	if (opts.strike !== void 0) out.strike = opts.strike;
+	if (opts.outline !== void 0) out.outline = opts.outline;
+	if (opts.shadow !== void 0) out.shadow = opts.shadow;
+	if (opts.condense !== void 0) out.condense = opts.condense;
+	if (opts.extend !== void 0) out.extend = opts.extend;
+	if (opts.underline !== void 0) {
+		if (!UNDERLINE_SET.has(opts.underline)) throw new OpenXmlSchemaError(`Font underline must be one of [${UNDERLINE_STYLES.join(", ")}]; got "${opts.underline}"`);
+		out.underline = opts.underline;
+	}
+	if (opts.vertAlign !== void 0) {
+		if (!VERT_SET.has(opts.vertAlign)) throw new OpenXmlSchemaError(`Font vertAlign must be one of [${VERT_ALIGNS.join(", ")}]; got "${opts.vertAlign}"`);
+		out.vertAlign = opts.vertAlign;
+	}
+	if (opts.scheme !== void 0) {
+		if (!SCHEME_SET.has(opts.scheme)) throw new OpenXmlSchemaError(`Font scheme must be one of [${FONT_SCHEMES.join(", ")}]; got "${opts.scheme}"`);
+		out.scheme = opts.scheme;
+	}
+	return Object.freeze(out);
+}
+/** Excel's default cell font: Calibri 11, minor scheme, theme=1 colour. */
+const DEFAULT_FONT = makeFont({
+	name: "Calibri",
+	size: 11,
+	family: 2,
+	scheme: "minor",
+	color: makeColor({ theme: 1 })
+});
+/**
+* Translate a {@link Font} to a CSS-property record suitable for HTML
+* rendering / preview. Boolean toggles map to weight/style/decoration,
+* `size` becomes `font-size: <n>pt`, and an explicit rgb/indexed
+* `color` is rendered as `#RRGGBB` (alpha dropped). theme/auto colours
+* are skipped — callers without a theme can't resolve them.
+*
+* `vertAlign='superscript'|'subscript'` lowers `font-size` to 0.83em
+* (W3C convention) and sets `vertical-align`.
+*
+* Returns `{}` for an empty Font so callers can spread it without
+* overwriting upstream defaults.
+*/
+function fontToCss(font) {
+	const css = {};
+	if (!font) return css;
+	if (font.name !== void 0) css["font-family"] = `'${font.name.replace(/'/g, "\\'")}'`;
+	if (font.size !== void 0) css["font-size"] = `${font.size}pt`;
+	if (font.bold) css["font-weight"] = "bold";
+	if (font.italic) css["font-style"] = "italic";
+	const decorations = [];
+	if (font.underline !== void 0) decorations.push("underline");
+	if (font.strike) decorations.push("line-through");
+	if (decorations.length > 0) css["text-decoration"] = decorations.join(" ");
+	if (font.color !== void 0) {
+		const argb = colorToHex(font.color);
+		if (argb !== void 0) css["color"] = `#${argb.slice(2)}`;
+	}
+	if (font.vertAlign === "superscript" || font.vertAlign === "subscript") {
+		css["vertical-align"] = font.vertAlign;
+		if (css["font-size"] === void 0) css["font-size"] = "0.83em";
+	}
+	return css;
+}
+//#endregion
+//#region src/styles/numbers.ts
+/** Canonical OOXML built-in number formats — verbatim from openpyxl. */
+const BUILTIN_FORMATS = Object.freeze({
+	0: "General",
+	1: "0",
+	2: "0.00",
+	3: "#,##0",
+	4: "#,##0.00",
+	5: "\"$\"#,##0_);(\"$\"#,##0)",
+	6: "\"$\"#,##0_);[Red](\"$\"#,##0)",
+	7: "\"$\"#,##0.00_);(\"$\"#,##0.00)",
+	8: "\"$\"#,##0.00_);[Red](\"$\"#,##0.00)",
+	9: "0%",
+	10: "0.00%",
+	11: "0.00E+00",
+	12: "# ?/?",
+	13: "# ??/??",
+	14: "mm-dd-yy",
+	15: "d-mmm-yy",
+	16: "d-mmm",
+	17: "mmm-yy",
+	18: "h:mm AM/PM",
+	19: "h:mm:ss AM/PM",
+	20: "h:mm",
+	21: "h:mm:ss",
+	22: "m/d/yy h:mm",
+	37: "#,##0_);(#,##0)",
+	38: "#,##0_);[Red](#,##0)",
+	39: "#,##0.00_);(#,##0.00)",
+	40: "#,##0.00_);[Red](#,##0.00)",
+	41: "_(* #,##0_);_(* \\(#,##0\\);_(* \"-\"_);_(@_)",
+	42: "_(\"$\"* #,##0_);_(\"$\"* \\(#,##0\\);_(\"$\"* \"-\"_);_(@_)",
+	43: "_(* #,##0.00_);_(* \\(#,##0.00\\);_(* \"-\"??_);_(@_)",
+	44: "_(\"$\"* #,##0.00_)_(\"$\"* \\(#,##0.00\\)_(\"$\"* \"-\"??_)_(@_)",
+	45: "mm:ss",
+	46: "[h]:mm:ss",
+	47: "mmss.0",
+	48: "##0.0E+0",
+	49: "@"
+});
+/** First numFmtId Excel reserves for user-defined formats. */
+const BUILTIN_FORMATS_MAX_SIZE = 164;
+const REVERSE = new Map(Object.entries(BUILTIN_FORMATS).map(([k, v]) => [v, Number(k)]));
+const FORMAT_GENERAL = "General";
+const FORMAT_TEXT = "@";
+const FORMAT_NUMBER = "0";
+const FORMAT_NUMBER_00 = "0.00";
+const FORMAT_PERCENTAGE = "0%";
+const FORMAT_PERCENTAGE_00 = "0.00%";
+const FORMAT_DATE_DATETIME = "yyyy-mm-dd h:mm:ss";
+const FORMAT_DATE_TIMEDELTA = "[hh]:mm:ss";
+const FORMAT_DATE_YYYYMMDD2 = "yyyy-mm-dd";
+/** Look up the format code for a given numFmtId, or `undefined` if unknown. */
+function builtinFormatCode(id) {
+	return Object.hasOwn(BUILTIN_FORMATS, id) ? BUILTIN_FORMATS[id] : void 0;
+}
+/** Look up the numFmtId for a given format code, or `undefined` if not built-in. */
+function builtinFormatId(code) {
+	return REVERSE.get(code);
+}
+/** True iff `code` is one of the OOXML built-in format strings. */
+function isBuiltinFormat(code) {
+	return REVERSE.has(code);
+}
+const STRIP_RE = new RegExp(`\\[(BLACK|BLUE|CYAN|GREEN|MAGENTA|RED|WHITE|YELLOW)\\]|"[^"]*"|\\[(?!hh?\\]|mm?\\]|ss?\\])[^\\]]*\\]`, "g");
+const DATE_TOKEN_RE = /(?<![_\\])[dmhysDMHYS]/;
+const TIMEDELTA_RE = /\[hh?\](:mm(:ss(\.0*)?)?)?|\[mm?\](:ss(\.0*)?)?|\[ss?\](\.0*)?/i;
+/**
+* Heuristic: does the format string imply a date / time interpretation?
+* Looks at only the first format section (positive-value branch); strips
+* literals, colour codes and locale modifiers before scanning for date
+* tokens (d/m/h/y/s, case-insensitive) that aren't escaped.
+*/
+function isDateFormat(code) {
+	if (code == null) return false;
+	const stripped = (code.split(";")[0] ?? "").replace(STRIP_RE, "");
+	return DATE_TOKEN_RE.test(stripped);
+}
+/** Heuristic: does the format string indicate a duration ([h]:mm:ss etc.)? */
+function isTimedeltaFormat(code) {
+	if (code == null) return false;
+	const head = code.split(";")[0] ?? "";
+	return TIMEDELTA_RE.test(head);
+}
+/** Categorise a date format as 'date', 'time', 'datetime' or undefined. */
+function classifyDateFormat(code) {
+	if (!isDateFormat(code)) return void 0;
+	const stripped = (code.split(";")[0] ?? "").replace(STRIP_RE, "");
+	let date = false;
+	let time = false;
+	for (const ch of stripped) {
+		if (ch === "d" || ch === "D" || ch === "y" || ch === "Y") date = true;
+		else if (ch === "h" || ch === "H" || ch === "s" || ch === "S") time = true;
+		if (date && time) break;
+	}
+	if (date && time) return "datetime";
+	if (date) return "date";
+	return "time";
+}
+function makeNumberFormat(opts) {
+	if (!Number.isInteger(opts.numFmtId) || opts.numFmtId < 0) throw new OpenXmlSchemaError(`NumberFormat numFmtId must be a non-negative integer; got ${opts.numFmtId}`);
+	if (typeof opts.formatCode !== "string") throw new OpenXmlSchemaError("NumberFormat formatCode must be a string");
+	return Object.freeze({
+		numFmtId: opts.numFmtId,
+		formatCode: opts.formatCode
+	});
+}
+//#endregion
+//#region src/styles/stylesheet.ts
+/**
+* Build a fresh Stylesheet pre-populated with Excel's required default entries.
+* Mirrors openpyxl's empty Stylesheet: fonts: [DEFAULT_FONT] (index 0) fills:
+* [DEFAULT_EMPTY_FILL,
+*             DEFAULT_GRAY_FILL]          (indices 0, 1 — required)
+* borders: [DEFAULT_BORDER] (index 0) cellXfs: empty (indices allocated on
+* demand)
+*/
+function makeStylesheet() {
+	const fontKey = stableStringify(DEFAULT_FONT);
+	const fill0Key = stableStringify(DEFAULT_EMPTY_FILL);
+	const fill1Key = stableStringify(DEFAULT_GRAY_FILL);
+	const borderKey = stableStringify(DEFAULT_BORDER);
+	return {
+		fonts: [DEFAULT_FONT],
+		fills: [DEFAULT_EMPTY_FILL, DEFAULT_GRAY_FILL],
+		borders: [DEFAULT_BORDER],
+		numFmts: /* @__PURE__ */ new Map(),
+		cellXfs: [],
+		cellStyleXfs: [],
+		_fontIdByKey: new Map([[fontKey, 0]]),
+		_fillIdByKey: new Map([[fill0Key, 0], [fill1Key, 1]]),
+		_borderIdByKey: new Map([[borderKey, 0]]),
+		_xfIdByKey: /* @__PURE__ */ new Map(),
+		_styleXfIdByKey: /* @__PURE__ */ new Map(),
+		_numFmtIdByCode: /* @__PURE__ */ new Map()
+	};
+}
+/** Add a Font to the pool, returning its 0-based index. Idempotent. */
+function addFont(ss, font) {
+	return addToPool(font, ss.fonts, ss._fontIdByKey);
+}
+/** Add a Fill to the pool, returning its 0-based index. Idempotent. */
+function addFill(ss, fill) {
+	return addToPool(fill, ss.fills, ss._fillIdByKey);
+}
+/** Add a Border to the pool, returning its 0-based index. Idempotent. */
+function addBorder(ss, border) {
+	return addToPool(border, ss.borders, ss._borderIdByKey);
+}
+/**
+* Resolve a number-format string to its numFmtId.
+* - Built-in codes return their canonical OOXML ID.
+* - Otherwise the custom code is registered (and allocated an ID
+* ≥ {@link BUILTIN_FORMATS_MAX_SIZE}). Idempotent.
+*/
+function addNumFmt(ss, formatCode) {
+	const builtin = builtinFormatId(formatCode);
+	if (builtin !== void 0) return builtin;
+	const cached = ss._numFmtIdByCode.get(formatCode);
+	if (cached !== void 0) return cached;
+	const id = 164 + ss.numFmts.size;
+	ss.numFmts.set(id, formatCode);
+	ss._numFmtIdByCode.set(formatCode, id);
+	return id;
+}
+/** Add a CellXf to the cellXfs pool, returning its 0-based index. Idempotent. */
+function addCellXf(ss, xf) {
+	validateCellXfRefs(ss, xf, false);
+	return addToPool(xf, ss.cellXfs, ss._xfIdByKey);
+}
+/** Add a CellXf to the cellStyleXfs pool. Idempotent. */
+function addCellStyleXf(ss, xf) {
+	validateCellXfRefs(ss, xf, true);
+	return addToPool(xf, ss.cellStyleXfs, ss._styleXfIdByKey);
+}
+const addToPool = (value, pool, byKey) => {
+	const key = stableStringify(value);
+	const cached = byKey.get(key);
+	if (cached !== void 0) return cached;
+	const id = pool.length;
+	pool.push(value);
+	byKey.set(key, id);
+	return id;
+};
+const validateCellXfRefs = (ss, xf, isStyle) => {
+	if (xf.fontId < 0 || xf.fontId >= ss.fonts.length) throw new OpenXmlSchemaError(`CellXf.fontId ${xf.fontId} out of range [0, ${ss.fonts.length})`);
+	if (xf.fillId < 0 || xf.fillId >= ss.fills.length) throw new OpenXmlSchemaError(`CellXf.fillId ${xf.fillId} out of range [0, ${ss.fills.length})`);
+	if (xf.borderId < 0 || xf.borderId >= ss.borders.length) throw new OpenXmlSchemaError(`CellXf.borderId ${xf.borderId} out of range [0, ${ss.borders.length})`);
+	if (!Number.isInteger(xf.numFmtId) || xf.numFmtId < 0) throw new OpenXmlSchemaError(`CellXf.numFmtId must be a non-negative integer; got ${xf.numFmtId}`);
+	if (!isStyle && xf.xfId !== void 0) {
+		if (xf.xfId < 0 || xf.xfId >= ss.cellStyleXfs.length) throw new OpenXmlSchemaError(`CellXf.xfId ${xf.xfId} out of range [0, ${ss.cellStyleXfs.length})`);
+	}
+};
+/** Read-only snapshot of every Font entry in the pool, indexed by id. */
+function listFonts(ss) {
+	return ss.fonts;
+}
+/** Read-only snapshot of every Fill entry in the pool, indexed by id. */
+function listFills(ss) {
+	return ss.fills;
+}
+/** Read-only snapshot of every Border entry in the pool, indexed by id. */
+function listBorders(ss) {
+	return ss.borders;
+}
+/** Read-only snapshot of every CellXf entry in the cellXfs pool. */
+function listCellXfs(ss) {
+	return ss.cellXfs;
+}
+/** Read-only snapshot of every CellStyleXf entry (named-style xfs). */
+function listCellStyleXfs(ss) {
+	return ss.cellStyleXfs;
+}
+/**
+* Convenience: build the default `cellXfs[0]` Excel emits — points at the
+* workbook's font 0 / fill 0 / border 0 / numFmtId 0 (General).
+*/
+function defaultCellXf() {
+	return Object.freeze({
+		fontId: 0,
+		fillId: 0,
+		borderId: 0,
+		numFmtId: 0
+	});
+}
+//#endregion
+//#region src/styles/named-styles.ts
+/**
+* Register a NamedStyle on the Stylesheet:
+*  1. add Font / Fill / Border / NumberFormat to their pools
+*  2. push a CellXf with apply* flags into cellStyleXfs
+*  3. append a {name, xfId, builtinId} entry into the workbook's
+*     namedStyles list (caller-managed; this function returns the
+*     xfId so callers can connect the dots)
+* Idempotent on (name): re-registering by the same name returns the
+* cached xfId.
+*/
+function addNamedStyle(ss, style) {
+	const cached = ss._namedStyleByName?.get(style.name);
+	if (cached !== void 0) return cached.xfId;
+	const xfId = addCellStyleXf(ss, {
+		fontId: style.font !== void 0 ? addFont(ss, style.font) : 0,
+		fillId: style.fill !== void 0 ? addFill(ss, style.fill) : 0,
+		borderId: style.border !== void 0 ? addBorder(ss, style.border) : 0,
+		numFmtId: style.numberFormat !== void 0 ? addNumFmt(ss, style.numberFormat) : 0,
+		...style.alignment !== void 0 ? { alignment: style.alignment } : {},
+		...style.protection !== void 0 ? { protection: style.protection } : {}
+	});
+	if (ss._namedStyleByName === void 0) ss._namedStyleByName = /* @__PURE__ */ new Map();
+	if (ss.namedStyles === void 0) ss.namedStyles = [];
+	const entry = {
+		name: style.name,
+		xfId,
+		...style.builtinId !== void 0 ? { builtinId: style.builtinId } : {},
+		...style.customBuiltin !== void 0 ? { customBuiltin: style.customBuiltin } : {},
+		...style.hidden !== void 0 ? { hidden: style.hidden } : {},
+		...style.iLevel !== void 0 ? { iLevel: style.iLevel } : {}
+	};
+	ss.namedStyles.push(entry);
+	ss._namedStyleByName.set(style.name, entry);
+	return xfId;
+}
+const BODY_FONT = makeFont({
+	name: "Calibri",
+	family: 2,
+	size: 12,
+	color: makeColor({ theme: 1 }),
+	scheme: "minor"
+});
+const fillRgb = (rgb, fg = true) => makePatternFill(fg ? {
+	patternType: "solid",
+	bgColor: makeColor({ rgb }),
+	fgColor: makeColor({ rgb })
+} : { patternType: "solid" });
+/** Curated subset of openpyxl's `styles` dict. Keys match the user-visible names. */
+const BUILTIN_NAMED_STYLES = Object.freeze({
+	Normal: {
+		name: "Normal",
+		builtinId: 0,
+		font: BODY_FONT
+	},
+	Good: {
+		name: "Good",
+		builtinId: 26,
+		font: makeFont({
+			...BODY_FONT,
+			color: makeColor({ rgb: "FF006100" })
+		}),
+		fill: fillRgb("FFC6EFCE")
+	},
+	Bad: {
+		name: "Bad",
+		builtinId: 27,
+		font: makeFont({
+			...BODY_FONT,
+			color: makeColor({ rgb: "FF9C0006" })
+		}),
+		fill: fillRgb("FFFFC7CE")
+	},
+	Neutral: {
+		name: "Neutral",
+		builtinId: 28,
+		font: makeFont({
+			...BODY_FONT,
+			color: makeColor({ rgb: "FF9C5700" })
+		}),
+		fill: fillRgb("FFFFEB9C")
+	},
+	Calculation: {
+		name: "Calculation",
+		builtinId: 22,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true,
+			color: makeColor({ rgb: "FFFA7D00" })
+		}),
+		fill: fillRgb("FFF2F2F2")
+	},
+	"Check Cell": {
+		name: "Check Cell",
+		builtinId: 23,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true,
+			color: makeColor({ rgb: "FFFFFFFF" })
+		}),
+		fill: fillRgb("FFA5A5A5")
+	},
+	"Linked Cell": {
+		name: "Linked Cell",
+		builtinId: 24,
+		font: makeFont({
+			...BODY_FONT,
+			color: makeColor({ rgb: "FFFA7D00" })
+		})
+	},
+	Note: {
+		name: "Note",
+		builtinId: 10,
+		font: BODY_FONT,
+		fill: fillRgb("FFFFFFC0")
+	},
+	"Warning Text": {
+		name: "Warning Text",
+		builtinId: 11,
+		font: makeFont({
+			...BODY_FONT,
+			color: makeColor({ rgb: "FFFF0000" })
+		})
+	},
+	Input: {
+		name: "Input",
+		builtinId: 20,
+		font: makeFont({
+			...BODY_FONT,
+			color: makeColor({ rgb: "FF3F3F76" })
+		}),
+		fill: fillRgb("FFFFCC99")
+	},
+	Output: {
+		name: "Output",
+		builtinId: 21,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true,
+			color: makeColor({ rgb: "FF3F3F3F" })
+		}),
+		fill: fillRgb("FFF2F2F2")
+	},
+	"Explanatory Text": {
+		name: "Explanatory Text",
+		builtinId: 53,
+		font: makeFont({
+			...BODY_FONT,
+			italic: true,
+			color: makeColor({ rgb: "FF7F7F7F" })
+		})
+	},
+	Title: {
+		name: "Title",
+		builtinId: 15,
+		font: makeFont({
+			name: "Cambria",
+			family: 2,
+			size: 18,
+			scheme: "major",
+			color: makeColor({ theme: 3 })
+		})
+	},
+	"Headline 1": {
+		name: "Headline 1",
+		builtinId: 16,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true,
+			size: 15,
+			color: makeColor({ theme: 3 })
+		})
+	},
+	"Headline 2": {
+		name: "Headline 2",
+		builtinId: 17,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true,
+			size: 13,
+			color: makeColor({ theme: 3 })
+		})
+	},
+	"Headline 3": {
+		name: "Headline 3",
+		builtinId: 18,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true,
+			color: makeColor({ theme: 3 })
+		})
+	},
+	"Headline 4": {
+		name: "Headline 4",
+		builtinId: 19,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true,
+			italic: true,
+			color: makeColor({ theme: 3 })
+		})
+	},
+	Total: {
+		name: "Total",
+		builtinId: 25,
+		font: makeFont({
+			...BODY_FONT,
+			bold: true
+		})
+	},
+	Comma: {
+		name: "Comma",
+		builtinId: 3,
+		font: BODY_FONT,
+		numberFormat: "#,##0.00"
+	},
+	"Comma [0]": {
+		name: "Comma [0]",
+		builtinId: 6,
+		font: BODY_FONT,
+		numberFormat: "#,##0"
+	},
+	Currency: {
+		name: "Currency",
+		builtinId: 4,
+		font: BODY_FONT,
+		numberFormat: "\"$\"#,##0.00"
+	},
+	"Currency [0]": {
+		name: "Currency [0]",
+		builtinId: 7,
+		font: BODY_FONT,
+		numberFormat: "\"$\"#,##0"
+	},
+	Percent: {
+		name: "Percent",
+		builtinId: 5,
+		font: BODY_FONT,
+		numberFormat: "0%"
+	},
+	Hyperlink: {
+		name: "Hyperlink",
+		builtinId: 8,
+		font: makeFont({
+			...BODY_FONT,
+			underline: "single",
+			color: makeColor({ theme: 10 })
+		})
+	},
+	"Followed Hyperlink": {
+		name: "Followed Hyperlink",
+		builtinId: 9,
+		font: makeFont({
+			...BODY_FONT,
+			underline: "single",
+			color: makeColor({ theme: 11 })
+		})
+	}
+});
+/**
+* Register a built-in style with the supplied Stylesheet (idempotent).
+* Returns the cellStyleXfs index. Throws OpenXmlSchemaError when the
+* name is unknown.
+*/
+function ensureBuiltinStyle(ss, name) {
+	const spec = BUILTIN_NAMED_STYLES[name];
+	if (spec === void 0) throw new OpenXmlSchemaError(`ensureBuiltinStyle: unknown built-in style "${String(name)}"`);
+	return addNamedStyle(ss, spec);
+}
+//#endregion
+//#region src/styles/protection.ts
+function makeProtection(opts = {}) {
+	const out = {};
+	if (opts.locked !== void 0) out.locked = opts.locked;
+	if (opts.hidden !== void 0) out.hidden = opts.hidden;
+	return Object.freeze(out);
+}
+/** Excel's Stylesheet always contains an entry equal to {locked:true, hidden:false}. */
+const DEFAULT_PROTECTION = makeProtection({
+	locked: true,
+	hidden: false
+});
+//#endregion
+//#region src/styles/cell-style.ts
+/** Default General number format code (numFmtId 0). */
+const GENERAL_FORMAT_CODE = "General";
+/** Resolve a cell's current CellXf, falling back to defaults when unset. */
+function currentXf(ss, c) {
+	return ss.cellXfs[c.styleId] ?? defaultCellXf();
+}
+function getCellFont(wb, c) {
+	const xf = currentXf(wb.styles, c);
+	return wb.styles.fonts[xf.fontId] ?? DEFAULT_FONT;
+}
+function getCellFill(wb, c) {
+	const xf = currentXf(wb.styles, c);
+	return wb.styles.fills[xf.fillId] ?? DEFAULT_EMPTY_FILL;
+}
+function getCellBorder(wb, c) {
+	const xf = currentXf(wb.styles, c);
+	return wb.styles.borders[xf.borderId] ?? DEFAULT_BORDER;
+}
+function getCellAlignment(wb, c) {
+	return currentXf(wb.styles, c).alignment ?? {};
+}
+function getCellProtection(wb, c) {
+	return currentXf(wb.styles, c).protection ?? DEFAULT_PROTECTION;
+}
+/**
+* Returns the cell's number-format **code** (e.g. `"0.00"`, `"General"`).
+* Built-in IDs resolve through `builtinFormatCode`; custom IDs come from the
+* workbook's numFmts map.
+*/
+function getCellNumberFormat(wb, c) {
+	const id = currentXf(wb.styles, c).numFmtId;
+	const builtin = builtinFormatCode(id);
+	if (builtin !== void 0) return builtin;
+	return wb.styles.numFmts.get(id) ?? GENERAL_FORMAT_CODE;
+}
+/**
+* Aggregate `fontToCss` + `fillToCss` + `borderToCss` + `alignmentToCss` for a
+* cell into a single CSS-property record. Resolves the cell's `styleId` against
+* the workbook stylesheet, then merges the four partials. On key collision the
+* priority is alignment > border > fill > font (alignment is most specific,
+* font is the broad default). A fully-default cell (`styleId === 0` with empty
+* pools) returns `{}`.
+*/
+function cellStyleToCss(wb, c) {
+	if (c.styleId === 0) {
+		const xf = wb.styles.cellXfs[0];
+		if (!xf || xf.fontId === 0 && xf.fillId === 0 && xf.borderId === 0 && xf.alignment === void 0) return {};
+	}
+	const font = getCellFont(wb, c);
+	const fill = getCellFill(wb, c);
+	const border = getCellBorder(wb, c);
+	const alignment = getCellAlignment(wb, c);
+	return {
+		...fontToCss(font),
+		...fillToCss(fill),
+		...borderToCss(border),
+		...alignmentToCss(alignment)
+	};
+}
+/**
+* Reserve cellXfs[0] for the implicit default xf when the pool is empty.
+* Excel's `<c>` elements without an `s=` attribute resolve to `cellXfs[0]`, so
+* the first time a caller styles any cell we need to make sure that slot stays
+* the default — otherwise unstyled cells in the same sheet would inherit the
+* freshly added styled xf.
+*
+* Idempotent: calling this on a non-empty pool is a no-op.
+*/
+const reserveDefaultXfSlot = (wb) => {
+	if (wb.styles.cellXfs.length === 0) addCellXf(wb.styles, defaultCellXf());
+};
+/**
+* Replace one field on the cell's CellXf. Centralises the dedup + styleId
+* update so each `setCell*` is a single dispatch.
+*/
+function applyXfPatch(wb, c, patch) {
+	reserveDefaultXfSlot(wb);
+	const next = {
+		...currentXf(wb.styles, c),
+		...patch
+	};
+	c.styleId = addCellXf(wb.styles, next);
+}
+function setCellFont(wb, c, font) {
+	applyXfPatch(wb, c, {
+		fontId: addFont(wb.styles, font),
+		applyFont: true
+	});
+}
+function setCellFill(wb, c, fill) {
+	applyXfPatch(wb, c, {
+		fillId: addFill(wb.styles, fill),
+		applyFill: true
+	});
+}
+function setCellBorder(wb, c, border) {
+	applyXfPatch(wb, c, {
+		borderId: addBorder(wb.styles, border),
+		applyBorder: true
+	});
+}
+function setCellAlignment(wb, c, alignment) {
+	applyXfPatch(wb, c, {
+		alignment,
+		applyAlignment: true
+	});
+}
+function setCellProtection(wb, c, protection) {
+	applyXfPatch(wb, c, {
+		protection,
+		applyProtection: true
+	});
+}
+/**
+* Set the cell's number format by its **code** string. Built-in codes resolve
+* to their canonical id; custom codes are registered via `addNumFmt`.
+*/
+function setCellNumberFormat(wb, c, formatCode) {
+	applyXfPatch(wb, c, {
+		numFmtId: addNumFmt(wb.styles, formatCode),
+		applyNumberFormat: true
+	});
+}
+/**
+* Copy the source cell's `styleId` to the target cell. Both cells share the
+* same workbook stylesheet, so the styled appearance carries over without
+* allocating a new xf entry. Pass cells from different workbooks via {@link
+* cloneCellStyle} if you need a deep copy across workbooks.
+*/
+function copyCellStyle(_wb, source, target) {
+	target.styleId = source.styleId;
+}
+/**
+* Reset a cell back to the default (unstyled) appearance — equivalent to
+* Excel's "Clear Formatting" command. After the call, the cell inherits the
+* workbook's default font / fill / border / alignment / protection /
+* numberFormat. The underlying xf pool is **not** shrunk (Excel doesn't bother
+* either; the orphaned xf is harmless).
+*/
+function clearCellStyle(_wb, c) {
+	c.styleId = 0;
+}
+/**
+* Range-level shortcut for {@link clearCellStyle}. Walks every cell actually
+* present in the range and resets its `styleId` to 0; cells that don't exist
+* yet are **not** materialised (no-op for sparse regions, unlike the styled
+* `setRange*` family which has to create cells to make the patch observable).
+*/
+function clearRangeStyle(wb, ws, range) {
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	for (let r = minRow; r <= maxRow; r++) {
+		const row = ws.rows.get(r);
+		if (!row) continue;
+		for (let c = minCol; c <= maxCol; c++) {
+			const cell = row.get(c);
+			if (cell) clearCellStyle(wb, cell);
+		}
+	}
+}
+/**
+* Deep-copy the source cell's full xf (font / fill / border / alignment /
+* protection / numberFormat) into a possibly-different workbook. Returns the
+* new styleId in the target workbook.
+*/
+function cloneCellStyle(sourceWb, source, targetWb, target) {
+	reserveDefaultXfSlot(targetWb);
+	const srcXf = currentXf(sourceWb.styles, source);
+	const srcFont = sourceWb.styles.fonts[srcXf.fontId] ?? DEFAULT_FONT;
+	const srcFill = sourceWb.styles.fills[srcXf.fillId] ?? DEFAULT_EMPTY_FILL;
+	const srcBorder = sourceWb.styles.borders[srcXf.borderId] ?? DEFAULT_BORDER;
+	const srcNumFmt = builtinFormatCode(srcXf.numFmtId) ?? sourceWb.styles.numFmts.get(srcXf.numFmtId) ?? GENERAL_FORMAT_CODE;
+	const next = {
+		fontId: addFont(targetWb.styles, srcFont),
+		fillId: addFill(targetWb.styles, srcFill),
+		borderId: addBorder(targetWb.styles, srcBorder),
+		numFmtId: addNumFmt(targetWb.styles, srcNumFmt)
+	};
+	if (srcXf.applyFont) next.applyFont = true;
+	if (srcXf.applyFill) next.applyFill = true;
+	if (srcXf.applyBorder) next.applyBorder = true;
+	if (srcXf.applyNumberFormat) next.applyNumberFormat = true;
+	if (srcXf.alignment !== void 0) {
+		next.alignment = srcXf.alignment;
+		next.applyAlignment = true;
+	}
+	if (srcXf.protection !== void 0) {
+		next.protection = srcXf.protection;
+		next.applyProtection = true;
+	}
+	target.styleId = addCellXf(targetWb.styles, next);
+	return target.styleId;
+}
+/**
+* Build a single CellXf id from a multi-axis style spec, then apply it to every
+* cell in `range`. The xf is registered once per style shape, so a 1000-cell
+* range allocates one xf — much faster than looping `setCellStyle` per cell.
+*/
+function setRangeStyle(wb, ws, range, opts) {
+	const patch = {};
+	if (opts.font !== void 0) {
+		patch.fontId = addFont(wb.styles, opts.font);
+		patch.applyFont = true;
+	}
+	if (opts.fill !== void 0) {
+		patch.fillId = addFill(wb.styles, opts.fill);
+		patch.applyFill = true;
+	}
+	if (opts.border !== void 0) {
+		patch.borderId = addBorder(wb.styles, opts.border);
+		patch.applyBorder = true;
+	}
+	if (opts.alignment !== void 0) {
+		patch.alignment = opts.alignment;
+		patch.applyAlignment = true;
+	}
+	if (opts.protection !== void 0) {
+		patch.protection = opts.protection;
+		patch.applyProtection = true;
+	}
+	if (opts.numberFormat !== void 0) {
+		patch.numFmtId = addNumFmt(wb.styles, opts.numberFormat);
+		patch.applyNumberFormat = true;
+	}
+	if (Object.keys(patch).length === 0) return;
+	reserveDefaultXfSlot(wb);
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	for (let r = minRow; r <= maxRow; r++) for (let c = minCol; c <= maxCol; c++) {
+		let cell = ws.rows.get(r)?.get(c);
+		if (!cell) cell = setCell(ws, r, c);
+		const next = {
+			...currentXf(wb.styles, cell),
+			...patch
+		};
+		cell.styleId = addCellXf(wb.styles, next);
+	}
+}
+/**
+* Combined cell-style setter. Each axis is independent — pass any subset and
+* the corresponding `applyXxx` flags get set on the underlying CellXf. Avoids
+* 5+ separate stylesheet round-trips when a caller wants to style a single cell
+* across multiple axes (Excel dedupes the resulting xf record on every call).
+*/
+function setCellStyle(wb, c, opts) {
+	const patch = {};
+	if (opts.font !== void 0) {
+		patch.fontId = addFont(wb.styles, opts.font);
+		patch.applyFont = true;
+	}
+	if (opts.fill !== void 0) {
+		patch.fillId = addFill(wb.styles, opts.fill);
+		patch.applyFill = true;
+	}
+	if (opts.border !== void 0) {
+		patch.borderId = addBorder(wb.styles, opts.border);
+		patch.applyBorder = true;
+	}
+	if (opts.alignment !== void 0) {
+		patch.alignment = opts.alignment;
+		patch.applyAlignment = true;
+	}
+	if (opts.protection !== void 0) {
+		patch.protection = opts.protection;
+		patch.applyProtection = true;
+	}
+	if (opts.numberFormat !== void 0) {
+		patch.numFmtId = addNumFmt(wb.styles, opts.numberFormat);
+		patch.applyNumberFormat = true;
+	}
+	if (Object.keys(patch).length === 0) return;
+	applyXfPatch(wb, c, patch);
+}
+/**
+* Set the cell's background to a solid color. Accepts a hex string
+* (`'FFAAFFAA'`) or a partial `Color` object (`{ theme: 4, tint: 0.4 }`).
+* Equivalent to `setCellFill(wb, c, makePatternFill({ patternType: 'solid',
+* fgColor: makeColor(...) }))`.
+*/
+function setCellBackgroundColor(wb, c, color) {
+	setCellFill(wb, c, makePatternFill({
+		patternType: "solid",
+		fgColor: typeof color === "string" ? makeColor({ rgb: color }) : makeColor(color)
+	}));
+}
+/** Strip the cell's background fill, returning it to the default. */
+function clearCellBackground(wb, c) {
+	setCellFill(wb, c, DEFAULT_EMPTY_FILL);
+}
+/**
+* Range-level shortcut for `setCellBackgroundColor`. Each cell in the range
+* gets the same solid pattern fill via `setRangeStyle`, so the fill pool dedups
+* to a single entry across the whole range.
+*/
+function setRangeBackgroundColor(wb, ws, range, color) {
+	setRangeStyle(wb, ws, range, { fill: makePatternFill({
+		patternType: "solid",
+		fgColor: typeof color === "string" ? makeColor({ rgb: color }) : makeColor(color)
+	}) });
+}
+/** Range-level shortcut for `setCellFont` (full Font replacement). */
+function setRangeFont(wb, ws, range, font) {
+	setRangeStyle(wb, ws, range, { font });
+}
+/**
+* Range-level shortcut for `setCellNumberFormat`. Stamps the same format-code
+* onto every cell in the range; the numFmt pool dedups the code so callers
+* don't pay per-cell pool churn.
+*/
+function setRangeNumberFormat(wb, ws, range, formatCode) {
+	setRangeStyle(wb, ws, range, { numberFormat: formatCode });
+}
+/**
+* Range-level shortcut for `setCellProtection`. Stamps the same Protection
+* (locked / hidden) onto every cell in the range. Pass a full `Protection`
+* value or a partial — partials default missing fields to `false` per Excel's
+* `<protection>` semantics.
+*
+* Common usage: `setRangeProtection(wb, ws, 'B2:B100', { locked: false })` to
+* leave just an input column editable when the sheet is protected.
+*/
+function setRangeProtection(wb, ws, range, protection) {
+	setRangeStyle(wb, ws, range, { protection: Object.isFrozen(protection) ? protection : {
+		locked: protection.locked ?? false,
+		hidden: protection.hidden ?? false
+	} });
+}
+/**
+* Range-level shortcut for `wrapCellText`. Toggles "Wrap Text" on every cell in
+* the range while preserving each cell's existing alignment (horizontal /
+* vertical / textRotation / indent are not touched). Empty cells in the range
+* are materialised so the alignment patch is observable on round-trip.
+*/
+function setRangeWrapText(wb, ws, range, on = true) {
+	reserveDefaultXfSlot(wb);
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	for (let r = minRow; r <= maxRow; r++) for (let c = minCol; c <= maxCol; c++) {
+		let cell = ws.rows.get(r)?.get(c);
+		if (!cell) cell = setCell(ws, r, c);
+		wrapCellText(wb, cell, on);
+	}
+}
+/**
+* Range-level Alignment setter. Two modes:
+*
+*   - `mode: 'merge'` (default) — each cell's existing alignment is
+*     preserved; the supplied partial overlays it. Use this when you
+*     want to set just `horizontal` or `vertical` without wiping the
+*     other axes.
+*   - `mode: 'replace'` — each cell's alignment is **wholly replaced**
+*     by the supplied value. Indent / textRotation / wrapText that
+*     weren't supplied are dropped.
+*
+* Empty cells in the range are materialised so the patch is observable on
+* round-trip.
+*/
+function setRangeAlignment(wb, ws, range, alignment, mode = "merge") {
+	reserveDefaultXfSlot(wb);
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	if (mode === "replace") {
+		setRangeStyle(wb, ws, range, { alignment: makeAlignment(alignment) });
+		return;
+	}
+	for (let r = minRow; r <= maxRow; r++) for (let c = minCol; c <= maxCol; c++) {
+		let cell = ws.rows.get(r)?.get(c);
+		if (!cell) cell = setCell(ws, r, c);
+		const cur = currentXf(wb.styles, cell).alignment;
+		setCellAlignment(wb, cell, mergeAlignment(cur, alignment));
+	}
+}
+const mergeFont = (current, patch) => makeFont({
+	...current,
+	...patch
+});
+/** Toggle bold on a cell. Preserves other font fields. */
+function setBold(wb, c, on = true) {
+	setCellFont(wb, c, mergeFont(getCellFont(wb, c), { bold: on }));
+}
+/** Toggle italic on a cell. */
+function setItalic(wb, c, on = true) {
+	setCellFont(wb, c, mergeFont(getCellFont(wb, c), { italic: on }));
+}
+/** Toggle strike-through on a cell. */
+function setStrikethrough(wb, c, on = true) {
+	setCellFont(wb, c, mergeFont(getCellFont(wb, c), { strike: on }));
+}
+/**
+* Set the underline style. Pass `false` to drop underline; pass `'single' |
+* 'double' | 'singleAccounting' | 'doubleAccounting'` to apply that style; pass
+* `true` for the most common single-line.
+*/
+function setUnderline(wb, c, style = "single") {
+	const { underline: _drop, ...rest } = getCellFont(wb, c);
+	if (style === false) {
+		setCellFont(wb, c, makeFont(rest));
+		return;
+	}
+	const u = style === true ? "single" : style;
+	setCellFont(wb, c, makeFont({
+		...rest,
+		underline: u
+	}));
+}
+/** Set the font size in points (e.g. 14). Preserves other fields. */
+function setFontSize(wb, c, size) {
+	setCellFont(wb, c, mergeFont(getCellFont(wb, c), { size }));
+}
+/** Set the font family name (e.g. "Arial"). Preserves other fields. */
+function setFontName(wb, c, name) {
+	setCellFont(wb, c, mergeFont(getCellFont(wb, c), { name }));
+}
+/**
+* Set the font color. Accepts a hex string ("FFAA0033") or a partial `Color`
+* object (`{ theme: 4, tint: 0.4 }`). Preserves other font fields.
+*/
+function setFontColor(wb, c, color) {
+	const colorObj = typeof color === "string" ? makeColor({ rgb: color }) : makeColor(color);
+	setCellFont(wb, c, mergeFont(getCellFont(wb, c), { color: colorObj }));
+}
+const mergeAlignment = (current, patch) => {
+	return makeAlignment({
+		...current,
+		...patch
+	});
+};
+/**
+* Center a cell horizontally + vertically. Mirrors Excel's "Merge & Center" UI
+* button (without the merge — see {@link mergeCells} for that). Preserves any
+* other alignment fields already present.
+*/
+function centerCell(wb, c) {
+	const cur = currentXf(wb.styles, c).alignment;
+	setCellAlignment(wb, c, mergeAlignment(cur, {
+		horizontal: "center",
+		vertical: "center"
+	}));
+}
+/** Toggle "Wrap Text" on a cell, preserving other alignment fields. */
+function wrapCellText(wb, c, wrap = true) {
+	const cur = currentXf(wb.styles, c).alignment;
+	setCellAlignment(wb, c, mergeAlignment(cur, { wrapText: wrap }));
+}
+/** Set the horizontal alignment in isolation. */
+function alignCellHorizontal(wb, c, horizontal) {
+	const cur = currentXf(wb.styles, c).alignment;
+	setCellAlignment(wb, c, mergeAlignment(cur, { horizontal }));
+}
+/** Set the vertical alignment in isolation. */
+function alignCellVertical(wb, c, vertical) {
+	const cur = currentXf(wb.styles, c).alignment;
+	setCellAlignment(wb, c, mergeAlignment(cur, { vertical }));
+}
+/**
+* Rotate the cell's text. `degrees` accepts 0..180 (clockwise) or 255 for
+* Excel's "vertical stacked" mode. Mirrors the rotate icons in the alignment
+* ribbon.
+*/
+function rotateCellText(wb, c, degrees) {
+	const cur = currentXf(wb.styles, c).alignment;
+	setCellAlignment(wb, c, mergeAlignment(cur, { textRotation: degrees }));
+}
+/** Set or clear the indent level (0..255). */
+function indentCell(wb, c, levels) {
+	const cur = currentXf(wb.styles, c).alignment;
+	setCellAlignment(wb, c, mergeAlignment(cur, { indent: levels }));
+}
+/**
+* Format a cell as currency. Produces one of:
+* - default → `"$#,##0.00"` (US dollar, 2 decimals)
+* - `{ symbol: "€" }` → `"€#,##0.00"`
+* - `{ symbol: "¥", decimals: 0 }` → `"¥#,##0"`
+* - `{ accounting: true }` → `"_-$* #,##0.00_-;-$* #,##0.00_-;_-$* \"-\"??_-;_-@_-"`
+* (Excel's "Accounting" subtype with right-aligned symbol).
+*/
+function setCellAsCurrency(wb, c, opts = {}) {
+	const symbol = opts.symbol ?? "$";
+	const decimals = opts.decimals ?? 2;
+	const decTail = decimals > 0 ? `.${"0".repeat(decimals)}` : "";
+	setCellNumberFormat(wb, c, opts.accounting ? `_-${symbol}* #,##0${decTail}_-;-${symbol}* #,##0${decTail}_-;_-${symbol}* "-"${"?".repeat(decimals)}_-;_-@_-` : `${symbol}#,##0${decTail}`);
+}
+/**
+* Format a cell as a percentage. `decimals` defaults to 0 → `"0%"`; `decimals:
+* 2` → `"0.00%"`. The cell value is multiplied by 100 by Excel during display.
+*/
+function setCellAsPercent(wb, c, decimals = 0) {
+	if (!Number.isInteger(decimals) || decimals < 0) throw new OpenXmlSchemaError(`setCellAsPercent: decimals must be a non-negative integer; got ${decimals}`);
+	setCellNumberFormat(wb, c, decimals === 0 ? "0%" : `0.${"0".repeat(decimals)}%`);
+}
+/**
+* Format a cell as a date. `format` defaults to Excel's default
+* locale-independent ISO-style date `"yyyy-mm-dd"`. Common alternatives:
+* `"m/d/yyyy"`, `"dd-mmm-yy"`, `"yyyy-mm-dd hh:mm:ss"`.
+*/
+function setCellAsDate(wb, c, format = "yyyy-mm-dd") {
+	setCellNumberFormat(wb, c, format);
+}
+/**
+* Format a cell as a thousands-separated number. `decimals` defaults to 0 →
+* `"#,##0"`; `decimals: 2` → `"#,##0.00"`.
+*/
+function setCellAsNumber(wb, c, decimals = 0) {
+	if (!Number.isInteger(decimals) || decimals < 0) throw new OpenXmlSchemaError(`setCellAsNumber: decimals must be a non-negative integer; got ${decimals}`);
+	setCellNumberFormat(wb, c, decimals === 0 ? "#,##0" : `#,##0.${"0".repeat(decimals)}`);
+}
+/**
+* Apply Excel's stock "table header" formatting to a range: bold white text on
+* a dark fill, plus a thick bottom border. Override any axis via `opts` — pass
+* `bold: false` to drop the bold, or `fillColor: 'FF305496'` for a different
+* shade. Defaults match Excel's "Table Style Medium 2" header row.
+*/
+function formatAsHeader(wb, ws, range, opts = {}) {
+	const fillColor = opts.fillColor === void 0 ? "FF305496" : typeof opts.fillColor === "string" ? makeColor({ rgb: opts.fillColor }) : makeColor(opts.fillColor);
+	const fontColor = opts.fontColor === void 0 ? "FFFFFFFF" : typeof opts.fontColor === "string" ? makeColor({ rgb: opts.fontColor }) : makeColor(opts.fontColor);
+	const bold = opts.bold ?? true;
+	const borderStyle = opts.bottomBorder ?? "medium";
+	const borderColorObj = opts.bottomBorderColor === void 0 ? void 0 : typeof opts.bottomBorderColor === "string" ? makeColor({ rgb: opts.bottomBorderColor }) : makeColor(opts.bottomBorderColor);
+	const fillColorObj = typeof fillColor === "string" ? makeColor({ rgb: fillColor }) : fillColor;
+	const styleOpts = {
+		font: makeFont({
+			bold,
+			color: typeof fontColor === "string" ? makeColor({ rgb: fontColor }) : fontColor
+		}),
+		fill: makePatternFill({
+			patternType: "solid",
+			fgColor: fillColorObj
+		})
+	};
+	if (borderStyle !== false) styleOpts.border = makeBorder({ bottom: makeSide({
+		style: borderStyle,
+		...borderColorObj ? { color: borderColorObj } : {}
+	}) });
+	setRangeStyle(wb, ws, range, styleOpts);
+}
+/**
+* Apply a built-in Excel style ("Heading 1" / "Total" / "Good" / "Bad" /
+* "Calculation" / etc.) to a single cell. Registers the built-in on the
+* Stylesheet (idempotent) and points the cell's xf at it via `xfId` while
+* inheriting the matching font/fill/border/ numFmt ids so the cell renders
+* correctly on its own.
+*
+* Throws when `name` isn't in {@link BUILTIN_NAMED_STYLES}; use {@link
+* applyNamedStyle} for user-registered styles.
+*/
+function applyBuiltinStyle(wb, c, name) {
+	applyNamedStyleByXfId(wb, c, ensureBuiltinStyle(wb.styles, name));
+}
+/**
+* Apply a NamedStyle that's already registered on the workbook (via
+* `addNamedStyle` or `ensureBuiltinStyle`) to a single cell, by name.
+*/
+function applyNamedStyle(wb, c, name) {
+	const entry = wb.styles._namedStyleByName?.get(name);
+	if (entry === void 0) throw new OpenXmlSchemaError(`applyNamedStyle: no named style "${name}" registered`);
+	applyNamedStyleByXfId(wb, c, entry.xfId);
+}
+const applyNamedStyleByXfId = (wb, c, xfId) => {
+	const styleXf = wb.styles.cellStyleXfs[xfId];
+	if (!styleXf) throw new OpenXmlSchemaError(`applyNamedStyle: cellStyleXfs[${xfId}] missing`);
+	const patch = {
+		xfId,
+		fontId: styleXf.fontId,
+		fillId: styleXf.fillId,
+		borderId: styleXf.borderId,
+		numFmtId: styleXf.numFmtId,
+		applyFont: true,
+		applyFill: true,
+		applyBorder: true,
+		applyNumberFormat: true
+	};
+	if (styleXf.alignment !== void 0) {
+		patch.alignment = styleXf.alignment;
+		patch.applyAlignment = true;
+	}
+	if (styleXf.protection !== void 0) {
+		patch.protection = styleXf.protection;
+		patch.applyProtection = true;
+	}
+	applyXfPatch(wb, c, patch);
+};
+/**
+* Apply the same {@link SideStyle} to all four edges of a single cell. Optional
+* color via hex string or `Color` partial. Equivalent to `setCellBorder(wb, c,
+* makeBorder({ left, right, top, bottom: side }))` with all four sides
+* identical.
+*/
+function setCellBorderAll(wb, c, opts = { style: "thin" }) {
+	const colorObj = opts.color === void 0 ? void 0 : typeof opts.color === "string" ? makeColor({ rgb: opts.color }) : makeColor(opts.color);
+	const side = makeSide({
+		style: opts.style,
+		...colorObj ? { color: colorObj } : {}
+	});
+	setCellBorder(wb, c, makeBorder({
+		left: side,
+		right: side,
+		top: side,
+		bottom: side
+	}));
+}
+/**
+* Draw an outer border around a rectangular range. Cells on the perimeter
+* receive a partial border (only the edges that face outside the range); inner
+* cells are unaffected unless `inner` is provided, in which case every cell in
+* the range receives a border combining its perimeter edges with the `inner`
+* style for the inside edges.
+*/
+function setRangeBorderBox(wb, ws, range, opts = { style: "thin" }) {
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	const colorObj = opts.color === void 0 ? void 0 : typeof opts.color === "string" ? makeColor({ rgb: opts.color }) : makeColor(opts.color);
+	const outer = makeSide({
+		style: opts.style,
+		...colorObj ? { color: colorObj } : {}
+	});
+	const inner = opts.inner !== void 0 ? makeSide({
+		style: opts.inner,
+		...colorObj ? { color: colorObj } : {}
+	}) : void 0;
+	for (let r = minRow; r <= maxRow; r++) for (let col = minCol; col <= maxCol; col++) {
+		const onTop = r === minRow;
+		const onBottom = r === maxRow;
+		const onLeft = col === minCol;
+		const onRight = col === maxCol;
+		if (!inner && !onTop && !onBottom && !onLeft && !onRight) continue;
+		const sides = {};
+		const top = onTop ? outer : inner;
+		const bottom = onBottom ? outer : inner;
+		const left = onLeft ? outer : inner;
+		const right = onRight ? outer : inner;
+		if (top !== void 0) sides.top = top;
+		if (bottom !== void 0) sides.bottom = bottom;
+		if (left !== void 0) sides.left = left;
+		if (right !== void 0) sides.right = right;
+		let cell = ws.rows.get(r)?.get(col);
+		if (!cell) cell = setCell(ws, r, col);
+		setCellBorder(wb, cell, makeBorder(sides));
+	}
+}
+//#endregion
+export { ensureBuiltinStyle as $, setCellFill as A, makeNumberFormat as At, setRangeBackgroundColor as B, makeGradientFill as Bt, setCellAsCurrency as C, FORMAT_TEXT as Ct, setCellBackgroundColor as D, isBuiltinFormat as Dt, setCellAsPercent as E, classifyDateFormat as Et, setFontColor as F, fontToCss as Ft, setRangeStyle as G, makeBorder as Gt, setRangeFont as H, makePatternFill as Ht, setFontName as I, makeFont as It, setUnderline as J, VERTICAL_ALIGNMENTS as Jt, setRangeWrapText as K, makeSide as Kt, setFontSize as L, PATTERN_TYPES as Lt, setCellNumberFormat as M, FONT_SCHEMES as Mt, setCellProtection as N, UNDERLINE_STYLES as Nt, setCellBorder as O, isDateFormat as Ot, setCellStyle as P, VERT_ALIGNS as Pt, addNamedStyle as Q, setItalic as R, fillToCss as Rt, setCellAlignment as S, FORMAT_PERCENTAGE_00 as St, setCellAsNumber as T, builtinFormatId as Tt, setRangeNumberFormat as U, SIDE_STYLES as Ut, setRangeBorderBox as V, makeGradientStop as Vt, setRangeProtection as W, borderToCss as Wt, makeProtection as X, makeAlignment as Xt, wrapCellText as Y, alignmentToCss as Yt, BUILTIN_NAMED_STYLES as Z, stableStringify as Zt, getCellNumberFormat as _, FORMAT_DATE_YYYYMMDD2 as _t, cellStyleToCss as a, addNumFmt as at, rotateCellText as b, FORMAT_NUMBER_00 as bt, clearCellStyle as c, listCellStyleXfs as ct, copyCellStyle as d, listFonts as dt, addBorder as et, formatAsHeader as f, makeStylesheet as ft, getCellFont as g, FORMAT_DATE_TIMEDELTA as gt, getCellFill as h, FORMAT_DATE_DATETIME as ht, applyNamedStyle as i, addFont as it, setCellFont as j, DEFAULT_FONT as jt, setCellBorderAll as k, isTimedeltaFormat as kt, clearRangeStyle as l, listCellXfs as lt, getCellBorder as m, BUILTIN_FORMATS_MAX_SIZE as mt, alignCellVertical as n, addCellXf as nt, centerCell as o, defaultCellXf as ot, getCellAlignment as p, BUILTIN_FORMATS as pt, setStrikethrough as q, HORIZONTAL_ALIGNMENTS as qt, applyBuiltinStyle as r, addFill as rt, clearCellBackground as s, listBorders as st, alignCellHorizontal as t, addCellStyleXf as tt, cloneCellStyle as u, listFills as ut, getCellProtection as v, FORMAT_GENERAL as vt, setCellAsDate as w, builtinFormatCode as wt, setBold as x, FORMAT_PERCENTAGE as xt, indentCell as y, FORMAT_NUMBER as yt, setRangeAlignment as z, makeFill as zt };
+
+//# sourceMappingURL=cell-style-BEDjMX1y.mjs.map