reamkit 1.15.3 → 1.16.0

package/dist/esm/core/number-format.js

@@ -0,0 +1,800 @@
+import { INDEXED_COLORS } from "./indexed-colors.js";
+//#region src/core/number-format.ts
+var BUILTIN = new Map([
+	[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, "# ??/??"],
+	[37, "#,##0_);(#,##0)"],
+	[38, "#,##0_);[Red](#,##0)"],
+	[39, "#,##0.00_);(#,##0.00)"],
+	[40, "#,##0.00_);[Red](#,##0.00)"],
+	[48, "##0.0E+0"],
+	[49, "@"]
+]);
+var BUILTIN_DATE_FORMATS = new Map([
+	[14, "m/d/yyyy"],
+	[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/yyyy h:mm"],
+	[45, "mm:ss"],
+	[46, "[h]:mm:ss"],
+	[47, "mm:ss.0"]
+]);
+/**
+* Render a cell's raw stored value through its number format (§18.8.30 built-ins
+* and §18.8.31 custom codes). Handles `General`, text (`@`), the built-in date /
+* time formats, custom date codes, and the numeric placeholder grammar (`0` `#`
+* `,` `.` `%`, scientific notation, quoted literals, `;`-separated sections). An
+* unknown id, or a value that does not parse as a number, falls back to a plain
+* render of `rawValue`.
+*
+* @param rawValue      The cell's raw stored value (a serial for dates).
+* @param numFmtId      The number-format id from the cell's `cellXf`.
+* @param customFormats Custom format codes by id (from `<numFmts>`).
+* @param date1904      The workbook date epoch (1904 vs the 1900 default).
+* @returns The formatted display string.
+*/
+function applyNumberFormat(rawValue, numFmtId, customFormats, date1904 = false) {
+	if (rawValue.length === 0) return "";
+	if (numFmtId === 0) return defaultNumberRender(rawValue);
+	if (numFmtId === 49) return rawValue;
+	const builtinDate = BUILTIN_DATE_FORMATS.get(numFmtId);
+	if (builtinDate !== void 0) return formatExcelDate(rawValue, builtinDate, date1904);
+	const custom = customFormats.get(numFmtId);
+	if (custom !== void 0 && (isDateFormat(custom) || hasElapsedToken(custom))) return formatExcelDate(rawValue, custom, date1904);
+	const format = custom ?? BUILTIN.get(numFmtId);
+	if (!format) return defaultNumberRender(rawValue);
+	if (format.trim().toLowerCase() === "general") return defaultNumberRender(rawValue);
+	return applyFormatString(rawValue, format);
+}
+/**
+* The colour a number format paints its cell in (§18.8.31), as a 6-digit RRGGBB,
+* or undefined when the section that applies declares none.
+*
+* A `[Red]` at the head of a section is part of the format, not decoration: the
+* accounting codes write the negative section as `[Red]-#,##0.00`, and rendering
+* it in the cell's own font colour loses the one signal the format exists for.
+* `[Color 12]` indexes the same legacy palette a `<color indexed>` does.
+*
+* @param rawValue      The cell's raw stored value — it selects the section.
+* @param numFmtId      The number-format id from the cell's `cellXf`.
+* @param customFormats Custom format codes by id (from `<numFmts>`).
+*/
+function numberFormatColorHex(rawValue, numFmtId, customFormats) {
+	const format = customFormats.get(numFmtId) ?? BUILTIN.get(numFmtId);
+	if (format === void 0 || !format.includes("[")) return void 0;
+	const sections = splitSections(format);
+	const n = Number(rawValue);
+	const idx = Number.isFinite(n) ? sectionIndexFor(n, sections) : 3;
+	if (idx < 0) return void 0;
+	return colorOfSection(sections[idx] ?? sections[0]);
+}
+var FORMAT_COLORS = new Map([
+	["black", "000000"],
+	["blue", "0000FF"],
+	["cyan", "00FFFF"],
+	["green", "00FF00"],
+	["magenta", "FF00FF"],
+	["red", "FF0000"],
+	["white", "FFFFFF"],
+	["yellow", "FFFF00"]
+]);
+function colorOfSection(section) {
+	for (const m of section.matchAll(/\[([^\]]*)\]/g)) {
+		const body = m[1].trim().toLowerCase();
+		const named = FORMAT_COLORS.get(body);
+		if (named !== void 0) return named;
+		const indexed = /^color\s*(\d+)$/.exec(body);
+		if (indexed) {
+			const i = Number(indexed[1]) - 1;
+			if (i >= 0 && i < INDEXED_COLORS.length) return INDEXED_COLORS[i];
+		}
+	}
+}
+/**
+* §18.8.31 — a section may carry a CONDITION in brackets (`[>999]`), and then
+* the sections are no longer positive/negative/zero: the first whose test the
+* value passes applies, and a section without one is the else. Returns the
+* comparison, or undefined for a section that states none.
+*
+* The operator is what tells this bracket from the others a section may carry —
+* `[Red]`, `[$€-407]`, `[h]` — none of which start with one.
+*/
+function conditionOf(section) {
+	const m = /\[\s*(<=|>=|<>|<|>|=)\s*(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*\]/.exec(section);
+	if (!m) return void 0;
+	const rhs = Number(m[2]);
+	return Number.isFinite(rhs) ? {
+		op: m[1],
+		rhs
+	} : void 0;
+}
+function conditionHolds(n, c) {
+	switch (c.op) {
+		case "<": return n < c.rhs;
+		case "<=": return n <= c.rhs;
+		case ">": return n > c.rhs;
+		case ">=": return n >= c.rhs;
+		case "=": return n === c.rhs;
+		default: return n !== c.rhs;
+	}
+}
+/**
+* The section that applies to `n`, or -1 when the format is all conditions and
+* the value passes none of them — Excel then shows the number plainly, which is
+* what FormatChoiceTests.xlsx expects of `[<10]#" Wow"` at 11.
+*/
+function sectionIndexFor(n, sections) {
+	const numeric = Math.min(sections.length, 3);
+	const conditions = sections.slice(0, numeric).map(conditionOf);
+	if (conditions.some((c) => c !== void 0)) {
+		for (let i = 0; i < numeric; i++) {
+			const c = conditions[i];
+			if (c === void 0 || conditionHolds(n, c)) return i;
+		}
+		return -1;
+	}
+	if (n > 0) return 0;
+	if (n < 0) return sections.length > 1 ? 1 : 0;
+	return sections.length > 2 ? 2 : 0;
+}
+/**
+* Excel serial date → JS `Date`. The default 1900 epoch uses 1899-12-30 as day 0
+* (so serial 1 is 1900-01-01) and inherits the Lotus 1-2-3 leap-year bug: serial 60
+* is considered "1900-02-29" which never existed. For serial ≥ 61 the simple
+* formula is exact; values < 60 are vanishingly rare in business sheets (and our
+* render is approximate anyway).
+*
+* The 1904 epoch (legacy Mac Excel) uses 1904-01-01 as day 0 and has no leap bug.
+* Files saved with `<workbookPr date1904="1"/>` store dates offset by exactly 1462
+* days from the 1900-epoch interpretation.
+*/
+function excelSerialToDate(serial, date1904) {
+	const ms = serial * 86400 * 1e3;
+	if (date1904) return new Date(Date.UTC(1904, 0, 1) + ms);
+	return new Date(Date.UTC(1899, 11, 30) + ms);
+}
+/**
+* The inverse over a UTC calendar date: `(year, month0, day)` → the integer Excel
+* serial day, using the same epoch. Round-trips {@link excelSerialToDate} exactly
+* for an integer serial (the time-of-day is zero), so a serial → parts → serial
+* loop is stable. Used by the formula engine's date functions and the `timePeriod`
+* windows (E-SHEET W9) to map an injected reference date into serial space.
+*
+* @param month0 The 0-indexed month (0 = January).
+*/
+function excelSerialFromUtcParts(year, month0, day, date1904) {
+	const epoch = date1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+	return Math.round((Date.UTC(year, month0, day) - epoch) / 864e5);
+}
+var MONTH_ABBR = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+var MONTH_FULL = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+var DAY_ABBR = [
+	"Sun",
+	"Mon",
+	"Tue",
+	"Wed",
+	"Thu",
+	"Fri",
+	"Sat"
+];
+var DAY_FULL = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+function pad2(n) {
+	return String(n).padStart(2, "0");
+}
+/** An elapsed h/m/s count, truncated and zero-padded to its placeholder width. */
+function elapsed(value, width) {
+	const whole = Math.floor(value);
+	const digits = String(Math.abs(whole)).padStart(width, "0");
+	return whole < 0 ? `-${digits}` : digits;
+}
+/**
+* `[h]`, `[mm]`, `[ss]` — the elapsed-time brackets (§18.8.31), which suppress
+* the wrap at 24 h / 60 min / 60 s and count from serial 0 instead.
+*
+* They carry no date letter outside the bracket, so a code like `[ss].00` reads
+* as a plain numeric format to {@link isDateFormat} and lands in the placeholder
+* grammar, where `[ss]` is stripped as if it were a colour and `.00` renders the
+* serial as ".3".
+*/
+function hasElapsedToken(code) {
+	return /\[(?:h+|m+|s+)\]/i.test(code.replace(/"[^"]*"/g, ""));
+}
+function isDateFormat(code) {
+	const cleaned = code.replace(/"[^"]*"/g, "").replace(/\[[^\]]*\]/g, "");
+	return /[dyhs]|m+/i.test(cleaned) && /[dyhs]/i.test(cleaned);
+}
+function tokenizeDateFormat(format) {
+	const tokens = [];
+	let i = 0;
+	while (i < format.length) {
+		const ch = format[i];
+		if (ch === "\"") {
+			let lit = "";
+			i++;
+			while (i < format.length && format[i] !== "\"") {
+				lit += format[i];
+				i++;
+			}
+			i++;
+			tokens.push({
+				kind: "lit",
+				text: lit
+			});
+			continue;
+		}
+		if (ch === "\\" && i + 1 < format.length) {
+			tokens.push({
+				kind: "lit",
+				text: format[i + 1]
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === "[") {
+			let body = "";
+			i++;
+			while (i < format.length && format[i] !== "]") {
+				body += format[i];
+				i++;
+			}
+			i++;
+			if (/^h+$/i.test(body)) tokens.push({
+				kind: "elapsed-h",
+				text: body
+			});
+			else if (/^m+$/i.test(body)) tokens.push({
+				kind: "elapsed-m",
+				text: body
+			});
+			else if (/^s+$/i.test(body)) tokens.push({
+				kind: "elapsed-s",
+				text: body
+			});
+			continue;
+		}
+		if (ch === ".") {
+			const last = tokens[tokens.length - 1];
+			const run = /^\.(0+)/.exec(format.substring(i));
+			if (run && (last?.kind === "s" || last?.kind === "elapsed-s")) {
+				tokens.push({
+					kind: "subsec",
+					text: run[1]
+				});
+				i += run[0].length;
+				continue;
+			}
+		}
+		const lower = ch.toLowerCase();
+		if (lower === "y" || lower === "m" || lower === "d" || lower === "h" || lower === "s") {
+			let run = ch;
+			i++;
+			while (i < format.length && format[i].toLowerCase() === lower) {
+				run += format[i];
+				i++;
+			}
+			if (lower === "y") tokens.push({
+				kind: "y",
+				text: run
+			});
+			else if (lower === "d") tokens.push({
+				kind: "d",
+				text: run
+			});
+			else if (lower === "h") tokens.push({
+				kind: "h",
+				text: run
+			});
+			else if (lower === "s") tokens.push({
+				kind: "s",
+				text: run
+			});
+			else tokens.push({
+				kind: "m",
+				text: run
+			});
+			continue;
+		}
+		if (format.startsWith("AM/PM", i) || format.startsWith("A/P", i)) {
+			const len = format.startsWith("AM/PM", i) ? 5 : 3;
+			tokens.push({
+				kind: "ampm",
+				text: format.substring(i, i + len)
+			});
+			i += len;
+			continue;
+		}
+		tokens.push({
+			kind: "lit",
+			text: ch
+		});
+		i++;
+	}
+	return tokens;
+}
+function resolveMonthVsMinute(tokens) {
+	const resolved = tokens.map((t) => ({ ...t }));
+	for (let i = 0; i < resolved.length; i++) {
+		const t = resolved[i];
+		if (t.kind !== "m") continue;
+		let prev = i - 1;
+		while (prev >= 0 && resolved[prev].kind === "lit") prev--;
+		let next = i + 1;
+		while (next < resolved.length && resolved[next].kind === "lit") next++;
+		const prevKind = prev >= 0 ? resolved[prev].kind : void 0;
+		const prevIsHour = prevKind === "h" || prevKind === "elapsed-h";
+		const nextIsSec = next < resolved.length && resolved[next].kind === "s";
+		if (prevIsHour || nextIsSec) continue;
+		resolved[i] = {
+			kind: "M",
+			text: t.text
+		};
+	}
+	return resolved;
+}
+function formatExcelDate(rawValue, format, date1904) {
+	const serial = Number(rawValue);
+	if (!Number.isFinite(serial)) return rawValue;
+	format = splitSections(format)[0] ?? format;
+	const tokens = resolveMonthVsMinute(tokenizeDateFormat(format));
+	const subsecDigits = tokens.find((t) => t.kind === "subsec")?.text.length ?? 0;
+	const scale = 10 ** subsecDigits;
+	const totalSeconds = subsecDigits > 0 ? Math.round(serial * 86400 * scale) / scale : serial * 86400;
+	const date = excelSerialToDate(subsecDigits > 0 ? totalSeconds / 86400 : serial, date1904);
+	const year = date.getUTCFullYear();
+	const month = date.getUTCMonth() + 1;
+	const day = date.getUTCDate();
+	const weekday = date.getUTCDay();
+	const hour24 = date.getUTCHours();
+	const minute = date.getUTCMinutes();
+	const second = date.getUTCSeconds();
+	const hourValue = tokens.some((t) => t.kind === "ampm") ? hour24 % 12 === 0 ? 12 : hour24 % 12 : hour24;
+	const ampmLabel = (template) => {
+		const isUpper = template[0] === "A";
+		const isShort = template.length <= 3;
+		if (hour24 < 12) return isShort ? isUpper ? "A" : "a" : isUpper ? "AM" : "am";
+		return isShort ? isUpper ? "P" : "p" : isUpper ? "PM" : "pm";
+	};
+	let out = "";
+	for (const t of tokens) switch (t.kind) {
+		case "lit":
+			out += t.text;
+			break;
+		case "y":
+			out += t.text.length <= 2 ? pad2(year % 100) : String(year).padStart(4, "0");
+			break;
+		case "M": {
+			const len = t.text.length;
+			if (len === 5) out += MONTH_FULL[month - 1][0];
+			else if (len === 4) out += MONTH_FULL[month - 1];
+			else if (len === 3) out += MONTH_ABBR[month - 1];
+			else if (len === 2) out += pad2(month);
+			else out += String(month);
+			break;
+		}
+		case "d": {
+			const len = t.text.length;
+			if (len >= 4) out += DAY_FULL[weekday];
+			else if (len === 3) out += DAY_ABBR[weekday];
+			else if (len === 2) out += pad2(day);
+			else out += String(day);
+			break;
+		}
+		case "h":
+			out += t.text.length >= 2 ? pad2(hourValue) : String(hourValue);
+			break;
+		case "elapsed-h":
+			out += elapsed(totalSeconds / 3600, t.text.length);
+			break;
+		case "elapsed-m":
+			out += elapsed(totalSeconds / 60, t.text.length);
+			break;
+		case "elapsed-s":
+			out += elapsed(totalSeconds, t.text.length);
+			break;
+		case "subsec":
+			out += (totalSeconds - Math.floor(totalSeconds)).toFixed(subsecDigits).substring(1);
+			break;
+		case "m":
+			out += t.text.length >= 2 ? pad2(minute) : String(minute);
+			break;
+		case "s":
+			out += t.text.length >= 2 ? pad2(second) : String(second);
+			break;
+		case "ampm":
+			out += ampmLabel(t.text);
+			break;
+	}
+	return out;
+}
+function defaultNumberRender(rawValue) {
+	const n = Number(rawValue);
+	if (!Number.isFinite(n)) return rawValue;
+	return excelExponent(String(n));
+}
+/** Respell ECMAScript's `3e-104` as Excel's `3E-104` (§18.8.31). */
+function excelExponent(rendered) {
+	const m = /^(-?[\d.]+)e([+-]?)(\d+)$/i.exec(rendered);
+	if (!m) return rendered;
+	return `${m[1]}E${m[2] === "-" ? "-" : "+"}${m[3].padStart(2, "0")}`;
+}
+/**
+* A General number rounded to the decimals that fit `maxChars` characters.
+*
+* General is not a fixed format: a spreadsheet shows as many decimal places as
+* the column has room for and ROUNDS to that, so 4.3900875881221957 in a
+* column eight characters wide reads 4.390088. We rendered every stored digit
+* and let the cell clip it, which turns the same value into 4.390087 — off by
+* one in the last place shown, with nothing to say a digit was cut.
+*
+* The integer part is never dropped: a number too wide even without decimals
+* keeps them all and the cell says so its own way (see hashOnOverflow).
+*
+* `fits` decides, and it must measure in the face this will be DRAWN in rather
+* than count characters against the column's width in the document's unit.
+* Counted that way we produced nine digits for a column that holds nine of
+* Excel's and eight of ours, and the layout clipped the ninth — the very
+* truncation this exists to prevent. Fewer digits than the reference shows is a
+* coarser number; a clipped one is a different number.
+*
+* @param rawValue The cell's stored value.
+* @param fits     Whether a rendering will fit the cell.
+*/
+function generalToWidth(rawValue, fits) {
+	const n = Number(rawValue);
+	if (!Number.isFinite(n)) return defaultNumberRender(rawValue);
+	const full = defaultNumberRender(rawValue);
+	if (fits(full)) return full;
+	const dot = full.indexOf(".");
+	if (dot < 0) return scientificToWidth(n, fits) ?? full;
+	let shortened = full;
+	for (let decimals = full.length - dot - 2; decimals >= 0; decimals--) {
+		const shifted = Number(`${Number(n.toPrecision(15))}e${decimals}`);
+		const rounded = shifted < 0 ? -Math.round(-shifted) : Math.round(shifted);
+		const back = Number(`${rounded}e${-decimals}`);
+		if (!Number.isFinite(back)) break;
+		shortened = defaultNumberRender(String(back));
+		if (fits(shortened)) return shortened;
+	}
+	return scientificToWidth(n, fits) ?? shortened;
+}
+/**
+* `value` in scientific notation with as many mantissa decimals as `fits`
+* allows, spelled Excel's way: an upper-case `E`, a signed exponent of at least
+* two digits. Undefined when even a bare `1E+09` will not fit — the cell then
+* says so with hashes rather than shrinking further.
+*/
+function scientificToWidth(value, fits) {
+	for (let decimals = MAX_SCIENTIFIC_DECIMALS; decimals >= 0; decimals--) {
+		const [mantissa, exp] = value.toExponential(decimals).split("e");
+		const out = `${mantissa}E${exp.startsWith("-") ? "-" : "+"}${exp.replace(/^[-+]/, "").padStart(2, "0")}`;
+		if (fits(out)) return out;
+	}
+}
+/** Excel never shows more mantissa decimals than this under General. */
+var MAX_SCIENTIFIC_DECIMALS = 10;
+function applyFormatString(rawValue, format) {
+	const n = Number(rawValue);
+	const sections = splitSections(format);
+	if (!Number.isFinite(n)) {
+		const textSection = sections[3];
+		if (textSection !== void 0) return textSection.replace(/@/g, rawValue);
+		return rawValue;
+	}
+	const sectionIdx = sectionIndexFor(n, sections);
+	if (sectionIdx < 0) return defaultNumberRender(rawValue);
+	return applyNumericSection(n, sections[sectionIdx] ?? sections[0], sectionIdx === 1 && conditionOf(sections[0] ?? "") === void 0);
+}
+function splitSections(format) {
+	const out = [];
+	let current = "";
+	let inQuotes = false;
+	let bracketDepth = 0;
+	for (let i = 0; i < format.length; i++) {
+		const ch = format[i];
+		if (ch === "\"") {
+			inQuotes = !inQuotes;
+			current += ch;
+			continue;
+		}
+		if (!inQuotes) {
+			if (ch === "[") bracketDepth++;
+			else if (ch === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+			else if (ch === "\\" && i + 1 < format.length) {
+				current += ch + format[i + 1];
+				i++;
+				continue;
+			} else if (ch === ";" && bracketDepth === 0) {
+				out.push(current);
+				current = "";
+				continue;
+			}
+		}
+		current += ch;
+	}
+	out.push(current);
+	return out;
+}
+function countDigitPlaceholders(s) {
+	let n = 0;
+	for (const c of s) if (c === "0" || c === "#" || c === "?") n++;
+	return n;
+}
+/**
+* `value` rounded to `decimals` places the way a spreadsheet rounds: on the
+* DECIMAL number, half away from zero.
+*
+* `toFixed` rounds the binary double, which is not the number the file means.
+* A rate stored as 0.0095 is 0.009499999999999999… in binary; times 100 that is
+* 0.9499999999999998, and `toFixed(1)` dutifully answers "0.9" where Excel and
+* every other reader show 1.0%. AverageTaxRates.xlsx had eleven of its
+* percentages a tenth low for exactly this reason.
+*
+* Rounding to 15 significant digits first collapses the binary noise back to
+* the decimal the author typed; shifting through a string exponent then keeps
+* the scaling exact, so the final round sees 9.5 and not 9.499999999999998.
+*/
+function toFixedDecimal(value, decimals) {
+	if (!Number.isFinite(value)) return value.toFixed(decimals);
+	const decimal = Number(value.toPrecision(15));
+	const shifted = Number(`${decimal}e${decimals}`);
+	if (!Number.isFinite(shifted)) return value.toFixed(decimals);
+	const rounded = shifted < 0 ? -Math.round(-shifted) : Math.round(shifted);
+	const back = Number(`${rounded}e${-decimals}`);
+	return Number.isFinite(back) ? back.toFixed(decimals) : value.toFixed(decimals);
+}
+function formatScientific(value, cleaned, negativeSection) {
+	const m = /^(.*?)([eE])([+-])(.*)$/.exec(cleaned);
+	if (!m) return cleaned;
+	const mantissaFmt = m[1];
+	const eChar = m[2];
+	const expSignFmt = m[3];
+	const expFmt = m[4];
+	const dot = mantissaFmt.indexOf(".");
+	const intDigits = Math.max(1, countDigitPlaceholders(dot >= 0 ? mantissaFmt.slice(0, dot) : mantissaFmt));
+	const decimals = dot >= 0 ? countDigitPlaceholders(mantissaFmt.slice(dot + 1)) : 0;
+	let exp = 0;
+	let mant = Math.abs(value);
+	if (mant !== 0) {
+		exp = Math.floor(Math.log10(mant));
+		exp -= (exp % intDigits + intDigits) % intDigits;
+		mant = mant / Math.pow(10, exp);
+		if (Number(mant.toFixed(decimals)) >= Math.pow(10, intDigits)) {
+			exp += intDigits;
+			mant = mant / Math.pow(10, intDigits);
+		}
+	}
+	const mantStr = mant.toFixed(decimals);
+	const expDigits = countDigitPlaceholders(expFmt) || 2;
+	const expStr = String(Math.abs(exp)).padStart(expDigits, "0");
+	return `${value < 0 && !negativeSection ? "-" : ""}${mantStr}${eChar}${exp < 0 ? "-" : expSignFmt === "+" ? "+" : ""}${expStr}`;
+}
+/**
+* Resolve the `[...]` codes a numeric section may carry (§18.8.31).
+*
+* `[$SYMBOL-LOCALE]` is a currency tag and its SYMBOL is *rendered* — dropping
+* the whole bracket, as a colour or a locale is dropped, silently loses the `$`
+* from `[$$-409]#,##0`. The symbol becomes a quoted literal so the placeholder
+* grammar treats it as text. Everything else in brackets (colours, locales,
+* conditions) is decoration here and goes.
+*/
+function resolveBracketCodes(format) {
+	return format.replace(/\[([^\]]*)\]/g, (_, body) => {
+		const symbol = /^\$([^-]*)(?:-.*)?$/.exec(body)?.[1]?.replace(/"/g, "") ?? "";
+		return symbol.length > 0 ? `"${symbol}"` : "";
+	});
+}
+/**
+* §18.8.31 fraction formats — `# ?/?`, `# ??/??`, `?/?`, `# ?/16`.
+*
+* `?` is a digit placeholder like `#` but padded to width with spaces, and the
+* count of them on the right of the slash bounds the denominator: `??` admits
+* any denominator up to 99, so 25.378 renders as "25 31/82". A literal number
+* there instead (`?/16`) fixes the denominator. Returns undefined when the
+* section is not a fraction, leaving the ordinary grammar to run.
+*/
+function formatFraction(value, cleaned, negativeSection) {
+	const m = /^(.*?)([0#?]+)\s*\/\s*([0#?]+|\d+)(.*)$/.exec(cleaned);
+	if (!m) return void 0;
+	const head = m[1];
+	const denFmt = m[3];
+	const tail = m[4];
+	const intMatch = /([0#?]+)([^0#?]*)$/.exec(head);
+	const hasInteger = intMatch !== null;
+	const literalPrefix = unquoteLiteral(head.substring(0, intMatch ? intMatch.index : head.length));
+	const separator = intMatch ? unquoteLiteral(intMatch[2]) : " ";
+	const magnitude = Math.abs(value);
+	const whole = hasInteger ? Math.floor(magnitude) : 0;
+	const rest = magnitude - whole;
+	const fixedDen = /^\d+$/.test(denFmt) ? Number(denFmt) : void 0;
+	const maxDen = fixedDen ?? Math.pow(10, denFmt.length) - 1;
+	if (!Number.isFinite(maxDen) || maxDen < 1) return void 0;
+	let num;
+	let den;
+	if (fixedDen !== void 0) {
+		den = fixedDen;
+		num = Math.round(rest * fixedDen);
+	} else [num, den] = bestRational(rest, maxDen);
+	const pieces = [];
+	if (hasInteger) {
+		let integer = whole;
+		if (den > 0 && num >= den) {
+			integer += Math.floor(num / den);
+			num %= den;
+		}
+		if (integer !== 0 || num === 0) pieces.push(String(integer));
+	}
+	if (num !== 0 || !hasInteger) pieces.push(`${num}/${den}`);
+	const sign = value < 0 && !negativeSection ? "-" : "";
+	const gap = separator.length > 0 ? separator : " ";
+	return `${literalPrefix}${sign}${pieces.join(gap)}${unquoteLiteral(tail)}`;
+}
+/**
+* The closest `n/d` to `value` with `d <= maxDen`, by continued fractions —
+* the same approximation Excel and LibreOffice show for a `?/?` format.
+*/
+function bestRational(value, maxDen) {
+	if (value === 0) return [0, 1];
+	let [prevN, prevD] = [0, 1];
+	let [n, d] = [1, 0];
+	let x = value;
+	for (let i = 0; i < 64; i++) {
+		const a = Math.floor(x);
+		const nextN = a * n + prevN;
+		const nextD = a * d + prevD;
+		if (nextD > maxDen) break;
+		[prevN, prevD] = [n, d];
+		[n, d] = [nextN, nextD];
+		const frac = x - a;
+		if (frac < 1e-12) break;
+		x = 1 / frac;
+	}
+	if (d === 0) return [Math.round(value * maxDen), maxDen];
+	return [n, d];
+}
+function applyNumericSection(value, format, negativeSection) {
+	const cleaned = resolveBracketCodes(format);
+	if (cleaned.trim().toLowerCase() === "general") return defaultNumberRender(String(negativeSection ? Math.abs(value) : value));
+	const fraction = formatFraction(value, cleaned, negativeSection);
+	if (fraction !== void 0) return fraction;
+	if (/[eE][+-]/.test(cleaned)) return formatScientific(value, cleaned, negativeSection);
+	const isPercent = cleaned.includes("%");
+	let magnitude = Math.abs(value);
+	if (isPercent) magnitude *= 100;
+	const { intFormat, decFormat, literalPrefix, literalSuffix, scaleCommas } = splitNumberFormat(cleaned);
+	if (scaleCommas > 0) magnitude /= 1e3 ** scaleCommas;
+	let decimals = 0;
+	for (const c of decFormat) if (c === "0" || c === "#") decimals++;
+	const [intRaw, decRaw] = toFixedDecimal(magnitude, decimals).split(".");
+	const intStr = /,(?=\d)/.test(intFormat) || /[0#],[0#]/.test(intFormat) ? intRaw.replace(/\B(?=(\d{3})+(?!\d))/g, ",") : intRaw;
+	let numberPart = intRaw === "0" && !/[0?]/.test(intFormat) ? "" : intStr;
+	if (decimals > 0) {
+		let dec = decRaw ?? "".padEnd(decimals, "0");
+		if (dec.length < decimals) dec = dec.padEnd(decimals, "0");
+		let kept = "";
+		for (let i = 0; i < decFormat.length; i++) {
+			const placeholder = decFormat[i];
+			if (placeholder === "0" || placeholder === "#") kept += dec[i] ?? "0";
+		}
+		for (let i = kept.length - 1; i >= 0 && kept[i] === "0" && decFormat[i] === "#"; i--) kept = kept.substring(0, i);
+		if (kept.length > 0) numberPart += "." + kept;
+		else if (decFormat.includes("0")) numberPart += "." + dec;
+	}
+	let signPrefix = "";
+	if (value < 0 && !negativeSection) signPrefix = "-";
+	return `${literalPrefix}${signPrefix}${numberPart}${isPercent ? "%" : ""}${literalSuffix}`;
+}
+function splitNumberFormat(cleaned) {
+	let firstDigit = -1;
+	let lastDigit = -1;
+	for (let i = 0; i < cleaned.length; i++) {
+		const ch = cleaned[i];
+		if (ch === "0" || ch === "#") {
+			if (firstDigit < 0) firstDigit = i;
+			lastDigit = i;
+		}
+	}
+	if (firstDigit < 0) return {
+		literalPrefix: unquoteLiteral(cleaned),
+		intFormat: "",
+		decFormat: "",
+		literalSuffix: "",
+		scaleCommas: 0
+	};
+	const literalPrefix = unquoteLiteral(cleaned.substring(0, firstDigit));
+	const rawSuffix = cleaned.substring(lastDigit + 1);
+	const scaleCommas = /^,+/.exec(rawSuffix)?.[0]?.length ?? 0;
+	const literalSuffix = unquoteLiteral(rawSuffix.substring(scaleCommas));
+	const digitRange = cleaned.substring(firstDigit, lastDigit + 1);
+	const dotIdx = digitRange.indexOf(".");
+	return {
+		literalPrefix,
+		intFormat: dotIdx >= 0 ? digitRange.substring(0, dotIdx) : digitRange,
+		decFormat: dotIdx >= 0 ? digitRange.substring(dotIdx + 1) : "",
+		literalSuffix,
+		scaleCommas
+	};
+}
+function unquoteLiteral(s) {
+	let out = "";
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+		if (ch === "\"") {
+			i++;
+			while (i < s.length && s[i] !== "\"") {
+				out += s[i];
+				i++;
+			}
+			continue;
+		}
+		if (ch === "\\" && i + 1 < s.length) {
+			out += s[i + 1];
+			i++;
+			continue;
+		}
+		if (ch === "_" && i + 1 < s.length) {
+			out += " ";
+			i++;
+			continue;
+		}
+		if (ch === "*" && i + 1 < s.length) {
+			i++;
+			continue;
+		}
+		if (ch === "%") continue;
+		out += ch;
+	}
+	return out;
+}
+//#endregion
+export { applyNumberFormat, excelSerialFromUtcParts, excelSerialToDate, generalToWidth, numberFormatColorHex };