@cj-tech-master/excelts 9.3.1 → 9.4.0

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
-* @cj-tech-master/excelts v9.3.1
+* @cj-tech-master/excelts v9.4.0
 * Zero-dependency TypeScript toolkit — Excel (XLSX), PDF, CSV, Markdown, XML, ZIP/TAR, and streaming.
 * (c) 2026 cjnoname
 * Released under the MIT License
@@ -17468,6 +17468,1043 @@ onmessage = async (ev) => {
 		}
 	};
 	//#endregion
+	//#region src/utils/env.ts
+	/**
+	* Environment detection utilities
+	* Common functions to detect runtime environment (Node.js vs Browser)
+	*/
+	/**
+	* Check if running in Node.js environment
+	* Returns true if process.versions.node exists
+	*/
+	function isNode() {
+		return typeof process !== "undefined" && !!process.versions?.node;
+	}
+	//#endregion
+	//#region src/modules/xml/encode.ts
+	/**
+	* XML Encoding / Decoding Utilities
+	*
+	* Self-contained XML entity encoding and decoding functions.
+	*/
+	/** Standard XML entity decode map. */
+	const DECODE_MAP = {
+		lt: "<",
+		gt: ">",
+		amp: "&",
+		quot: "\"",
+		apos: "'"
+	};
+	/** Regex for decoding XML entities (named + numeric). */
+	const DECODE_RE = /&(#\d+|#[xX][0-9A-Fa-f]+|\w+);/g;
+	/**
+	* Lookup table for characters that need encoding in the ASCII range (0-127).
+	* 0 = safe, 1 = encode to entity, 2 = strip (invalid control char)
+	*/
+	const ENCODE_ACTION = /* @__PURE__ */ (() => {
+		const t = new Uint8Array(128);
+		for (let i = 0; i <= 8; i++) t[i] = 2;
+		t[11] = 2;
+		t[12] = 2;
+		for (let i = 14; i <= 31; i++) t[i] = 2;
+		t[127] = 2;
+		t[34] = 1;
+		t[38] = 1;
+		t[39] = 1;
+		t[60] = 1;
+		t[62] = 1;
+		return t;
+	})();
+	const ENCODE_ENTITIES = {
+		34: "&quot;",
+		38: "&amp;",
+		39: "&apos;",
+		60: "&lt;",
+		62: "&gt;"
+	};
+	/**
+	* Decode XML entities in a string.
+	*
+	* Handles named entities (`&lt;`, `&gt;`, `&amp;`, `&quot;`, `&apos;`)
+	* and numeric character references (`&#123;`, `&#x7B;`).
+	*
+	* Security: validates numeric code points are in range [1, 0x10FFFF]
+	* and rejects surrogate halves (0xD800-0xDFFF).
+	*
+	* Fast-path: returns the original string if no `&` is found.
+	*/
+	function xmlDecode(text) {
+		if (text.indexOf("&") === -1) return text;
+		return text.replace(DECODE_RE, (match, entity) => {
+			if (entity[0] === "#") {
+				const code = entity[1] === "x" || entity[1] === "X" ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+				if (Number.isNaN(code) || code < 1 || code >= 55296 && code <= 57343 || code > 1114111) return match;
+				return String.fromCodePoint(code);
+			}
+			return DECODE_MAP[entity] ?? match;
+		});
+	}
+	/**
+	* Encode special characters for XML output.
+	*
+	* Escapes `<`, `>`, `&`, `"`, `'` to their entity equivalents.
+	* Strips invalid XML control characters (0x00-0x08, 0x0B-0x0C, 0x0E-0x1F, 0x7F)
+	* and lone surrogates (0xD800-0xDFFF without a pair).
+	*
+	* Optimized: uses a lookup table and manual scan instead of regex for
+	* maximum throughput on the hot path (called per attribute/text value).
+	*/
+	function xmlEncode(text) {
+		const len = text.length;
+		let firstBad = -1;
+		for (let i = 0; i < len; i++) {
+			const code = text.charCodeAt(i);
+			if (code < 128) {
+				if (ENCODE_ACTION[code] !== 0) {
+					firstBad = i;
+					break;
+				}
+			} else if (code >= 55296 && code <= 57343) {
+				if (code <= 56319) {
+					const next = text.charCodeAt(i + 1);
+					if (next >= 56320 && next <= 57343) {
+						i++;
+						continue;
+					}
+				}
+				firstBad = i;
+				break;
+			} else if (code === 65534 || code === 65535) {
+				firstBad = i;
+				break;
+			}
+		}
+		if (firstBad === -1) return text;
+		const parts = [];
+		let lastIndex = 0;
+		for (let i = firstBad; i < len; i++) {
+			const code = text.charCodeAt(i);
+			if (code < 128) {
+				const action = ENCODE_ACTION[code];
+				if (action === 0) continue;
+				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
+				if (action === 1) parts.push(ENCODE_ENTITIES[code]);
+				lastIndex = i + 1;
+			} else if (code >= 55296 && code <= 56319) {
+				const next = text.charCodeAt(i + 1);
+				if (next >= 56320 && next <= 57343) {
+					i++;
+					continue;
+				}
+				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
+				lastIndex = i + 1;
+			} else if (code >= 56320 && code <= 57343) {
+				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
+				lastIndex = i + 1;
+			} else if (code === 65534 || code === 65535) {
+				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
+				lastIndex = i + 1;
+			}
+		}
+		if (lastIndex < len) parts.push(text.substring(lastIndex));
+		return parts.length === 1 ? parts[0] : parts.join("");
+	}
+	/**
+	* Encode a value for use in an XML attribute.
+	*
+	* Same as {@link xmlEncode} — provided as a semantic alias.
+	* In the future this could apply attribute-specific normalisation
+	* (e.g. collapsing whitespace per XML 1.0 §3.3.3).
+	*/
+	function xmlEncodeAttr(value) {
+		return xmlEncode(value);
+	}
+	/**
+	* Characters that must NEVER appear in XML element or attribute names.
+	* This is a fast security check to prevent markup injection via names,
+	* not a full XML NameChar validation (which would require Unicode tables).
+	*/
+	const INVALID_NAME_CHARS = /[\s<>"'/=&]/;
+	/**
+	* Validate an XML element or attribute name against injection attacks.
+	*
+	* Rejects:
+	* - Empty names
+	* - Names containing whitespace, `<`, `>`, `"`, `'`, `/`, `=`, `&`
+	* - Names starting with a digit, `-`, or `.`
+	*
+	* This is NOT a full XML Name validation (which requires Unicode NameStartChar
+	* tables). It is a focused security check to prevent markup injection.
+	*/
+	function validateXmlName(name) {
+		if (!name) throw new XmlError("XML name must not be empty");
+		if (INVALID_NAME_CHARS.test(name)) throw new XmlError(`Invalid XML name: contains forbidden character in "${name}"`);
+		const first = name.charCodeAt(0);
+		if (first >= 48 && first <= 57 || first === 45 || first === 46) throw new XmlError(`Invalid XML name: "${name}" starts with forbidden character`);
+	}
+	/**
+	* Encode text for a CDATA section, splitting on `]]>` to produce valid output.
+	*
+	* The sequence `]]>` cannot appear inside CDATA, so each occurrence is split
+	* into adjacent CDATA sections: `<![CDATA[...]]]]><![CDATA[>...]]>`.
+	*/
+	function encodeCData(text) {
+		return "<![CDATA[" + text.split("]]>").join("]]]]><![CDATA[>") + "]]>";
+	}
+	/**
+	* Validate that text is legal for an XML comment.
+	*
+	* XML spec: comments must not contain `--` and must not end with `-`.
+	* @throws {XmlError} if the text is invalid.
+	*/
+	function validateCommentText(text) {
+		if (text.includes("--") || text.endsWith("-")) throw new XmlError("Invalid comment: must not contain \"--\" or end with \"-\"");
+	}
+	/** Default XML declaration attributes (`version`, `encoding`, `standalone`). */
+	const StdDocAttributes = {
+		version: "1.0",
+		encoding: "UTF-8",
+		standalone: "yes"
+	};
+	//#endregion
+	//#region src/utils/utils.base.ts
+	/**
+	* Base utility functions shared between Node.js and Browser
+	* All functions use standard Web APIs that work in both environments
+	* (Node.js 16+ supports atob/btoa/TextEncoder/TextDecoder globally)
+	*/
+	/**
+	* Convert base64 string to Uint8Array
+	* Uses native Buffer in Node.js for better performance
+	*/
+	function base64ToUint8Array(base64) {
+		if (isNode()) return Buffer.from(base64, "base64");
+		const binary = atob(base64);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	}
+	function dateToExcel(d, date1904) {
+		return 25569 + d.getTime() / (24 * 3600 * 1e3) - (date1904 ? 1462 : 0);
+	}
+	function excelToDate(v, date1904) {
+		const millisecondSinceEpoch = Math.round((v - 25569 + (date1904 ? 1462 : 0)) * 24 * 3600 * 1e3);
+		return new Date(millisecondSinceEpoch);
+	}
+	/**
+	* Parse an OOXML date string into a Date object.
+	* OOXML dates like "2024-01-15T00:00:00" lack a timezone suffix,
+	* which some JS engines parse as local time. Appending "Z" forces UTC.
+	*/
+	function parseOoxmlDate(raw) {
+		return new Date(raw.endsWith("Z") ? raw : raw + "Z");
+	}
+	/**
+	* Pattern matching OOXML `_xHHHH_` escape sequences (case-insensitive hex).
+	*
+	* Per the OOXML spec, `_xHHHH_` encodes a Unicode code point where HHHH is
+	* a 4-digit hexadecimal number. The spec uses uppercase, but real-world files
+	* from third-party tools (Google Sheets, LibreOffice, etc.) may use lowercase.
+	*/
+	const ooxmlEscapeRegex = /_x([0-9A-Fa-f]{4})_/g;
+	/**
+	* Decode OOXML `_xHHHH_` escape sequences in a string.
+	*
+	* Used when reading text content from `<t>` elements in shared strings,
+	* rich text runs, and inline strings. The replacement works left-to-right,
+	* so `_x005F_x000D_` correctly decodes to the literal string `_x000D_`
+	* (the `_x005F_` decodes to `_`, consuming the match).
+	*/
+	function decodeOoxmlEscape(text) {
+		return text.replace(ooxmlEscapeRegex, (match, $1) => {
+			const code = parseInt($1, 16);
+			if (code === 0 || code >= 1 && code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127 || code >= 55296 && code <= 57343 || code === 65534 || code === 65535) return match;
+			return String.fromCharCode(code);
+		});
+	}
+	/**
+	* Encode literal `_xHHHH_` patterns in a string for OOXML output.
+	*
+	* If a string naturally contains the pattern `_xHHHH_` (e.g., the user typed
+	* `_x000D_`), the leading underscore must be escaped as `_x005F_` to prevent
+	* readers from misinterpreting it as an escape sequence.
+	*
+	* Roundtrip guarantee: `decodeOoxmlEscape(encodeOoxmlEscape(s)) === s`
+	*/
+	function encodeOoxmlEscape(text) {
+		return text.replace(ooxmlEscapeRegex, "_x005F_x$1_");
+	}
+	/**
+	* Characters that XML attribute-value normalisation replaces with spaces
+	* (XML 1.0 §3.3.3). When writing OOXML attribute values we must encode
+	* these as `_xHHHH_` so that the original characters survive a round-trip.
+	*/
+	const xmlAttrUnsafeRe = /[\t\n\r]/g;
+	const xmlAttrUnsafeMap = {
+		"	": "_x0009_",
+		"\n": "_x000A_",
+		"\r": "_x000D_"
+	};
+	/**
+	* Encode a string for safe use in an OOXML **XML attribute** value.
+	*
+	* Two transformations are applied (order matters):
+	* 1. Literal `_xHHHH_` patterns are escaped (`_x005F_xHHHH_`) so readers
+	*    do not misinterpret them as escape sequences.
+	* 2. Characters that XML attribute-value normalisation would mangle
+	*    (`\t`, `\n`, `\r`) are encoded as `_x0009_`, `_x000A_`, `_x000D_`.
+	*
+	* This is the write-side counterpart of {@link decodeOoxmlEscape}.
+	* Use `encodeOoxmlEscape` for element **text** content and this function
+	* for **attribute** values.
+	*/
+	function encodeOoxmlAttr(text) {
+		let result = text.replace(ooxmlEscapeRegex, "_x005F_x$1_");
+		result = result.replace(xmlAttrUnsafeRe, (ch) => xmlAttrUnsafeMap[ch]);
+		return result;
+	}
+	function validInt(value) {
+		const i = typeof value === "number" ? value : parseInt(value, 10);
+		return Number.isNaN(i) ? 0 : i;
+	}
+	/**
+	* Split an Excel numFmt string by semicolons, respecting quoted strings and brackets.
+	*
+	* Excel numFmt can have up to 4 sections: `positive ; negative ; zero ; text`.
+	* Semicolons inside `"..."` (literal text) or `[...]` (locale/color tags) must NOT
+	* be treated as section separators.
+	*/
+	function splitFormatSections(fmt) {
+		const sections = [];
+		let current = "";
+		let inQuote = false;
+		let inBracket = false;
+		for (let i = 0; i < fmt.length; i++) {
+			const char = fmt[i];
+			if (char === "\"" && !inBracket) {
+				inQuote = !inQuote;
+				current += char;
+			} else if (char === "[" && !inQuote) {
+				inBracket = true;
+				current += char;
+			} else if (char === "]" && !inQuote) {
+				inBracket = false;
+				current += char;
+			} else if (char === ";" && !inQuote && !inBracket) {
+				sections.push(current);
+				current = "";
+			} else current += char;
+		}
+		sections.push(current);
+		return sections;
+	}
+	/** Reusable regex — no capture groups, so safe for `test()`. */
+	const DATE_FMT_RE = /[ymdhMsb]/;
+	/** Strips bracket expressions `[...]` and quoted literals `"..."` from a format string. */
+	const STRIP_BRACKETS_QUOTES_RE = /\[[^\]]*\]|"[^"]*"/g;
+	/** Cache for isDateFmt results — typically only 5-20 unique formats per workbook,
+	*  but each may be tested hundreds of thousands of times during reconcile. */
+	const _isDateFmtCache = /* @__PURE__ */ new Map();
+	function isDateFmt(fmt) {
+		if (!fmt) return false;
+		const cached = _isDateFmtCache.get(fmt);
+		if (cached !== void 0) return cached;
+		const clean = splitFormatSections(fmt)[0].replace(STRIP_BRACKETS_QUOTES_RE, "");
+		let result;
+		if (clean.indexOf("@") > -1) result = false;
+		else result = DATE_FMT_RE.test(clean);
+		_isDateFmtCache.set(fmt, result);
+		return result;
+	}
+	function parseBoolean(value) {
+		return value === true || value === "true" || value === 1 || value === "1";
+	}
+	function* range(start, stop, step = 1) {
+		const compareOrder = step > 0 ? (a, b) => a < b : (a, b) => a > b;
+		for (let value = start; compareOrder(value, stop); value += step) yield value;
+	}
+	function toSortedArray(values) {
+		const result = Array.from(values);
+		if (result.length <= 1) return result;
+		if (result.every((item) => Number.isFinite(item))) return result.sort((a, b) => a - b);
+		if (result.every((item) => item instanceof Date)) return result.sort((a, b) => a.getTime() - b.getTime());
+		return result.sort((a, b) => {
+			const ta = sortTypeRank(a);
+			const tb = sortTypeRank(b);
+			if (ta !== tb) return ta - tb;
+			if (ta === 0) return a - b;
+			if (ta === 1) return a.getTime() - b.getTime();
+			return String(a).localeCompare(String(b));
+		});
+	}
+	/** Rank for mixed-type sort: numbers=0, dates=1, everything else=2 */
+	function sortTypeRank(v) {
+		if (Number.isFinite(v)) return 0;
+		if (v instanceof Date) return 1;
+		return 2;
+	}
+	const textDecoder = new TextDecoder("utf-8");
+	let latin1Decoder;
+	let _latin1DecoderResolved = false;
+	function getLatin1Decoder() {
+		if (!_latin1DecoderResolved) {
+			_latin1DecoderResolved = true;
+			try {
+				latin1Decoder = new TextDecoder("latin1");
+			} catch {
+				latin1Decoder = void 0;
+			}
+		}
+		return latin1Decoder;
+	}
+	/**
+	* Convert a Buffer, ArrayBuffer, or Uint8Array to a UTF-8 string
+	* Works in both Node.js and browser environments
+	*/
+	function bufferToString(chunk) {
+		if (typeof chunk === "string") return chunk;
+		return textDecoder.decode(chunk);
+	}
+	/**
+	* Convert Uint8Array to base64 string
+	* Uses native Buffer in Node.js, optimized chunked conversion in browser
+	*/
+	function uint8ArrayToBase64(bytes) {
+		if (isNode()) return Buffer.from(bytes).toString("base64");
+		if (getLatin1Decoder()) try {
+			return btoa(latin1Decoder.decode(bytes));
+		} catch {}
+		const CHUNK_SIZE = 32768;
+		const chunks = [];
+		for (let i = 0; i < bytes.length; i += CHUNK_SIZE) chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK_SIZE)));
+		return btoa(chunks.join(""));
+	}
+	/**
+	* Convert string to UTF-16LE Uint8Array (used for Excel password hashing)
+	*/
+	function stringToUtf16Le(str) {
+		const bytes = new Uint8Array(str.length * 2);
+		for (let i = 0; i < str.length; i++) {
+			const code = str.charCodeAt(i);
+			bytes[i * 2] = code & 255;
+			bytes[i * 2 + 1] = code >> 8 & 255;
+		}
+		return bytes;
+	}
+	/**
+	* Yield to the event loop via a macrotask.
+	* Uses `setTimeout(0)` which works in both Node.js and browsers.
+	*/
+	function yieldToEventLoop() {
+		return new Promise((resolve) => setTimeout(resolve, 0));
+	}
+	//#endregion
+	//#region src/modules/excel/utils/cell-format.ts
+	/**
+	* Pad number with leading zeros
+	*/
+	function pad0(num, len) {
+		let s = Math.round(num).toString();
+		while (s.length < len) s = "0" + s;
+		return s;
+	}
+	/**
+	* Add thousand separators to a number string
+	*/
+	function commaify(s) {
+		const w = 3;
+		if (s.length <= w) return s;
+		const j = s.length % w;
+		let o = s.substring(0, j);
+		for (let i = j; i < s.length; i += w) o += (o.length > 0 ? "," : "") + s.substring(i, i + w);
+		return o;
+	}
+	/**
+	* Round a number to specified decimal places
+	*/
+	function roundTo(val, decimals) {
+		const factor = Math.pow(10, decimals);
+		return Math.round(val * factor) / factor;
+	}
+	/**
+	* Process _ (underscore) placeholder - adds space with width of next character
+	* Process * (asterisk) placeholder - repeats next character to fill width (simplified to single char)
+	*/
+	function processPlaceholders(fmt) {
+		let result = fmt.replace(/_./g, " ");
+		result = result.replace(/\*./g, "");
+		return result;
+	}
+	/**
+	* Check if format is "General"
+	*/
+	function isGeneral(fmt) {
+		return /^General$/i.test(fmt.trim());
+	}
+	/**
+	* Check if format is a date format
+	*/
+	function isDateFormat(fmt) {
+		const cleaned = fmt.replace(/\[[^\]]*\]/g, "");
+		return /[ymdhs]/i.test(cleaned) && !/^[#0.,E%$\s()\-+]+$/i.test(cleaned);
+	}
+	const MONTHS_SHORT = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	];
+	const MONTHS_LONG = [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	];
+	const MONTHS_LETTER = [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	];
+	const DAYS_SHORT = [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	];
+	const DAYS_LONG = [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	];
+	/**
+	* Disambiguate each `mm` occurrence in a format string that has already been
+	* placeholder-substituted for the other date/time tokens.
+	*
+	* Excel's rule: `mm` is minutes when it's adjacent to an hour or seconds
+	* token (with no intervening date tokens); otherwise it's a zero-padded
+	* month. This must be decided per occurrence — a single format string can
+	* contain both roles (e.g. `"yyyy-mm-dd hh:mm:ss"`).
+	*
+	* The caller has already replaced `yyyy`/`yy` → `Y4/Y2`, month-name tokens
+	* `mmmmm/mmmm/mmm` → `MN5/MN4/MN3`, `dd`/`d` → `D2/D1`, `hh`/`h` → `H2/H1`,
+	* `ss`/`s` → `S2/S1`. So any remaining literal `mm` substrings here are
+	* ambiguous between minute and month.
+	*
+	* Returns the input with each `mm` replaced by either `\x00MI2\x00` (minutes)
+	* or `\x00M2\x00` (month, zero-padded).
+	*/
+	function resolveMonthOrMinute(s) {
+		const DATE_TOKEN = /\x00(?:Y[24]|D[12]|MN[345])\x00/;
+		const HOUR_TOKEN = /\x00H[12]\x00/g;
+		const SEC_TOKEN = /\x00S[12]\x00/g;
+		let out = "";
+		let work = s;
+		let idx = work.search(/mm/i);
+		while (idx !== -1) {
+			const before = work.slice(0, idx);
+			const after = work.slice(idx + 2);
+			let nearestHourIdx = -1;
+			let m;
+			HOUR_TOKEN.lastIndex = 0;
+			while ((m = HOUR_TOKEN.exec(before)) !== null) nearestHourIdx = m.index;
+			SEC_TOKEN.lastIndex = 0;
+			const secMatch = SEC_TOKEN.exec(after);
+			const nearestSecIdx = secMatch ? secMatch.index : -1;
+			const hourInRange = nearestHourIdx !== -1 && !DATE_TOKEN.test(before.slice(nearestHourIdx));
+			const secInRange = nearestSecIdx !== -1 && !DATE_TOKEN.test(after.slice(0, nearestSecIdx));
+			out += before + (hourInRange || secInRange ? "\0MI2\0" : "\0M2\0");
+			work = after;
+			idx = work.search(/mm/i);
+		}
+		out += work;
+		return out;
+	}
+	/**
+	* Format a date value using Excel date format
+	* @param serial Excel serial number (days since 1900-01-01)
+	* @param fmt Format string
+	*/
+	function formatDate(serial, fmt) {
+		const timeOfDay = Math.round(serial * 86400) % 86400;
+		const hours = Math.floor(timeOfDay / 3600);
+		const minutes = Math.floor(timeOfDay % 3600 / 60);
+		const seconds = timeOfDay % 60;
+		const date = excelToDate(serial, false);
+		const year = date.getUTCFullYear();
+		const month = date.getUTCMonth();
+		const day = date.getUTCDate();
+		const dayOfWeek = date.getUTCDay();
+		const fractionalSeconds = serial * 86400 - Math.floor(serial * 86400);
+		const hasAmPm = /AM\/PM|A\/P/i.test(fmt);
+		const isPm = hours >= 12;
+		const hours12 = hours % 12 || 12;
+		let result = fmt.replace(/\[(Red|Green|Blue|Yellow|Magenta|Cyan|White|Black|Color\d+)\]/gi, "");
+		result = processPlaceholders(result);
+		const fracSecMatch = result.match(/ss\.(0+)/i);
+		let fracSecStr = "";
+		if (fracSecMatch) {
+			const decPlaces = fracSecMatch[1].length;
+			fracSecStr = Math.round(fractionalSeconds * Math.pow(10, decPlaces)).toString().padStart(decPlaces, "0");
+			result = result.replace(/ss\.0+/gi, "\0SF\0");
+		}
+		result = result.replace(/yyyy/gi, "\0Y4\0");
+		result = result.replace(/yy/gi, "\0Y2\0");
+		result = result.replace(/mmmmm/gi, "\0MN5\0");
+		result = result.replace(/mmmm/gi, "\0MN4\0");
+		result = result.replace(/mmm/gi, "\0MN3\0");
+		result = result.replace(/dddd/gi, "\0DN4\0");
+		result = result.replace(/ddd/gi, "\0DN3\0");
+		result = result.replace(/dd/gi, "\0D2\0");
+		result = result.replace(/\bd\b/gi, "\0D1\0");
+		result = result.replace(/hh/gi, "\0H2\0");
+		result = result.replace(/\bh\b/gi, "\0H1\0");
+		result = result.replace(/ss/gi, "\0S2\0");
+		result = result.replace(/\bs\b/gi, "\0S1\0");
+		result = resolveMonthOrMinute(result);
+		result = result.replace(/\bm\b/gi, "\0M1\0");
+		result = result.replace(/AM\/PM/gi, "\0AMPM\0");
+		result = result.replace(/A\/P/gi, "\0AP\0");
+		const hourVal = hasAmPm ? hours12 : hours;
+		result = result.replace(/\x00Y4\x00/g, year.toString()).replace(/\x00Y2\x00/g, (year % 100).toString().padStart(2, "0")).replace(/\x00MN5\x00/g, MONTHS_LETTER[month]).replace(/\x00MN4\x00/g, MONTHS_LONG[month]).replace(/\x00MN3\x00/g, MONTHS_SHORT[month]).replace(/\x00M2\x00/g, (month + 1).toString().padStart(2, "0")).replace(/\x00M1\x00/g, (month + 1).toString()).replace(/\x00DN4\x00/g, DAYS_LONG[dayOfWeek]).replace(/\x00DN3\x00/g, DAYS_SHORT[dayOfWeek]).replace(/\x00D2\x00/g, day.toString().padStart(2, "0")).replace(/\x00D1\x00/g, day.toString()).replace(/\x00H2\x00/g, hourVal.toString().padStart(2, "0")).replace(/\x00H1\x00/g, hourVal.toString()).replace(/\x00MI2\x00/g, minutes.toString().padStart(2, "0")).replace(/\x00S2\x00/g, seconds.toString().padStart(2, "0")).replace(/\x00S1\x00/g, seconds.toString()).replace(/\x00SF\x00/g, seconds.toString().padStart(2, "0") + "." + fracSecStr).replace(/\x00AMPM\x00/g, isPm ? "PM" : "AM").replace(/\x00AP\x00/g, isPm ? "P" : "A");
+		result = result.replace(/\\/g, "");
+		return result;
+	}
+	/**
+	* Format a number using "General" format
+	*/
+	function formatGeneral(val) {
+		if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
+		if (typeof val === "string") return val;
+		if (Number.isInteger(val)) return val.toString();
+		return val.toPrecision(11).replace(/\.?0+$/, "").replace(/\.?0+e/, "e");
+	}
+	/**
+	* Format a percentage value
+	* @param val The decimal value (e.g., 0.25 for 25%)
+	* @param fmt The format string containing %
+	*/
+	function formatPercentage(val, fmt) {
+		const percentCount = (fmt.match(/%/g) ?? []).length;
+		return formatNumberPattern(val * Math.pow(100, percentCount), fmt.replace(/%/g, "") || "0") + "%".repeat(percentCount);
+	}
+	/**
+	* Format a number in scientific notation
+	* @param val The number to format
+	* @param fmt The format string (e.g., "0.00E+00")
+	*/
+	function formatScientific(val, fmt) {
+		const sign = val < 0 ? "-" : "";
+		const absVal = Math.abs(val);
+		if (absVal === 0) {
+			const decMatch = fmt.match(/\.([0#]+)E/i);
+			const decPlaces = decMatch ? decMatch[1].length : 2;
+			return "0." + "0".repeat(decPlaces) + "E+00";
+		}
+		const decMatch = fmt.match(/\.([0#]+)E/i);
+		const decPlaces = decMatch ? decMatch[1].length : 2;
+		const hasPlus = fmt.includes("E+");
+		const exp = Math.floor(Math.log10(absVal));
+		const mantissaStr = roundTo(absVal / Math.pow(10, exp), decPlaces).toFixed(decPlaces);
+		const expSign = exp >= 0 ? hasPlus ? "+" : "" : "-";
+		const expStr = pad0(Math.abs(exp), 2);
+		return sign + mantissaStr + "E" + expSign + expStr;
+	}
+	/**
+	* Convert decimal to fraction using continued fraction algorithm
+	*/
+	function toFraction(val, maxDenom) {
+		const sign = val < 0 ? -1 : 1;
+		let absVal = Math.abs(val);
+		const whole = Math.floor(absVal);
+		absVal -= whole;
+		if (absVal < 1e-10) return [
+			sign * whole,
+			0,
+			1
+		];
+		let p0 = 0, p1 = 1;
+		let q0 = 1, q1 = 0;
+		let a = Math.floor(absVal);
+		let p = a;
+		let q = 1;
+		while (q1 < maxDenom) {
+			a = Math.floor(absVal);
+			p = a * p1 + p0;
+			q = a * q1 + q0;
+			if (absVal - a < 1e-10) break;
+			absVal = 1 / (absVal - a);
+			p0 = p1;
+			p1 = p;
+			q0 = q1;
+			q1 = q;
+		}
+		if (q > maxDenom) {
+			q = q1;
+			p = p1;
+		}
+		return [
+			sign * whole,
+			sign * p,
+			q
+		];
+	}
+	/**
+	* Format a number as a fraction
+	* @param val The number to format
+	* @param fmt The format string (e.g., "# ?/?", "# ??/??")
+	*/
+	function formatFraction(val, fmt) {
+		const sign = val < 0 ? "-" : "";
+		const absVal = Math.abs(val);
+		const fixedDenomMatch = fmt.match(/\?+\s*\/\s*(\d+)/);
+		if (fixedDenomMatch) {
+			const denom = parseInt(fixedDenomMatch[1], 10);
+			const whole = Math.floor(absVal);
+			const frac = absVal - whole;
+			const numer = Math.round(frac * denom);
+			if (fmt.includes("#") || fmt.includes("0")) {
+				if (numer === 0) return sign + whole.toString();
+				return sign + (whole > 0 ? whole + " " : "") + numer + "/" + denom;
+			}
+			return sign + (whole * denom + numer) + "/" + denom;
+		}
+		const denomMatch = fmt.match(/\/\s*(\?+)/);
+		const maxDigits = denomMatch ? denomMatch[1].length : 2;
+		const [whole, numer, denom] = toFraction(absVal, Math.pow(10, maxDigits) - 1);
+		if (fmt.includes("#") && whole !== 0) {
+			if (numer === 0) return sign + Math.abs(whole).toString();
+			return sign + Math.abs(whole) + " " + Math.abs(numer) + "/" + denom;
+		}
+		if (numer === 0) return whole === 0 ? "0" : sign + Math.abs(whole).toString();
+		return sign + (Math.abs(whole) * denom + Math.abs(numer)) + "/" + denom;
+	}
+	/**
+	* Format elapsed time (e.g., [h]:mm:ss for durations > 24 hours)
+	*/
+	function formatElapsedTime(serial, fmt) {
+		const totalSeconds = Math.round(serial * 86400);
+		const totalMinutes = Math.floor(totalSeconds / 60);
+		const totalHours = Math.floor(totalMinutes / 60);
+		const seconds = totalSeconds % 60;
+		const minutes = totalMinutes % 60;
+		const hours = totalHours;
+		let result = fmt;
+		if (/\[h+\]/i.test(result)) result = result.replace(/\[h+\]/gi, hours.toString());
+		if (/\[m+\]/i.test(result)) result = result.replace(/\[m+\]/gi, totalMinutes.toString());
+		if (/\[s+\]/i.test(result)) result = result.replace(/\[s+\]/gi, totalSeconds.toString());
+		result = result.replace(/mm/gi, minutes.toString().padStart(2, "0"));
+		result = result.replace(/ss/gi, seconds.toString().padStart(2, "0"));
+		return result;
+	}
+	/**
+	* Format a number with the given pattern
+	* Handles patterns like "0", "00", "#,##0", "0-0", "000-0000" etc.
+	*/
+	function formatNumberPattern(val, fmt) {
+		const absVal = Math.abs(val);
+		const sign = val < 0 ? "-" : "";
+		let trailingCommas = 0;
+		let workFmt = fmt;
+		while (workFmt.endsWith(",")) {
+			trailingCommas++;
+			workFmt = workFmt.slice(0, -1);
+		}
+		const scaledVal = absVal / Math.pow(1e3, trailingCommas);
+		const decimalIdx = workFmt.indexOf(".");
+		let intFmt = workFmt;
+		let decFmt = "";
+		if (decimalIdx !== -1) {
+			intFmt = workFmt.substring(0, decimalIdx);
+			decFmt = workFmt.substring(decimalIdx + 1);
+		}
+		const decimalPlaces = decFmt.replace(/[^0#?]/g, "").length;
+		const roundedVal = roundTo(scaledVal, decimalPlaces);
+		if (roundedVal === 0 && !intFmt.includes("0") && !decFmt.includes("0")) {
+			let result = "";
+			for (const ch of intFmt) if (ch === "?") result += " ";
+			else if (ch !== "#" && ch !== ",") result += ch;
+			if (decimalPlaces > 0) {
+				if (/[0?]/.test(decFmt)) {
+					result += ".";
+					for (const ch of decFmt) if (ch === "?") result += " ";
+				}
+			}
+			return sign + result;
+		}
+		const [intPart, decPart = ""] = roundedVal.toString().split(".");
+		const hasLiteralInFormat = /[0#?][^0#?,.\s][0#?]/.test(intFmt);
+		let formattedInt;
+		if (hasLiteralInFormat) {
+			const digitPlaceholders = intFmt.replace(/[^0#?]/g, "").length;
+			let digits = intPart;
+			if (digits.length < digitPlaceholders) digits = "0".repeat(digitPlaceholders - digits.length) + digits;
+			formattedInt = "";
+			let digitIndex = digits.length - digitPlaceholders;
+			for (let i = 0; i < intFmt.length; i++) {
+				const char = intFmt[i];
+				if (char === "0" || char === "#" || char === "?") {
+					if (digitIndex < digits.length) {
+						formattedInt += digits[digitIndex];
+						digitIndex++;
+					}
+				} else if (char !== ",") formattedInt += char;
+			}
+		} else {
+			formattedInt = intPart;
+			if (intFmt.includes(",")) formattedInt = commaify(intPart);
+			const minIntDigits = (intFmt.match(/0/g) ?? []).length;
+			const totalIntSlots = (intFmt.match(/[0?]/g) ?? []).length;
+			if (formattedInt.length < minIntDigits) formattedInt = "0".repeat(minIntDigits - formattedInt.length) + formattedInt;
+			if (formattedInt.length < totalIntSlots) formattedInt = " ".repeat(totalIntSlots - formattedInt.length) + formattedInt;
+			if (formattedInt === "0" && minIntDigits === 0 && totalIntSlots === 0) formattedInt = "";
+		}
+		let formattedDec = "";
+		if (decimalPlaces > 0) {
+			const decChars = (decPart + "0".repeat(decimalPlaces)).substring(0, decimalPlaces).split("");
+			for (let i = decFmt.length - 1; i >= 0; i--) {
+				if (i >= decChars.length) continue;
+				if (decFmt[i] === "#" && decChars[i] === "0") decChars[i] = "";
+				else if (decFmt[i] === "?" && decChars[i] === "0") decChars[i] = " ";
+				else break;
+			}
+			const decStr = decChars.join("");
+			if (decStr.length > 0) formattedDec = "." + decStr;
+		}
+		return sign + formattedInt + formattedDec;
+	}
+	/**
+	* Remove quoted literal text markers and return the literal characters
+	* Also handles backslash escape sequences
+	*/
+	function processQuotedText(fmt) {
+		let result = "";
+		let i = 0;
+		while (i < fmt.length) if (fmt[i] === "\"") {
+			i++;
+			while (i < fmt.length && fmt[i] !== "\"") {
+				result += fmt[i];
+				i++;
+			}
+			i++;
+		} else if (fmt[i] === "\\" && i + 1 < fmt.length) {
+			i++;
+			result += fmt[i];
+			i++;
+		} else {
+			result += fmt[i];
+			i++;
+		}
+		return result;
+	}
+	/**
+	* Check if a condition matches (e.g., [>100], [<=50])
+	*/
+	function checkCondition(val, condition) {
+		const match = condition.match(/\[(=|>|<|>=|<=|<>)(-?\d+(?:\.\d*)?)\]/);
+		if (!match) return false;
+		const op = match[1];
+		const threshold = parseFloat(match[2]);
+		switch (op) {
+			case "=": return val === threshold;
+			case ">": return val > threshold;
+			case "<": return val < threshold;
+			case ">=": return val >= threshold;
+			case "<=": return val <= threshold;
+			case "<>": return val !== threshold;
+			default: return false;
+		}
+	}
+	/**
+	* Parse format string and handle positive/negative/zero/text sections
+	* Excel format: positive;negative;zero;text
+	* Also handles conditional formats like [>100]
+	*/
+	function chooseFormat(fmt, val) {
+		if (typeof val === "string") {
+			const sections = splitFormatSections(fmt);
+			if (sections.length >= 4 && sections[3]) return processQuotedText(sections[3]).replace(/@/g, val);
+			return val;
+		}
+		if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
+		const sections = splitFormatSections(fmt);
+		const condRegex = /\[(=|>|<|>=|<=|<>)-?\d+(?:\.\d*)?\]/;
+		if ((sections[0] && condRegex.test(sections[0]) || sections[1] && condRegex.test(sections[1])) && sections.length >= 2) {
+			for (let i = 0; i < Math.min(sections.length, 2); i++) {
+				const condMatch = sections[i].match(/\[(=|>|<|>=|<=|<>)-?\d+(?:\.\d*)?\]/);
+				if (condMatch && checkCondition(val, condMatch[0])) return sections[i];
+			}
+			return sections[sections.length > 2 ? 2 : 1];
+		}
+		if (sections.length === 1) return sections[0];
+		if (sections.length === 2) return val >= 0 ? sections[0] : sections[1];
+		if (val > 0) return sections[0];
+		if (val < 0) return sections[1];
+		return sections[2] || sections[0];
+	}
+	/**
+	* Check if format section is for negative values (2nd section in multi-section format)
+	*/
+	function isNegativeSection(fmt, selectedFmt) {
+		const sections = splitFormatSections(fmt);
+		return sections.length >= 2 && sections[1] === selectedFmt;
+	}
+	/**
+	* Main format function - formats a value according to Excel numFmt
+	* @param fmt The Excel number format string (e.g., "0.00%", "#,##0", "yyyy-mm-dd")
+	* @param val The value to format
+	*/
+	function format(fmt, val) {
+		if (val == null) return "";
+		if (isGeneral(fmt)) return formatGeneral(val);
+		if (typeof val === "string") return chooseFormat(fmt, val);
+		if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
+		let numVal = val;
+		const selectedFmt = chooseFormat(fmt, numVal);
+		if (numVal < 0 && isNegativeSection(fmt, selectedFmt)) numVal = Math.abs(numVal);
+		let cleanFmt = selectedFmt.replace(/\[(Red|Green|Blue|Yellow|Magenta|Cyan|White|Black|Color\d+)\]/gi, "");
+		cleanFmt = cleanFmt.replace(/\[(>|<|>=|<=|=|<>)-?\d+(\.\d+)?\]/g, "");
+		cleanFmt = cleanFmt.replace(/\[\$[^\]]*\]/g, "");
+		cleanFmt = processPlaceholders(cleanFmt);
+		cleanFmt = processQuotedText(cleanFmt);
+		if (/\[[hms]+\]/i.test(cleanFmt)) return formatElapsedTime(numVal, cleanFmt);
+		if (isDateFormat(cleanFmt)) return formatDate(numVal, cleanFmt);
+		if (cleanFmt.includes("%")) return formatPercentage(numVal, cleanFmt);
+		if (/E[+-]?/i.test(cleanFmt)) return formatScientific(numVal, cleanFmt);
+		if (/\?+\s*\/\s*[\d?]+/.test(cleanFmt)) return formatFraction(numVal, cleanFmt);
+		if (cleanFmt.includes("(") && cleanFmt.includes(")") && numVal < 0) {
+			const innerFmt = cleanFmt.replace(/\(|\)/g, "");
+			return "(" + formatNumberPattern(-numVal, innerFmt) + ")";
+		}
+		if (cleanFmt === "@") return numVal.toString();
+		let prefix = "";
+		let suffix = "";
+		const prefixMatch = cleanFmt.match(/^([^#0?.,]+)/);
+		if (prefixMatch) {
+			prefix = prefixMatch[1];
+			cleanFmt = cleanFmt.substring(prefixMatch[0].length);
+		}
+		const suffixMatch = cleanFmt.match(/([^#0?.,]+)$/);
+		if (suffixMatch && !suffixMatch[1].includes("%")) {
+			suffix = suffixMatch[1];
+			cleanFmt = cleanFmt.substring(0, cleanFmt.length - suffixMatch[0].length);
+		}
+		const formattedNum = formatNumberPattern(numVal, cleanFmt);
+		return prefix + formattedNum + suffix;
+	}
+	/**
+	* Check if format is a pure time format (no date components like y, m for month, d).
+	* Time formats only contain: h, m (minutes in time context), s, AM/PM.
+	* Excludes elapsed time formats like [h]:mm:ss which need the full serial number.
+	*/
+	function isTimeOnlyFormat(fmt) {
+		const cleaned = fmt.replace(/"[^"]*"/g, "");
+		if (/\[[hms]\]/i.test(cleaned)) return false;
+		const withoutBrackets = cleaned.replace(/\[[^\]]*\]/g, "");
+		const hasTimeComponents = /[hs]/i.test(withoutBrackets) || /AM\/PM|A\/P/i.test(withoutBrackets);
+		if (/[yd]/i.test(withoutBrackets)) return false;
+		if (/m/i.test(withoutBrackets) && !hasTimeComponents) return false;
+		return hasTimeComponents;
+	}
+	/**
+	* Check if format is a date format (contains y, d, or month-m).
+	* More precise than the internal isDateFormat — correctly handles elapsed time
+	* formats like [h]:mm:ss (not a date format) and distinguishes month-m from minute-m.
+	*/
+	function isDateDisplayFormat(fmt) {
+		const cleaned = fmt.replace(/"[^"]*"/g, "");
+		if (/\[[hms]\]/i.test(cleaned)) return false;
+		const withoutBrackets = cleaned.replace(/\[[^\]]*\]/g, "");
+		if (/[yd]/i.test(withoutBrackets)) return true;
+		if (/m/i.test(withoutBrackets)) {
+			if (!(/[hs]/i.test(withoutBrackets) || /AM\/PM|A\/P/i.test(withoutBrackets))) return true;
+		}
+		return false;
+	}
+	/**
+	* Default format applied to Date values whose numFmt is `General` or empty.
+	*
+	* Excel itself substitutes a locale-dependent short date in this case (US:
+	* `m/d/yyyy`). We pick an ISO-like `yyyy-mm-dd` so consumers who never set a
+	* `numFmt` still get a sensible, unambiguous rendering instead of the raw
+	* Excel serial number.
+	*/
+	const DEFAULT_DATE_FORMAT = "yyyy-mm-dd";
+	const DEFAULT_DATETIME_FORMAT = "yyyy-mm-dd hh:mm:ss";
+	/**
+	* Format a value according to the given format string.
+	* Handles Date objects with timezone-independent Excel serial conversion.
+	*/
+	function formatCellValue(value, fmt, dateFormat) {
+		if (value instanceof Date) {
+			let serial = dateToExcel(value);
+			if (isTimeOnlyFormat(fmt)) {
+				serial = serial % 1;
+				if (serial < 0) serial += 1;
+				return format(fmt, serial);
+			}
+			let effectiveFmt;
+			if (dateFormat && isDateDisplayFormat(fmt)) effectiveFmt = dateFormat;
+			else if (!fmt || isGeneral(fmt)) effectiveFmt = serial % 1 === 0 ? DEFAULT_DATE_FORMAT : DEFAULT_DATETIME_FORMAT;
+			else effectiveFmt = fmt;
+			return format(effectiveFmt, serial);
+		}
+		return format(fmt, value);
+	}
+	/**
+	* Get the formatted display text for a cell value.
+	*
+	* Handles primitive values, Date objects, formula results, and falls back to
+	* `cell.text` for complex types (rich text, hyperlinks, errors, etc.).
+	*
+	* @param cell       - A cell (or cell-like object) with `.value`, `.numFmt`, and `.text`
+	* @param dateFormat - Optional custom date format override
+	*/
+	function getCellDisplayText$1(cell, dateFormat) {
+		const value = cell.value;
+		const numFmt = cell.numFmt;
+		const fmt = typeof numFmt === "string" ? numFmt : numFmt?.formatCode ?? "General";
+		if (value == null) return "";
+		if (value instanceof Date || typeof value === "number" || typeof value === "boolean" || typeof value === "string") return formatCellValue(value, fmt, dateFormat);
+		if (typeof value === "object" && "formula" in value) {
+			const result = value.result;
+			if (result == null) return "";
+			if (result instanceof Date || typeof result === "number" || typeof result === "boolean" || typeof result === "string") return formatCellValue(result, fmt, dateFormat);
+		}
+		return cell.text;
+	}
+	//#endregion
 	//#region src/modules/excel/utils/shared-formula.ts
 	const replacementCandidateRx = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi;
 	const CRrx = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i;
@@ -17692,6 +18729,26 @@ onmessage = async (ev) => {
 		get text() {
 			return this._value.toString();
 		}
+		/**
+		* The cell's display text — the value formatted the way Excel would render
+		* it, applying the cell's `numFmt`. For a Date cell with `numFmt` `"mm-dd-yy"`,
+		* this returns e.g. `"04-12-19"` rather than the JS `Date.prototype.toString()`
+		* output you'd get from `cell.text`.
+		*
+		* Handles primitive values, dates, and formula results. For rich text,
+		* hyperlinks, errors, and other complex types, falls back to `cell.text`.
+		*
+		* Note: numFmt codes that are locale-dependent in Excel (e.g. built-in
+		* numFmtId 14 renders as `dd.mm.yyyy` under German locale but is stored
+		* as `mm-dd-yy`) are applied literally — excelts does not perform
+		* Excel's locale-based format substitution. If you need a specific date
+		* style across cells regardless of per-cell numFmts, call the exported
+		* {@link getCellDisplayText} helper with a `dateFormat` argument, or use
+		* `worksheet.toJSON({ dateFormat })`.
+		*/
+		get displayText() {
+			return getCellDisplayText$1(this);
+		}
 		get html() {
 			return escapeHtml(this.text);
 		}
@@ -18808,437 +19865,6 @@ onmessage = async (ev) => {
 		}
 	};
 	//#endregion
-	//#region src/utils/env.ts
-	/**
-	* Environment detection utilities
-	* Common functions to detect runtime environment (Node.js vs Browser)
-	*/
-	/**
-	* Check if running in Node.js environment
-	* Returns true if process.versions.node exists
-	*/
-	function isNode() {
-		return typeof process !== "undefined" && !!process.versions?.node;
-	}
-	//#endregion
-	//#region src/modules/xml/encode.ts
-	/**
-	* XML Encoding / Decoding Utilities
-	*
-	* Self-contained XML entity encoding and decoding functions.
-	*/
-	/** Standard XML entity decode map. */
-	const DECODE_MAP = {
-		lt: "<",
-		gt: ">",
-		amp: "&",
-		quot: "\"",
-		apos: "'"
-	};
-	/** Regex for decoding XML entities (named + numeric). */
-	const DECODE_RE = /&(#\d+|#[xX][0-9A-Fa-f]+|\w+);/g;
-	/**
-	* Lookup table for characters that need encoding in the ASCII range (0-127).
-	* 0 = safe, 1 = encode to entity, 2 = strip (invalid control char)
-	*/
-	const ENCODE_ACTION = /* @__PURE__ */ (() => {
-		const t = new Uint8Array(128);
-		for (let i = 0; i <= 8; i++) t[i] = 2;
-		t[11] = 2;
-		t[12] = 2;
-		for (let i = 14; i <= 31; i++) t[i] = 2;
-		t[127] = 2;
-		t[34] = 1;
-		t[38] = 1;
-		t[39] = 1;
-		t[60] = 1;
-		t[62] = 1;
-		return t;
-	})();
-	const ENCODE_ENTITIES = {
-		34: "&quot;",
-		38: "&amp;",
-		39: "&apos;",
-		60: "&lt;",
-		62: "&gt;"
-	};
-	/**
-	* Decode XML entities in a string.
-	*
-	* Handles named entities (`&lt;`, `&gt;`, `&amp;`, `&quot;`, `&apos;`)
-	* and numeric character references (`&#123;`, `&#x7B;`).
-	*
-	* Security: validates numeric code points are in range [1, 0x10FFFF]
-	* and rejects surrogate halves (0xD800-0xDFFF).
-	*
-	* Fast-path: returns the original string if no `&` is found.
-	*/
-	function xmlDecode(text) {
-		if (text.indexOf("&") === -1) return text;
-		return text.replace(DECODE_RE, (match, entity) => {
-			if (entity[0] === "#") {
-				const code = entity[1] === "x" || entity[1] === "X" ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
-				if (Number.isNaN(code) || code < 1 || code >= 55296 && code <= 57343 || code > 1114111) return match;
-				return String.fromCodePoint(code);
-			}
-			return DECODE_MAP[entity] ?? match;
-		});
-	}
-	/**
-	* Encode special characters for XML output.
-	*
-	* Escapes `<`, `>`, `&`, `"`, `'` to their entity equivalents.
-	* Strips invalid XML control characters (0x00-0x08, 0x0B-0x0C, 0x0E-0x1F, 0x7F)
-	* and lone surrogates (0xD800-0xDFFF without a pair).
-	*
-	* Optimized: uses a lookup table and manual scan instead of regex for
-	* maximum throughput on the hot path (called per attribute/text value).
-	*/
-	function xmlEncode(text) {
-		const len = text.length;
-		let firstBad = -1;
-		for (let i = 0; i < len; i++) {
-			const code = text.charCodeAt(i);
-			if (code < 128) {
-				if (ENCODE_ACTION[code] !== 0) {
-					firstBad = i;
-					break;
-				}
-			} else if (code >= 55296 && code <= 57343) {
-				if (code <= 56319) {
-					const next = text.charCodeAt(i + 1);
-					if (next >= 56320 && next <= 57343) {
-						i++;
-						continue;
-					}
-				}
-				firstBad = i;
-				break;
-			} else if (code === 65534 || code === 65535) {
-				firstBad = i;
-				break;
-			}
-		}
-		if (firstBad === -1) return text;
-		const parts = [];
-		let lastIndex = 0;
-		for (let i = firstBad; i < len; i++) {
-			const code = text.charCodeAt(i);
-			if (code < 128) {
-				const action = ENCODE_ACTION[code];
-				if (action === 0) continue;
-				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
-				if (action === 1) parts.push(ENCODE_ENTITIES[code]);
-				lastIndex = i + 1;
-			} else if (code >= 55296 && code <= 56319) {
-				const next = text.charCodeAt(i + 1);
-				if (next >= 56320 && next <= 57343) {
-					i++;
-					continue;
-				}
-				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
-				lastIndex = i + 1;
-			} else if (code >= 56320 && code <= 57343) {
-				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
-				lastIndex = i + 1;
-			} else if (code === 65534 || code === 65535) {
-				if (lastIndex < i) parts.push(text.substring(lastIndex, i));
-				lastIndex = i + 1;
-			}
-		}
-		if (lastIndex < len) parts.push(text.substring(lastIndex));
-		return parts.length === 1 ? parts[0] : parts.join("");
-	}
-	/**
-	* Encode a value for use in an XML attribute.
-	*
-	* Same as {@link xmlEncode} — provided as a semantic alias.
-	* In the future this could apply attribute-specific normalisation
-	* (e.g. collapsing whitespace per XML 1.0 §3.3.3).
-	*/
-	function xmlEncodeAttr(value) {
-		return xmlEncode(value);
-	}
-	/**
-	* Characters that must NEVER appear in XML element or attribute names.
-	* This is a fast security check to prevent markup injection via names,
-	* not a full XML NameChar validation (which would require Unicode tables).
-	*/
-	const INVALID_NAME_CHARS = /[\s<>"'/=&]/;
-	/**
-	* Validate an XML element or attribute name against injection attacks.
-	*
-	* Rejects:
-	* - Empty names
-	* - Names containing whitespace, `<`, `>`, `"`, `'`, `/`, `=`, `&`
-	* - Names starting with a digit, `-`, or `.`
-	*
-	* This is NOT a full XML Name validation (which requires Unicode NameStartChar
-	* tables). It is a focused security check to prevent markup injection.
-	*/
-	function validateXmlName(name) {
-		if (!name) throw new XmlError("XML name must not be empty");
-		if (INVALID_NAME_CHARS.test(name)) throw new XmlError(`Invalid XML name: contains forbidden character in "${name}"`);
-		const first = name.charCodeAt(0);
-		if (first >= 48 && first <= 57 || first === 45 || first === 46) throw new XmlError(`Invalid XML name: "${name}" starts with forbidden character`);
-	}
-	/**
-	* Encode text for a CDATA section, splitting on `]]>` to produce valid output.
-	*
-	* The sequence `]]>` cannot appear inside CDATA, so each occurrence is split
-	* into adjacent CDATA sections: `<![CDATA[...]]]]><![CDATA[>...]]>`.
-	*/
-	function encodeCData(text) {
-		return "<![CDATA[" + text.split("]]>").join("]]]]><![CDATA[>") + "]]>";
-	}
-	/**
-	* Validate that text is legal for an XML comment.
-	*
-	* XML spec: comments must not contain `--` and must not end with `-`.
-	* @throws {XmlError} if the text is invalid.
-	*/
-	function validateCommentText(text) {
-		if (text.includes("--") || text.endsWith("-")) throw new XmlError("Invalid comment: must not contain \"--\" or end with \"-\"");
-	}
-	/** Default XML declaration attributes (`version`, `encoding`, `standalone`). */
-	const StdDocAttributes = {
-		version: "1.0",
-		encoding: "UTF-8",
-		standalone: "yes"
-	};
-	//#endregion
-	//#region src/utils/utils.base.ts
-	/**
-	* Base utility functions shared between Node.js and Browser
-	* All functions use standard Web APIs that work in both environments
-	* (Node.js 16+ supports atob/btoa/TextEncoder/TextDecoder globally)
-	*/
-	/**
-	* Convert base64 string to Uint8Array
-	* Uses native Buffer in Node.js for better performance
-	*/
-	function base64ToUint8Array(base64) {
-		if (isNode()) return Buffer.from(base64, "base64");
-		const binary = atob(base64);
-		const bytes = new Uint8Array(binary.length);
-		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-		return bytes;
-	}
-	function dateToExcel(d, date1904) {
-		return 25569 + d.getTime() / (24 * 3600 * 1e3) - (date1904 ? 1462 : 0);
-	}
-	function excelToDate(v, date1904) {
-		const millisecondSinceEpoch = Math.round((v - 25569 + (date1904 ? 1462 : 0)) * 24 * 3600 * 1e3);
-		return new Date(millisecondSinceEpoch);
-	}
-	/**
-	* Parse an OOXML date string into a Date object.
-	* OOXML dates like "2024-01-15T00:00:00" lack a timezone suffix,
-	* which some JS engines parse as local time. Appending "Z" forces UTC.
-	*/
-	function parseOoxmlDate(raw) {
-		return new Date(raw.endsWith("Z") ? raw : raw + "Z");
-	}
-	/**
-	* Pattern matching OOXML `_xHHHH_` escape sequences (case-insensitive hex).
-	*
-	* Per the OOXML spec, `_xHHHH_` encodes a Unicode code point where HHHH is
-	* a 4-digit hexadecimal number. The spec uses uppercase, but real-world files
-	* from third-party tools (Google Sheets, LibreOffice, etc.) may use lowercase.
-	*/
-	const ooxmlEscapeRegex = /_x([0-9A-Fa-f]{4})_/g;
-	/**
-	* Decode OOXML `_xHHHH_` escape sequences in a string.
-	*
-	* Used when reading text content from `<t>` elements in shared strings,
-	* rich text runs, and inline strings. The replacement works left-to-right,
-	* so `_x005F_x000D_` correctly decodes to the literal string `_x000D_`
-	* (the `_x005F_` decodes to `_`, consuming the match).
-	*/
-	function decodeOoxmlEscape(text) {
-		return text.replace(ooxmlEscapeRegex, (match, $1) => {
-			const code = parseInt($1, 16);
-			if (code === 0 || code >= 1 && code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127 || code >= 55296 && code <= 57343 || code === 65534 || code === 65535) return match;
-			return String.fromCharCode(code);
-		});
-	}
-	/**
-	* Encode literal `_xHHHH_` patterns in a string for OOXML output.
-	*
-	* If a string naturally contains the pattern `_xHHHH_` (e.g., the user typed
-	* `_x000D_`), the leading underscore must be escaped as `_x005F_` to prevent
-	* readers from misinterpreting it as an escape sequence.
-	*
-	* Roundtrip guarantee: `decodeOoxmlEscape(encodeOoxmlEscape(s)) === s`
-	*/
-	function encodeOoxmlEscape(text) {
-		return text.replace(ooxmlEscapeRegex, "_x005F_x$1_");
-	}
-	/**
-	* Characters that XML attribute-value normalisation replaces with spaces
-	* (XML 1.0 §3.3.3). When writing OOXML attribute values we must encode
-	* these as `_xHHHH_` so that the original characters survive a round-trip.
-	*/
-	const xmlAttrUnsafeRe = /[\t\n\r]/g;
-	const xmlAttrUnsafeMap = {
-		"	": "_x0009_",
-		"\n": "_x000A_",
-		"\r": "_x000D_"
-	};
-	/**
-	* Encode a string for safe use in an OOXML **XML attribute** value.
-	*
-	* Two transformations are applied (order matters):
-	* 1. Literal `_xHHHH_` patterns are escaped (`_x005F_xHHHH_`) so readers
-	*    do not misinterpret them as escape sequences.
-	* 2. Characters that XML attribute-value normalisation would mangle
-	*    (`\t`, `\n`, `\r`) are encoded as `_x0009_`, `_x000A_`, `_x000D_`.
-	*
-	* This is the write-side counterpart of {@link decodeOoxmlEscape}.
-	* Use `encodeOoxmlEscape` for element **text** content and this function
-	* for **attribute** values.
-	*/
-	function encodeOoxmlAttr(text) {
-		let result = text.replace(ooxmlEscapeRegex, "_x005F_x$1_");
-		result = result.replace(xmlAttrUnsafeRe, (ch) => xmlAttrUnsafeMap[ch]);
-		return result;
-	}
-	function validInt(value) {
-		const i = typeof value === "number" ? value : parseInt(value, 10);
-		return Number.isNaN(i) ? 0 : i;
-	}
-	/**
-	* Split an Excel numFmt string by semicolons, respecting quoted strings and brackets.
-	*
-	* Excel numFmt can have up to 4 sections: `positive ; negative ; zero ; text`.
-	* Semicolons inside `"..."` (literal text) or `[...]` (locale/color tags) must NOT
-	* be treated as section separators.
-	*/
-	function splitFormatSections(fmt) {
-		const sections = [];
-		let current = "";
-		let inQuote = false;
-		let inBracket = false;
-		for (let i = 0; i < fmt.length; i++) {
-			const char = fmt[i];
-			if (char === "\"" && !inBracket) {
-				inQuote = !inQuote;
-				current += char;
-			} else if (char === "[" && !inQuote) {
-				inBracket = true;
-				current += char;
-			} else if (char === "]" && !inQuote) {
-				inBracket = false;
-				current += char;
-			} else if (char === ";" && !inQuote && !inBracket) {
-				sections.push(current);
-				current = "";
-			} else current += char;
-		}
-		sections.push(current);
-		return sections;
-	}
-	/** Reusable regex — no capture groups, so safe for `test()`. */
-	const DATE_FMT_RE = /[ymdhMsb]/;
-	/** Strips bracket expressions `[...]` and quoted literals `"..."` from a format string. */
-	const STRIP_BRACKETS_QUOTES_RE = /\[[^\]]*\]|"[^"]*"/g;
-	/** Cache for isDateFmt results — typically only 5-20 unique formats per workbook,
-	*  but each may be tested hundreds of thousands of times during reconcile. */
-	const _isDateFmtCache = /* @__PURE__ */ new Map();
-	function isDateFmt(fmt) {
-		if (!fmt) return false;
-		const cached = _isDateFmtCache.get(fmt);
-		if (cached !== void 0) return cached;
-		const clean = splitFormatSections(fmt)[0].replace(STRIP_BRACKETS_QUOTES_RE, "");
-		let result;
-		if (clean.indexOf("@") > -1) result = false;
-		else result = DATE_FMT_RE.test(clean);
-		_isDateFmtCache.set(fmt, result);
-		return result;
-	}
-	function parseBoolean(value) {
-		return value === true || value === "true" || value === 1 || value === "1";
-	}
-	function* range(start, stop, step = 1) {
-		const compareOrder = step > 0 ? (a, b) => a < b : (a, b) => a > b;
-		for (let value = start; compareOrder(value, stop); value += step) yield value;
-	}
-	function toSortedArray(values) {
-		const result = Array.from(values);
-		if (result.length <= 1) return result;
-		if (result.every((item) => Number.isFinite(item))) return result.sort((a, b) => a - b);
-		if (result.every((item) => item instanceof Date)) return result.sort((a, b) => a.getTime() - b.getTime());
-		return result.sort((a, b) => {
-			const ta = sortTypeRank(a);
-			const tb = sortTypeRank(b);
-			if (ta !== tb) return ta - tb;
-			if (ta === 0) return a - b;
-			if (ta === 1) return a.getTime() - b.getTime();
-			return String(a).localeCompare(String(b));
-		});
-	}
-	/** Rank for mixed-type sort: numbers=0, dates=1, everything else=2 */
-	function sortTypeRank(v) {
-		if (Number.isFinite(v)) return 0;
-		if (v instanceof Date) return 1;
-		return 2;
-	}
-	const textDecoder = new TextDecoder("utf-8");
-	let latin1Decoder;
-	let _latin1DecoderResolved = false;
-	function getLatin1Decoder() {
-		if (!_latin1DecoderResolved) {
-			_latin1DecoderResolved = true;
-			try {
-				latin1Decoder = new TextDecoder("latin1");
-			} catch {
-				latin1Decoder = void 0;
-			}
-		}
-		return latin1Decoder;
-	}
-	/**
-	* Convert a Buffer, ArrayBuffer, or Uint8Array to a UTF-8 string
-	* Works in both Node.js and browser environments
-	*/
-	function bufferToString(chunk) {
-		if (typeof chunk === "string") return chunk;
-		return textDecoder.decode(chunk);
-	}
-	/**
-	* Convert Uint8Array to base64 string
-	* Uses native Buffer in Node.js, optimized chunked conversion in browser
-	*/
-	function uint8ArrayToBase64(bytes) {
-		if (isNode()) return Buffer.from(bytes).toString("base64");
-		if (getLatin1Decoder()) try {
-			return btoa(latin1Decoder.decode(bytes));
-		} catch {}
-		const CHUNK_SIZE = 32768;
-		const chunks = [];
-		for (let i = 0; i < bytes.length; i += CHUNK_SIZE) chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK_SIZE)));
-		return btoa(chunks.join(""));
-	}
-	/**
-	* Convert string to UTF-16LE Uint8Array (used for Excel password hashing)
-	*/
-	function stringToUtf16Le(str) {
-		const bytes = new Uint8Array(str.length * 2);
-		for (let i = 0; i < str.length; i++) {
-			const code = str.charCodeAt(i);
-			bytes[i * 2] = code & 255;
-			bytes[i * 2 + 1] = code >> 8 & 255;
-		}
-		return bytes;
-	}
-	/**
-	* Yield to the event loop via a macrotask.
-	* Uses `setTimeout(0)` which works in both Node.js and browsers.
-	*/
-	function yieldToEventLoop() {
-		return new Promise((resolve) => setTimeout(resolve, 0));
-	}
-	//#endregion
 	//#region src/modules/excel/stream/worksheet-reader.ts
 	/**
 	* WorksheetReader - Cross-Platform Streaming Worksheet Reader
@@ -21971,7 +22597,7 @@ onmessage = async (ev) => {
 		19: { f: "h:mm:ss AM/PM" },
 		20: { f: "h:mm" },
 		21: { f: "h:mm:ss" },
-		22: { f: "m/d/yy \"h\":mm" },
+		22: { f: "m/d/yy h:mm" },
 		27: {
 			"zh-tw": "[$-404]e/m/d",
 			"zh-cn": "yyyy\"年\"m\"月\"",
@@ -22034,8 +22660,8 @@ onmessage = async (ev) => {
 		},
 		37: { f: "#,##0 ;(#,##0)" },
 		38: { f: "#,##0 ;[Red](#,##0)" },
-		39: { f: "#,##0.00 ;(#,##0.00)" },
-		40: { f: "#,##0.00 ;[Red](#,##0.00)" },
+		39: { f: "#,##0.00;(#,##0.00)" },
+		40: { f: "#,##0.00;[Red](#,##0.00)" },
 		45: { f: "mm:ss" },
 		46: { f: "[h]:mm:ss" },
 		47: { f: "mmss.0" },
@@ -33435,1008 +34061,458 @@ self.onmessage = async function(event) {
 			return this.column.name;
 		}
 		set name(value) {
-			this._set("name", value);
-		}
-		get filterButton() {
-			return this.column.filterButton;
-		}
-		set filterButton(value) {
-			this.column.filterButton = value;
-		}
-		get style() {
-			return this.column.style;
-		}
-		set style(value) {
-			this.column.style = value;
-		}
-		get totalsRowLabel() {
-			return this.column.totalsRowLabel;
-		}
-		set totalsRowLabel(value) {
-			this._set("totalsRowLabel", value);
-		}
-		get totalsRowFunction() {
-			return this.column.totalsRowFunction;
-		}
-		set totalsRowFunction(value) {
-			this._set("totalsRowFunction", value);
-		}
-		get totalsRowResult() {
-			return this.column.totalsRowResult;
-		}
-		set totalsRowResult(value) {
-			this._set("totalsRowResult", value);
-		}
-		get totalsRowFormula() {
-			return this.column.totalsRowFormula;
-		}
-		set totalsRowFormula(value) {
-			this._set("totalsRowFormula", value);
-		}
-	};
-	var Table = class Table {
-		constructor(worksheet, table) {
-			this.worksheet = worksheet;
-			if (table) {
-				this.table = table;
-				if (Array.isArray(table.rows) && table.rows.length === 0 && table.tableRef) {
-					const decoded = colCache.decode(table.tableRef);
-					if ("dimensions" in decoded) {
-						const startRow = decoded.top + (table.headerRow === false ? 0 : 1);
-						const endRow = decoded.bottom - (table.totalsRow === true ? 1 : 0);
-						if (endRow >= startRow) for (let r = startRow; r <= endRow; r++) {
-							const row = worksheet.getRow(r);
-							const values = [];
-							for (let c = decoded.left; c <= decoded.right; c++) values.push(row.getCell(c).value);
-							table.rows.push(values);
-						}
-					}
-				}
-				this.validate();
-				this.store();
-			}
-		}
-		static {
-			this.SUBTOTAL_FUNCTIONS = {
-				average: 101,
-				countNums: 102,
-				count: 103,
-				max: 104,
-				min: 105,
-				stdDev: 107,
-				var: 110,
-				sum: 109
-			};
-		}
-		getFormula(column) {
-			if (column.totalsRowFunction === "none") return null;
-			if (column.totalsRowFunction === "custom") return column.totalsRowFormula ?? null;
-			const fnNum = column.totalsRowFunction ? Table.SUBTOTAL_FUNCTIONS[column.totalsRowFunction] : void 0;
-			if (fnNum !== void 0) return `SUBTOTAL(${fnNum},${this.table.name}[${column.name}])`;
-			throw new TableError(`Invalid Totals Row Function: ${column.totalsRowFunction}`);
-		}
-		get width() {
-			return this.table.columns.length;
-		}
-		get height() {
-			return this.table.rows.length;
-		}
-		get filterHeight() {
-			return this.height + (this.table.headerRow ? 1 : 0);
-		}
-		get tableHeight() {
-			return this.filterHeight + (this.table.totalsRow ? 1 : 0);
-		}
-		validate() {
-			const { table } = this;
-			const assign = (o, name, dflt) => {
-				if (o[name] === void 0) o[name] = dflt;
-			};
-			assign(table, "headerRow", true);
-			assign(table, "totalsRow", false);
-			assign(table, "style", {});
-			const style = table.style;
-			assign(style, "theme", "TableStyleMedium2");
-			assign(style, "showFirstColumn", false);
-			assign(style, "showLastColumn", false);
-			assign(style, "showRowStripes", false);
-			assign(style, "showColumnStripes", false);
-			if (table.name) table.name = sanitizeTableName(table.name);
-			if (table.displayName) table.displayName = sanitizeTableName(table.displayName);
-			const assert = (test, message) => {
-				if (!test) throw new TableError(message);
-			};
-			assert(!!table.name, "Table must have a name");
-			assert(!!table.ref, "Table must have ref");
-			assert(!!table.columns, "Table must have column definitions");
-			assert(!!table.rows, "Table must have row definitions");
-			table.tl = colCache.decodeAddress(table.ref);
-			const { row, col } = table.tl;
-			assert(row > 0, "Table must be on valid row");
-			assert(col > 0, "Table must be on valid col");
-			const { width, tableHeight } = this;
-			table.autoFilterRef = colCache.encode(row, col, row, col + width - 1);
-			table.tableRef = colCache.encode(row, col, row + tableHeight - 1, col + width - 1);
-			table.columns.forEach((column, i) => {
-				assert(!!column.name, `Column ${i} must have a name`);
-				if (i === 0) assign(column, "totalsRowLabel", "Total");
-				else {
-					assign(column, "totalsRowFunction", "none");
-					column.totalsRowFormula = this.getFormula(column) ?? void 0;
-				}
-			});
-		}
-		store() {
-			const assignStyle = (cell, style) => {
-				if (style) Object.assign(cell.style, style);
-			};
-			const { worksheet, table } = this;
-			const { row, col } = table.tl;
-			let count = 0;
-			if (table.headerRow) {
-				const r = worksheet.getRow(row + count++);
-				table.columns.forEach((column, j) => {
-					const { style, name } = column;
-					const cell = r.getCell(col + j);
-					cell.value = name;
-					assignStyle(cell, style);
-				});
-			}
-			table.rows.forEach((data) => {
-				const r = worksheet.getRow(row + count++);
-				data.forEach((value, j) => {
-					const cell = r.getCell(col + j);
-					if (typeof value === "object" && value !== null && "formula" in value && typeof value.formula === "string") {
-						const formulaValue = value;
-						const shouldQualify = table.qualifyImplicitStructuredReferences === true;
-						cell.value = {
-							...formulaValue,
-							formula: shouldQualify ? formulaValue.formula.replace(/(^|[^A-Za-z0-9_])\[@\[?([^[\]]+?)\]?\]/g, `$1${table.name}[[#This Row],[$2]]`) : formulaValue.formula
-						};
-					} else cell.value = value;
-					assignStyle(cell, table.columns[j]?.style);
-				});
-			});
-			if (table.totalsRow) {
-				const r = worksheet.getRow(row + count++);
-				table.columns.forEach((column, j) => {
-					const cell = r.getCell(col + j);
-					if (j === 0) cell.value = column.totalsRowLabel;
-					else {
-						const formula = this.getFormula(column);
-						if (formula) cell.value = {
-							formula,
-							result: column.totalsRowResult
-						};
-						else cell.value = null;
-					}
-					assignStyle(cell, column.style);
-				});
-			}
-		}
-		load(worksheet) {
-			const { table } = this;
-			const { row, col } = table.tl;
-			let count = 0;
-			if (table.headerRow) {
-				const r = worksheet.getRow(row + count++);
-				table.columns.forEach((column, j) => {
-					const cell = r.getCell(col + j);
-					cell.value = column.name;
-				});
-			}
-			table.rows.forEach((data) => {
-				const r = worksheet.getRow(row + count++);
-				data.forEach((value, j) => {
-					const cell = r.getCell(col + j);
-					cell.value = value;
-				});
-			});
-			if (table.totalsRow) {
-				const r = worksheet.getRow(row + count++);
-				table.columns.forEach((column, j) => {
-					const cell = r.getCell(col + j);
-					if (j === 0) cell.value = column.totalsRowLabel;
-					else {
-						const formula = this.getFormula(column);
-						if (formula) cell.value = {
-							formula,
-							result: column.totalsRowResult
-						};
-					}
-				});
-			}
-		}
-		get model() {
-			return this.table;
-		}
-		set model(value) {
-			this.table = value;
-		}
-		cacheState() {
-			if (!this._cache) this._cache = {
-				ref: this.ref,
-				width: this.width,
-				tableHeight: this.tableHeight
-			};
-		}
-		commit() {
-			if (!this._cache) return;
-			this.validate();
-			const ref = colCache.decodeAddress(this._cache.ref);
-			if (this.ref !== this._cache.ref) for (let i = 0; i < this._cache.tableHeight; i++) {
-				const row = this.worksheet.getRow(ref.row + i);
-				for (let j = 0; j < this._cache.width; j++) {
-					const cell = row.getCell(ref.col + j);
-					cell.value = null;
-				}
-			}
-			else {
-				for (let i = this.tableHeight; i < this._cache.tableHeight; i++) {
-					const row = this.worksheet.getRow(ref.row + i);
-					for (let j = 0; j < this._cache.width; j++) {
-						const cell = row.getCell(ref.col + j);
-						cell.value = null;
-					}
-				}
-				for (let i = 0; i < this.tableHeight; i++) {
-					const row = this.worksheet.getRow(ref.row + i);
-					for (let j = this.width; j < this._cache.width; j++) {
-						const cell = row.getCell(ref.col + j);
-						cell.value = null;
-					}
-				}
-			}
-			this.store();
-			this._cache = void 0;
-		}
-		addRow(values, rowNumber, options) {
-			this.cacheState();
-			if (rowNumber === void 0) this.table.rows.push(values);
-			else this.table.rows.splice(rowNumber, 0, values);
-			if (options?.commit !== false) this.commit();
-		}
-		removeRows(rowIndex, count = 1, options) {
-			this.cacheState();
-			this.table.rows.splice(rowIndex, count);
-			if (options?.commit !== false) this.commit();
-		}
-		getColumn(colIndex) {
-			const column = this.table.columns[colIndex];
-			return new Column$1(this, column, colIndex);
-		}
-		addColumn(column, values, colIndex) {
-			this.cacheState();
-			if (colIndex === void 0) {
-				this.table.columns.push(column);
-				this.table.rows.forEach((row, i) => {
-					row.push(values[i]);
-				});
-			} else {
-				this.table.columns.splice(colIndex, 0, column);
-				this.table.rows.forEach((row, i) => {
-					row.splice(colIndex, 0, values[i]);
-				});
-			}
-		}
-		removeColumns(colIndex, count = 1) {
-			this.cacheState();
-			this.table.columns.splice(colIndex, count);
-			this.table.rows.forEach((row) => {
-				row.splice(colIndex, count);
-			});
-		}
-		_assign(target, prop, value) {
-			this.cacheState();
-			target[prop] = value;
-		}
-		get ref() {
-			return this.table.ref;
-		}
-		set ref(value) {
-			this._assign(this.table, "ref", value);
-		}
-		get name() {
-			return this.table.name;
-		}
-		set name(value) {
-			this.cacheState();
-			this.table.name = sanitizeTableName(value);
-		}
-		get displayName() {
-			return this.table.displayName || this.table.name;
-		}
-		set displayName(value) {
-			this.cacheState();
-			this.table.displayName = sanitizeTableName(value);
-		}
-		get headerRow() {
-			return this.table.headerRow;
-		}
-		set headerRow(value) {
-			this._assign(this.table, "headerRow", value);
-		}
-		get totalsRow() {
-			return this.table.totalsRow;
+			this._set("name", value);
 		}
-		set totalsRow(value) {
-			this._assign(this.table, "totalsRow", value);
+		get filterButton() {
+			return this.column.filterButton;
 		}
-		_ensureStyle() {
-			if (!this.table.style) this.table.style = {};
-			return this.table.style;
+		set filterButton(value) {
+			this.column.filterButton = value;
 		}
-		get theme() {
-			return this.table.style?.theme;
+		get style() {
+			return this.column.style;
 		}
-		set theme(value) {
-			this._ensureStyle().theme = value;
+		set style(value) {
+			this.column.style = value;
 		}
-		get showFirstColumn() {
-			return this.table.style?.showFirstColumn;
+		get totalsRowLabel() {
+			return this.column.totalsRowLabel;
 		}
-		set showFirstColumn(value) {
-			this._ensureStyle().showFirstColumn = value;
+		set totalsRowLabel(value) {
+			this._set("totalsRowLabel", value);
 		}
-		get showLastColumn() {
-			return this.table.style?.showLastColumn;
+		get totalsRowFunction() {
+			return this.column.totalsRowFunction;
 		}
-		set showLastColumn(value) {
-			this._ensureStyle().showLastColumn = value;
+		set totalsRowFunction(value) {
+			this._set("totalsRowFunction", value);
 		}
-		get showRowStripes() {
-			return this.table.style?.showRowStripes;
+		get totalsRowResult() {
+			return this.column.totalsRowResult;
 		}
-		set showRowStripes(value) {
-			this._ensureStyle().showRowStripes = value;
+		set totalsRowResult(value) {
+			this._set("totalsRowResult", value);
 		}
-		get showColumnStripes() {
-			return this.table.style?.showColumnStripes;
+		get totalsRowFormula() {
+			return this.column.totalsRowFormula;
 		}
-		set showColumnStripes(value) {
-			this._ensureStyle().showColumnStripes = value;
+		set totalsRowFormula(value) {
+			this._set("totalsRowFormula", value);
 		}
 	};
-	//#endregion
-	//#region src/modules/excel/utils/address.ts
-	/**
-	* Cell address encoding/decoding utilities (0-indexed)
-	*
-	* These functions use 0-indexed coordinates (column A = 0, row 1 = 0),
-	* matching the convention used by SheetJS and most spreadsheet APIs.
-	*
-	* @module
-	*/
-	/**
-	* Decode column string to 0-indexed number
-	* @example decodeCol("A") // => 0
-	* @example decodeCol("Z") // => 25
-	* @example decodeCol("AA") // => 26
-	*/
-	function decodeCol(colstr) {
-		return colCache.l2n(colstr.toUpperCase()) - 1;
-	}
-	/**
-	* Encode 0-indexed column number to string
-	* @example encodeCol(0) // => "A"
-	* @example encodeCol(25) // => "Z"
-	* @example encodeCol(26) // => "AA"
-	*/
-	function encodeCol(col) {
-		return colCache.n2l(col + 1);
-	}
-	/**
-	* Decode row string to 0-indexed number
-	* @example decodeRow("1") // => 0
-	* @example decodeRow("10") // => 9
-	*/
-	function decodeRow(rowstr) {
-		return parseInt(rowstr, 10) - 1;
-	}
-	/**
-	* Encode 0-indexed row number to string
-	* @example encodeRow(0) // => "1"
-	* @example encodeRow(9) // => "10"
-	*/
-	function encodeRow(row) {
-		return String(row + 1);
-	}
-	/**
-	* Decode cell address string to CellAddress object (0-indexed)
-	* @example decodeCell("A1") // => { c: 0, r: 0 }
-	* @example decodeCell("B2") // => { c: 1, r: 1 }
-	*/
-	function decodeCell(cstr) {
-		const addr = colCache.decodeAddress(cstr.toUpperCase());
-		return {
-			c: addr.col - 1,
-			r: addr.row - 1
-		};
-	}
-	/**
-	* Encode CellAddress object (0-indexed) to cell address string
-	* @example encodeCell({ c: 0, r: 0 }) // => "A1"
-	* @example encodeCell({ c: 1, r: 1 }) // => "B2"
-	*/
-	function encodeCell(cell) {
-		return colCache.encodeAddress(cell.r + 1, cell.c + 1);
-	}
-	/**
-	* Decode range string to SheetRange object (0-indexed)
-	* @example decodeRange("A1:B2") // => { s: { c: 0, r: 0 }, e: { c: 1, r: 1 } }
-	*/
-	function decodeRange(range) {
-		const idx = range.indexOf(":");
-		if (idx === -1) {
-			const cell = decodeCell(range);
-			return {
-				s: cell,
-				e: { ...cell }
+	var Table = class Table {
+		constructor(worksheet, table) {
+			this.worksheet = worksheet;
+			if (table) {
+				this.table = table;
+				if (Array.isArray(table.rows) && table.rows.length === 0 && table.tableRef) {
+					const decoded = colCache.decode(table.tableRef);
+					if ("dimensions" in decoded) {
+						const startRow = decoded.top + (table.headerRow === false ? 0 : 1);
+						const endRow = decoded.bottom - (table.totalsRow === true ? 1 : 0);
+						if (endRow >= startRow) for (let r = startRow; r <= endRow; r++) {
+							const row = worksheet.getRow(r);
+							const values = [];
+							for (let c = decoded.left; c <= decoded.right; c++) values.push(row.getCell(c).value);
+							table.rows.push(values);
+						}
+					}
+				}
+				this.validate();
+				this.store();
+			}
+		}
+		static {
+			this.SUBTOTAL_FUNCTIONS = {
+				average: 101,
+				countNums: 102,
+				count: 103,
+				max: 104,
+				min: 105,
+				stdDev: 107,
+				var: 110,
+				sum: 109
 			};
 		}
-		return {
-			s: decodeCell(range.slice(0, idx)),
-			e: decodeCell(range.slice(idx + 1))
-		};
-	}
-	function encodeRange(startOrRange, end) {
-		if (end === void 0) {
-			const range = startOrRange;
-			return encodeRange(range.s, range.e);
+		getFormula(column) {
+			if (column.totalsRowFunction === "none") return null;
+			if (column.totalsRowFunction === "custom") return column.totalsRowFormula ?? null;
+			const fnNum = column.totalsRowFunction ? Table.SUBTOTAL_FUNCTIONS[column.totalsRowFunction] : void 0;
+			if (fnNum !== void 0) return `SUBTOTAL(${fnNum},${this.table.name}[${column.name}])`;
+			throw new TableError(`Invalid Totals Row Function: ${column.totalsRowFunction}`);
 		}
-		const startStr = encodeCell(startOrRange);
-		const endStr = encodeCell(end);
-		return startStr === endStr ? startStr : `${startStr}:${endStr}`;
-	}
-	//#endregion
-	//#region src/modules/excel/utils/cell-format.ts
-	/**
-	* Pad number with leading zeros
-	*/
-	function pad0(num, len) {
-		let s = Math.round(num).toString();
-		while (s.length < len) s = "0" + s;
-		return s;
-	}
-	/**
-	* Add thousand separators to a number string
-	*/
-	function commaify(s) {
-		const w = 3;
-		if (s.length <= w) return s;
-		const j = s.length % w;
-		let o = s.substring(0, j);
-		for (let i = j; i < s.length; i += w) o += (o.length > 0 ? "," : "") + s.substring(i, i + w);
-		return o;
-	}
-	/**
-	* Round a number to specified decimal places
-	*/
-	function roundTo(val, decimals) {
-		const factor = Math.pow(10, decimals);
-		return Math.round(val * factor) / factor;
-	}
-	/**
-	* Process _ (underscore) placeholder - adds space with width of next character
-	* Process * (asterisk) placeholder - repeats next character to fill width (simplified to single char)
-	*/
-	function processPlaceholders(fmt) {
-		let result = fmt.replace(/_./g, " ");
-		result = result.replace(/\*./g, "");
-		return result;
-	}
-	/**
-	* Check if format is "General"
-	*/
-	function isGeneral(fmt) {
-		return /^General$/i.test(fmt.trim());
-	}
-	/**
-	* Check if format is a date format
-	*/
-	function isDateFormat(fmt) {
-		const cleaned = fmt.replace(/\[[^\]]*\]/g, "");
-		return /[ymdhs]/i.test(cleaned) && !/^[#0.,E%$\s()\-+]+$/i.test(cleaned);
-	}
-	const MONTHS_SHORT = [
-		"Jan",
-		"Feb",
-		"Mar",
-		"Apr",
-		"May",
-		"Jun",
-		"Jul",
-		"Aug",
-		"Sep",
-		"Oct",
-		"Nov",
-		"Dec"
-	];
-	const MONTHS_LONG = [
-		"January",
-		"February",
-		"March",
-		"April",
-		"May",
-		"June",
-		"July",
-		"August",
-		"September",
-		"October",
-		"November",
-		"December"
-	];
-	const MONTHS_LETTER = [
-		"J",
-		"F",
-		"M",
-		"A",
-		"M",
-		"J",
-		"J",
-		"A",
-		"S",
-		"O",
-		"N",
-		"D"
-	];
-	const DAYS_SHORT = [
-		"Sun",
-		"Mon",
-		"Tue",
-		"Wed",
-		"Thu",
-		"Fri",
-		"Sat"
-	];
-	const DAYS_LONG = [
-		"Sunday",
-		"Monday",
-		"Tuesday",
-		"Wednesday",
-		"Thursday",
-		"Friday",
-		"Saturday"
-	];
-	/**
-	* Format a date value using Excel date format
-	* @param serial Excel serial number (days since 1900-01-01)
-	* @param fmt Format string
-	*/
-	function formatDate(serial, fmt) {
-		const timeOfDay = Math.round(serial * 86400) % 86400;
-		const hours = Math.floor(timeOfDay / 3600);
-		const minutes = Math.floor(timeOfDay % 3600 / 60);
-		const seconds = timeOfDay % 60;
-		const date = excelToDate(serial, false);
-		const year = date.getUTCFullYear();
-		const month = date.getUTCMonth();
-		const day = date.getUTCDate();
-		const dayOfWeek = date.getUTCDay();
-		const fractionalSeconds = serial * 86400 - Math.floor(serial * 86400);
-		const hasAmPm = /AM\/PM|A\/P/i.test(fmt);
-		const isPm = hours >= 12;
-		const hours12 = hours % 12 || 12;
-		let result = fmt.replace(/\[(Red|Green|Blue|Yellow|Magenta|Cyan|White|Black|Color\d+)\]/gi, "");
-		result = processPlaceholders(result);
-		const fracSecMatch = result.match(/ss\.(0+)/i);
-		let fracSecStr = "";
-		if (fracSecMatch) {
-			const decPlaces = fracSecMatch[1].length;
-			fracSecStr = Math.round(fractionalSeconds * Math.pow(10, decPlaces)).toString().padStart(decPlaces, "0");
-			result = result.replace(/ss\.0+/gi, "\0SF\0");
+		get width() {
+			return this.table.columns.length;
 		}
-		result = result.replace(/yyyy/gi, "\0Y4\0");
-		result = result.replace(/yy/gi, "\0Y2\0");
-		result = result.replace(/mmmmm/gi, "\0MN5\0");
-		result = result.replace(/mmmm/gi, "\0MN4\0");
-		result = result.replace(/mmm/gi, "\0MN3\0");
-		result = result.replace(/dddd/gi, "\0DN4\0");
-		result = result.replace(/ddd/gi, "\0DN3\0");
-		result = result.replace(/dd/gi, "\0D2\0");
-		result = result.replace(/\bd\b/gi, "\0D1\0");
-		result = result.replace(/hh/gi, "\0H2\0");
-		result = result.replace(/\bh\b/gi, "\0H1\0");
-		result = result.replace(/ss/gi, "\0S2\0");
-		result = result.replace(/\bs\b/gi, "\0S1\0");
-		if (/\x00H[12]\x00.*mm|mm.*\x00S[12]\x00/i.test(result)) result = result.replace(/mm/gi, "\0MI2\0");
-		else result = result.replace(/mm/gi, "\0M2\0");
-		result = result.replace(/\bm\b/gi, "\0M1\0");
-		result = result.replace(/AM\/PM/gi, "\0AMPM\0");
-		result = result.replace(/A\/P/gi, "\0AP\0");
-		const hourVal = hasAmPm ? hours12 : hours;
-		result = result.replace(/\x00Y4\x00/g, year.toString()).replace(/\x00Y2\x00/g, (year % 100).toString().padStart(2, "0")).replace(/\x00MN5\x00/g, MONTHS_LETTER[month]).replace(/\x00MN4\x00/g, MONTHS_LONG[month]).replace(/\x00MN3\x00/g, MONTHS_SHORT[month]).replace(/\x00M2\x00/g, (month + 1).toString().padStart(2, "0")).replace(/\x00M1\x00/g, (month + 1).toString()).replace(/\x00DN4\x00/g, DAYS_LONG[dayOfWeek]).replace(/\x00DN3\x00/g, DAYS_SHORT[dayOfWeek]).replace(/\x00D2\x00/g, day.toString().padStart(2, "0")).replace(/\x00D1\x00/g, day.toString()).replace(/\x00H2\x00/g, hourVal.toString().padStart(2, "0")).replace(/\x00H1\x00/g, hourVal.toString()).replace(/\x00MI2\x00/g, minutes.toString().padStart(2, "0")).replace(/\x00S2\x00/g, seconds.toString().padStart(2, "0")).replace(/\x00S1\x00/g, seconds.toString()).replace(/\x00SF\x00/g, seconds.toString().padStart(2, "0") + "." + fracSecStr).replace(/\x00AMPM\x00/g, isPm ? "PM" : "AM").replace(/\x00AP\x00/g, isPm ? "P" : "A");
-		result = result.replace(/\\/g, "");
-		return result;
-	}
-	/**
-	* Format a number using "General" format
-	*/
-	function formatGeneral(val) {
-		if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
-		if (typeof val === "string") return val;
-		if (Number.isInteger(val)) return val.toString();
-		return val.toPrecision(11).replace(/\.?0+$/, "").replace(/\.?0+e/, "e");
-	}
-	/**
-	* Format a percentage value
-	* @param val The decimal value (e.g., 0.25 for 25%)
-	* @param fmt The format string containing %
-	*/
-	function formatPercentage(val, fmt) {
-		const percentCount = (fmt.match(/%/g) ?? []).length;
-		return formatNumberPattern(val * Math.pow(100, percentCount), fmt.replace(/%/g, "") || "0") + "%".repeat(percentCount);
-	}
-	/**
-	* Format a number in scientific notation
-	* @param val The number to format
-	* @param fmt The format string (e.g., "0.00E+00")
-	*/
-	function formatScientific(val, fmt) {
-		const sign = val < 0 ? "-" : "";
-		const absVal = Math.abs(val);
-		if (absVal === 0) {
-			const decMatch = fmt.match(/\.([0#]+)E/i);
-			const decPlaces = decMatch ? decMatch[1].length : 2;
-			return "0." + "0".repeat(decPlaces) + "E+00";
+		get height() {
+			return this.table.rows.length;
 		}
-		const decMatch = fmt.match(/\.([0#]+)E/i);
-		const decPlaces = decMatch ? decMatch[1].length : 2;
-		const hasPlus = fmt.includes("E+");
-		const exp = Math.floor(Math.log10(absVal));
-		const mantissaStr = roundTo(absVal / Math.pow(10, exp), decPlaces).toFixed(decPlaces);
-		const expSign = exp >= 0 ? hasPlus ? "+" : "" : "-";
-		const expStr = pad0(Math.abs(exp), 2);
-		return sign + mantissaStr + "E" + expSign + expStr;
-	}
-	/**
-	* Convert decimal to fraction using continued fraction algorithm
-	*/
-	function toFraction(val, maxDenom) {
-		const sign = val < 0 ? -1 : 1;
-		let absVal = Math.abs(val);
-		const whole = Math.floor(absVal);
-		absVal -= whole;
-		if (absVal < 1e-10) return [
-			sign * whole,
-			0,
-			1
-		];
-		let p0 = 0, p1 = 1;
-		let q0 = 1, q1 = 0;
-		let a = Math.floor(absVal);
-		let p = a;
-		let q = 1;
-		while (q1 < maxDenom) {
-			a = Math.floor(absVal);
-			p = a * p1 + p0;
-			q = a * q1 + q0;
-			if (absVal - a < 1e-10) break;
-			absVal = 1 / (absVal - a);
-			p0 = p1;
-			p1 = p;
-			q0 = q1;
-			q1 = q;
+		get filterHeight() {
+			return this.height + (this.table.headerRow ? 1 : 0);
 		}
-		if (q > maxDenom) {
-			q = q1;
-			p = p1;
+		get tableHeight() {
+			return this.filterHeight + (this.table.totalsRow ? 1 : 0);
 		}
-		return [
-			sign * whole,
-			sign * p,
-			q
-		];
-	}
-	/**
-	* Format a number as a fraction
-	* @param val The number to format
-	* @param fmt The format string (e.g., "# ?/?", "# ??/??")
-	*/
-	function formatFraction(val, fmt) {
-		const sign = val < 0 ? "-" : "";
-		const absVal = Math.abs(val);
-		const fixedDenomMatch = fmt.match(/\?+\s*\/\s*(\d+)/);
-		if (fixedDenomMatch) {
-			const denom = parseInt(fixedDenomMatch[1], 10);
-			const whole = Math.floor(absVal);
-			const frac = absVal - whole;
-			const numer = Math.round(frac * denom);
-			if (fmt.includes("#") || fmt.includes("0")) {
-				if (numer === 0) return sign + whole.toString();
-				return sign + (whole > 0 ? whole + " " : "") + numer + "/" + denom;
+		validate() {
+			const { table } = this;
+			const assign = (o, name, dflt) => {
+				if (o[name] === void 0) o[name] = dflt;
+			};
+			assign(table, "headerRow", true);
+			assign(table, "totalsRow", false);
+			assign(table, "style", {});
+			const style = table.style;
+			assign(style, "theme", "TableStyleMedium2");
+			assign(style, "showFirstColumn", false);
+			assign(style, "showLastColumn", false);
+			assign(style, "showRowStripes", false);
+			assign(style, "showColumnStripes", false);
+			if (table.name) table.name = sanitizeTableName(table.name);
+			if (table.displayName) table.displayName = sanitizeTableName(table.displayName);
+			const assert = (test, message) => {
+				if (!test) throw new TableError(message);
+			};
+			assert(!!table.name, "Table must have a name");
+			assert(!!table.ref, "Table must have ref");
+			assert(!!table.columns, "Table must have column definitions");
+			assert(!!table.rows, "Table must have row definitions");
+			table.tl = colCache.decodeAddress(table.ref);
+			const { row, col } = table.tl;
+			assert(row > 0, "Table must be on valid row");
+			assert(col > 0, "Table must be on valid col");
+			const { width, tableHeight } = this;
+			table.autoFilterRef = colCache.encode(row, col, row, col + width - 1);
+			table.tableRef = colCache.encode(row, col, row + tableHeight - 1, col + width - 1);
+			table.columns.forEach((column, i) => {
+				assert(!!column.name, `Column ${i} must have a name`);
+				if (i === 0) assign(column, "totalsRowLabel", "Total");
+				else {
+					assign(column, "totalsRowFunction", "none");
+					column.totalsRowFormula = this.getFormula(column) ?? void 0;
+				}
+			});
+		}
+		store() {
+			const assignStyle = (cell, style) => {
+				if (style) Object.assign(cell.style, style);
+			};
+			const { worksheet, table } = this;
+			const { row, col } = table.tl;
+			let count = 0;
+			if (table.headerRow) {
+				const r = worksheet.getRow(row + count++);
+				table.columns.forEach((column, j) => {
+					const { style, name } = column;
+					const cell = r.getCell(col + j);
+					cell.value = name;
+					assignStyle(cell, style);
+				});
+			}
+			table.rows.forEach((data) => {
+				const r = worksheet.getRow(row + count++);
+				data.forEach((value, j) => {
+					const cell = r.getCell(col + j);
+					if (typeof value === "object" && value !== null && "formula" in value && typeof value.formula === "string") {
+						const formulaValue = value;
+						const shouldQualify = table.qualifyImplicitStructuredReferences === true;
+						cell.value = {
+							...formulaValue,
+							formula: shouldQualify ? formulaValue.formula.replace(/(^|[^A-Za-z0-9_])\[@\[?([^[\]]+?)\]?\]/g, `$1${table.name}[[#This Row],[$2]]`) : formulaValue.formula
+						};
+					} else cell.value = value;
+					assignStyle(cell, table.columns[j]?.style);
+				});
+			});
+			if (table.totalsRow) {
+				const r = worksheet.getRow(row + count++);
+				table.columns.forEach((column, j) => {
+					const cell = r.getCell(col + j);
+					if (j === 0) cell.value = column.totalsRowLabel;
+					else {
+						const formula = this.getFormula(column);
+						if (formula) cell.value = {
+							formula,
+							result: column.totalsRowResult
+						};
+						else cell.value = null;
+					}
+					assignStyle(cell, column.style);
+				});
 			}
-			return sign + (whole * denom + numer) + "/" + denom;
 		}
-		const denomMatch = fmt.match(/\/\s*(\?+)/);
-		const maxDigits = denomMatch ? denomMatch[1].length : 2;
-		const [whole, numer, denom] = toFraction(absVal, Math.pow(10, maxDigits) - 1);
-		if (fmt.includes("#") && whole !== 0) {
-			if (numer === 0) return sign + Math.abs(whole).toString();
-			return sign + Math.abs(whole) + " " + Math.abs(numer) + "/" + denom;
+		load(worksheet) {
+			const { table } = this;
+			const { row, col } = table.tl;
+			let count = 0;
+			if (table.headerRow) {
+				const r = worksheet.getRow(row + count++);
+				table.columns.forEach((column, j) => {
+					const cell = r.getCell(col + j);
+					cell.value = column.name;
+				});
+			}
+			table.rows.forEach((data) => {
+				const r = worksheet.getRow(row + count++);
+				data.forEach((value, j) => {
+					const cell = r.getCell(col + j);
+					cell.value = value;
+				});
+			});
+			if (table.totalsRow) {
+				const r = worksheet.getRow(row + count++);
+				table.columns.forEach((column, j) => {
+					const cell = r.getCell(col + j);
+					if (j === 0) cell.value = column.totalsRowLabel;
+					else {
+						const formula = this.getFormula(column);
+						if (formula) cell.value = {
+							formula,
+							result: column.totalsRowResult
+						};
+					}
+				});
+			}
 		}
-		if (numer === 0) return whole === 0 ? "0" : sign + Math.abs(whole).toString();
-		return sign + (Math.abs(whole) * denom + Math.abs(numer)) + "/" + denom;
-	}
-	/**
-	* Format elapsed time (e.g., [h]:mm:ss for durations > 24 hours)
-	*/
-	function formatElapsedTime(serial, fmt) {
-		const totalSeconds = Math.round(serial * 86400);
-		const totalMinutes = Math.floor(totalSeconds / 60);
-		const totalHours = Math.floor(totalMinutes / 60);
-		const seconds = totalSeconds % 60;
-		const minutes = totalMinutes % 60;
-		const hours = totalHours;
-		let result = fmt;
-		if (/\[h+\]/i.test(result)) result = result.replace(/\[h+\]/gi, hours.toString());
-		if (/\[m+\]/i.test(result)) result = result.replace(/\[m+\]/gi, totalMinutes.toString());
-		if (/\[s+\]/i.test(result)) result = result.replace(/\[s+\]/gi, totalSeconds.toString());
-		result = result.replace(/mm/gi, minutes.toString().padStart(2, "0"));
-		result = result.replace(/ss/gi, seconds.toString().padStart(2, "0"));
-		return result;
-	}
-	/**
-	* Format a number with the given pattern
-	* Handles patterns like "0", "00", "#,##0", "0-0", "000-0000" etc.
-	*/
-	function formatNumberPattern(val, fmt) {
-		const absVal = Math.abs(val);
-		const sign = val < 0 ? "-" : "";
-		let trailingCommas = 0;
-		let workFmt = fmt;
-		while (workFmt.endsWith(",")) {
-			trailingCommas++;
-			workFmt = workFmt.slice(0, -1);
+		get model() {
+			return this.table;
 		}
-		const scaledVal = absVal / Math.pow(1e3, trailingCommas);
-		const decimalIdx = workFmt.indexOf(".");
-		let intFmt = workFmt;
-		let decFmt = "";
-		if (decimalIdx !== -1) {
-			intFmt = workFmt.substring(0, decimalIdx);
-			decFmt = workFmt.substring(decimalIdx + 1);
+		set model(value) {
+			this.table = value;
 		}
-		const decimalPlaces = decFmt.replace(/[^0#?]/g, "").length;
-		const roundedVal = roundTo(scaledVal, decimalPlaces);
-		if (roundedVal === 0 && !intFmt.includes("0") && !decFmt.includes("0")) {
-			let result = "";
-			for (const ch of intFmt) if (ch === "?") result += " ";
-			else if (ch !== "#" && ch !== ",") result += ch;
-			if (decimalPlaces > 0) {
-				if (/[0?]/.test(decFmt)) {
-					result += ".";
-					for (const ch of decFmt) if (ch === "?") result += " ";
+		cacheState() {
+			if (!this._cache) this._cache = {
+				ref: this.ref,
+				width: this.width,
+				tableHeight: this.tableHeight
+			};
+		}
+		commit() {
+			if (!this._cache) return;
+			this.validate();
+			const ref = colCache.decodeAddress(this._cache.ref);
+			if (this.ref !== this._cache.ref) for (let i = 0; i < this._cache.tableHeight; i++) {
+				const row = this.worksheet.getRow(ref.row + i);
+				for (let j = 0; j < this._cache.width; j++) {
+					const cell = row.getCell(ref.col + j);
+					cell.value = null;
 				}
 			}
-			return sign + result;
-		}
-		const [intPart, decPart = ""] = roundedVal.toString().split(".");
-		const hasLiteralInFormat = /[0#?][^0#?,.\s][0#?]/.test(intFmt);
-		let formattedInt;
-		if (hasLiteralInFormat) {
-			const digitPlaceholders = intFmt.replace(/[^0#?]/g, "").length;
-			let digits = intPart;
-			if (digits.length < digitPlaceholders) digits = "0".repeat(digitPlaceholders - digits.length) + digits;
-			formattedInt = "";
-			let digitIndex = digits.length - digitPlaceholders;
-			for (let i = 0; i < intFmt.length; i++) {
-				const char = intFmt[i];
-				if (char === "0" || char === "#" || char === "?") {
-					if (digitIndex < digits.length) {
-						formattedInt += digits[digitIndex];
-						digitIndex++;
+			else {
+				for (let i = this.tableHeight; i < this._cache.tableHeight; i++) {
+					const row = this.worksheet.getRow(ref.row + i);
+					for (let j = 0; j < this._cache.width; j++) {
+						const cell = row.getCell(ref.col + j);
+						cell.value = null;
 					}
-				} else if (char !== ",") formattedInt += char;
+				}
+				for (let i = 0; i < this.tableHeight; i++) {
+					const row = this.worksheet.getRow(ref.row + i);
+					for (let j = this.width; j < this._cache.width; j++) {
+						const cell = row.getCell(ref.col + j);
+						cell.value = null;
+					}
+				}
 			}
-		} else {
-			formattedInt = intPart;
-			if (intFmt.includes(",")) formattedInt = commaify(intPart);
-			const minIntDigits = (intFmt.match(/0/g) ?? []).length;
-			const totalIntSlots = (intFmt.match(/[0?]/g) ?? []).length;
-			if (formattedInt.length < minIntDigits) formattedInt = "0".repeat(minIntDigits - formattedInt.length) + formattedInt;
-			if (formattedInt.length < totalIntSlots) formattedInt = " ".repeat(totalIntSlots - formattedInt.length) + formattedInt;
-			if (formattedInt === "0" && minIntDigits === 0 && totalIntSlots === 0) formattedInt = "";
+			this.store();
+			this._cache = void 0;
 		}
-		let formattedDec = "";
-		if (decimalPlaces > 0) {
-			const decChars = (decPart + "0".repeat(decimalPlaces)).substring(0, decimalPlaces).split("");
-			for (let i = decFmt.length - 1; i >= 0; i--) {
-				if (i >= decChars.length) continue;
-				if (decFmt[i] === "#" && decChars[i] === "0") decChars[i] = "";
-				else if (decFmt[i] === "?" && decChars[i] === "0") decChars[i] = " ";
-				else break;
+		addRow(values, rowNumber, options) {
+			this.cacheState();
+			if (rowNumber === void 0) this.table.rows.push(values);
+			else this.table.rows.splice(rowNumber, 0, values);
+			if (options?.commit !== false) this.commit();
+		}
+		removeRows(rowIndex, count = 1, options) {
+			this.cacheState();
+			this.table.rows.splice(rowIndex, count);
+			if (options?.commit !== false) this.commit();
+		}
+		getColumn(colIndex) {
+			const column = this.table.columns[colIndex];
+			return new Column$1(this, column, colIndex);
+		}
+		addColumn(column, values, colIndex) {
+			this.cacheState();
+			if (colIndex === void 0) {
+				this.table.columns.push(column);
+				this.table.rows.forEach((row, i) => {
+					row.push(values[i]);
+				});
+			} else {
+				this.table.columns.splice(colIndex, 0, column);
+				this.table.rows.forEach((row, i) => {
+					row.splice(colIndex, 0, values[i]);
+				});
 			}
-			const decStr = decChars.join("");
-			if (decStr.length > 0) formattedDec = "." + decStr;
 		}
-		return sign + formattedInt + formattedDec;
-	}
+		removeColumns(colIndex, count = 1) {
+			this.cacheState();
+			this.table.columns.splice(colIndex, count);
+			this.table.rows.forEach((row) => {
+				row.splice(colIndex, count);
+			});
+		}
+		_assign(target, prop, value) {
+			this.cacheState();
+			target[prop] = value;
+		}
+		get ref() {
+			return this.table.ref;
+		}
+		set ref(value) {
+			this._assign(this.table, "ref", value);
+		}
+		get name() {
+			return this.table.name;
+		}
+		set name(value) {
+			this.cacheState();
+			this.table.name = sanitizeTableName(value);
+		}
+		get displayName() {
+			return this.table.displayName || this.table.name;
+		}
+		set displayName(value) {
+			this.cacheState();
+			this.table.displayName = sanitizeTableName(value);
+		}
+		get headerRow() {
+			return this.table.headerRow;
+		}
+		set headerRow(value) {
+			this._assign(this.table, "headerRow", value);
+		}
+		get totalsRow() {
+			return this.table.totalsRow;
+		}
+		set totalsRow(value) {
+			this._assign(this.table, "totalsRow", value);
+		}
+		_ensureStyle() {
+			if (!this.table.style) this.table.style = {};
+			return this.table.style;
+		}
+		get theme() {
+			return this.table.style?.theme;
+		}
+		set theme(value) {
+			this._ensureStyle().theme = value;
+		}
+		get showFirstColumn() {
+			return this.table.style?.showFirstColumn;
+		}
+		set showFirstColumn(value) {
+			this._ensureStyle().showFirstColumn = value;
+		}
+		get showLastColumn() {
+			return this.table.style?.showLastColumn;
+		}
+		set showLastColumn(value) {
+			this._ensureStyle().showLastColumn = value;
+		}
+		get showRowStripes() {
+			return this.table.style?.showRowStripes;
+		}
+		set showRowStripes(value) {
+			this._ensureStyle().showRowStripes = value;
+		}
+		get showColumnStripes() {
+			return this.table.style?.showColumnStripes;
+		}
+		set showColumnStripes(value) {
+			this._ensureStyle().showColumnStripes = value;
+		}
+	};
+	//#endregion
+	//#region src/modules/excel/utils/address.ts
 	/**
-	* Remove quoted literal text markers and return the literal characters
-	* Also handles backslash escape sequences
+	* Cell address encoding/decoding utilities (0-indexed)
+	*
+	* These functions use 0-indexed coordinates (column A = 0, row 1 = 0),
+	* matching the convention used by SheetJS and most spreadsheet APIs.
+	*
+	* @module
 	*/
-	function processQuotedText(fmt) {
-		let result = "";
-		let i = 0;
-		while (i < fmt.length) if (fmt[i] === "\"") {
-			i++;
-			while (i < fmt.length && fmt[i] !== "\"") {
-				result += fmt[i];
-				i++;
-			}
-			i++;
-		} else if (fmt[i] === "\\" && i + 1 < fmt.length) {
-			i++;
-			result += fmt[i];
-			i++;
-		} else {
-			result += fmt[i];
-			i++;
-		}
-		return result;
-	}
 	/**
-	* Check if a condition matches (e.g., [>100], [<=50])
+	* Decode column string to 0-indexed number
+	* @example decodeCol("A") // => 0
+	* @example decodeCol("Z") // => 25
+	* @example decodeCol("AA") // => 26
 	*/
-	function checkCondition(val, condition) {
-		const match = condition.match(/\[(=|>|<|>=|<=|<>)(-?\d+(?:\.\d*)?)\]/);
-		if (!match) return false;
-		const op = match[1];
-		const threshold = parseFloat(match[2]);
-		switch (op) {
-			case "=": return val === threshold;
-			case ">": return val > threshold;
-			case "<": return val < threshold;
-			case ">=": return val >= threshold;
-			case "<=": return val <= threshold;
-			case "<>": return val !== threshold;
-			default: return false;
-		}
+	function decodeCol(colstr) {
+		return colCache.l2n(colstr.toUpperCase()) - 1;
 	}
 	/**
-	* Parse format string and handle positive/negative/zero/text sections
-	* Excel format: positive;negative;zero;text
-	* Also handles conditional formats like [>100]
+	* Encode 0-indexed column number to string
+	* @example encodeCol(0) // => "A"
+	* @example encodeCol(25) // => "Z"
+	* @example encodeCol(26) // => "AA"
 	*/
-	function chooseFormat(fmt, val) {
-		if (typeof val === "string") {
-			const sections = splitFormatSections(fmt);
-			if (sections.length >= 4 && sections[3]) return processQuotedText(sections[3]).replace(/@/g, val);
-			return val;
-		}
-		if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
-		const sections = splitFormatSections(fmt);
-		const condRegex = /\[(=|>|<|>=|<=|<>)-?\d+(?:\.\d*)?\]/;
-		if ((sections[0] && condRegex.test(sections[0]) || sections[1] && condRegex.test(sections[1])) && sections.length >= 2) {
-			for (let i = 0; i < Math.min(sections.length, 2); i++) {
-				const condMatch = sections[i].match(/\[(=|>|<|>=|<=|<>)-?\d+(?:\.\d*)?\]/);
-				if (condMatch && checkCondition(val, condMatch[0])) return sections[i];
-			}
-			return sections[sections.length > 2 ? 2 : 1];
-		}
-		if (sections.length === 1) return sections[0];
-		if (sections.length === 2) return val >= 0 ? sections[0] : sections[1];
-		if (val > 0) return sections[0];
-		if (val < 0) return sections[1];
-		return sections[2] || sections[0];
+	function encodeCol(col) {
+		return colCache.n2l(col + 1);
 	}
 	/**
-	* Check if format section is for negative values (2nd section in multi-section format)
+	* Decode row string to 0-indexed number
+	* @example decodeRow("1") // => 0
+	* @example decodeRow("10") // => 9
 	*/
-	function isNegativeSection(fmt, selectedFmt) {
-		const sections = splitFormatSections(fmt);
-		return sections.length >= 2 && sections[1] === selectedFmt;
+	function decodeRow(rowstr) {
+		return parseInt(rowstr, 10) - 1;
 	}
 	/**
-	* Main format function - formats a value according to Excel numFmt
-	* @param fmt The Excel number format string (e.g., "0.00%", "#,##0", "yyyy-mm-dd")
-	* @param val The value to format
+	* Encode 0-indexed row number to string
+	* @example encodeRow(0) // => "1"
+	* @example encodeRow(9) // => "10"
 	*/
-	function format(fmt, val) {
-		if (val == null) return "";
-		if (isGeneral(fmt)) return formatGeneral(val);
-		if (typeof val === "string") return chooseFormat(fmt, val);
-		if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
-		let numVal = val;
-		const selectedFmt = chooseFormat(fmt, numVal);
-		if (numVal < 0 && isNegativeSection(fmt, selectedFmt)) numVal = Math.abs(numVal);
-		let cleanFmt = selectedFmt.replace(/\[(Red|Green|Blue|Yellow|Magenta|Cyan|White|Black|Color\d+)\]/gi, "");
-		cleanFmt = cleanFmt.replace(/\[(>|<|>=|<=|=|<>)-?\d+(\.\d+)?\]/g, "");
-		cleanFmt = cleanFmt.replace(/\[\$[^\]]*\]/g, "");
-		cleanFmt = processPlaceholders(cleanFmt);
-		cleanFmt = processQuotedText(cleanFmt);
-		if (/\[[hms]+\]/i.test(cleanFmt)) return formatElapsedTime(numVal, cleanFmt);
-		if (isDateFormat(cleanFmt)) return formatDate(numVal, cleanFmt);
-		if (cleanFmt.includes("%")) return formatPercentage(numVal, cleanFmt);
-		if (/E[+-]?/i.test(cleanFmt)) return formatScientific(numVal, cleanFmt);
-		if (/\?+\s*\/\s*[\d?]+/.test(cleanFmt)) return formatFraction(numVal, cleanFmt);
-		if (cleanFmt.includes("(") && cleanFmt.includes(")") && numVal < 0) {
-			const innerFmt = cleanFmt.replace(/\(|\)/g, "");
-			return "(" + formatNumberPattern(-numVal, innerFmt) + ")";
-		}
-		if (cleanFmt === "@") return numVal.toString();
-		let prefix = "";
-		let suffix = "";
-		const prefixMatch = cleanFmt.match(/^([^#0?.,]+)/);
-		if (prefixMatch) {
-			prefix = prefixMatch[1];
-			cleanFmt = cleanFmt.substring(prefixMatch[0].length);
-		}
-		const suffixMatch = cleanFmt.match(/([^#0?.,]+)$/);
-		if (suffixMatch && !suffixMatch[1].includes("%")) {
-			suffix = suffixMatch[1];
-			cleanFmt = cleanFmt.substring(0, cleanFmt.length - suffixMatch[0].length);
-		}
-		const formattedNum = formatNumberPattern(numVal, cleanFmt);
-		return prefix + formattedNum + suffix;
+	function encodeRow(row) {
+		return String(row + 1);
 	}
 	/**
-	* Check if format is a pure time format (no date components like y, m for month, d).
-	* Time formats only contain: h, m (minutes in time context), s, AM/PM.
-	* Excludes elapsed time formats like [h]:mm:ss which need the full serial number.
+	* Decode cell address string to CellAddress object (0-indexed)
+	* @example decodeCell("A1") // => { c: 0, r: 0 }
+	* @example decodeCell("B2") // => { c: 1, r: 1 }
 	*/
-	function isTimeOnlyFormat(fmt) {
-		const cleaned = fmt.replace(/"[^"]*"/g, "");
-		if (/\[[hms]\]/i.test(cleaned)) return false;
-		const withoutBrackets = cleaned.replace(/\[[^\]]*\]/g, "");
-		const hasTimeComponents = /[hs]/i.test(withoutBrackets) || /AM\/PM|A\/P/i.test(withoutBrackets);
-		if (/[yd]/i.test(withoutBrackets)) return false;
-		if (/m/i.test(withoutBrackets) && !hasTimeComponents) return false;
-		return hasTimeComponents;
+	function decodeCell(cstr) {
+		const addr = colCache.decodeAddress(cstr.toUpperCase());
+		return {
+			c: addr.col - 1,
+			r: addr.row - 1
+		};
 	}
 	/**
-	* Check if format is a date format (contains y, d, or month-m).
-	* More precise than the internal isDateFormat — correctly handles elapsed time
-	* formats like [h]:mm:ss (not a date format) and distinguishes month-m from minute-m.
+	* Encode CellAddress object (0-indexed) to cell address string
+	* @example encodeCell({ c: 0, r: 0 }) // => "A1"
+	* @example encodeCell({ c: 1, r: 1 }) // => "B2"
 	*/
-	function isDateDisplayFormat(fmt) {
-		const cleaned = fmt.replace(/"[^"]*"/g, "");
-		if (/\[[hms]\]/i.test(cleaned)) return false;
-		const withoutBrackets = cleaned.replace(/\[[^\]]*\]/g, "");
-		if (/[yd]/i.test(withoutBrackets)) return true;
-		if (/m/i.test(withoutBrackets)) {
-			if (!(/[hs]/i.test(withoutBrackets) || /AM\/PM|A\/P/i.test(withoutBrackets))) return true;
-		}
-		return false;
+	function encodeCell(cell) {
+		return colCache.encodeAddress(cell.r + 1, cell.c + 1);
 	}
 	/**
-	* Format a value according to the given format string.
-	* Handles Date objects with timezone-independent Excel serial conversion.
+	* Decode range string to SheetRange object (0-indexed)
+	* @example decodeRange("A1:B2") // => { s: { c: 0, r: 0 }, e: { c: 1, r: 1 } }
 	*/
-	function formatCellValue(value, fmt, dateFormat) {
-		if (value instanceof Date) {
-			let serial = dateToExcel(value);
-			if (isTimeOnlyFormat(fmt)) {
-				serial = serial % 1;
-				if (serial < 0) serial += 1;
-				return format(fmt, serial);
-			}
-			return format(dateFormat && isDateDisplayFormat(fmt) ? dateFormat : fmt, serial);
+	function decodeRange(range) {
+		const idx = range.indexOf(":");
+		if (idx === -1) {
+			const cell = decodeCell(range);
+			return {
+				s: cell,
+				e: { ...cell }
+			};
 		}
-		return format(fmt, value);
+		return {
+			s: decodeCell(range.slice(0, idx)),
+			e: decodeCell(range.slice(idx + 1))
+		};
 	}
-	/**
-	* Get the formatted display text for a cell value.
-	*
-	* Handles primitive values, Date objects, formula results, and falls back to
-	* `cell.text` for complex types (rich text, hyperlinks, errors, etc.).
-	*
-	* @param cell       - A cell (or cell-like object) with `.value`, `.numFmt`, and `.text`
-	* @param dateFormat - Optional custom date format override
-	*/
-	function getCellDisplayText$1(cell, dateFormat) {
-		const value = cell.value;
-		const numFmt = cell.numFmt;
-		const fmt = typeof numFmt === "string" ? numFmt : numFmt?.formatCode ?? "General";
-		if (value == null) return "";
-		if (value instanceof Date || typeof value === "number" || typeof value === "boolean" || typeof value === "string") return formatCellValue(value, fmt, dateFormat);
-		if (typeof value === "object" && "formula" in value) {
-			const result = value.result;
-			if (result == null) return "";
-			if (result instanceof Date || typeof result === "number" || typeof result === "boolean" || typeof result === "string") return formatCellValue(result, fmt, dateFormat);
+	function encodeRange(startOrRange, end) {
+		if (end === void 0) {
+			const range = startOrRange;
+			return encodeRange(range.s, range.e);
 		}
-		return cell.text;
+		const startStr = encodeCell(startOrRange);
+		const endStr = encodeCell(end);
+		return startStr === endStr ? startStr : `${startStr}:${endStr}`;
 	}
 	//#endregion
 	//#region src/modules/excel/utils/font-data.ts
@@ -47440,6 +47516,53 @@ self.onmessage = async function(event) {
 		calculateFormulas() {
 			invokeFormulaEngine(this);
 		}
+		/**
+		* Register (or replace) a custom formula function on this workbook.
+		*
+		* The function becomes visible to `calculateFormulas()` on this
+		* workbook only — the built-in registry stays untouched. Names are
+		* case-insensitive (normalised to uppercase) and must not include
+		* the `_XLFN.` prefix — the engine strips that automatically.
+		*
+		* @param name    Function name (case-insensitive).
+		* @param fn      Implementation. Receives already-evaluated RuntimeValue
+		*                arguments; return a RuntimeValue. Wrap failures with
+		*                `rvError("#VALUE!")` rather than throwing — throws are
+		*                caught at the evaluator boundary and surface as
+		*                `#VALUE!` so a buggy custom function doesn't tear
+		*                down the whole calculation pass.
+		* @param options Optional arity bounds. Defaults to `minArity=0`,
+		*                `maxArity=255` (Excel's universal argument cap), so
+		*                simple variadic functions work without extra config.
+		*                Set `volatile: true` when the function should be
+		*                re-evaluated on every calc cycle (analogous to
+		*                built-in `RAND`, `NOW`). Currently reserved for
+		*                future use; the engine recomputes every formula on
+		*                each `calculateFormulas()` call regardless.
+		*
+		* ```ts
+		* import { rvNumber } from "@cj-tech-master/excelts/formula";
+		* workbook.registerFunction("DOUBLE", ([x]) => {
+		*   return rvNumber((x as any).value * 2);
+		* }, { minArity: 1, maxArity: 1 });
+		* ```
+		*/
+		registerFunction(name, fn, options) {
+			if (!this.userFunctions) this.userFunctions = /* @__PURE__ */ new Map();
+			this.userFunctions.set(name.toUpperCase(), {
+				minArity: options?.minArity ?? 0,
+				maxArity: options?.maxArity ?? 255,
+				invoke: fn,
+				volatile: options?.volatile ?? false
+			});
+		}
+		/**
+		* Remove a user-registered function. No-op when the name isn't
+		* registered; returns `true` when an entry was removed.
+		*/
+		unregisterFunction(name) {
+			return this.userFunctions?.delete(name.toUpperCase()) ?? false;
+		}
 		clearThemes() {
 			this._themes = void 0;
 		}