@office-kit/xlsx 0.16.0 → 0.18.0

package/dist/styles.mjs

@@ -1,4 +1,1161 @@
-import { An as pickReadableTextColor, Cn as hexToHsl, Dn as makeColor, En as luminance, Mn as rgbColor, Nn as rotateHue, On as mixColors, Sn as darken, Tn as lighten, bn as colorToHex, jn as resolveIndexedColor, kn as normaliseRgb, vn as adjustLightness, wn as hslToHex, xn as contrastRatio, yn as adjustSaturation } from "./worksheet-B2NOQ6dM.mjs";
-import { $ as BUILTIN_NAMED_STYLES, $t as makeAlignment, A as setCellBorder, At as isBuiltinFormat, B as setItalic, C as setBold, Ct as FORMAT_NUMBER_00, D as setCellAsNumber, Dt as builtinFormatCode, E as setCellAsDate, Et as FORMAT_TEXT, F as setCellProtection, G as setRangeNumberFormat, Gt as makePatternFill, H as setRangeBackgroundColor, Ht as makeFill, I as setCellStyle, J as setRangeWrapText, Jt as makeBorder, K as setRangeProtection, L as setFontColor, M as setCellFill, Mt as isTimedeltaFormat, N as setCellFont, Nt as makeNumberFormat, O as setCellAsPercent, Ot as builtinFormatId, P as setCellNumberFormat, Pt as DEFAULT_FONT, Q as makeProtection, Qt as alignmentToCss, R as setFontName, Rt as fontToCss, S as rotateCellText, St as FORMAT_NUMBER, T as setCellAsCurrency, Tt as FORMAT_PERCENTAGE_00, U as setRangeBorderBox, Ut as makeGradientFill, V as setRangeAlignment, Vt as fillToCss, W as setRangeFont, Wt as makeGradientStop, X as setUnderline, Y as setStrikethrough, Yt as makeSide, Z as wrapCellText, _ as getCellNumberFormat, _t as BUILTIN_FORMATS_MAX_SIZE, a as cellStyleToCss, at as addFill, b as patchCellFont, bt as FORMAT_DATE_YYYYMMDD2, c as clearCellStyle, d as copyCellStyle, dt as listCellStyleXfs, et as addNamedStyle, f as formatAsHeader, ft as listCellXfs, g as getCellFont, gt as BUILTIN_FORMATS, h as getCellFill, ht as makeStylesheet, i as applyNamedStyle, it as addCellXf, j as setCellBorderAll, jt as isDateFormat, k as setCellBackgroundColor, kt as classifyDateFormat, l as clearRangeStyle, lt as defaultCellXf, m as getCellBorder, mt as listFonts, n as alignCellVertical, nt as addBorder, o as centerCell, ot as addFont, p as getCellAlignment, pt as listFills, q as setRangeStyle, qt as borderToCss, r as applyBuiltinStyle, rt as addCellStyleXf, s as clearCellBackground, st as addNumFmt, t as alignCellHorizontal, tt as ensureBuiltinStyle, u as cloneCellStyle, ut as listBorders, v as getCellProtection, vt as FORMAT_DATE_DATETIME, w as setCellAlignment, wt as FORMAT_PERCENTAGE, x as registerCellStyle, xt as FORMAT_GENERAL, y as indentCell, yt as FORMAT_DATE_TIMEDELTA, z as setFontSize, zt as makeFont } from "./cell-style-CNsET6WU.mjs";
-import { r as makeDifferentialStyle, t as addDxf } from "./differential-BPKa7wXi.mjs";
-export { BUILTIN_FORMATS, BUILTIN_FORMATS_MAX_SIZE, BUILTIN_NAMED_STYLES, DEFAULT_FONT, FORMAT_DATE_DATETIME, FORMAT_DATE_TIMEDELTA, FORMAT_DATE_YYYYMMDD2, FORMAT_GENERAL, FORMAT_NUMBER, FORMAT_NUMBER_00, FORMAT_PERCENTAGE, FORMAT_PERCENTAGE_00, FORMAT_TEXT, addBorder, addCellStyleXf, addCellXf, addDxf, addFill, addFont, addNamedStyle, addNumFmt, adjustLightness, adjustSaturation, alignCellHorizontal, alignCellVertical, alignmentToCss, applyBuiltinStyle, applyNamedStyle, borderToCss, builtinFormatCode, builtinFormatId, cellStyleToCss, centerCell, classifyDateFormat, clearCellBackground, clearCellStyle, clearRangeStyle, cloneCellStyle, colorToHex, contrastRatio, copyCellStyle, darken, defaultCellXf, ensureBuiltinStyle, fillToCss, fontToCss, formatAsHeader, getCellAlignment, getCellBorder, getCellFill, getCellFont, getCellNumberFormat, getCellProtection, hexToHsl, hslToHex, indentCell, isBuiltinFormat, isDateFormat, isTimedeltaFormat, lighten, listBorders, listCellStyleXfs, listCellXfs, listFills, listFonts, luminance, makeAlignment, makeBorder, makeColor, makeDifferentialStyle, makeFill, makeFont, makeGradientFill, makeGradientStop, makeNumberFormat, makePatternFill, makeProtection, makeSide, makeStylesheet, mixColors, normaliseRgb, patchCellFont, pickReadableTextColor, registerCellStyle, resolveIndexedColor, rgbColor, rotateCellText, rotateHue, setBold, setCellAlignment, setCellAsCurrency, setCellAsDate, setCellAsNumber, setCellAsPercent, setCellBackgroundColor, setCellBorder, setCellBorderAll, setCellFill, setCellFont, setCellNumberFormat, setCellProtection, setCellStyle, setFontColor, setFontName, setFontSize, setItalic, setRangeAlignment, setRangeBackgroundColor, setRangeBorderBox, setRangeFont, setRangeNumberFormat, setRangeProtection, setRangeStyle, setRangeWrapText, setStrikethrough, setUnderline, wrapCellText };
+import { N as richTextToString, h as isFormulaValue, o as cellValueAsString, p as isErrorValue, u as isDurationValue, v as isRichTextValue } from "./cell-B5OUUdfI.mjs";
+import { An as mixColors, Cn as contrastRatio, Dn as lighten, En as hslToHex, Fn as rotateHue, Mn as pickReadableTextColor, Nn as resolveIndexedColor, On as luminance, Pn as rgbColor, Sn as colorToHex, Tn as hexToHsl, bn as adjustLightness, jn as normaliseRgb, kn as makeColor, wn as darken, xn as adjustSaturation } from "./worksheet-DLMyDD7W.mjs";
+import { $ as BUILTIN_NAMED_STYLES, $t as alignmentToCss, A as setCellBorder, At as classifyDateFormat, B as setItalic, Bt as makeFont, C as setBold, Ct as FORMAT_NUMBER, D as setCellAsNumber, Dt as FORMAT_TEXT, E as setCellAsDate, Et as FORMAT_PERCENTAGE_00, F as setCellProtection, Ft as DEFAULT_FONT, G as setRangeNumberFormat, Gt as makeGradientStop, H as setRangeBackgroundColor, Ht as fillToCss, I as setCellStyle, J as setRangeWrapText, Jt as borderToCss, K as setRangeProtection, Kt as makePatternFill, L as setFontColor, M as setCellFill, Mt as isDateFormat, N as setCellFont, Nt as isTimedeltaFormat, O as setCellAsPercent, Ot as builtinFormatCode, P as setCellNumberFormat, Pt as makeNumberFormat, Q as makeProtection, R as setFontName, S as rotateCellText, St as FORMAT_GENERAL, T as setCellAsCurrency, Tt as FORMAT_PERCENTAGE, U as setRangeBorderBox, Ut as makeFill, V as setRangeAlignment, W as setRangeFont, Wt as makeGradientFill, X as setUnderline, Xt as makeSide, Y as setStrikethrough, Yt as makeBorder, Z as wrapCellText, _ as getCellNumberFormat, _t as BUILTIN_FORMATS_MAX_SIZE, a as cellStyleToCss, at as addFill, b as patchCellFont, bt as FORMAT_DATE_TIMEDELTA, c as clearCellStyle, d as copyCellStyle, dt as listCellStyleXfs, en as makeAlignment, et as addNamedStyle, f as formatAsHeader, ft as listCellXfs, g as getCellFont, gt as BUILTIN_FORMATS, h as getCellFill, ht as makeStylesheet, i as applyNamedStyle, it as addCellXf, j as setCellBorderAll, jt as isBuiltinFormat, k as setCellBackgroundColor, kt as builtinFormatId, l as clearRangeStyle, lt as defaultCellXf, m as getCellBorder, mt as listFonts, n as alignCellVertical, nt as addBorder, o as centerCell, ot as addFont, p as getCellAlignment, pt as listFills, q as setRangeStyle, r as applyBuiltinStyle, rt as addCellStyleXf, s as clearCellBackground, st as addNumFmt, t as alignCellHorizontal, tt as ensureBuiltinStyle, u as cloneCellStyle, ut as listBorders, v as getCellProtection, vt as FORMAT_COLOR_NAMES, w as setCellAlignment, wt as FORMAT_NUMBER_00, x as registerCellStyle, xt as FORMAT_DATE_YYYYMMDD2, y as indentCell, yt as FORMAT_DATE_DATETIME, z as setFontSize, zt as fontToCss } from "./cell-style-CbB4nXTY.mjs";
+import { a as excelToDate, i as durationToExcel, r as dateToExcel } from "./datetime-B2ySVlXt.mjs";
+import { r as makeDifferentialStyle, t as addDxf } from "./differential-QLaKEiBk.mjs";
+//#region src/styles/format-code.ts
+/** Excel carries 15 significant decimal digits and never shows more. */
+const EXCEL_SIGNIFICANT_DIGITS = 15;
+/** Positive, negative, zero, text. */
+const MAX_SECTIONS = 4;
+const GROUP_SEPARATOR = ",";
+const GROUP_SIZE = 3;
+const SCALE_DIVISOR = 1e3;
+const PERCENT_MULTIPLIER = 100;
+/** `mmm` and wider render a month or weekday name, never a minute. */
+const NAME_TOKEN_WIDTH = 3;
+const MONTH_FULL_WIDTH = 4;
+/** Excel pads a `General` exponent to two digits, so 1e-7 shows as `1E-07`. */
+const GENERAL_EXPONENT_DIGITS = 2;
+const FULL_YEAR_DIGITS = 4;
+/** Excel stores time to the millisecond, so `.0000` gains nothing over `.000`. */
+const MAX_SUBSECOND_DIGITS = 3;
+const SECONDS_PER_DAY = 86400;
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_HOUR = 60;
+const HOURS_PER_DAY = 24;
+const HOURS_PER_HALF_DAY = 12;
+const ZERO_CHAR_CODE = "0".charCodeAt(0);
+const FIVE_CHAR_CODE = "5".charCodeAt(0);
+const NINE_CHAR_CODE = "9".charCodeAt(0);
+/** Terms and closeness at which the fraction search stops chasing a double. */
+const FRACTION_MAX_TERMS = 64;
+const FRACTION_EPSILON = 1e-12;
+const MONTH_NAMES = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+const WEEKDAY_NAMES = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+const COLOR_NAMES = new Set(FORMAT_COLOR_NAMES.toLowerCase().split("|"));
+const INDEXED_COLOR_RE = /^color\s*\d+$/i;
+/**
+* The body of an elapsed-time bracket: one letter repeated, as in `[h]` or
+* `[mm]`. `isTimedeltaFormat` in `./numbers.js` answers the different question
+* of whether a whole code is a duration, so it cannot stand in here.
+*/
+const ELAPSED_RE = /^([hms])\1*$/i;
+/**
+* Plain (never exponential) decimal digits of a finite non-negative number at
+* Excel's precision. Rounding has to go through this string: `(1.005).toFixed(2)`
+* is `"1.00"` because the double nearest 1.005 sits just below it, while Excel
+* rounds the 15-digit decimal it shows and prints `1.01`.
+*/
+const toPlainDecimal = (value) => {
+	const text = value.toPrecision(EXCEL_SIGNIFICANT_DIGITS);
+	const parsed = /^(\d+)(?:\.(\d+))?e([+-]\d+)$/.exec(text);
+	if (parsed === null) return text;
+	const intPart = parsed[1] ?? "";
+	const digits = intPart + (parsed[2] ?? "");
+	const point = intPart.length + Number(parsed[3] ?? "0");
+	if (point <= 0) return `0.${"0".repeat(-point)}${digits}`;
+	if (point >= digits.length) return digits + "0".repeat(point - digits.length);
+	return `${digits.slice(0, point)}.${digits.slice(point)}`;
+};
+/** Add one to the last digit of a digit string, growing it on overflow. */
+const carryOne = (digits) => {
+	let i = digits.length - 1;
+	let tail = "";
+	while (i >= 0 && digits.charCodeAt(i) === NINE_CHAR_CODE) {
+		tail = `0${tail}`;
+		i--;
+	}
+	if (i < 0) return `1${tail}`;
+	return digits.slice(0, i) + String(digits.charCodeAt(i) - ZERO_CHAR_CODE + 1) + tail;
+};
+/** Round `int`.`frac` to `decimals` places, half away from zero. */
+const roundParts = (int, frac, decimals) => {
+	if (frac.length <= decimals) return {
+		int,
+		frac: frac.padEnd(decimals, "0")
+	};
+	const kept = frac.slice(0, decimals);
+	if (frac.charCodeAt(decimals) < FIVE_CHAR_CODE) return {
+		int,
+		frac: kept
+	};
+	const bumped = carryOne(int + kept);
+	return {
+		int: bumped.slice(0, bumped.length - decimals),
+		frac: bumped.slice(bumped.length - decimals)
+	};
+};
+const roundDecimal = (value, decimals) => {
+	const text = toPlainDecimal(value);
+	const dot = text.indexOf(".");
+	if (dot === -1) return roundParts(text, "", decimals);
+	return roundParts(text.slice(0, dot), text.slice(dot + 1), decimals);
+};
+/** Significant digits of a non-negative number, most significant first. */
+const significantDigits = (value) => toPlainDecimal(value).replace(".", "").replace(/^0+/, "");
+/** Power of ten of the leading significant digit; 0 for a zero value. */
+const decimalOrder = (value) => {
+	const text = toPlainDecimal(value);
+	const dot = text.indexOf(".");
+	const int = (dot === -1 ? text : text.slice(0, dot)).replace(/^0+/, "");
+	if (int.length > 0) return int.length - 1;
+	const leading = (dot === -1 ? "" : text.slice(dot + 1)).search(/[1-9]/);
+	return leading === -1 ? 0 : -(leading + 1);
+};
+const pushLiteral = (tokens, text) => {
+	const last = tokens[tokens.length - 1];
+	if (last?.kind === "literal") tokens[tokens.length - 1] = {
+		kind: "literal",
+		text: last.text + text
+	};
+	else tokens.push({
+		kind: "literal",
+		text
+	});
+};
+const datePartOf = (letter) => {
+	if (letter === "y") return "year";
+	if (letter === "d") return "day";
+	if (letter === "h") return "hour";
+	if (letter === "s") return "second";
+	return "monthOrMinute";
+};
+/** `[Red]`, `[$€-407]`, `[hh]`, `[>100]`: everything Excel puts in brackets. */
+const tokenizeBracket = (body, tokens) => {
+	const elapsed = ELAPSED_RE.exec(body);
+	if (elapsed !== null) {
+		const letter = (elapsed[1] ?? "h").toLowerCase();
+		const part = letter === "h" ? "hour" : letter === "m" ? "minute" : "second";
+		tokens.push({
+			kind: "elapsed",
+			part,
+			width: body.length
+		});
+		return true;
+	}
+	if (body.startsWith("$")) {
+		const symbol = body.slice(1).split("-")[0] ?? "";
+		if (symbol.length > 0) pushLiteral(tokens, symbol);
+		return true;
+	}
+	const lower = body.toLowerCase();
+	if (COLOR_NAMES.has(lower) || INDEXED_COLOR_RE.test(body)) return true;
+	return false;
+};
+const MERIDIEM_LONG = "AM/PM";
+const MERIDIEM_SHORT = "A/P";
+const meridiemToken = (raw) => {
+	const slash = raw.indexOf("/");
+	return {
+		kind: "meridiem",
+		am: raw.slice(0, slash),
+		pm: raw.slice(slash + 1)
+	};
+};
+const tokenizeSection = (src) => {
+	const tokens = [];
+	let i = 0;
+	while (i < src.length) {
+		const ch = src.charAt(i);
+		if (ch === "\"") {
+			const end = src.indexOf("\"", i + 1);
+			if (end === -1) return void 0;
+			pushLiteral(tokens, src.slice(i + 1, end));
+			i = end + 1;
+			continue;
+		}
+		if (ch === "\\") {
+			pushLiteral(tokens, src.charAt(i + 1));
+			i += 2;
+			continue;
+		}
+		if (ch === "_") {
+			pushLiteral(tokens, " ");
+			i += 2;
+			continue;
+		}
+		if (ch === "*") {
+			i += 2;
+			continue;
+		}
+		if (ch === "[") {
+			const end = src.indexOf("]", i + 1);
+			if (end === -1) return void 0;
+			if (!tokenizeBracket(src.slice(i + 1, end), tokens)) return void 0;
+			i = end + 1;
+			continue;
+		}
+		if (ch === "0" || ch === "#" || ch === "?") {
+			tokens.push({
+				kind: "digit",
+				placeholder: ch
+			});
+			i++;
+			continue;
+		}
+		if (ch === ".") {
+			tokens.push({ kind: "point" });
+			i++;
+			continue;
+		}
+		if (ch === ",") {
+			tokens.push({ kind: "comma" });
+			i++;
+			continue;
+		}
+		if (ch === "%") {
+			tokens.push({ kind: "percent" });
+			i++;
+			continue;
+		}
+		if (ch === "/") {
+			tokens.push({ kind: "slash" });
+			i++;
+			const fixed = /^[1-9][0-9]*/.exec(src.slice(i));
+			if (fixed !== null) {
+				tokens.push({
+					kind: "fixedDenominator",
+					text: fixed[0]
+				});
+				i += fixed[0].length;
+			}
+			continue;
+		}
+		if (ch === "@") {
+			tokens.push({ kind: "textPlaceholder" });
+			i++;
+			continue;
+		}
+		const long = src.slice(i, i + 5);
+		if (long.toUpperCase() === MERIDIEM_LONG) {
+			tokens.push(meridiemToken(long));
+			i += 5;
+			continue;
+		}
+		const short = src.slice(i, i + 3);
+		if (short.toUpperCase() === MERIDIEM_SHORT) {
+			tokens.push(meridiemToken(short));
+			i += 3;
+			continue;
+		}
+		if (src.slice(i, i + 7).toLowerCase() === "general") {
+			tokens.push({ kind: "general" });
+			i += 7;
+			continue;
+		}
+		const lower = ch.toLowerCase();
+		if (lower === "e") {
+			const sign = src.charAt(i + 1);
+			if (sign !== "+" && sign !== "-") return void 0;
+			tokens.push({
+				kind: "exponent",
+				explicitSign: sign === "+"
+			});
+			i += 2;
+			continue;
+		}
+		if (lower === "y" || lower === "m" || lower === "d" || lower === "h" || lower === "s") {
+			let width = 1;
+			while (src.charAt(i + width).toLowerCase() === lower) width++;
+			tokens.push({
+				kind: "datePart",
+				part: datePartOf(lower),
+				width
+			});
+			i += width;
+			continue;
+		}
+		if (lower === "g" || lower === "b") return void 0;
+		pushLiteral(tokens, ch);
+		i++;
+	}
+	return tokens;
+};
+const splitSections = (code) => {
+	const out = [];
+	let start = 0;
+	let i = 0;
+	while (i < code.length) {
+		const ch = code.charAt(i);
+		if (ch === "\"") {
+			const end = code.indexOf("\"", i + 1);
+			if (end === -1) return void 0;
+			i = end + 1;
+			continue;
+		}
+		if (ch === "[") {
+			const end = code.indexOf("]", i + 1);
+			if (end === -1) return void 0;
+			i = end + 1;
+			continue;
+		}
+		if (ch === "\\" || ch === "_" || ch === "*") {
+			i += 2;
+			continue;
+		}
+		if (ch === ";") {
+			out.push(code.slice(start, i));
+			start = i + 1;
+		}
+		i++;
+	}
+	out.push(code.slice(start));
+	return out;
+};
+const literalFor = (token) => {
+	switch (token.kind) {
+		case "literal":
+		case "fixedDenominator": return token.text;
+		case "percent": return "%";
+		case "slash": return "/";
+		case "point": return ".";
+		case "comma": return GROUP_SEPARATOR;
+		default: return "";
+	}
+};
+const onlyCommasBetween = (tokens, from, to) => {
+	for (let i = from + 1; i < to; i++) if (tokens[i]?.kind !== "comma") return false;
+	return true;
+};
+/**
+* A comma means three different things depending on where it sits: thousands
+* grouping between digit placeholders, division by a thousand after the last
+* one, and a plain comma anywhere else.
+*/
+const resolveCommas = (tokens) => {
+	const isDigit = tokens.map((t) => t.kind === "digit");
+	const firstDigit = isDigit.indexOf(true);
+	const lastDigit = isDigit.lastIndexOf(true);
+	const out = [];
+	let grouped = false;
+	let scale = 0;
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === void 0) continue;
+		if (token.kind !== "comma") {
+			out.push(token);
+			continue;
+		}
+		if (firstDigit !== -1 && i > firstDigit && i < lastDigit) {
+			grouped = true;
+			continue;
+		}
+		if (lastDigit !== -1 && i > lastDigit && onlyCommasBetween(tokens, lastDigit, i)) {
+			scale++;
+			continue;
+		}
+		pushLiteral(out, GROUP_SEPARATOR);
+	}
+	return {
+		tokens: out,
+		grouped,
+		scale
+	};
+};
+const placeholdersIn = (tokens, from, to) => {
+	const out = [];
+	for (let i = from; i < to; i++) {
+		const token = tokens[i];
+		if (token?.kind === "digit") out.push(token.placeholder);
+	}
+	return out;
+};
+const resolveNumberSection = (resolved) => {
+	const { tokens } = resolved;
+	if (tokens.filter((t) => t.kind === "point").length > 1) return void 0;
+	if (tokens.filter((t) => t.kind === "exponent").length > 1) return void 0;
+	const pointIndex = tokens.findIndex((t) => t.kind === "point");
+	const exponentIndex = tokens.findIndex((t) => t.kind === "exponent");
+	const intEnd = pointIndex !== -1 ? pointIndex : exponentIndex !== -1 ? exponentIndex : tokens.length;
+	const fracEnd = exponentIndex !== -1 ? exponentIndex : tokens.length;
+	const exponentToken = exponentIndex === -1 ? void 0 : tokens[exponentIndex];
+	return {
+		kind: "number",
+		tokens,
+		grouped: resolved.grouped,
+		scale: resolved.scale,
+		percents: tokens.filter((t) => t.kind === "percent").length,
+		intEnd,
+		intPlaceholders: placeholdersIn(tokens, 0, intEnd),
+		fracPlaceholders: pointIndex === -1 ? [] : placeholdersIn(tokens, pointIndex + 1, fracEnd),
+		exponentIndex,
+		exponentDigits: exponentIndex === -1 ? 0 : placeholdersIn(tokens, exponentIndex + 1, tokens.length).length,
+		exponentExplicitSign: exponentToken?.kind === "exponent" ? exponentToken.explicitSign : false
+	};
+};
+const digitRunStart = (tokens, end) => {
+	let start = end;
+	while (start > 0 && tokens[start - 1]?.kind === "digit") start--;
+	return start;
+};
+/** `# ??/??`: a slash with digit placeholders on both sides is a fraction. */
+const resolveFractionSection = (tokens) => {
+	const slashIndex = tokens.findIndex((t) => t.kind === "slash");
+	if (slashIndex < 1 || tokens[slashIndex - 1]?.kind !== "digit") return void 0;
+	const numeratorStart = digitRunStart(tokens, slashIndex);
+	const after = tokens[slashIndex + 1];
+	let denominatorEnd;
+	let fixedDenominator = 0;
+	if (after?.kind === "digit") {
+		denominatorEnd = slashIndex + 1;
+		while (tokens[denominatorEnd]?.kind === "digit") denominatorEnd++;
+	} else if (after?.kind === "fixedDenominator") {
+		denominatorEnd = slashIndex + 2;
+		fixedDenominator = Number(after.text);
+		if (!Number.isSafeInteger(fixedDenominator) || fixedDenominator === 0) return void 0;
+	} else return;
+	let wholeEnd = -1;
+	let wholeStart = -1;
+	for (let i = numeratorStart - 1; i >= 0; i--) {
+		if (tokens[i]?.kind !== "digit") continue;
+		wholeEnd = i + 1;
+		wholeStart = digitRunStart(tokens, wholeEnd);
+		break;
+	}
+	return {
+		kind: "fraction",
+		tokens,
+		slashIndex,
+		wholeStart,
+		wholeEnd,
+		numeratorStart,
+		denominatorEnd,
+		denominatorDigits: fixedDenominator > 0 ? 0 : placeholdersIn(tokens, slashIndex + 1, denominatorEnd).length,
+		fixedDenominator
+	};
+};
+const nextDateToken = (tokens, index, step) => {
+	for (let i = index + step; i >= 0 && i < tokens.length; i += step) {
+		const token = tokens[i];
+		if (token === void 0) return void 0;
+		if (token.kind === "datePart" || token.kind === "elapsed") return token;
+	}
+};
+const resolveDateSection = (tokens) => {
+	const withSubseconds = [];
+	let subsecondDigits = 0;
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === void 0) continue;
+		if (token.kind !== "point") {
+			withSubseconds.push(token);
+			continue;
+		}
+		let digits = 0;
+		for (let j = i + 1; j < tokens.length; j++) {
+			const next = tokens[j];
+			if (next?.kind !== "digit" || next.placeholder !== "0") break;
+			digits++;
+		}
+		const previous = withSubseconds[withSubseconds.length - 1];
+		const afterSeconds = previous?.kind === "datePart" || previous?.kind === "elapsed" ? previous.part === "second" : false;
+		if (digits === 0 || !afterSeconds) {
+			pushLiteral(withSubseconds, ".");
+			continue;
+		}
+		withSubseconds.push({
+			kind: "subsecond",
+			digits
+		});
+		subsecondDigits = Math.max(subsecondDigits, digits);
+		i += digits;
+	}
+	const resolved = withSubseconds.map((token, index) => {
+		if (token.kind !== "datePart" || token.part !== "monthOrMinute") return token;
+		if (token.width >= NAME_TOKEN_WIDTH) return {
+			kind: "datePart",
+			part: "month",
+			width: token.width
+		};
+		const previous = nextDateToken(withSubseconds, index, -1);
+		const next = nextDateToken(withSubseconds, index, 1);
+		return {
+			kind: "datePart",
+			part: previous?.part === "hour" || next?.part === "second" ? "minute" : "month",
+			width: token.width
+		};
+	});
+	const elapsed = resolved.some((t) => t.kind === "elapsed");
+	const calendarPart = resolved.some((t) => t.kind === "datePart" && (t.part === "year" || t.part === "month" || t.part === "day"));
+	if (resolved.some((t) => t.kind === "digit" || t.kind === "exponent")) return void 0;
+	if (elapsed && calendarPart) return void 0;
+	return {
+		kind: "date",
+		tokens: resolved,
+		elapsed,
+		calendar: calendarPart,
+		hasMeridiem: resolved.some((t) => t.kind === "meridiem"),
+		subsecondDigits
+	};
+};
+const parseSection = (src) => {
+	const tokens = tokenizeSection(src);
+	if (tokens === void 0) return void 0;
+	if (tokens.length === 0) return { kind: "blank" };
+	if (tokens.some((t) => t.kind === "general")) return tokens.length === 1 ? { kind: "general" } : void 0;
+	const hasText = tokens.some((t) => t.kind === "textPlaceholder");
+	const hasDate = tokens.some((t) => t.kind === "datePart" || t.kind === "elapsed" || t.kind === "meridiem");
+	if (hasText && hasDate) return void 0;
+	if (hasText) return {
+		kind: "text",
+		tokens
+	};
+	if (hasDate) return resolveDateSection(tokens);
+	if (tokens.every((token) => token.kind === "literal")) return {
+		kind: "literal",
+		text: tokens.map(literalFor).join("")
+	};
+	const resolved = resolveCommas(tokens);
+	return resolveFractionSection(resolved.tokens) ?? resolveNumberSection(resolved);
+};
+/**
+* Distinct format codes in a workbook number in the tens while cells number in
+* the millions, so the parse is memoised. Both bounds exist because the codes
+* arrive from an untrusted `styles.xml`: a full map drops its oldest entry
+* rather than every entry, so a workbook carrying more codes than fit loses one
+* cached parse per new code instead of all of them, and a code longer than the
+* 255 characters Excel itself allows is parsed on each call rather than stored.
+*/
+const PARSE_CACHE_LIMIT = 256;
+const MAX_CACHED_CODE_LENGTH = 255;
+const parseCache = /* @__PURE__ */ new Map();
+const buildFormat = (code) => {
+	const raw = splitSections(code);
+	if (raw === void 0 || raw.length > MAX_SECTIONS) return void 0;
+	const sections = [];
+	for (const src of raw) {
+		const section = parseSection(src);
+		if (section === void 0) return void 0;
+		sections.push(section);
+	}
+	return { sections };
+};
+/** Parse a `numFmt` format code, or `undefined` when it is out of scope. */
+function parseFormatCode(code) {
+	const cached = parseCache.get(code);
+	if (cached !== void 0) return cached.format;
+	const format = buildFormat(code);
+	if (code.length > MAX_CACHED_CODE_LENGTH) return format;
+	if (parseCache.size >= PARSE_CACHE_LIMIT) {
+		const oldest = parseCache.keys().next().value;
+		if (oldest !== void 0) parseCache.delete(oldest);
+	}
+	parseCache.set(code, { format });
+	return format;
+}
+/**
+* True when the format reads as a calendar date: a date section carrying a
+* year, month or day, rather than a time of day (`h:mm`), an elapsed span
+* (`[h]:mm`) or a numeric layout. The section selected for the value decides.
+*/
+function hasCalendarDate(format, value) {
+	const first = pickSection(format.sections, value)?.section;
+	return first?.kind === "date" && first.calendar;
+}
+const padFor = (placeholder) => {
+	if (placeholder === "0") return "0";
+	return placeholder === "?" ? " " : "";
+};
+const withGrouping = (digits, grouped) => {
+	if (!grouped || digits.length <= GROUP_SIZE) return digits;
+	const groups = [];
+	for (let end = digits.length; end > 0; end -= GROUP_SIZE) groups.unshift(digits.slice(Math.max(0, end - GROUP_SIZE), end));
+	return groups.join(GROUP_SEPARATOR);
+};
+/**
+* Render `[from, to)` right to left, feeding `digits` into the placeholders from
+* the low-order end. The leftmost placeholder absorbs whatever is left over,
+* which is how `#,##0` still prints all seven digits of 1,234,567.
+*/
+const renderDigitsRightToLeft = (tokens, from, to, digits) => {
+	const leftmost = placeholderIndex(tokens, from, to);
+	const pieces = [];
+	let pos = digits.length;
+	for (let i = to - 1; i >= from; i--) {
+		const token = tokens[i];
+		if (token === void 0) continue;
+		if (token.kind !== "digit") {
+			pieces.push(literalFor(token));
+			continue;
+		}
+		if (i === leftmost) {
+			pieces.push(pos > 0 ? digits.slice(0, pos) : padFor(token.placeholder));
+			pos = 0;
+			continue;
+		}
+		if (pos === 0) {
+			pieces.push(padFor(token.placeholder));
+			continue;
+		}
+		let take = pos - 1;
+		while (take > 0 && digits.charAt(take - 1) === GROUP_SEPARATOR) take--;
+		pieces.push(digits.slice(take, pos));
+		pos = take;
+	}
+	pieces.reverse();
+	return pieces.join("");
+};
+const placeholderIndex = (tokens, from, to) => {
+	for (let i = from; i < to; i++) if (tokens[i]?.kind === "digit") return i;
+	return -1;
+};
+/** `#` drops trailing zeros, `?` blanks them, `0` keeps them. */
+const renderFracDigits = (placeholders, digits) => {
+	const pieces = [];
+	let trailing = true;
+	for (let i = placeholders.length - 1; i >= 0; i--) {
+		const placeholder = placeholders[i];
+		if (placeholder === void 0) continue;
+		const digit = digits.charAt(i);
+		if (trailing && digit === "0" && placeholder !== "0") {
+			pieces.push(placeholder === "?" ? " " : "");
+			continue;
+		}
+		trailing = false;
+		pieces.push(digit);
+	}
+	pieces.reverse();
+	return pieces.join("");
+};
+const assembleNumber = (section, parts, exponentText) => {
+	const minIntDigits = section.intPlaceholders.filter((p) => p === "0").length;
+	const intDigits = withGrouping(parts.int.replace(/^0+/, "").padStart(minIntDigits, "0"), section.grouped);
+	const head = renderDigitsRightToLeft(section.tokens, 0, section.intEnd, intDigits);
+	const intText = section.intPlaceholders.length === 0 ? head + intDigits : head;
+	const fracText = renderFracDigits(section.fracPlaceholders, parts.frac);
+	const tail = [];
+	let fracEmitted = false;
+	for (let i = section.intEnd; i < section.tokens.length; i++) {
+		const token = section.tokens[i];
+		if (token === void 0) continue;
+		if (token.kind === "point") {
+			tail.push(fracText.length > 0 ? "." : "");
+			continue;
+		}
+		if (token.kind === "exponent") {
+			tail.push(exponentText);
+			continue;
+		}
+		if (token.kind === "digit") {
+			if (section.exponentIndex !== -1 && i > section.exponentIndex) continue;
+			if (!fracEmitted) {
+				tail.push(fracText);
+				fracEmitted = true;
+			}
+			continue;
+		}
+		tail.push(literalFor(token));
+	}
+	return intText + tail.join("");
+};
+const partsAreZero = (parts) => !/[1-9]/.test(parts.int + parts.frac);
+const renderScientificSection = (section, magnitude) => {
+	const decimals = section.fracPlaceholders.length;
+	const step = Math.max(1, section.intPlaceholders.length);
+	let digits = significantDigits(magnitude);
+	let order = decimalOrder(magnitude);
+	for (;;) {
+		const exponent = magnitude === 0 ? 0 : Math.floor(order / step) * step;
+		const intWidth = order - exponent + 1;
+		const parts = roundParts(digits.slice(0, intWidth).padEnd(intWidth, "0") || "0", digits.slice(intWidth), decimals);
+		if (parts.int.length > intWidth) {
+			order += 1;
+			digits = "1";
+			continue;
+		}
+		const exponentText = `E${exponent < 0 ? "-" : section.exponentExplicitSign ? "+" : ""}${String(Math.abs(exponent)).padStart(section.exponentDigits, "0")}`;
+		return {
+			text: assembleNumber(section, parts, exponentText),
+			zero: partsAreZero(parts)
+		};
+	}
+};
+const renderNumberSection = (section, magnitude) => {
+	const scaled = magnitude * PERCENT_MULTIPLIER ** section.percents / SCALE_DIVISOR ** section.scale;
+	if (!Number.isFinite(scaled)) return void 0;
+	if (section.exponentIndex !== -1) return renderScientificSection(section, scaled);
+	const parts = roundDecimal(scaled, section.fracPlaceholders.length);
+	return {
+		text: assembleNumber(section, parts, ""),
+		zero: partsAreZero(parts)
+	};
+};
+/**
+* Closest `p/q` with `q <= maxDenominator`. Continued-fraction convergents alone
+* are not always the closest (0.7 gives 2/3 before 5/7), so the last step also
+* weighs the best semiconvergent.
+*/
+const bestFraction = (value, maxDenominator) => {
+	let numeratorPrev = 0;
+	let numerator = 1;
+	let denominatorPrev = 1;
+	let denominator = 0;
+	let best = {
+		numerator: Math.round(value),
+		denominator: 1
+	};
+	let x = value;
+	for (let term = 0; term < FRACTION_MAX_TERMS; term++) {
+		const a = Math.floor(x);
+		const nextNumerator = a * numerator + numeratorPrev;
+		const nextDenominator = a * denominator + denominatorPrev;
+		if (nextDenominator > maxDenominator) {
+			const steps = Math.floor((maxDenominator - denominatorPrev) / denominator);
+			if (steps > 0) {
+				const candidate = {
+					numerator: steps * numerator + numeratorPrev,
+					denominator: steps * denominator + denominatorPrev
+				};
+				if (Math.abs(value - candidate.numerator / candidate.denominator) < Math.abs(value - best.numerator / best.denominator)) best = candidate;
+			}
+			break;
+		}
+		numeratorPrev = numerator;
+		numerator = nextNumerator;
+		denominatorPrev = denominator;
+		denominator = nextDenominator;
+		best = {
+			numerator,
+			denominator
+		};
+		const remainder = x - a;
+		if (remainder < FRACTION_EPSILON) break;
+		x = 1 / remainder;
+	}
+	return best;
+};
+const blankFor = (placeholder) => placeholder === "#" ? "" : " ";
+const renderDigitsLeftToRight = (tokens, from, to, digits) => {
+	const pieces = [];
+	let pos = 0;
+	const lastPlaceholder = lastPlaceholderIndex(tokens, from, to);
+	for (let i = from; i < to; i++) {
+		const token = tokens[i];
+		if (token === void 0) continue;
+		if (token.kind !== "digit") {
+			pieces.push(literalFor(token));
+			continue;
+		}
+		if (i === lastPlaceholder) {
+			pieces.push(pos < digits.length ? digits.slice(pos) : padFor(token.placeholder));
+			pos = digits.length;
+			continue;
+		}
+		if (pos < digits.length) {
+			pieces.push(digits.charAt(pos));
+			pos++;
+			continue;
+		}
+		pieces.push(padFor(token.placeholder));
+	}
+	return pieces.join("");
+};
+const lastPlaceholderIndex = (tokens, from, to) => {
+	for (let i = to - 1; i >= from; i--) if (tokens[i]?.kind === "digit") return i;
+	return -1;
+};
+const blankRange = (tokens, from, to) => {
+	const pieces = [];
+	for (let i = from; i < to; i++) {
+		const token = tokens[i];
+		if (token === void 0) continue;
+		pieces.push(token.kind === "digit" ? blankFor(token.placeholder) : token.kind === "slash" ? " " : literalFor(token));
+	}
+	return pieces.join("");
+};
+/** The digits a code spells the denominator out as: `16` in `# ?/16`. */
+const fixedDenominatorText = (section) => {
+	const token = section.tokens[section.slashIndex + 1];
+	return token?.kind === "fixedDenominator" ? token.text : "";
+};
+/**
+* `?` and `#` pad the denominator on the right, which is what lines the slash up
+* down a column. A `0` cannot: a pad zero on the right would multiply the
+* denominator by ten, so a run carrying one fills from the right instead.
+*/
+const denominatorText = (section, denominator) => {
+	const from = section.slashIndex + 1;
+	const digits = String(denominator);
+	return placeholdersIn(section.tokens, from, section.denominatorEnd).includes("0") ? renderDigitsRightToLeft(section.tokens, from, section.denominatorEnd, digits) : renderDigitsLeftToRight(section.tokens, from, section.denominatorEnd, digits);
+};
+const renderFractionSection = (section, magnitude) => {
+	const hasWhole = section.wholeStart !== -1;
+	const maxDenominator = section.fixedDenominator > 0 ? section.fixedDenominator : 10 ** section.denominatorDigits - 1;
+	let whole = hasWhole ? Math.floor(magnitude) : 0;
+	const remainder = magnitude - whole;
+	const approximation = section.fixedDenominator > 0 ? {
+		numerator: Math.round(remainder * section.fixedDenominator),
+		denominator: section.fixedDenominator
+	} : bestFraction(remainder, Math.max(1, maxDenominator));
+	const denominator = approximation.denominator;
+	let numerator = approximation.numerator;
+	if (hasWhole && numerator === denominator && numerator !== 0) {
+		whole += 1;
+		numerator = 0;
+	}
+	const pieces = [];
+	if (hasWhole) {
+		pieces.push(renderDigitsRightToLeft(section.tokens, 0, section.wholeStart, ""));
+		const wholeDigits = whole === 0 ? "" : String(whole);
+		pieces.push(renderDigitsRightToLeft(section.tokens, section.wholeStart, section.wholeEnd, wholeDigits));
+		pieces.push(blankRange(section.tokens, section.wholeEnd, section.numeratorStart));
+	} else pieces.push(renderDigitsRightToLeft(section.tokens, 0, section.numeratorStart, ""));
+	if (numerator === 0 && hasWhole) {
+		pieces.push(blankRange(section.tokens, section.numeratorStart, section.slashIndex + 1));
+		pieces.push(section.fixedDenominator > 0 ? " ".repeat(fixedDenominatorText(section).length) : blankRange(section.tokens, section.slashIndex + 1, section.denominatorEnd));
+	} else {
+		pieces.push(renderDigitsRightToLeft(section.tokens, section.numeratorStart, section.slashIndex, String(numerator)));
+		pieces.push("/");
+		pieces.push(section.fixedDenominator > 0 ? fixedDenominatorText(section) : denominatorText(section, denominator));
+	}
+	pieces.push(renderDigitsRightToLeft(section.tokens, section.denominatorEnd, section.tokens.length, ""));
+	return {
+		text: pieces.join(""),
+		zero: whole === 0 && numerator === 0
+	};
+};
+/**
+* Excel's `General`: the value at the 15 significant digits Excel stores, which
+* is what turns `1.1 + 2.2` into `3.3` instead of `3.3000000000000003`. How
+* many of those digits Excel shows, and where it gives up and switches to
+* scientific notation, also depends on the column width, which is not part of
+* the cell data, so every stored digit is kept and the notation switches where
+* JavaScript's own shortest round-trip form does.
+*/
+const renderGeneral = (magnitude) => {
+	const plain = String(Number(magnitude.toPrecision(EXCEL_SIGNIFICANT_DIGITS)));
+	const exponential = /^(\d(?:\.\d+)?)e([+-])(\d+)$/.exec(plain);
+	if (exponential === null) return plain;
+	return `${exponential[1] ?? ""}E${exponential[2] ?? ""}${(exponential[3] ?? "").padStart(GENERAL_EXPONENT_DIGITS, "0")}`;
+};
+const twoDigits = (value, width) => width === 1 ? String(value) : String(value).padStart(2, "0");
+const renderDatePart = (token, fields, hasMeridiem) => {
+	switch (token.part) {
+		case "year": return token.width <= 2 ? String(fields.year % 100).padStart(2, "0") : String(fields.year).padStart(FULL_YEAR_DIGITS, "0");
+		case "month": {
+			if (token.width < NAME_TOKEN_WIDTH) return twoDigits(fields.month, token.width);
+			const name = MONTH_NAMES[fields.month - 1] ?? "";
+			if (token.width === NAME_TOKEN_WIDTH) return name.slice(0, NAME_TOKEN_WIDTH);
+			return token.width === MONTH_FULL_WIDTH ? name : name.slice(0, 1);
+		}
+		case "day": {
+			if (token.width < NAME_TOKEN_WIDTH) return twoDigits(fields.day, token.width);
+			const name = WEEKDAY_NAMES[fields.weekday] ?? "";
+			return token.width === NAME_TOKEN_WIDTH ? name.slice(0, NAME_TOKEN_WIDTH) : name;
+		}
+		case "hour": {
+			const hour = hasMeridiem ? fields.hour % HOURS_PER_HALF_DAY || HOURS_PER_HALF_DAY : fields.hour;
+			return twoDigits(hour, token.width);
+		}
+		case "minute": return twoDigits(fields.minute, token.width);
+		case "second": return twoDigits(fields.second, token.width);
+		default: return "";
+	}
+};
+const renderElapsed = (token, fields) => {
+	const total = token.part === "hour" ? Math.floor(fields.totalSeconds / SECONDS_PER_HOUR) : token.part === "minute" ? Math.floor(fields.totalSeconds / SECONDS_PER_MINUTE) : fields.totalSeconds;
+	return String(total).padStart(token.width, "0");
+};
+/**
+* A section can carry two fractional-second groups of different widths
+* (`[ss].000" "ss.0`). The serial is rounded once, at the widest, so a narrower
+* group rounds the digits that rounding already produced.
+*/
+const subsecondText = (subsecond, digits) => {
+	if (digits >= subsecond.length) return subsecond.padEnd(digits, "0");
+	const kept = subsecond.slice(0, digits);
+	if (subsecond.charCodeAt(digits) < FIVE_CHAR_CODE) return kept;
+	const bumped = carryOne(kept);
+	return bumped.length > digits ? "9".repeat(digits) : bumped;
+};
+const renderDateTokens = (section, fields) => {
+	const pieces = [];
+	for (const token of section.tokens) switch (token.kind) {
+		case "datePart":
+			pieces.push(renderDatePart(token, fields, section.hasMeridiem));
+			break;
+		case "elapsed":
+			pieces.push(renderElapsed(token, fields));
+			break;
+		case "meridiem":
+			pieces.push(fields.hour < HOURS_PER_HALF_DAY ? token.am : token.pm);
+			break;
+		case "subsecond":
+			pieces.push(`.${subsecondText(fields.subsecond, token.digits)}`);
+			break;
+		default: pieces.push(literalFor(token));
+	}
+	return pieces.join("");
+};
+const renderDateSection = (section, serial, epoch) => {
+	const subDigits = Math.min(section.subsecondDigits, MAX_SUBSECOND_DIGITS);
+	const subUnits = 10 ** subDigits;
+	const unitsPerDay = SECONDS_PER_DAY * subUnits;
+	const units = Math.round(serial * unitsPerDay);
+	if (!Number.isSafeInteger(units)) return void 0;
+	const totalSeconds = Math.floor(units / subUnits);
+	const subsecond = String(units % subUnits).padStart(subDigits, "0");
+	if (section.elapsed) return renderDateTokens(section, {
+		year: 0,
+		month: 1,
+		day: 1,
+		weekday: 0,
+		hour: Math.floor(totalSeconds / SECONDS_PER_HOUR) % HOURS_PER_DAY,
+		minute: Math.floor(totalSeconds / SECONDS_PER_MINUTE) % MINUTES_PER_HOUR,
+		second: totalSeconds % SECONDS_PER_MINUTE,
+		totalSeconds,
+		subsecond
+	});
+	const date = excelToDate(units / unitsPerDay, { epoch });
+	if (Number.isNaN(date.getTime())) return void 0;
+	return renderDateTokens(section, {
+		year: date.getUTCFullYear(),
+		month: date.getUTCMonth() + 1,
+		day: date.getUTCDate(),
+		weekday: date.getUTCDay(),
+		hour: date.getUTCHours(),
+		minute: date.getUTCMinutes(),
+		second: date.getUTCSeconds(),
+		totalSeconds,
+		subsecond
+	});
+};
+/**
+* Excel picks the section by sign: one section covers everything, two split
+* at zero, three or four add a dedicated zero branch. Only a lone section has
+* to be handed the sign, because the others spell their own.
+*/
+const pickSection = (sections, value) => {
+	const first = sections[0];
+	if (first === void 0) return void 0;
+	if (sections.length === 1) return {
+		section: first,
+		signed: value < 0
+	};
+	if (value < 0) {
+		const negative = sections[1];
+		return negative === void 0 ? void 0 : {
+			section: negative,
+			signed: false
+		};
+	}
+	if (value === 0 && sections.length > 2) {
+		const zero = sections[2];
+		return zero === void 0 ? void 0 : {
+			section: zero,
+			signed: false
+		};
+	}
+	return {
+		section: first,
+		signed: false
+	};
+};
+const renderSection = (section, magnitude, epoch) => {
+	switch (section.kind) {
+		case "literal": return {
+			text: section.text,
+			zero: true
+		};
+		case "blank": return {
+			text: "",
+			zero: true
+		};
+		case "general":
+		case "text": return {
+			text: renderGeneral(magnitude),
+			zero: magnitude === 0
+		};
+		case "number": return renderNumberSection(section, magnitude);
+		case "fraction": return renderFractionSection(section, magnitude);
+		case "date": {
+			const text = renderDateSection(section, magnitude, epoch);
+			return text === void 0 ? void 0 : {
+				text,
+				zero: false
+			};
+		}
+	}
+};
+/**
+* Render a numeric cell value (a plain number, or a date / duration already
+* converted to its Excel serial). `undefined` means the value has no reading
+* under this format and the caller should degrade.
+*/
+function renderNumericValue(format, value, epoch) {
+	if (!Number.isFinite(value)) return void 0;
+	const picked = pickSection(format.sections, value);
+	if (picked === void 0) return void 0;
+	if (picked.section.kind === "date" && !picked.section.elapsed && value < 0) return void 0;
+	const rendered = renderSection(picked.section, Math.abs(value), epoch);
+	if (rendered === void 0) return void 0;
+	if (!picked.signed || rendered.zero) return rendered.text;
+	return `-${rendered.text}`;
+}
+/**
+* Render a string cell value. Only the fourth section of a code applies to
+* text, plus a lone section that is itself a text layout (`@" pcs"`); under any
+* other code Excel prints the string unchanged.
+*/
+function renderTextValue(format, text) {
+	const section = format.sections.length === MAX_SECTIONS ? format.sections[MAX_SECTIONS - 1] : format.sections.length === 1 ? format.sections[0] : void 0;
+	if (section === void 0) return text;
+	if (section.kind === "blank") return "";
+	if (section.kind === "literal" && format.sections.length === MAX_SECTIONS) return section.text;
+	if (section.kind !== "text") return text;
+	return section.tokens.map((token) => token.kind === "textPlaceholder" ? text : literalFor(token)).join("");
+}
+//#endregion
+//#region src/styles/display-text.ts
+const epochOf = (wb) => wb.date1904 ? "mac" : "windows";
+const renderValue = (format, value, epoch) => {
+	if (isRichTextValue(value)) return renderTextValue(format, richTextToString(value.runs));
+	if (typeof value === "string") return renderTextValue(format, value);
+	if (value instanceof Date) return renderNumericValue(format, dateToExcel(value, { epoch }), epoch);
+	if (isDurationValue(value)) return Number.isFinite(value.ms) ? renderNumericValue(format, durationToExcel(value.ms), epoch) : void 0;
+	if (typeof value === "number") return renderNumericValue(format, value, epoch);
+};
+const displayText = (code, value, epoch) => {
+	if (value === null) return "";
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	if (isErrorValue(value)) return value.code;
+	if (value instanceof Date && Number.isNaN(value.getTime())) return String(value);
+	if (isFormulaValue(value)) {
+		if (value.cachedValue === void 0) return "";
+		if (value.cachedValueType === "error") return String(value.cachedValue);
+		return displayText(code, value.cachedValue, epoch);
+	}
+	const format = parseFormatCode(code);
+	if (format === void 0) return cellValueAsString(value);
+	return renderValue(format, value, epoch) ?? cellValueAsString(value);
+};
+/**
+* The text Excel prints in `c`: the cell's value put through the number format
+* its style points at.
+*
+* This is not a shorter `cellValueAsString`. That one takes a `CellValue` and
+* answers "what is this value in JavaScript terms", so it never sees the
+* stylesheet and cannot know that `0.5` is a percentage or that `45365` is a
+* date. This one takes the workbook and the cell, resolves the cell's `numFmt`,
+* and answers "what would somebody looking at this file in Excel read". Pick
+* `cellValueAsString` when you want the value and this when you want the text:
+* writing a sheet out as CSV, rendering it as HTML, diffing two workbooks by
+* what they show, or logging a cell for a human. Choosing wrong fails quietly,
+* which is why both say so.
+*
+* Covered:
+*
+* - `General`, at the 15 significant digits Excel stores. This is what turns
+*   `=1.1+2.2` into `3.3` rather than `3.3000000000000003`.
+* - Every code in `BUILTIN_FORMATS`, including the accounting codes,
+*   scientific notation and the two fraction codes. The one exception is that
+*   catalogue's entry for numFmtId 44, whose stored form is missing the `;`
+*   section separators Excel's own accounting code carries, so it reads as a
+*   text layout.
+* - Custom numeric codes: `0` `#` `?` digit placeholders, thousands grouping,
+*   trailing commas that divide by a thousand, `%`, `E+`/`E-` (including the
+*   engineering step `##0.0E+0`), `?/?` fractions with a placeholder or a
+*   spelled-out denominator, quoted and `\`-escaped literals, `_x` width
+*   reservations, currency symbols, and colour codes (which change nothing
+*   about the text).
+* - The positive / negative / zero / text sections of a multi-section code. A
+*   lone section takes the minus sign in front of it; a value that rounds to
+*   zero prints without one.
+* - Dates and times: `y` `m` `d` `h` `s` runs, `mmm` / `mmmm` month names,
+*   `ddd` / `dddd` weekday names, `AM/PM` and `A/P`, fractional seconds, and
+*   the elapsed forms `[h]` `[mm]` `[ss]`.
+* - Booleans as `TRUE` / `FALSE`, error cells as their token, rich text as its
+*   runs joined, a formula cell from the value Excel cached for it, and an
+*   empty cell as `''`.
+*
+* Not covered, and the cell falls back to `cellValueAsString` so the reading is
+* a plain coercion rather than a guess:
+*
+* - Comparison sections (`[>=100]"over";[<0]"under";0`).
+* - A section splicing two numeric layouts together (`0.00" ("0.00")"`).
+* - Calendar and numbering modifiers: era tokens (`g`, `e`, `b`) and bracket
+*   groups such as `[DBNum1]` that replace the digits themselves.
+* - More than four sections, or an unterminated `"` or `[`.
+*
+* Three more places where the text is a judgement call, because Excel's own
+* answer is not recoverable from the cell:
+*
+* - `*x` repeats `x` until the column is full, so nothing is printed for it.
+* - Month and weekday names come out in English; a `[$-409]`-style locale tag
+*   is read for its currency symbol and otherwise ignored.
+* - How wide the column is decides how many digits `General` shows and when it
+*   gives up and switches to scientific notation. Every stored digit is kept.
+*
+* A `Date` cell value is converted to its serial and run through the format, so
+* it reads as a date only if the cell carries a date format. That is the same
+* rule the file itself follows: the worksheet stores a serial and the style
+* decides what it means. Use `setCellAsDate` on the write side.
+*/
+function getCellDisplayText(wb, c) {
+	return displayText(getCellNumberFormat(wb, c), c.value, epochOf(wb));
+}
+/**
+* The `Date` a date-formatted cell stands for, or `undefined` when the cell has
+* no date reading.
+*
+* Excel stores a date as a plain number of days since the workbook epoch, so
+* nothing in a loaded cell's value distinguishes `45365` the date from `45365`
+* the count: the cell's number format is the only evidence, and
+* `cellValueAsDate` deliberately does not consult it. This composes the three
+* steps that reading one otherwise takes, `getCellNumberFormat` then the
+* format's own reading then `excelToDate` with the epoch from `wb.date1904`,
+* into the call that reading a foreign workbook actually needs.
+*
+* - A `Date` value passes through, formatted or not.
+* - A number needs a format that names a day: a year, month or day part.
+*   Without one it is a count, and the answer is `undefined`.
+* - A formula cell is read from the value Excel cached for it.
+* - A time-of-day format (`h:mm`) names a moment inside a day but not which
+*   day, and an elapsed-time format (`[h]:mm`) measures a span rather than
+*   naming a moment, so neither has a date reading. Neither does a `duration`
+*   value: its `ms` is already the span.
+* - The format is read by the parser {@link getCellDisplayText} renders with,
+*   so the two agree on what any one cell is. A code outside the subset that
+*   one documents has no date reading here either.
+*
+* The returned `Date` is built in UTC, which is how `excelToDate` and
+* `dateToExcel` read every serial in this library. Use `getUTCFullYear` and
+* friends, or the local-time accessors will shift the day for anybody east or
+* west of UTC.
+*/
+function getCellDate(wb, c) {
+	const value = isFormulaValue(c.value) ? c.value.cachedValue : c.value;
+	if (value instanceof Date) return value;
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	const format = parseFormatCode(getCellNumberFormat(wb, c));
+	if (format === void 0 || !hasCalendarDate(format, value)) return void 0;
+	const date = excelToDate(value, { epoch: epochOf(wb) });
+	return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+//#endregion
+export { BUILTIN_FORMATS, BUILTIN_FORMATS_MAX_SIZE, BUILTIN_NAMED_STYLES, DEFAULT_FONT, FORMAT_DATE_DATETIME, FORMAT_DATE_TIMEDELTA, FORMAT_DATE_YYYYMMDD2, FORMAT_GENERAL, FORMAT_NUMBER, FORMAT_NUMBER_00, FORMAT_PERCENTAGE, FORMAT_PERCENTAGE_00, FORMAT_TEXT, addBorder, addCellStyleXf, addCellXf, addDxf, addFill, addFont, addNamedStyle, addNumFmt, adjustLightness, adjustSaturation, alignCellHorizontal, alignCellVertical, alignmentToCss, applyBuiltinStyle, applyNamedStyle, borderToCss, builtinFormatCode, builtinFormatId, cellStyleToCss, centerCell, classifyDateFormat, clearCellBackground, clearCellStyle, clearRangeStyle, cloneCellStyle, colorToHex, contrastRatio, copyCellStyle, darken, defaultCellXf, ensureBuiltinStyle, fillToCss, fontToCss, formatAsHeader, getCellAlignment, getCellBorder, getCellDate, getCellDisplayText, getCellFill, getCellFont, getCellNumberFormat, getCellProtection, hexToHsl, hslToHex, indentCell, isBuiltinFormat, isDateFormat, isTimedeltaFormat, lighten, listBorders, listCellStyleXfs, listCellXfs, listFills, listFonts, luminance, makeAlignment, makeBorder, makeColor, makeDifferentialStyle, makeFill, makeFont, makeGradientFill, makeGradientStop, makeNumberFormat, makePatternFill, makeProtection, makeSide, makeStylesheet, mixColors, normaliseRgb, patchCellFont, pickReadableTextColor, registerCellStyle, resolveIndexedColor, rgbColor, rotateCellText, rotateHue, setBold, setCellAlignment, setCellAsCurrency, setCellAsDate, setCellAsNumber, setCellAsPercent, setCellBackgroundColor, setCellBorder, setCellBorderAll, setCellFill, setCellFont, setCellNumberFormat, setCellProtection, setCellStyle, setFontColor, setFontName, setFontSize, setItalic, setRangeAlignment, setRangeBackgroundColor, setRangeBorderBox, setRangeFont, setRangeNumberFormat, setRangeProtection, setRangeStyle, setRangeWrapText, setStrikethrough, setUnderline, wrapCellText };
+
+//# sourceMappingURL=styles.mjs.map