@univerjs/core 1.0.0-alpha.3 → 1.0.0-alpha.4

package/lib/cjs/index.js

@@ -6,6 +6,19 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
 		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -31,8 +44,6 @@ let _univerjs_protocol = require("@univerjs/protocol");
 let rxjs_operators = require("rxjs/operators");
 let _wendellhu_redi = require("@wendellhu/redi");
 let lodash_es = require("lodash-es");
-let numfmt = require("numfmt");
-numfmt = __toESM(numfmt);
 let rbush = require("rbush");
 rbush = __toESM(rbush);
 let async_lock = require("async-lock");
@@ -1732,7 +1743,7 @@ let ThemeColors = /* @__PURE__ */ function(ThemeColors) {
 //#endregion
 //#region package.json
 var name = "@univerjs/core";
-var version = "1.0.0-alpha.3";
+var version = "1.0.0-alpha.4";
 
 //#endregion
 //#region src/common/array.ts
@@ -3903,79 +3914,3516 @@ let DOC_RANGE_TYPE = /* @__PURE__ */ function(DOC_RANGE_TYPE) {
 	return DOC_RANGE_TYPE;
 }({});
 /**
-* Determines whether the cell(row, column) is within the range of the merged cells.
-* @deprecated please use worksheet.getCellInfoInMergeData instead
+* Determines whether the cell(row, column) is within the range of the merged cells.
+* @deprecated please use worksheet.getCellInfoInMergeData instead
+*/
+function getCellInfoInMergeData(row, column, mergeData) {
+	let isMerged = false;
+	let isMergedMainCell = false;
+	let newEndRow = row;
+	let newEndColumn = column;
+	let mergeRow = row;
+	let mergeColumn = column;
+	if (mergeData == null) return {
+		actualRow: row,
+		actualColumn: column,
+		isMergedMainCell,
+		isMerged,
+		endRow: newEndRow,
+		endColumn: newEndColumn,
+		startRow: mergeRow,
+		startColumn: mergeColumn
+	};
+	for (let i = 0; i < mergeData.length; i++) {
+		const { startRow: startRowMarge, endRow: endRowMarge, startColumn: startColumnMarge, endColumn: endColumnMarge } = mergeData[i];
+		if (row === startRowMarge && column === startColumnMarge) {
+			newEndRow = endRowMarge;
+			newEndColumn = endColumnMarge;
+			mergeRow = startRowMarge;
+			mergeColumn = startColumnMarge;
+			isMergedMainCell = true;
+			break;
+		}
+		if (row >= startRowMarge && row <= endRowMarge && column >= startColumnMarge && column <= endColumnMarge) {
+			newEndRow = endRowMarge;
+			newEndColumn = endColumnMarge;
+			mergeRow = startRowMarge;
+			mergeColumn = startColumnMarge;
+			isMerged = true;
+			break;
+		}
+	}
+	return {
+		actualRow: row,
+		actualColumn: column,
+		isMergedMainCell,
+		isMerged,
+		endRow: newEndRow,
+		endColumn: newEndColumn,
+		startRow: mergeRow,
+		startColumn: mergeColumn
+	};
+}
+let CellModeEnum = /* @__PURE__ */ function(CellModeEnum) {
+	CellModeEnum["Raw"] = "raw";
+	CellModeEnum["Intercepted"] = "intercepted";
+	CellModeEnum["Both"] = "both";
+	return CellModeEnum;
+}({});
+
+//#endregion
+//#region src/types/const/theme-color-map.ts
+const THEME_COLORS = { ["Office"]: {
+	[4]: "#4472C4",
+	[5]: "#ED7D31",
+	[6]: "#A5A5A5",
+	[7]: "#70AD47",
+	[8]: "#5B9BD5",
+	[9]: "#70AD47",
+	[0]: "#000000",
+	[2]: "#44546A",
+	[1]: "#FFFFFF",
+	[3]: "#E7E6E6",
+	[10]: "#0563C1",
+	[11]: "#954F72"
+} };
+
+//#endregion
+//#region src/shared/numfmt/constants.ts
+const MAX_S_DATE = 2958466;
+const MIN_L_DATE = -694324;
+const MAX_L_DATE = 35830291;
+const TOKEN_GENERAL = "general";
+const TOKEN_HASH = "hash";
+const TOKEN_ZERO = "zero";
+const TOKEN_QMARK = "qmark";
+const TOKEN_SLASH = "slash";
+const TOKEN_GROUP = "group";
+const TOKEN_SCALE = "scale";
+const TOKEN_COMMA = "comma";
+const TOKEN_BREAK = "break";
+const TOKEN_TEXT = "text";
+const TOKEN_PLUS = "plus";
+const TOKEN_MINUS = "minus";
+const TOKEN_POINT = "point";
+const TOKEN_SPACE = "space";
+const TOKEN_PERCENT = "percent";
+const TOKEN_DIGIT = "digit";
+const TOKEN_CALENDAR = "calendar";
+const TOKEN_ERROR = "error";
+const TOKEN_DATETIME = "datetime";
+const TOKEN_DURATION = "duration";
+const TOKEN_CONDITION = "condition";
+const TOKEN_DBNUM = "dbnum";
+const TOKEN_NATNUM = "natnum";
+const TOKEN_LOCALE = "locale";
+const TOKEN_COLOR = "color";
+const TOKEN_MODIFIER = "modifier";
+const TOKEN_AMPM = "ampm";
+const TOKEN_ESCAPED = "escaped";
+const TOKEN_STRING = "string";
+const TOKEN_SKIP = "skip";
+const TOKEN_FILL = "fill";
+const TOKEN_PAREN = "paren";
+const TOKEN_CHAR = "char";
+const indexColors = [
+	"#000000",
+	"#FFFFFF",
+	"#FF0000",
+	"#00FF00",
+	"#0000FF",
+	"#FFFF00",
+	"#FF00FF",
+	"#00FFFF",
+	"#800000",
+	"#008000",
+	"#000080",
+	"#808000",
+	"#800080",
+	"#008080",
+	"#C0C0C0",
+	"#808080",
+	"#9999FF",
+	"#993366",
+	"#FFFFCC",
+	"#CCFFFF",
+	"#660066",
+	"#FF8080",
+	"#0066CC",
+	"#CCCCFF",
+	"#000080",
+	"#FF00FF",
+	"#FFFF00",
+	"#00FFFF",
+	"#800080",
+	"#800000",
+	"#008080",
+	"#0000FF",
+	"#00CCFF",
+	"#CCFFFF",
+	"#CCFFCC",
+	"#FFFF99",
+	"#99CCFF",
+	"#FF99CC",
+	"#CC99FF",
+	"#FFCC99",
+	"#3366FF",
+	"#33CCCC",
+	"#99CC00",
+	"#FFCC00",
+	"#FF9900",
+	"#FF6600",
+	"#666699",
+	"#969696",
+	"#003366",
+	"#339966",
+	"#003300",
+	"#333300",
+	"#993300",
+	"#993366",
+	"#333399",
+	"#333333"
+];
+const currencySymbols$1 = [
+	"¤",
+	"$",
+	"£",
+	"¥",
+	"֏",
+	"؋",
+	"৳",
+	"฿",
+	"៛",
+	"₡",
+	"₦",
+	"₩",
+	"₪",
+	"₫",
+	"€",
+	"₭",
+	"₮",
+	"₱",
+	"₲",
+	"₴",
+	"₸",
+	"₹",
+	"₺",
+	"₼",
+	"₽",
+	"₾",
+	"₿"
+];
+const reCurrencySymbols = new RegExp(`[${currencySymbols$1.join("")}]`);
+
+//#endregion
+//#region src/shared/numfmt/format-info.ts
+function isParsedSection$1(part) {
+	return !!part && "scale" in part;
+}
+function isGenerated(part) {
+	return !!part && "generated" in part && Boolean(part.generated);
+}
+function isPercent(partitions) {
+	return !!(isParsedSection$1(partitions[0]) && partitions[0].percent || isParsedSection$1(partitions[1]) && partitions[1].percent || isParsedSection$1(partitions[2]) && partitions[2].percent || isParsedSection$1(partitions[3]) && partitions[3].percent);
+}
+function isDate(partitions) {
+	return !!(isParsedSection$1(partitions[0]) && partitions[0].date || isParsedSection$1(partitions[1]) && partitions[1].date || isParsedSection$1(partitions[2]) && partitions[2].date || isParsedSection$1(partitions[3]) && partitions[3].date);
+}
+function isText(partitions) {
+	const [part1, part2, part3, part4] = partitions;
+	return !!((!part1 || isGenerated(part1)) && (!part2 || isGenerated(part2)) && (!part3 || isGenerated(part3)) && isParsedSection$1(part4) && part4.text && !isGenerated(part4));
+}
+const level = {
+	text: 15,
+	datetime: 10.8,
+	date: 10.8,
+	time: 10.8,
+	percent: 10.6,
+	currency: 10.4,
+	grouped: 10.2,
+	scientific: 6,
+	number: 4,
+	fraction: 2,
+	general: 0,
+	error: 0
+};
+const dateCodes = [
+	["DMY", 1],
+	["DM", 2],
+	["MY", 3],
+	["MDY", 4],
+	["MD", 5],
+	["hmsa", 6],
+	["hma", 7],
+	["hms", 8],
+	["hm", 9]
+];
+function info(partitions, currencyId = null) {
+	var _positive$scale;
+	const [partPositive, partNegative] = partitions;
+	if (!partPositive) throw new TypeError("Cannot read properties of undefined (reading 'frac_max')");
+	const positive = isParsedSection$1(partPositive) ? partPositive : void 0;
+	const negative = isParsedSection$1(partNegative) ? partNegative : void 0;
+	const isError = "error" in partPositive;
+	const fracMax = positive === null || positive === void 0 ? void 0 : positive.frac_max;
+	const output = {
+		type: "general",
+		isDate: isDate(partitions),
+		isText: isText(partitions),
+		isPercent: isPercent(partitions),
+		maxDecimals: (positive === null || positive === void 0 ? void 0 : positive.general) ? 9 : fracMax !== null && fracMax !== void 0 ? fracMax : 0,
+		scale: (_positive$scale = positive === null || positive === void 0 ? void 0 : positive.scale) !== null && _positive$scale !== void 0 ? _positive$scale : 1,
+		color: 0,
+		parentheses: 0,
+		grouped: (positive === null || positive === void 0 ? void 0 : positive.grouping) ? 1 : 0,
+		code: "",
+		level: 0
+	};
+	const isCurrency = !output.isDate && !output.isText && !isError && partPositive.tokens.some((token) => token.type === "string" && typeof token.value === "string" && (currencyId ? token.value === currencyId : reCurrencySymbols.test(token.value)));
+	let codeType = "G";
+	let codeNumber = fracMax !== void 0 && fracMax >= 0 ? Math.min(15, fracMax) : "";
+	let codeParentheses = "";
+	let codeDash = "";
+	if (negative === null || negative === void 0 ? void 0 : negative.color) {
+		codeDash = "-";
+		output.color = 1;
+	}
+	if (positive === null || positive === void 0 ? void 0 : positive.parens) {
+		codeParentheses = "()";
+		output.parentheses = 1;
+	}
+	if (isCurrency) {
+		codeType = "C";
+		output.type = "currency";
+	} else if (isError) {
+		output.type = "error";
+		output.maxDecimals = 0;
+	} else if (output.isDate) {
+		let haveTime = 0;
+		let haveDate = 0;
+		let order = "";
+		partPositive.tokens.forEach((token) => {
+			const type = token.type;
+			if (/^(b-)?year/.test(type)) {
+				order += "Y";
+				haveDate++;
+			} else if (type.startsWith("month")) {
+				order += "M";
+				haveDate++;
+			} else if (/^(week)?day/.test(type)) {
+				order += "D";
+				haveDate++;
+			} else if (type === "hour" || type === "min" || type === "sec" || type === "ampm") {
+				order += type[0];
+				haveTime++;
+			}
+		});
+		output.type = "date";
+		if (haveDate && haveTime) output.type = "datetime";
+		else if (!haveDate && haveTime) output.type = "time";
+		const code = dateCodes.find(([prefix]) => order.startsWith(prefix));
+		codeType = code ? "D" : "G";
+		codeNumber = code ? code[1] : "";
+	} else if (output.isText) {
+		codeType = "G";
+		output.type = "text";
+		codeNumber = "";
+		output.maxDecimals = 0;
+	} else if (positive === null || positive === void 0 ? void 0 : positive.general) {
+		codeType = "G";
+		output.type = "general";
+		codeNumber = "";
+	} else if (positive === null || positive === void 0 ? void 0 : positive.fractions) {
+		codeType = "G";
+		output.type = "fraction";
+		codeNumber = "";
+	} else if (positive === null || positive === void 0 ? void 0 : positive.exponential) {
+		codeType = "S";
+		output.type = "scientific";
+	} else if (output.isPercent) {
+		codeType = "P";
+		output.type = "percent";
+	} else if (positive === null || positive === void 0 ? void 0 : positive.grouping) {
+		codeType = ",";
+		output.type = "grouped";
+	} else if (positive && (positive.int_max || fracMax)) {
+		codeType = "F";
+		output.type = "number";
+	}
+	output.code = codeType + codeNumber + codeDash + codeParentheses;
+	output.level = level[output.type];
+	return Object.freeze(output);
+}
+function dateInfo(partitions) {
+	var _positive$date;
+	const [partPositive] = partitions;
+	if (!partPositive) throw new TypeError("Cannot read properties of undefined (reading 'date')");
+	const positive = isParsedSection$1(partPositive) ? partPositive : void 0;
+	const date = (_positive$date = positive === null || positive === void 0 ? void 0 : positive.date) !== null && _positive$date !== void 0 ? _positive$date : 0;
+	return {
+		year: !!(date & 2),
+		month: !!(date & 4),
+		day: !!(date & 8),
+		hours: !!(date & 16),
+		minutes: !!(date & 32),
+		seconds: !!(date & 64),
+		clockType: (positive === null || positive === void 0 ? void 0 : positive.clock) === 12 ? 12 : 24
+	};
+}
+
+//#endregion
+//#region src/shared/numfmt/decimal.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+const SPREADSHEET_SIGNIFICANT_DIGITS = 15;
+function decimalFromNumber(value) {
+	if (!Number.isFinite(value)) throw new RangeError("decimalFromNumber requires a finite number");
+	const negative = value < 0 || Object.is(value, -0);
+	if (value === 0) return {
+		negative,
+		digits: "0",
+		exponent: 0
+	};
+	const [mantissa, exponentText] = Math.abs(value).toExponential(15 - 1).split("e");
+	return {
+		negative,
+		digits: mantissa.replace(".", "").replace(/0+$/, "") || "0",
+		exponent: Number(exponentText)
+	};
+}
+function shiftDecimal(value, power) {
+	return {
+		...value,
+		exponent: value.digits === "0" ? 0 : value.exponent + Math.trunc(power)
+	};
+}
+function incrementDigits(value) {
+	const characters = [...value];
+	for (let index = characters.length - 1; index >= 0; index--) {
+		if (characters[index] !== "9") {
+			characters[index] = String(Number(characters[index]) + 1);
+			return characters.join("");
+		}
+		characters[index] = "0";
+	}
+	return `1${characters.join("")}`;
+}
+function roundDecimal(value, places = 0) {
+	const normalizedPlaces = Math.trunc(places);
+	const keep = value.exponent + 1 + normalizedPlaces;
+	let units;
+	if (keep < 0) units = "0";
+	else if (keep === 0) units = value.digits[0] >= "5" ? "1" : "0";
+	else {
+		units = value.digits.slice(0, keep).padEnd(keep, "0") || "0";
+		if (keep < value.digits.length && value.digits[keep] >= "5") units = incrementDigits(units);
+	}
+	if (/^0+$/.test(units)) return {
+		negative: value.negative,
+		integer: "0",
+		fraction: "",
+		zero: true
+	};
+	if (normalizedPlaces <= 0) return {
+		negative: value.negative,
+		integer: units + "0".repeat(-normalizedPlaces),
+		fraction: "",
+		zero: false
+	};
+	const fixed = units.padStart(normalizedPlaces + 1, "0");
+	return {
+		negative: value.negative,
+		integer: fixed.slice(0, -normalizedPlaces),
+		fraction: fixed.slice(-normalizedPlaces).replace(/0+$/, ""),
+		zero: false
+	};
+}
+function decimalPartsToNumber(value) {
+	const magnitude = Number(value.fraction ? `${value.integer}.${value.fraction}` : value.integer);
+	return value.negative && !value.zero ? -magnitude : magnitude;
+}
+function decimalPartsToPlainString(value) {
+	return `${value.negative && !value.zero ? "-" : ""}${value.integer}${value.fraction ? `.${value.fraction}` : ""}`;
+}
+function roundScientificDecimal(value, integerDigits, hasIntegerPattern, fractionDigits) {
+	if (value.digits === "0") return {
+		exponent: 0,
+		rounded: roundDecimal(value, fractionDigits)
+	};
+	let exponent = integerDigits > 1 ? Math.floor(value.exponent / integerDigits) * integerDigits : value.exponent;
+	if (!hasIntegerPattern) exponent++;
+	let rounded = roundDecimal(shiftDecimal(value, -exponent), fractionDigits);
+	if (integerDigits === 1 && rounded.integer.length > 1) {
+		exponent++;
+		rounded = roundDecimal(shiftDecimal(value, -exponent), fractionDigits);
+	}
+	return {
+		exponent,
+		rounded
+	};
+}
+
+//#endregion
+//#region src/shared/numfmt/code-to-locale.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+const codeToLocale = Object.freeze({
+	1078: "af",
+	1052: "sq",
+	1118: "am",
+	5121: "ar_DZ",
+	15361: "ar_BH",
+	3073: "ar_EG",
+	2049: "ar_IQ",
+	11265: "ar_JO",
+	13313: "ar_KW",
+	12289: "ar_LB",
+	4097: "ar_LY",
+	6145: "ar_MA",
+	8193: "ar_OM",
+	16385: "ar_QA",
+	1025: "ar_SA",
+	10241: "ar_SY",
+	7169: "ar_TN",
+	14337: "ar_AE",
+	9217: "ar_YE",
+	1067: "hy",
+	1101: "as",
+	2092: "az_AZ",
+	1068: "az_AZ",
+	1069: "eu",
+	1059: "be",
+	2117: "bn",
+	1093: "bn_IN",
+	5146: "bs",
+	1026: "bg",
+	1109: "my",
+	1027: "ca",
+	2052: "zh_CN",
+	3076: "zh_HK",
+	5124: "zh_MO",
+	4100: "zh_SG",
+	1028: "zh_TW",
+	1050: "hr",
+	1029: "cs",
+	1030: "da",
+	1125: "dv",
+	2067: "nl_BE",
+	1043: "nl_NL",
+	1126: "bin",
+	3081: "en_AU",
+	10249: "en_BZ",
+	4105: "en_CA",
+	9225: "en_CB",
+	2057: "en_GB",
+	16393: "en_IN",
+	6153: "en_IE",
+	8201: "en_JM",
+	5129: "en_NZ",
+	13321: "en_PH",
+	7177: "en_ZA",
+	11273: "en_TT",
+	1033: "en_US",
+	12297: "en_ZW",
+	1061: "et",
+	1071: "mk",
+	1080: "fo",
+	1065: "fa",
+	1124: "fil",
+	1035: "fi",
+	2060: "fr_BE",
+	11276: "fr_CM",
+	3084: "fr_CA",
+	9228: "fr_CG",
+	12300: "fr_CI",
+	1036: "fr_FR",
+	5132: "fr_LU",
+	13324: "fr_ML",
+	6156: "fr_MC",
+	14348: "fr_MA",
+	10252: "fr_SN",
+	4108: "fr_CH",
+	7180: "fr",
+	1122: "fy_NL",
+	2108: "gd_IE",
+	1084: "gd",
+	1110: "gl",
+	1079: "ka",
+	3079: "de_AT",
+	1031: "de_DE",
+	5127: "de_LI",
+	4103: "de_LU",
+	2055: "de_CH",
+	1032: "el",
+	1140: "gn",
+	1095: "gu",
+	1279: "en",
+	1037: "he",
+	1081: "hi",
+	1038: "hu",
+	1039: "is",
+	1136: "ig_NG",
+	1057: "id",
+	1040: "it_IT",
+	2064: "it_CH",
+	1041: "ja",
+	1099: "kn",
+	1120: "ks",
+	1087: "kk",
+	1107: "km",
+	1111: "kok",
+	1042: "ko",
+	1088: "ky",
+	1108: "lo",
+	1142: "la",
+	1062: "lv",
+	1063: "lt",
+	2110: "ms_BN",
+	1086: "ms_MY",
+	1100: "ml",
+	1082: "mt",
+	1112: "mni",
+	1153: "mi",
+	1102: "mr",
+	1104: "mn",
+	2128: "mn",
+	1121: "ne",
+	1044: "no_NO",
+	2068: "no_NO",
+	1096: "or",
+	1045: "pl",
+	1046: "pt_BR",
+	2070: "pt_PT",
+	1094: "pa",
+	1047: "rm",
+	2072: "ro_MO",
+	1048: "ro_RO",
+	1049: "ru",
+	2073: "ru_MO",
+	1083: "se",
+	1103: "sa",
+	3098: "sr_SP",
+	2074: "sr_SP",
+	1072: "st",
+	1074: "tn",
+	1113: "sd",
+	1115: "si",
+	1051: "sk",
+	1060: "sl",
+	1143: "so",
+	1070: "sb",
+	11274: "es_AR",
+	16394: "es_BO",
+	13322: "es_CL",
+	9226: "es_CO",
+	5130: "es_CR",
+	7178: "es_DO",
+	12298: "es_EC",
+	17418: "es_SV",
+	4106: "es_GT",
+	18442: "es_HN",
+	2058: "es_MX",
+	19466: "es_NI",
+	6154: "es_PA",
+	15370: "es_PY",
+	10250: "es_PE",
+	20490: "es_PR",
+	1034: "es_ES",
+	14346: "es_UY",
+	8202: "es_VE",
+	1089: "sw",
+	2077: "sv_FI",
+	1053: "sv_SE",
+	1114: "syc",
+	1064: "tg",
+	1097: "ta",
+	1092: "tt",
+	1098: "te",
+	1054: "th",
+	1105: "bo",
+	1073: "ts",
+	1055: "tr",
+	1090: "tk",
+	1058: "uk",
+	1056: "ur",
+	2115: "uz_UZ",
+	1091: "uz_UZ",
+	1075: "ve",
+	1066: "vi",
+	1106: "cy",
+	1076: "xh",
+	1085: "yi",
+	1077: "zu"
+});
+
+//#endregion
+//#region src/shared/numfmt/locale.ts
+const re_locale = /^([a-z\d]+)(?:[_-]([a-z\d]+))?(?:\.([a-z\d]+))?(?:@([a-z\d]+))?$/i;
+const locales = {};
+/**
+* Split a semicolon delimited string and replace instances of characters
+* @ignore
+* @param {string} str Semicolon delimited string
+* @param {string} [tilde] String to be inserted on every instance of ~
+* @returns {string[]} Array of strings
+*/
+const _ = (str, tilde = "") => str.replace(/~/g, tilde).split(";");
+const xm = (o, ml = 0, dl = 0) => {
+	if (!o.mmm) o.mmm = ml < 1 ? o.mmmm.concat() : o.mmmm.map((d) => {
+		const s = d.slice(0, ml % 10);
+		return s + (ml < 10 || d === s ? "" : ".");
+	});
+	if (!o.ddd) o.ddd = dl < 1 ? o.dddd.concat() : o.dddd.map((d) => {
+		const s = d.slice(0, dl % 10);
+		return s + (dl < 10 || d === s ? "" : ".");
+	});
+	if (!o.mmm6 && o.mmmm6) o.mmm6 = o.mmmm6;
+	return o;
+};
+/**
+* @typedef {object} LocaleData
+*   An object of properties used by a formatter when printing a number in a certain locale.
+* @property {string} group - Symbol used as a grouping separator (`1,000,000` uses `,`)
+* @property {string} decimal - Symbol used to separate integers from fractions (usually `.`)
+* @property {string} positive - Symbol used to indicate positive numbers (usually `+`)
+* @property {string} negative - Symbol used to indicate positive numbers (usually `-`)
+* @property {string} percent - Symbol used to indicate a percentage (usually `%`)
+* @property {string} exponent - Symbol used to indicate an exponent (usually `E`)
+* @property {string} nan - Symbol used to indicate NaN values (`NaN`)
+* @property {string} infinity - Symbol used to indicate infinite values (`∞`)
+* @property {Array<string>} ampm - How AM and PM should be presented
+* @property {Array<string>} mmmm6 - Long month names for the Islamic calendar (`Rajab`)
+* @property {Array<string>} mmm6 - Short month names for the Islamic calendar (`Raj.`)
+* @property {Array<string>} mmmm - Long month names for the Gregorian calendar (`November`)
+* @property {Array<string>} mmm - Short month names for the Gregorian calendar (`Nov`)
+* @property {Array<string>} dddd - Long day names (`Wednesday`)
+* @property {Array<string>} ddd - Shortened day names (`Wed`)
+* @property {Array<string>} bool - How TRUE and FALSE should be presented
+* @property {boolean} preferMDY - Is the prefered date format month first (12/31/2025) or day first (31/12/2025)
+*/
+/**
+* @ignore
+* @type {LocaleData}
+*/
+const baseLocaleData = {
+	group: "\xA0",
+	decimal: ".",
+	positive: "+",
+	negative: "-",
+	percent: "%",
+	exponent: "E",
+	nan: "NaN",
+	infinity: "∞",
+	ampm: _("AM;PM"),
+	mmmm6: _("Muharram;Safar;Rabiʻ I;Rabiʻ II;Jumada I;Jumada II;Rajab;Shaʻban;Ramadan;Shawwal;Dhuʻl-Qiʻdah;Dhuʻl-Hijjah"),
+	mmm6: _("Muh.;Saf.;Rab. I;Rab. II;Jum. I;Jum. II;Raj.;Sha.;Ram.;Shaw.;Dhuʻl-Q.;Dhuʻl-H."),
+	mmmm: _("January;February;March;April;May;June;July;August;September;October;November;December"),
+	mmm: _("Jan;Feb;Mar;Apr;May;Jun;Jul;Aug;Sep;Oct;Nov;Dec"),
+	dddd: _("Sunday;Monday;Tuesday;Wednesday;Thursday;Friday;Saturday"),
+	ddd: _("Sun;Mon;Tue;Wed;Thu;Fri;Sat"),
+	bool: _("TRUE;FALSE"),
+	preferMDY: false
+};
+/**
+* @typedef {object} LocaleToken - An object of properties for a locale tag.
+* @property {string} lang - The basic tag such as `zh_CN` or `fi`
+* @property {string} language - The language section (`zh` for `zh_CN`)
+* @property {string} territory - The territory section (`CN` for `zh_CN`)
+*/
+/**
+* Parse a regular IETF BCP 47 locale tag and emit an object of its parts.
+* Irregular tags and subtags are not supported.
+*
+* @param {string} locale - A BCP 47 string tag of the locale.
+* @returns {LocaleToken} - An object describing the locale.
+*/
+function parseLocale(locale) {
+	const lm = re_locale.exec(locale);
+	if (!lm) throw new SyntaxError(`Malformed locale: ${locale}`);
+	return {
+		lang: lm[1] + (lm[2] ? `_${lm[2]}` : ""),
+		language: lm[1],
+		territory: lm[2] || ""
+	};
+}
+function resolveLocale(locale) {
+	if (typeof locale === "number") return codeToLocale[locale & 65535] || null;
+	const wincode = Number.parseInt(locale, 16);
+	if (Number.isFinite(wincode) && codeToLocale[wincode & 65535]) return codeToLocale[wincode & 65535] || null;
+	if (re_locale.test(locale)) return locale;
+	return null;
+}
+/**
+* Used by the formatter to pull a locate from its registered locales. If
+* subtag isn't available but the base language is, the base language is used.
+* So if `en-CA` is not found, the formatter tries to find `en` else it
+* returns a `null`.
+*
+* @param {string} locale - A BCP 47 string tag of the locale, or an Excel locale code.
+* @returns {LocaleData | null} - An object of format date properties.
+*/
+function getLocale(locale) {
+	const tag = resolveLocale(locale);
+	let obj = null;
+	if (tag) {
+		const c = parseLocale(tag);
+		obj = locales[c.lang] || locales[c.language] || null;
+	}
+	return obj;
+}
+function createLocale(settings) {
+	return Object.assign({}, baseLocaleData, settings);
+}
+/**
+* Register locale data for a language so for use when formatting.
+*
+* Any partial set of properties may be returned to have the defaults used where properties are missing.
+*
+* @see {LocaleData}
+* @param {object} settings - A collection of settings for a locale.
+* @param {string} [settings.group]
+*    Symbol used as a grouping separator (`1,000,000` uses `,`)
+* @param {string} [settings.decimal]
+*    Symbol used to separate integers from fractions (usually `.`)
+* @param {string} [settings.positive]
+*    Symbol used to indicate positive numbers (usually `+`)
+* @param {string} [settings.negative]
+*    Symbol used to indicate positive numbers (usually `-`)
+* @param {string} [settings.percent]
+*    Symbol used to indicate a percentage (usually `%`)
+* @param {string} [settings.exponent]
+*    Symbol used to indicate an exponent (usually `E`)
+* @param {string} [settings.nan]
+*    Symbol used to indicate NaN values (`NaN`)
+* @param {string} [settings.infinity]
+*    Symbol used to indicate infinite values (`∞`)
+* @param {Array<string>} [settings.ampm]
+*    How AM and PM should be presented.
+* @param {Array<string>} [settings.mmmm6]
+*    Long month names for the Islamic calendar (e.g. `Rajab`)
+* @param {Array<string>} [settings.mmm6]
+*    Short month names for the Islamic calendar (e.g. `Raj.`)
+* @param {Array<string>} [settings.mmmm]
+*    Long month names for the Gregorian calendar (e.g. `November`)
+* @param {Array<string>} [settings.mmm]
+*    Short month names for the Gregorian calendar (e.g. `Nov`)
+* @param {Array<string>} [settings.dddd]
+*    Long day names (e.g. `Wednesday`)
+* @param {Array<string>} [settings.ddd]
+*    Shortened day names (e.g. `Wed`)
+* @param {Array<string>} [settings.bool]
+*    How TRUE and FALSE should be presented.
+* @param {boolean} [settings.preferMDY]
+*    Is the prefered date format month first (12/31/2025) or day first (31/12/2025)
+* @param {string | LocaleToken} locale - A string BCP 47 tag or parsed locale token.
+* @returns {LocaleData} - A full collection of settings for a locale
+*/
+function addLocale(settings, locale) {
+	const c = typeof locale === "object" ? locale : parseLocale(locale);
+	locales[c.lang] = createLocale(settings);
+	if (c.language !== c.lang && !locales[c.language]) locales[c.language] = createLocale(settings);
+	return locales[c.lang];
+}
+const defaultLocale = createLocale({
+	group: ",",
+	preferMDY: true
+});
+defaultLocale.isDefault = true;
+addLocale({
+	group: ",",
+	ampm: _("上午;下午"),
+	mmmm: _("一月;二月;三月;四月;五月;六月;七月;八月;九月;十月;十一月;十二月"),
+	mmm: _("1月;2月;3月;4月;5月;6月;7月;8月;9月;10月;11月;12月"),
+	dddd: _("~日;~一;~二;~三;~四;~五;~六", "星期"),
+	ddd: _("周日;周一;周二;周三;周四;周五;周六")
+}, "zh_CN");
+const _zh = {
+	group: ",",
+	ampm: _("上午;下午"),
+	mmmm: _("1月;2月;3月;4月;5月;6月;7月;8月;9月;10月;11月;12月"),
+	mmm: _("1月;2月;3月;4月;5月;6月;7月;8月;9月;10月;11月;12月"),
+	dddd: _("~日;~一;~二;~三;~四;~五;~六", "星期"),
+	ddd: _("周日;周一;周二;周三;周四;周五;周六")
+};
+addLocale({
+	..._zh,
+	nan: "非數值",
+	dddd: _("~日;~一;~二;~三;~四;~五;~六", "星期")
+}, "zh_TW");
+addLocale({
+	..._zh,
+	dddd: _("~日;~一;~二;~三;~四;~五;~六", "星期")
+}, "zh_HK");
+addLocale({
+	..._zh,
+	ampm: _("午前;午後"),
+	dddd: _("日~;月~;火~;水~;木~;金~;土~", "曜日"),
+	ddd: _("日;月;火;水;木;金;土")
+}, "ja");
+addLocale({
+	group: ",",
+	ampm: _("오전;오후"),
+	mmmm: _("1월;2월;3월;4월;5월;6월;7월;8월;9월;10월;11월;12월"),
+	mmm: _("1월;2월;3월;4월;5월;6월;7월;8월;9월;10월;11월;12월"),
+	dddd: _("일요일;월요일;화요일;수요일;목요일;금요일;토요일"),
+	ddd: _("일;월;화;수;목;금;토")
+}, "ko");
+addLocale({
+	group: ",",
+	ampm: _("ก่อนเที่ยง;หลังเที่ยง"),
+	mmmm: _("มกร~;กุมภาพันธ์;มีน~;เมษายน;พฤษภ~;มิถุนายน;กรกฎ~;สิงห~;กันยายน;ตุล~;พฤศจิกายน;ธันว~", "าคม"),
+	mmm: _("ม.ค.;ก.พ.;มี.ค.;เม.ย.;พ.ค.;มิ.ย.;ก.ค.;ส.ค.;ก.ย.;ต.ค.;พ.ย.;ธ.ค."),
+	dddd: _("วันอาทิตย์;วันจันทร์;วันอังคาร;วันพุธ;วันพฤหัสบดี;วันศุกร์;วันเสาร์"),
+	ddd: _("อา.;จ.;อ.;พ.;พฤ.;ศ.;ส.")
+}, "th");
+addLocale(xm({
+	decimal: ",",
+	ampm: _("dop.;odp."),
+	mmmm: _("ledna;února;března;dubna;května;června;července;srpna;září;října;listopadu;prosince"),
+	mmm: _("I;II;III;IV;V;VI;VII;VIII;IX;X;XI;XII"),
+	dddd: _("neděle;pondělí;úterý;středa;čtvrtek;pátek;sobota"),
+	bool: _("PRAVDA;NEPRAVDA")
+}, -1, 2), "cs");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	mmmm: _("januar;februar;marts;april;maj;juni;juli;august;september;oktober;november;december"),
+	dddd: _("søn~;man~;tirs~;ons~;tors~;fre~;lør~", "dag"),
+	bool: _("SAND;FALSK")
+}, 13, 13), "da");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	ampm: _("a.m.;p.m."),
+	mmmm: _("januari;februari;maart;april;mei;juni;juli;augustus;september;oktober;november;december"),
+	mmm: _("jan.;feb.;mrt.;apr.;mei;jun.;jul.;aug.;sep.;okt.;nov.;dec."),
+	dddd: _("zondag;maandag;dinsdag;woensdag;donderdag;vrijdag;zaterdag"),
+	bool: _("WAAR;ONWAAR")
+}, -1, 2), "nl");
+addLocale({
+	group: ",",
+	preferMDY: true
+}, "en");
+addLocale({
+	group: ",",
+	preferMDY: true
+}, "en_US");
+addLocale({ group: "," }, "en_AU");
+addLocale({ group: "," }, "en_CA");
+addLocale({ group: "," }, "en_GB");
+addLocale({
+	group: ",",
+	mmm: _("Jan;Feb;Mar;Apr;May;Jun;Jul;Aug;Sept;Oct;Nov;Dec")
+}, "en_IE");
+addLocale(xm({
+	decimal: ",",
+	nan: "epäluku",
+	ampm: _("ap.;ip."),
+	mmmm: _("tammi~;helmi~;maalis~;huhti~;touko~;kesä~;heinä~;elo~;syys~;loka~;marras~;joulu~", "kuuta"),
+	mmm: _("tammik.;helmik.;maalisk.;huhtik.;toukok.;kesäk.;heinäk.;elok.;syysk.;lokak.;marrask.;jouluk."),
+	dddd: _("sunnun~;maanan~;tiis~;keskiviikkona;tors~;perjan~;lauan~", "taina"),
+	bool: _("TOSI;EPÄTOSI")
+}, -1, 2), "fi");
+const _fr = xm({
+	group: " ",
+	decimal: ",",
+	mmmm: _("janvier;février;mars;avril;mai;juin;juillet;août;septembre;octobre;novembre;décembre"),
+	mmm: _("janv.;févr.;mars;avr.;mai;juin;juil.;août;sept.;oct.;nov.;déc."),
+	dddd: _("~manche;lun~;mar~;mercre~;jeu~;vendre~;same~", "di"),
+	bool: _("VRAI;FAUX")
+}, -1, 13);
+addLocale({ ..._fr }, "fr");
+addLocale({
+	..._fr,
+	mmm: _("janv.;févr.;mars;avr.;mai;juin;juill.;août;sept.;oct.;nov.;déc.")
+}, "fr_CA");
+addLocale({
+	group: "'",
+	decimal: ".",
+	..._fr
+}, "fr_CH");
+const _de = xm({
+	mmmm: _("Januar;Februar;März;April;Mai;Juni;Juli;August;September;Oktober;November;Dezember"),
+	mmm: _("Jan.;Feb.;März;Apr.;Mai;Juni;Juli;Aug.;Sept.;Okt.;Nov.;Dez."),
+	dddd: _("Sonn~;Mon~;Diens~;Mittwoch;Donners~;Frei~;Sams~", "tag"),
+	bool: _("WAHR;FALSCH")
+}, -1, 12);
+addLocale({
+	group: ".",
+	decimal: ",",
+	..._de
+}, "de");
+addLocale({
+	group: "'",
+	decimal: ".",
+	..._de
+}, "de_CH");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	ampm: _("π.μ.;μ.μ."),
+	mmmm: _("Ιανουαρ~;Φεβρουαρ~;Μαρτ~;Απριλ~;Μαΐου;Ιουν~;Ιουλ~;Αυγούστου;Σεπτεμβρ~;Οκτωβρ~;Νοεμβρ~;Δεκεμβρ~", "ίου"),
+	mmm: _("Ιαν;Φεβ;Μαρ;Απρ;Μαΐ;Ιουν;Ιουλ;Αυγ;Σεπ;Οκτ;Νοε;Δεκ"),
+	dddd: _("Κυριακή;Δευτέρα;Τρίτη;Τετάρτη;Πέμπτη;Παρασκευή;Σάββατο")
+}, -1, 3), "el");
+addLocale({
+	decimal: ",",
+	ampm: _("de.;du."),
+	mmmm: _("január;február;március;április;május;június;július;augusztus;szeptember;október;november;december"),
+	mmm: _("jan.;febr.;márc.;ápr.;máj.;jún.;júl.;aug.;szept.;okt.;nov.;dec."),
+	dddd: _("vasárnap;hétfő;kedd;szerda;csütörtök;péntek;szombat"),
+	ddd: _("V;H;K;Sze;Cs;P;Szo"),
+	bool: _("IGAZ;HAMIS")
+}, "hu");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	ampm: _("f.h.;e.h."),
+	mmmm: _("janúar;febrúar;mars;apríl;maí;júní;júlí;ágúst;september;október;nóvember;desember"),
+	dddd: _("sunnu~;mánu~;þriðju~;miðviku~;fimmtu~;föstu~;laugar~", "dagur")
+}, 13, 13), "is");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	mmmm: _("Januari;Februari;Maret;April;Mei;Juni;Juli;Agustus;September;Oktober;November;Desember"),
+	dddd: _("Minggu;Senin;Selasa;Rabu;Kamis;Jumat;Sabtu")
+}, 3, 3), "id");
+const _it = xm({
+	mmmm: _("gennaio;febbraio;marzo;aprile;maggio;giugno;luglio;agosto;settembre;ottobre;novembre;dicembre"),
+	dddd: _("domenica;lunedì;martedì;mercoledì;giovedì;venerdì;sabato"),
+	bool: _("VERO;FALSO")
+}, 3, 3);
+addLocale({
+	group: ".",
+	decimal: ",",
+	..._it
+}, "it");
+addLocale({
+	group: "'",
+	decimal: ".",
+	..._it
+}, "it_CH");
+const _no = {
+	decimal: ",",
+	ampm: _("a.m.;p.m."),
+	mmmm: _("januar;februar;mars;april;mai;juni;juli;august;september;oktober;november;desember"),
+	mmm: _("jan.;feb.;mar.;apr.;mai;jun.;jul.;aug.;sep.;okt.;nov.;des."),
+	dddd: _("søn~;man~;tirs~;ons~;tors~;fre~;lør~", "dag"),
+	bool: _("SANN;USANN")
+};
+addLocale(xm({ ..._no }, -1, 13), "nb");
+addLocale(xm({ ..._no }, -1, 13), "no");
+addLocale(xm({
+	decimal: ",",
+	mmmm: _("stycznia;lutego;marca;kwietnia;maja;czerwca;lipca;sierpnia;września;października;listopada;grudnia"),
+	dddd: _("niedziela;poniedziałek;wtorek;środa;czwartek;piątek;sobota"),
+	ddd: _("niedz.;pon.;wt.;śr.;czw.;pt.;sob."),
+	bool: _("PRAWDA;FAŁSZ")
+}, 3, -1), "pl");
+const _pt = {
+	group: ".",
+	decimal: ",",
+	mmmm: _("janeiro;fevereiro;março;abril;maio;junho;julho;agosto;setembro;outubro;novembro;dezembro"),
+	dddd: _("domingo;segunda-feira;terça-feira;quarta-feira;quinta-feira;sexta-feira;sábado"),
+	bool: _("VERDADEIRO;FALSO")
+};
+addLocale(xm(_pt, 13, 13), "pt");
+addLocale(xm(_pt, 13, 13), "pt_BR");
+addLocale({
+	decimal: ",",
+	nan: "не\xA0число",
+	mmmm: _("января;февраля;марта;апреля;мая;июня;июля;августа;сентября;октября;ноября;декабря"),
+	mmm: _("янв.;февр.;мар.;апр.;мая;июн.;июл.;авг.;сент.;окт.;нояб.;дек."),
+	dddd: _("воскресенье;понедельник;вторник;среда;четверг;пятница;суббота"),
+	ddd: _("вс;пн;вт;ср;чт;пт;сб"),
+	mmmm6: _("рамадан;шавваль;зуль-каада;зуль-хиджжа;мухаррам;раби-уль-авваль;раби-уль-ахир;джумад-уль-авваль;джумад-уль-ахир;раджаб;шаабан;рамадан"),
+	mmm6: _("рам.;шав.;зуль-к.;зуль-х.;мух.;раб. I;раб. II;джум. I;джум. II;радж.;шааб.;рам."),
+	bool: _("ИСТИНА;ЛОЖЬ")
+}, "ru");
+addLocale(xm({
+	decimal: ",",
+	mmmm: _("januára;februára;marca;apríla;mája;júna;júla;augusta;septembra;októbra;novembra;decembra"),
+	dddd: _("nedeľa;pondelok;utorok;streda;štvrtok;piatok;sobota")
+}, 3, 2), "sk");
+const _es = {
+	group: ".",
+	decimal: ",",
+	ampm: _("a.\xA0m.;p.\xA0m."),
+	mmmm: _("enero;febrero;marzo;abril;mayo;junio;julio;agosto;septiem~;octu~;noviem~;diciem~", "bre"),
+	mmm: _("ene;feb;mar;abr;may;jun;jul;ago;sept;oct;nov;dic"),
+	dddd: _("domingo;lunes;martes;miércoles;jueves;viernes;sábado"),
+	ddd: _("dom;lun;mar;mié;jue;vie;sáb"),
+	bool: _("VERDADERO;FALSO")
+};
+const _esM3 = _("ene;feb;mar;abr;may;jun;jul;ago;sep;oct;nov;dic");
+const _esM13 = _("ene.;feb.;mar.;abr.;may.;jun.;jul.;ago.;sept.;oct.;nov.;dic.");
+addLocale({ ..._es }, "es");
+addLocale({ ..._es }, "es_AR");
+addLocale({ ..._es }, "es_BO");
+addLocale({ ..._es }, "es_CL");
+addLocale({ ..._es }, "es_CO");
+addLocale({ ..._es }, "es_EC");
+addLocale({
+	..._es,
+	mmm: _esM3,
+	ampm: _("a.m.;p.m.")
+}, "es_MX");
+addLocale({
+	..._es,
+	mmm: _esM13
+}, "es_PY");
+addLocale({
+	..._es,
+	mmm: _esM13
+}, "es_UY");
+addLocale({
+	..._es,
+	mmm: _esM13,
+	mmmm: _("enero;febrero;marzo;abril;mayo;junio;julio;agosto;setiembre;octubre;noviembre;diciembre")
+}, "es_VE");
+addLocale({
+	decimal: ",",
+	ampm: _("fm;em"),
+	mmmm: _("januari;februari;mars;april;maj;juni;juli;augusti;september;oktober;november;december"),
+	mmm: _("jan.;feb.;mars;apr.;maj;juni;juli;aug.;sep.;okt.;nov.;dec."),
+	dddd: _("sön~;mån~;tis~;ons~;tors~;fre~;lör~", "dag"),
+	ddd: _("sön;mån;tis;ons;tors;fre;lör")
+}, "sv");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	ampm: _("ÖÖ;ÖS"),
+	mmmm: _("Ocak;Şubat;Mart;Nisan;Mayıs;Haziran;Temmuz;Ağustos;Eylül;Ekim;Kasım;Aralık"),
+	mmm: _("Oca;Şub;Mar;Nis;May;Haz;Tem;Ağu;Eyl;Eki;Kas;Ara"),
+	dddd: _("Pazar;Pazartesi;Salı;Çarşamba;Perşembe;Cuma;Cumartesi"),
+	ddd: _("Paz;Pzt;Sal;Çar;Per;Cum;Cmt"),
+	bool: _("DOĞRU;YANLIŞ")
+}, 3, -1), "tr");
+addLocale({
+	group: ",",
+	ampm: _("yb;yh"),
+	mmmm: _("Ionawr;Chwefror;Mawrth;Ebrill;Mai;Mehefin;Gorffennaf;Awst;Medi;Hydref;Tachwedd;Rhagfyr"),
+	mmm: _("Ion;Chwef;Maw;Ebr;Mai;Meh;Gorff;Awst;Medi;Hyd;Tach;Rhag"),
+	dddd: _("Dydd Sul;Dydd Llun;Dydd Mawrth;Dydd Mercher;Dydd Iau;Dydd Gwener;Dydd Sadwrn"),
+	ddd: _("Sul;Llun;Maw;Mer;Iau;Gwen;Sad")
+}, "cy");
+addLocale({
+	group: ".",
+	decimal: ",",
+	mmmm: _("yanvar;fevral;mart;aprel;may;iyun;iyul;avqust;sentyabr;oktyabr;noyabr;dekabr"),
+	mmm: _("yan;fev;mar;apr;may;iyn;iyl;avq;sen;okt;noy;dek"),
+	dddd: _("bazar;bazar ertəsi;çərşənbə axşamı;çərşənbə;cümə axşamı;cümə;şənbə"),
+	ddd: _("B.;B.e.;Ç.a.;Ç.;C.a.;C.;Ş.")
+}, "az");
+addLocale(xm({
+	decimal: ",",
+	mmmm: _("студзеня;лютага;сакавіка;красавіка;мая;чэрвеня;ліпеня;жніўня;верасня;кастрычніка;лістапада;снежня"),
+	dddd: _("нядзеля;панядзелак;аўторак;серада;чацвер;пятніца;субота"),
+	ddd: _("нд;пн;аў;ср;чц;пт;сб")
+}, 3, -1), "be");
+addLocale({
+	decimal: ",",
+	ampm: _("пр.об.;сл.об."),
+	mmmm: _("януари;февруари;март;април;май;юни;юли;август;септември;октомври;ноември;декември"),
+	mmm: _("яну;фев;март;апр;май;юни;юли;авг;сеп;окт;ное;дек"),
+	dddd: _("неделя;понеделник;вторник;сряда;четвъртък;петък;събота"),
+	ddd: _("нд;пн;вт;ср;чт;пт;сб"),
+	bool: _("ИСТИНА;ЛОЖЬ")
+}, "bg");
+addLocale({
+	group: ".",
+	decimal: ",",
+	mmmm: _("de gener;de febrer;de març;d’abril;de maig;de juny;de juliol;d’agost;de setembre;d’octubre;de novembre;de desembre"),
+	mmm: _("de gen.;de febr.;de març;d’abr.;de maig;de juny;de jul.;d’ag.;de set.;d’oct.;de nov.;de des."),
+	dddd: _("diumenge;dilluns;dimarts;dimecres;dijous;divendres;dissabte"),
+	ddd: _("dg.;dl.;dt.;dc.;dj.;dv.;ds."),
+	ampm: _("a.\xA0m.;p.\xA0m.")
+}, "ca");
+addLocale(xm({
+	group: ",",
+	decimal: ".",
+	mmmm: _("Enero;Pebrero;Marso;Abril;Mayo;Hunyo;Hulyo;Agosto;Setyembre;Oktubre;Nobyembre;Disyembre"),
+	dddd: _("Linggo;Lunes;Martes;Miyerkules;Huwebes;Biyernes;Sabado")
+}, 3, 3), "fil");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("જાન્યુઆરી;ફેબ્રુઆરી;માર્ચ;એપ્રિલ;મે;જૂન;જુલાઈ;ઑગસ્ટ;સપ્ટેમ્બર;ઑક્ટોબર;નવેમ્બર;ડિસેમ્બર"),
+	mmm: _("જાન્યુ;ફેબ્રુ;માર્ચ;એપ્રિલ;મે;જૂન;જુલાઈ;ઑગસ્ટ;સપ્ટે;ઑક્ટો;નવે;ડિસે"),
+	dddd: _("રવિ~;સોમ~;મંગળ~;બુધ~;ગુરુ~;શુક્ર~;શનિ~", "વાર"),
+	ddd: _("રવિ;સોમ;મંગળ;બુધ;ગુરુ;શુક્ર;શનિ")
+}, "gu");
+addLocale({
+	group: ",",
+	decimal: ".",
+	ampm: _("לפנה״צ;אחה״צ"),
+	dddd: _("~ראשון;~שני;~שלישי;~רביעי;~חמישי;~שישי;~שבת", "יום "),
+	ddd: _("~א׳;~ב׳;~ג׳;~ד׳;~ה׳;~ו׳;שבת", "יום "),
+	mmmm: _("ינואר;פברואר;מרץ;אפריל;מאי;יוני;יולי;אוגוסט;ספטמבר;אוקטובר;נובמבר;דצמבר"),
+	mmm: _("ינו׳;פבר׳;מרץ;אפר׳;מאי;יוני;יולי;אוג׳;ספט׳;אוק׳;נוב׳;דצמ׳"),
+	mmmm6: _("רמדאן;שוואל;ד׳ו אל־קעדה;ד׳ו אל־חיג׳ה;מוחרם;רביע אל־אוול;רביע א־ת׳אני;ג׳ומאדא אל־אולא;ג׳ומאדא א־ת׳אניה;רג׳ב;שעבאן;רמדאן"),
+	mmm6: _("רמדאן;שוואל;ד׳ו אל־קעדה;ד׳ו אל־חיג׳ה;מוחרם;רביע א׳;רביע ב׳;ג׳ומאדא א׳;ג׳ומאדא ב׳;רג׳ב;שעבאן;רמדאן")
+}, "he");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	mmmm: _("siječnja;veljače;ožujka;travnja;svibnja;lipnja;srpnja;kolovoza;rujna;listopada;studenoga;prosinca"),
+	mmm: _("sij;velj;ožu;tra;svi;lip;srp;kol;ruj;lis;stu;pro"),
+	dddd: _("nedjelja;ponedjeljak;utorak;srijeda;četvrtak;petak;subota")
+}, -1, 3), "hr");
+addLocale({
+	decimal: ",",
+	mmmm: _("հունվարի;փետրվարի;մարտի;ապրիլի;մայիսի;հունիսի;հուլիսի;օգոստոսի;սեպտեմբերի;հոկտեմբերի;նոյեմբերի;դեկտեմբերի"),
+	mmm: _("հնվ;փտվ;մրտ;ապր;մյս;հնս;հլս;օգս;սեպ;հոկ;նոյ;դեկ"),
+	dddd: _("կիրակի;երկուշաբթի;երեքշաբթի;չորեքշաբթի;հինգշաբթի;ուրբաթ;շաբաթ"),
+	ddd: _("կիր;երկ;երք;չրք;հնգ;ուր;շբթ")
+}, "hy");
+addLocale(xm({
+	decimal: ",",
+	mmmm: _("იანვარი;თებერვალი;მარტი;აპრილი;მაისი;ივნისი;ივლისი;აგვისტო;სექტემბერი;ოქტომბერი;ნოემბერი;დეკემბერი"),
+	dddd: _("კვირა;ორშაბათი;სამშაბათი;ოთხშაბათი;ხუთშაბათი;პარასკევი;შაბათი")
+}, 3, 3), "ka");
+addLocale(xm({
+	decimal: ",",
+	mmmm: _("қаңтар;ақпан;наурыз;сәуір;мамыр;маусым;шілде;тамыз;қыркүйек;қазан;қараша;желтоқсан"),
+	dddd: _("жексенбі;дүйсенбі;сейсенбі;сәрсенбі;бейсенбі;жұма;сенбі"),
+	ddd: _("жс;дс;сс;ср;бс;жм;сб")
+}, 13, -1), "kk");
+addLocale({
+	group: ",",
+	mmmm: _("ಜನವರಿ;ಫೆಬ್ರವರಿ;ಮಾರ್ಚ್;ಏಪ್ರಿಲ್;ಮೇ;ಜೂನ್;ಜುಲೈ;ಆಗಸ್ಟ್;ಸೆಪ್ಟೆಂಬರ್;ಅಕ್ಟೋಬರ್;ನವೆಂಬರ್;ಡಿಸೆಂಬರ್"),
+	mmm: _("ಜನವರಿ;ಫೆಬ್ರವರಿ;ಮಾರ್ಚ್;ಏಪ್ರಿ;ಮೇ;ಜೂನ್;ಜುಲೈ;ಆಗಸ್ಟ್;ಸೆಪ್ಟೆಂ;ಅಕ್ಟೋ;ನವೆಂ;ಡಿಸೆಂ"),
+	dddd: _("ಭಾನು~;ಸೋಮ~;ಮಂಗಳ~;ಬುಧ~;ಗುರು~;ಶುಕ್ರ~;ಶನಿ~", "ವಾರ"),
+	ddd: _("ಭಾನು;ಸೋಮ;ಮಂಗಳ;ಬುಧ;ಗುರು;ಶುಕ್ರ;ಶನಿ"),
+	ampm: _("ಪೂರ್ವಾಹ್ನ;ಅಪರಾಹ್ನ")
+}, "kn");
+addLocale({
+	decimal: ",",
+	mmmm: _("sausio;vasario;kovo;balandžio;gegužės;birželio;liepos;rugpjūčio;rugsėjo;spalio;lapkričio;gruodžio"),
+	mmm: _("saus.;vas.;kov.;bal.;geg.;birž.;liep.;rugp.;rugs.;spal.;lapkr.;gruod."),
+	dddd: _("sekmadienis;pirmadienis;antradienis;trečiadienis;ketvirtadienis;penktadienis;šeštadienis"),
+	ddd: _("sk;pr;an;tr;kt;pn;št"),
+	ampm: _("priešpiet;popiet")
+}, "lt");
+addLocale({
+	decimal: ",",
+	mmmm: _("janvāris;februāris;marts;aprīlis;maijs;jūnijs;jūlijs;augusts;septembris;oktobris;novembris;decembris"),
+	mmm: _("janv.;febr.;marts;apr.;maijs;jūn.;jūl.;aug.;sept.;okt.;nov.;dec."),
+	dddd: _("svētdiena;pirmdiena;otrdiena;trešdiena;ceturtdiena;piektdiena;sestdiena"),
+	ddd: _("svētd.;pirmd.;otrd.;trešd.;ceturtd.;piektd.;sestd."),
+	ampm: _("priekšpusdienā;pēcpusdienā")
+}, "lv");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("ജനുവരി;ഫെബ്രുവരി;മാർച്ച്;ഏപ്രിൽ;മേയ്;ജൂൺ;ജൂലൈ;ഓഗസ്റ്റ്;സെപ്റ്റംബർ;ഒക്‌ടോബർ;നവംബർ;ഡിസംബർ"),
+	mmm: _("ജനു;ഫെബ്രു;മാർ;ഏപ്രി;മേയ്;ജൂൺ;ജൂലൈ;ഓഗ;സെപ്റ്റം;ഒക്ടോ;നവം;ഡിസം"),
+	dddd: _("ഞായറാഴ്‌ച;തിങ്കളാഴ്‌ച;ചൊവ്വാഴ്ച;ബുധനാഴ്‌ച;വ്യാഴാഴ്‌ച;വെള്ളിയാഴ്‌ച;ശനിയാഴ്‌ച"),
+	ddd: _("ഞായർ;തിങ്കൾ;ചൊവ്വ;ബുധൻ;വ്യാഴം;വെള്ളി;ശനി")
+}, "ml");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("нэгдүгээ~;хоёрдугаа~;гуравдугаа~;дөрөвдүгээ~;тавдугаа~;зургаадугаа~;долоодугаа~;наймдугаа~;есдүгээ~;аравдугаа~;арван нэгдүгээ~;арван хоёрдугаа~", "р сар"),
+	mmm: _("1~;2~;3~;4~;5~;6~;7~;8~;9~;10~;11~;12~", "-р сар"),
+	dddd: _("ням;даваа;мягмар;лхагва;пүрэв;баасан;бямба"),
+	ddd: _("Ня;Да;Мя;Лх;Пү;Ба;Бя"),
+	ampm: _("ү.ө.;ү.х.")
+}, "mn");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("जानेवारी;फेब्रुवारी;मार्च;एप्रिल;मे;जून;जुलै;ऑगस्ट;सप्टेंबर;ऑक्टोबर;नोव्हेंबर;डिसेंबर"),
+	mmm: _("जाने;फेब्रु;मार्च;एप्रि;मे;जून;जुलै;ऑग;सप्टें;ऑक्टो;नोव्हें;डिसें"),
+	dddd: _("रविवार;सोमवार;मंगळवार;बुधवार;गुरुवार;शुक्रवार;शनिवार"),
+	ddd: _("रवि;सोम;मंगळ;बुध;गुरु;शुक्र;शनि")
+}, "mr");
+addLocale(xm({
+	group: ",",
+	decimal: ".",
+	mmmm: _("ဇန်နဝါရီ;ဖေဖော်ဝါရီ;မတ်;ဧပြီ;မေ;ဇွန်;ဇူလိုင်;ဩဂုတ်;စက်တင်ဘာ;အောက်တိုဘာ;နိုဝင်ဘာ;ဒီဇင်ဘာ"),
+	mmm: _("ဇန်;ဖေ;မတ်;ဧ;မေ;ဇွန်;ဇူ;ဩ;စက်;အောက်;နို;ဒီ"),
+	dddd: _("တနင်္ဂနွေ;တနင်္လာ;အင်္ဂါ;ဗုဒ္ဓဟူး;ကြာသပတေး;သောကြာ;စနေ"),
+	ampm: _("နံနက်;ညနေ")
+}, -1, 0), "my");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("ਜਨਵਰੀ;ਫ਼ਰਵਰੀ;ਮਾਰਚ;ਅਪ੍ਰੈਲ;ਮਈ;ਜੂਨ;ਜੁਲਾਈ;ਅਗਸਤ;ਸਤੰਬਰ;ਅਕਤੂਬਰ;ਨਵੰਬਰ;ਦਸੰਬਰ"),
+	mmm: _("ਜਨ;ਫ਼ਰ;ਮਾਰਚ;ਅਪ੍ਰੈ;ਮਈ;ਜੂਨ;ਜੁਲਾ;ਅਗ;ਸਤੰ;ਅਕਤੂ;ਨਵੰ;ਦਸੰ"),
+	dddd: _("ਐਤਵਾਰ;ਸੋਮਵਾਰ;ਮੰਗਲਵਾਰ;ਬੁੱਧਵਾਰ;ਵੀਰਵਾਰ;ਸ਼ੁੱਕਰਵਾਰ;ਸ਼ਨਿੱਚਰਵਾਰ"),
+	ddd: _("ਐਤ;ਸੋਮ;ਮੰਗਲ;ਬੁੱਧ;ਵੀਰ;ਸ਼ੁੱਕਰ;ਸ਼ਨਿੱਚਰ"),
+	ampm: _("ਪੂ.ਦੁ.;ਬਾ.ਦੁ.")
+}, "pa");
+addLocale({
+	group: ".",
+	decimal: ",",
+	mmmm: _("ianuarie;februarie;martie;aprilie;mai;iunie;iulie;august;septem~;octom~;noiem~;decem~", "brie"),
+	mmm: _("ian.;feb.;mar.;apr.;mai;iun.;iul.;aug.;sept.;oct.;nov.;dec."),
+	dddd: _("duminică;luni;marți;miercuri;joi;vineri;sâmbătă"),
+	ddd: _("dum.;lun.;mar.;mie.;joi;vin.;sâm."),
+	ampm: _("a.m.;p.m.")
+}, "ro");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	mmmm: _("januar;februar;marec;april;maj;junij;julij;avgust;september;oktober;november;december"),
+	mmm: _("jan.;feb.;mar.;apr.;maj;jun.;jul.;avg.;sep.;okt.;nov.;dec."),
+	dddd: _("nedelja;ponedeljek;torek;sreda;četrtek;petek;sobota"),
+	ampm: _("dop.;pop.")
+}, -1, 13), "sl");
+addLocale(xm({
+	group: ".",
+	decimal: ",",
+	mmmm: _("јануар;фебруар;март;април;мај;јун;јул;август;септембар;октобар;новембар;децембар"),
+	dddd: _("недеља;понедељак;уторак;среда;четвртак;петак;субота")
+}, 3, 3), "sr");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("ஜனவரி;பிப்ரவரி;மார்ச்;ஏப்ரல்;மே;ஜூன்;ஜூலை;ஆகஸ்ட்;செப்டம்பர்;அக்டோபர்;நவம்பர்;டிசம்பர்"),
+	mmm: _("ஜன.;பிப்.;மார்.;ஏப்.;மே;ஜூன்;ஜூலை;ஆக.;செப்.;அக்.;நவ.;டிச."),
+	dddd: _("ஞாயிறு;திங்கள்;செவ்வாய்;புதன்;வியாழன்;வெள்ளி;சனி"),
+	ddd: _("ஞாயி.;திங்.;செவ்.;புத.;வியா.;வெள்.;சனி")
+}, "ta");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("జనవరి;ఫిబ్రవరి;మార్చి;ఏప్రిల్;మే;జూన్;జులై;ఆగస్టు;సెప్టెంబర్;అక్టోబర్;నవంబర్;డిసెంబర్"),
+	mmm: _("జన;ఫిబ్ర;మార్చి;ఏప్రి;మే;జూన్;జులై;ఆగ;సెప్టెం;అక్టో;నవం;డిసెం"),
+	dddd: _("ఆదివారం;సోమవారం;మంగళవారం;బుధవారం;గురువారం;శుక్రవారం;శనివారం"),
+	ddd: _("ఆది;సోమ;మంగళ;బుధ;గురు;శుక్ర;శని")
+}, "te");
+addLocale({
+	decimal: ",",
+	mmmm: _("січня;лютого;березня;квітня;травня;червня;липня;серпня;вересня;жовтня;листопада;грудня"),
+	mmm: _("січ.;лют.;бер.;квіт.;трав.;черв.;лип.;серп.;вер.;жовт.;лист.;груд."),
+	dddd: _("неділю;понеділок;вівторок;середу;четвер;пʼятницю;суботу"),
+	ddd: _("нд;пн;вт;ср;чт;пт;сб"),
+	ampm: _("дп;пп")
+}, "uk");
+addLocale({
+	group: ".",
+	decimal: ",",
+	mmmm: _("~1;~2;~3;~4;~5;~6;~7;~8;~9;~10;~11;~12", "tháng "),
+	mmm: _("~1;~2;~3;~4;~5;~6;~7;~8;~9;~10;~11;~12", "thg "),
+	dddd: _("Chủ Nhật;Thứ Hai;Thứ Ba;Thứ Tư;Thứ Năm;Thứ Sáu;Thứ Bảy"),
+	ddd: _("CN;Th 2;Th 3;Th 4;Th 5;Th 6;Th 7"),
+	ampm: _("SA;CH")
+}, "vi");
+addLocale(xm({
+	group: "٬",
+	decimal: "٫",
+	ampm: _("ص;م"),
+	mmmm: _("يناير;فبراير;مارس;أبريل;مايو;يونيو;يوليو;أغسطس;سبتمبر;أكتوبر;نوفمبر;ديسمبر"),
+	dddd: _("الأحد;الاثنين;الثلاثاء;الأربعاء;الخميس;الجمعة;السبت"),
+	mmmm6: _("رمضان;شوال;ذو القعدة;ذو الحجة;محرم;ربيع الأول;ربيع الآخرة;جمادى الأولى;جمادى الآخرة;رجب;شعبان;رمضان")
+}, 0, 0), "ar");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("জানুয়ারী;ফেব্রুয়ারী;মার্চ;এপ্রিল;মে;জুন;জুলাই;আগস্ট;সেপ্টেম্বর;অক্টোবর;নভেম্বর;ডিসেম্বর"),
+	mmm: _("জানু;ফেব;মার্চ;এপ্রি;মে;জুন;জুল;আগ;সেপ্টেঃ;অক্টোঃ;নভেঃ;ডিসেঃ"),
+	dddd: _("রবিবার;সোমবার;মঙ্গলবার;বুধবার;বৃহস্পতিবার;শুক্রবার;শনিবার"),
+	ddd: _("রবি;সোম;মঙ্গল;বুধ;বৃহস্পতি;শুক্র;শনি")
+}, "bn");
+addLocale({
+	group: ",",
+	decimal: ".",
+	mmmm: _("जनवरी;फ़रवरी;मार्च;अप्रैल;मई;जून;जुलाई;अगस्त;सितंबर;अक्तूबर;नवंबर;दिसंबर"),
+	mmm: _("जन॰;फ़र॰;मार्च;अप्रैल;मई;जून;जुल॰;अग॰;सित॰;अक्तू॰;नव॰;दिस॰"),
+	dddd: _("रविवार;सोमवार;मंगलवार;बुधवार;गुरुवार;शुक्रवार;शनिवार"),
+	ddd: _("रवि;सोम;मंगल;बुध;गुरु;शुक्र;शनि"),
+	ampm: _("am;pm")
+}, "hi");
+
+//#endregion
+//#region src/shared/numfmt/parse-format-section.ts
+function getNumberPattern(part, prefix) {
+	switch (prefix) {
+		case "int": return part.int_pattern;
+		case "frac": return part.frac_pattern;
+		case "man": return part.man_pattern;
+		case "den": return part.den_pattern;
+		case "num": return part.num_pattern;
+	}
+}
+function minMaxPad(str, part, prefix) {
+	const max = str.length;
+	const min = str.replace(/#/g, "").length;
+	switch (prefix) {
+		case "int":
+			part.int_max = max;
+			part.int_min = min;
+			break;
+		case "frac":
+			part.frac_max = max;
+			part.frac_min = min;
+			break;
+		case "man":
+			part.man_max = max;
+			part.man_min = min;
+			break;
+		case "den":
+			part.den_max = max;
+			part.den_min = min;
+			break;
+		case "num":
+			part.num_max = max;
+			part.num_min = min;
+			break;
+	}
+	return part;
+}
+function add(token, tokens) {
+	if (typeof token === "string") tokens.push({
+		type: "string",
+		value: token
+	});
+	else tokens.push(token);
+}
+function isNumOp$1(token, activePattern) {
+	const type = token === null || token === void 0 ? void 0 : token.type;
+	return type === "hash" || type === "zero" || type === "qmark" || type === "digit" && activePattern === "den";
+}
+function assertNumberChunk(token) {
+	if (token === null) throw new TypeError("Cannot read properties of null (reading 'num')");
+}
+function parseFormatSection(inputTokens) {
+	const outputTokens = [];
+	const part = {
+		scale: 1,
+		scaleExponent: 0,
+		percent: false,
+		text: false,
+		date: 0,
+		date_eval: false,
+		date_system: 1,
+		sec_decimals: 0,
+		general: false,
+		clock: 24,
+		int_pattern: [],
+		frac_pattern: [],
+		man_pattern: [],
+		den_pattern: [],
+		num_pattern: [],
+		tokens: outputTokens,
+		tokensUsed: 0,
+		pattern: "",
+		int_max: 0,
+		int_min: 0,
+		frac_max: 0,
+		frac_min: 0,
+		man_max: 0,
+		man_min: 0,
+		num_max: 0,
+		num_min: 0,
+		den_max: 0,
+		den_min: 0,
+		int_p: "",
+		man_p: "",
+		num_p: "",
+		den_p: "",
+		integer: false
+	};
+	let currentPattern = "int";
+	let lastNumberChunk = null;
+	const dateChunks = [];
+	let last;
+	let haveLocale = false;
+	let index = -1;
+	let partOver = false;
+	let patternSource = "";
+	let haveSlash = false;
+	while (++index < inputTokens.length && !partOver) {
+		var _inputTokens;
+		const token = inputTokens[index];
+		const type = token.type || "error";
+		patternSource += token.raw;
+		if (type === "general") {
+			part.general = true;
+			add(token, outputTokens);
+		} else if (isNumOp$1(token, currentPattern)) {
+			const pattern = getNumberPattern(part, currentPattern);
+			if (isNumOp$1(last, currentPattern) || (last === null || last === void 0 ? void 0 : last.type) === "group") {
+				pattern.push((pattern.pop() || "") + token.value);
+				assertNumberChunk(lastNumberChunk);
+				lastNumberChunk.num += token.value;
+			} else {
+				pattern.push(token.value);
+				lastNumberChunk = {
+					type: currentPattern,
+					num: token.value
+				};
+				add(lastNumberChunk, outputTokens);
+			}
+		} else if (type === "paren") {
+			if (token.value === "(") part.parens = true;
+			add(token.value, outputTokens);
+		} else if (type === "digit") add(token.value, outputTokens);
+		else if (type === "slash") {
+			haveSlash = true;
+			const pattern = getNumberPattern(part, currentPattern);
+			if (pattern.length) {
+				if (!lastNumberChunk) throw new SyntaxError("Format pattern is missing a numerator");
+				part.fractions = true;
+				const numerator = pattern.pop();
+				if (numerator === void 0) throw new SyntaxError("Format pattern is missing a numerator");
+				part.num_pattern.push(numerator);
+				lastNumberChunk.type = "num";
+				currentPattern = "den";
+				add({ type: "div" }, outputTokens);
+			} else add(token.value, outputTokens);
+		} else if (type === "comma") add(",", outputTokens);
+		else if (type === "scale") {
+			part.scale = .001 ** token.raw.length;
+			part.scaleExponent = -3 * token.raw.length;
+		} else if (type === "group") {
+			if (currentPattern === "int") part.grouping = true;
+			if (currentPattern === "den") throw new SyntaxError("Cannot group denominator digits");
+		} else if (type === "space") add(token, outputTokens);
+		else if (type === "break") {
+			partOver = true;
+			break;
+		} else if (type === "text") {
+			part.text = true;
+			add(token, outputTokens);
+		} else if (type === "plus" || type === "minus") add(token, outputTokens);
+		else if (type === "duration") {
+			const tokenValue = token.value.toLowerCase();
+			const startsWith = tokenValue[0];
+			const bit = {
+				type: "",
+				size: 0,
+				date: 1,
+				pad: tokenValue.length
+			};
+			if (startsWith === "h") {
+				bit.size = 16;
+				bit.type = "hour-elap";
+			} else if (startsWith === "m") {
+				bit.size = 32;
+				bit.type = "min-elap";
+			} else {
+				bit.size = 64;
+				bit.type = "sec-elap";
+			}
+			part.date = part.date | bit.size;
+			dateChunks.push(bit);
+			add(bit, outputTokens);
+		} else if (part.date && type === "point" && ((_inputTokens = inputTokens[index + 1]) === null || _inputTokens === void 0 ? void 0 : _inputTokens.type) === "zero") {
+			var _inputTokens2, _inputTokens3;
+			let decimals = 1;
+			index++;
+			let raw = "0";
+			if (((_inputTokens2 = inputTokens[index + 1]) === null || _inputTokens2 === void 0 ? void 0 : _inputTokens2.type) === "zero") {
+				raw += "0";
+				decimals = 2;
+				index++;
+			}
+			if (((_inputTokens3 = inputTokens[index + 1]) === null || _inputTokens3 === void 0 ? void 0 : _inputTokens3.type) === "zero") {
+				raw += "0";
+				decimals = 3;
+				index++;
+			}
+			patternSource += raw;
+			const size = [
+				64,
+				128,
+				256,
+				512
+			][decimals];
+			part.date = part.date | size;
+			part.date_eval = true;
+			part.sec_decimals = Math.max(part.sec_decimals, decimals);
+			add({
+				type: "subsec",
+				size,
+				decimals,
+				date: 1
+			}, outputTokens);
+		} else if (type === "calendar") {
+			if (!haveLocale) if (token.value === "B2" || token.value === "b2") part.date_system = 6;
+			else part.date_system = 1;
+		} else if (type === "datetime") {
+			const bit = {
+				type: "",
+				size: 0,
+				date: 1
+			};
+			const value = token.value.toLowerCase();
+			const startsWith = value[0];
+			if (value === "y" || value === "yy") {
+				bit.size = 2;
+				bit.type = "year-short";
+			} else if (startsWith === "y" || startsWith === "e") {
+				bit.size = 2;
+				bit.type = "year";
+			} else if (value === "b" || value === "bb") {
+				bit.size = 2;
+				bit.type = "b-year-short";
+			} else if (startsWith === "b") {
+				bit.size = 2;
+				bit.type = "b-year";
+			} else if (value === "d" || value === "dd") {
+				bit.size = 8;
+				bit.type = "day";
+				bit.pad = /dd/.test(value);
+			} else if (value === "ddd" || value === "aaa") {
+				bit.size = 8;
+				bit.type = "weekday-short";
+			} else if (startsWith === "d" || startsWith === "a") {
+				bit.size = 8;
+				bit.type = "weekday";
+			} else if (startsWith === "h") {
+				bit.size = 16;
+				bit.type = "hour";
+				bit.pad = /hh/i.test(value);
+			} else if (startsWith === "m") {
+				if (value.length === 3) {
+					bit.size = 4;
+					bit.type = "monthname-short";
+				} else if (value.length === 5) {
+					bit.size = 4;
+					bit.type = "monthname-single";
+				} else if (value.length >= 4) {
+					bit.size = 4;
+					bit.type = "monthname";
+				}
+				const lastDateChunk = dateChunks[dateChunks.length - 1];
+				if (!bit.type && lastDateChunk && !lastDateChunk.used && lastDateChunk.size & (16 | 64)) {
+					lastDateChunk.used = true;
+					bit.size = 32;
+					bit.type = "min";
+					bit.pad = /mm/.test(value);
+				}
+				if (!bit.type) {
+					bit.size = 4;
+					bit.type = "month";
+					bit.pad = /mm/.test(value);
+					bit.indeterminate = true;
+				}
+			} else if (startsWith === "s") {
+				bit.size = 64;
+				bit.type = "sec";
+				bit.pad = /ss/.test(value);
+				const lastDateChunk = dateChunks[dateChunks.length - 1];
+				if (lastDateChunk && lastDateChunk.size & 32) bit.used = true;
+				else if (lastDateChunk === null || lastDateChunk === void 0 ? void 0 : lastDateChunk.indeterminate) {
+					delete lastDateChunk.indeterminate;
+					lastDateChunk.size = 32;
+					lastDateChunk.type = "min";
+					bit.used = true;
+				}
+			} else if (startsWith === "g") {}
+			part.date = part.date | bit.size;
+			part.date_eval = true;
+			dateChunks.push(bit);
+			add(bit, outputTokens);
+		} else if (type === "ampm") {
+			part.clock = 12;
+			part.date = part.date | 16;
+			part.date_eval = true;
+			token.short = token.value === "A/P";
+			add(token, outputTokens);
+		} else if (type === "string" || type === "escaped" || type === "char") add(token.value, outputTokens);
+		else if (type === "condition") part.condition = [token.value[0], Number.parseFloat(token.value[1])];
+		else if (type === "locale") {
+			const bits = token.value.split("-");
+			const code = bits.length < 2 ? "" : bits.slice(1).join("-");
+			const currency = bits[0];
+			if (currency) add(currency, outputTokens);
+			const locale = resolveLocale(code);
+			if (locale) part.locale = locale;
+			const windowsCode = Number.parseInt(code, 16);
+			if (Number.isFinite(windowsCode) && windowsCode & 16711680) {
+				if ((windowsCode >> 16 & 255) === 6) part.date_system = 6;
+			}
+			haveLocale = true;
+		} else if (type === "color") {
+			const normalizedColor = token.value.toLowerCase();
+			let color = normalizedColor;
+			const colorMatch = /^color\s*(\d+)$/i.exec(normalizedColor);
+			if (colorMatch) color = Number.parseInt(colorMatch[1], 10);
+			part.color = color;
+		} else if (type === "percent") {
+			part.scale = 100;
+			part.scaleExponent = 2;
+			part.percent = true;
+			add("%", outputTokens);
+		} else if (type === "point") {
+			add(token, outputTokens);
+			if (!part.date) {
+				part.dec_fractions = true;
+				currentPattern = "frac";
+			}
+		} else if (type === "exp") {
+			part.exponential = true;
+			part.exp_plus = token.value.includes("+");
+			currentPattern = "man";
+			add({
+				type: "exp",
+				plus: part.exp_plus
+			}, outputTokens);
+		} else if (type === "skip" || type === "fill") add(token, outputTokens);
+		else if (type === "dbnum" || type === "natnum") {} else if (type === "error") throw new SyntaxError(`Illegal character: ${patternSource}`);
+		else throw new SyntaxError(`Unknown token ${type} in ${patternSource}`);
+		last = token;
+	}
+	part.tokensUsed = index;
+	part.pattern = patternSource;
+	if (/^((?:\[[^\]]+\])+)(;|$)/.test(part.pattern) && !/^\[(?:h+|m+|s+)\]/.test(part.pattern)) add({ type: "text" }, outputTokens);
+	if (part.fractions && part.dec_fractions || part.grouping && !part.int_pattern.length || part.fractions && part.exponential || part.fractions && part.den_pattern.length * part.num_pattern.length === 0 || haveSlash && !part.fractions && !part.date || part.exponential && (part.int_pattern.length || part.frac_pattern.length) * part.man_pattern.length === 0) throw new SyntaxError(`Invalid pattern: ${patternSource}`);
+	const intPattern = part.int_pattern.join("");
+	const manPattern = part.man_pattern.join("");
+	const fracPattern = part.frac_pattern.join("");
+	minMaxPad(intPattern, part, "int");
+	let min = 0;
+	for (let patternIndex = 0; patternIndex < intPattern.length; patternIndex++) {
+		const character = intPattern[intPattern.length - 1 - patternIndex];
+		if (/^[0-9?]/.test(character)) min = patternIndex + 1;
+	}
+	part.int_min = min;
+	minMaxPad(fracPattern, part, "frac");
+	minMaxPad(manPattern, part, "man");
+	let numeratorPattern = part.num_pattern.join("");
+	let denominatorPattern = part.den_pattern[0] || "";
+	if (denominatorPattern.includes("?") || numeratorPattern.includes("?")) {
+		denominatorPattern = denominatorPattern.replace(/\d/g, "?");
+		denominatorPattern = denominatorPattern.replace(/#$/g, "?");
+		minMaxPad(numeratorPattern, part, "num");
+		minMaxPad(denominatorPattern, part, "den");
+		numeratorPattern = numeratorPattern.replace(/#$/g, "?");
+	} else {
+		minMaxPad(numeratorPattern, part, "num");
+		minMaxPad(denominatorPattern, part, "den");
+	}
+	part.int_p = intPattern;
+	part.man_p = manPattern;
+	part.num_p = numeratorPattern;
+	part.den_p = denominatorPattern;
+	if (part.den_pattern.length) part.denominator = Number.parseInt(part.den_pattern.join("").replace(/\D/g, ""), 10);
+	part.integer = !!intPattern.length;
+	if (!part.integer && !part.exponential && fracPattern.length) {
+		const pointIndex = part.tokens.findIndex((token) => token.type === "point");
+		part.tokens.splice(pointIndex, 0, {
+			type: "int",
+			value: "#"
+		});
+		part.integer = true;
+		part.int_pattern = ["#"];
+		part.int_p = "#";
+	}
+	if (part.fractions) for (let tokenIndex = 0; tokenIndex < outputTokens.length - 1; tokenIndex++) {
+		const token = outputTokens[tokenIndex];
+		if (token.type !== "string" && token.type !== "space") continue;
+		const nextType = outputTokens[tokenIndex + 1].type;
+		if (nextType === "num") token.rule = "num+int";
+		else if (nextType === "div") token.rule = "num";
+		else if (nextType === "den") token.rule = "den";
+	}
+	if (part.grouping && part.int_pattern.length > 1) part.grouping = false;
+	return part;
+}
+
+//#endregion
+//#region src/shared/numfmt/clamp.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+function clamp(number) {
+	if (number === 0) return number;
+	const d = Math.ceil(Math.log10(number < 0 ? -number : number));
+	const mag = 10 ** (16 - Math.floor(d));
+	return isFinite(mag) ? Math.round(number * mag) / mag : 0;
+}
+
+//#endregion
+//#region src/shared/numfmt/dec-to-frac.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+const PRECISION = 1e-13;
+/**
+* Split a fractional number into a numerator and denominator for display as
+* vulgar fractions.
+*
+* @ignore
+* @param {number} number The value to split
+* @param {number} [numeratorMaxDigits] The maxdigits number
+* @param {number} [denominatorMaxDigits] The maxdigits de
+* @returns {Array<number>} Array of two numbers, numerator and denominator.
+*/
+function dec2frac(number, numeratorMaxDigits = 2, denominatorMaxDigits = 2) {
+	const sign = number < 0 ? -1 : 1;
+	const maxdigits_n = 10 ** (numeratorMaxDigits || 2);
+	const maxdigits_d = 10 ** (denominatorMaxDigits || 2);
+	let z = Math.abs(number);
+	let last_d = 0;
+	let last_n = 0;
+	let curr_n = 0;
+	let curr_d = 1;
+	let tmp;
+	let r;
+	number = z;
+	if (number % 1 === 0) r = [number * sign, 1];
+	else if (number < 1e-19) r = [sign, 0x8ac7230489e80000];
+	else if (number > 0x8ac7230489e80000) r = [0x8ac7230489e80000 * sign, 1];
+	else {
+		do {
+			z = 1 / (z - Math.floor(z));
+			tmp = curr_d;
+			curr_d = curr_d * Math.floor(z) + last_d;
+			last_d = tmp;
+			last_n = curr_n;
+			curr_n = Math.floor(number * curr_d + .5);
+			if (curr_n >= maxdigits_n || curr_d >= maxdigits_d) return [sign * last_n, last_d];
+		} while (Math.abs(number - curr_n / curr_d) >= PRECISION && z !== Math.floor(z));
+		r = [sign * curr_n, curr_d];
+	}
+	return r;
+}
+
+//#endregion
+//#region src/shared/numfmt/num-dec.ts
+const ZERO_DIGITS = {
+	total: 1,
+	sign: 0,
+	period: 0,
+	int: 1,
+	frac: 0
+};
+function numDec(value, includeSign = true) {
+	const decimal = decimalFromNumber(value);
+	if (decimal.digits === "0") return ZERO_DIGITS;
+	const decimalPoint = decimal.exponent + 1;
+	const intSize = Math.max(decimalPoint, 1);
+	const fracSize = Math.max(0, decimal.digits.length - decimalPoint);
+	const signSize = includeSign && decimal.negative ? 1 : 0;
+	const periodSize = fracSize > 0 ? 1 : 0;
+	return {
+		total: signSize + intSize + periodSize + fracSize,
+		digits: Math.max(decimalPoint, 0) + fracSize,
+		sign: signSize,
+		period: periodSize,
+		int: intSize,
+		frac: fracSize
+	};
+}
+
+//#endregion
+//#region src/shared/numfmt/number-props.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+function getExponent(number, intMax = 0) {
+	const exponent = Math.floor(Math.log10(number));
+	return intMax > 1 ? Math.floor(exponent / intMax) * intMax : exponent;
+}
+function getSignificand(number, exponent = 1) {
+	if (exponent < -300) return Number.parseFloat(number.toExponential().split("e")[0]);
+	return number * 10 ** -exponent;
+}
+
+//#endregion
+//#region src/shared/numfmt/round.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+function legacyRound$1(number, places = 0) {
+	if (number < 0) return -legacyRound$1(-number, places);
+	if (places) {
+		const power = 10 ** places || 1;
+		return legacyRound$1(number * power, 0) / power;
+	}
+	return Math.round(number);
+}
+function round(number, places = 0) {
+	if (typeof number !== "number") return number;
+	if (!Number.isFinite(number) || number === 0) return number === 0 ? 0 : number;
+	if (!Number.isFinite(places)) return legacyRound$1(number, places);
+	const normalizedPlaces = Math.trunc(places);
+	if (Number.isInteger(number) && normalizedPlaces >= 0 || normalizedPlaces > 324) return number;
+	const rounded = decimalPartsToNumber(roundDecimal(decimalFromNumber(number), normalizedPlaces));
+	return Number.isFinite(rounded) ? rounded : number;
+}
+
+//#endregion
+//#region src/shared/numfmt/general.ts
+function fixLocale(value, locale) {
+	return value.replace(/\./, locale.decimal);
+}
+function getAbsoluteDecimal(value) {
+	if (!value) return null;
+	return value.negative ? {
+		...value,
+		negative: false
+	} : value;
+}
+function getDecimalExponent(value) {
+	var _value$exponent;
+	return (_value$exponent = value === null || value === void 0 ? void 0 : value.exponent) !== null && _value$exponent !== void 0 ? _value$exponent : 0;
+}
+function usesShortestSignificand(value) {
+	return !value || value.exponent < -308;
+}
+function getExp(value, locale) {
+	const scientific = roundScientificDecimal(value, 1, true, 5);
+	const exponent = scientific.exponent;
+	const absoluteExponent = Math.abs(exponent);
+	return [
+		fixLocale(decimalPartsToPlainString(scientific.rounded), locale),
+		locale.exponent,
+		exponent < 0 ? locale.negative : locale.positive,
+		absoluteExponent < 10 ? "0" : "",
+		absoluteExponent
+	];
+}
+function getShortestExp(number, exponent, locale) {
+	const absoluteExponent = Math.abs(exponent);
+	const mantissa = number === 1 ? number : Math.round(number * 1e5) / 1e5;
+	return [
+		fixLocale(String(mantissa), locale),
+		locale.exponent,
+		exponent < 0 ? locale.negative : locale.positive,
+		absoluteExponent < 10 ? "0" : "",
+		absoluteExponent
+	];
+}
+function general(output, part, value, locale, decimalValue = null) {
+	const integer = typeof value === "number" ? value | 0 : 0;
+	if (typeof value === "string") output.push(value);
+	else if (value === integer) output.push(Math.abs(integer));
+	else {
+		const absoluteValue = Math.abs(value);
+		const absoluteDecimal = getAbsoluteDecimal(decimalValue);
+		let exponent = getDecimalExponent(absoluteDecimal);
+		let shortestSignificand = null;
+		if (usesShortestSignificand(absoluteDecimal)) {
+			exponent = getExponent(absoluteValue);
+			shortestSignificand = getSignificand(absoluteValue, exponent);
+			if (shortestSignificand === 10) {
+				shortestSignificand = 1;
+				exponent++;
+			}
+		}
+		const digits = numDec(absoluteValue);
+		if (exponent >= -4 && exponent <= -1) {
+			const formatted = absoluteValue.toPrecision(10 + exponent).replace(/\.?0+$/, "");
+			output.push(fixLocale(formatted, locale));
+		} else if (exponent === 10) {
+			const formatted = absoluteValue.toFixed(10).slice(0, 12).replace(/\.$/, "");
+			output.push(fixLocale(formatted, locale));
+		} else if (Math.abs(exponent) <= 9) if (digits.total <= 11) {
+			const formatted = round(absoluteValue, 9).toFixed(digits.frac);
+			output.push(fixLocale(formatted, locale));
+		} else if (exponent === 9) output.push(Math.floor(absoluteValue));
+		else if (exponent >= 0 && exponent < 9) output.push(fixLocale(String(round(absoluteValue, 9 - exponent)), locale));
+		else output.push(...shortestSignificand === null ? getExp(absoluteDecimal, locale) : getShortestExp(shortestSignificand, exponent, locale));
+		else if (digits.total >= 12) output.push(...shortestSignificand === null ? getExp(absoluteDecimal, locale) : getShortestExp(shortestSignificand, exponent, locale));
+		else output.push(fixLocale(round(absoluteValue, 9).toFixed(digits.frac), locale));
+	}
+	return output;
+}
+
+//#endregion
+//#region src/shared/numfmt/pad.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/**
+* @ignore
+* @param {string} char Instruction character (['#', '?', '0'])
+* @param {boolean} [nbsp] Use nonbreaking space or not?
+* @returns {string} Padding character
+*/
+function pad$1(char, nbsp = false) {
+	if (char === "0") return "0";
+	else if (char === "?") return nbsp ? "\xA0" : " ";
+	return "";
+}
+
+//#endregion
+//#region src/shared/numfmt/to-ymd.ts
+const floor$1 = Math.floor;
+function toYMD1900(serial, leap1900 = true) {
+	if (leap1900 && serial >= 0) {
+		if (serial === 0) return [
+			1900,
+			1,
+			0
+		];
+		if (serial === 60) return [
+			1900,
+			2,
+			29
+		];
+		if (serial < 60) return [
+			1900,
+			serial < 32 ? 1 : 2,
+			(serial - 1) % 31 + 1
+		];
+	}
+	let l = serial + 68569 + 2415019;
+	const n = floor$1(4 * l / 146097);
+	l -= floor$1((146097 * n + 3) / 4);
+	const i = floor$1(4e3 * (l + 1) / 1461001);
+	l = l - floor$1(1461 * i / 4) + 31;
+	const j = floor$1(80 * l / 2447);
+	const nDay = l - floor$1(2447 * j / 80);
+	l = floor$1(j / 11);
+	const nMonth = j + 2 - 12 * l;
+	return [
+		100 * (n - 49) + i + l | 0,
+		nMonth | 0,
+		nDay | 0
+	];
+}
+function toYMD1904(serial) {
+	return toYMD1900(serial + 1462);
+}
+function toYMD1317(serial) {
+	if (serial === 60) throw new Error("#VALUE!");
+	if (serial <= 1) return [
+		1317,
+		8,
+		29
+	];
+	if (serial < 60) return [
+		1317,
+		serial < 32 ? 9 : 10,
+		1 + (serial - 2) % 30
+	];
+	const y = 10631 / 30;
+	const shift1 = 8.01 / 60;
+	let z = serial + 466935;
+	const cyc = floor$1(z / 10631);
+	z -= 10631 * cyc;
+	const j = floor$1((z - shift1) / y);
+	z -= floor$1(j * y + shift1);
+	const m = floor$1((z + 28.5001) / 29.5);
+	if (m === 13) return [
+		30 * cyc + j,
+		12,
+		30
+	];
+	return [
+		30 * cyc + j,
+		m,
+		z - floor$1(29.5001 * m - 29)
+	];
+}
+function toYMD(serial, system = 0, leap1900 = true) {
+	const int = floor$1(serial);
+	if (system === 6) return toYMD1317(int);
+	if (system === -1) return toYMD1904(int);
+	return toYMD1900(int, leap1900);
+}
+
+//#endregion
+//#region src/shared/numfmt/run-part.ts
+const DAYSIZE$1 = 86400;
+function dateOverflows(inputValue, roundedValue, bigRange) {
+	if (bigRange) return inputValue < -694324 || roundedValue >= 35830291;
+	return inputValue < 0 || roundedValue >= 2958466;
+}
+function legacyRound(number, places = 0) {
+	if (number < 0) return -legacyRound(-number, places);
+	if (places) {
+		const power = 10 ** places || 1;
+		return legacyRound(number * power, 0) / power;
+	}
+	return Math.round(number);
+}
+function runPart(value, part, options, locale, decimalValue = null) {
+	var _options$grouping$, _options$grouping$2;
+	const section = part;
+	let renderValue = value;
+	let numericValue = value;
+	let mantissa = "";
+	let mantissaSign = "";
+	let numerator = "";
+	let denominator = "";
+	let fraction = "";
+	let integer = "";
+	let exponent = 0;
+	let roundedNumber = null;
+	let date = 0;
+	if (typeof renderValue === "bigint") {
+		if (renderValue <= Number.MAX_SAFE_INTEGER && renderValue >= Number.MIN_SAFE_INTEGER) {
+			numericValue = Number(renderValue);
+			renderValue = numericValue;
+		} else return options.bigintErrorNumber ? String(renderValue) : options.overflow;
+		date = numericValue;
+	} else date = Math.trunc(numericValue);
+	let time = 0;
+	let year = 0;
+	let month = 1;
+	let day = 0;
+	let weekday = 0;
+	let hour = 0;
+	let minute = 0;
+	let second = 0;
+	let subsec = 0;
+	const l10n = locale || defaultLocale;
+	let decimal = decimalValue;
+	if (!decimal && typeof value === "number" && Number.isFinite(value)) decimal = decimalFromNumber(value);
+	if (decimal && !section.text && section.scaleExponent) decimal = shiftDecimal(decimal, section.scaleExponent);
+	if (!section.text && Number.isFinite(section.scale) && section.scale !== 1) {
+		numericValue = clamp(numericValue * section.scale);
+		renderValue = numericValue;
+	}
+	if (section.exponential && decimal && decimal.exponent >= -308) {
+		const scientific = roundScientificDecimal(decimal, section.int_max, Boolean(section.integer), section.frac_max);
+		exponent = scientific.exponent;
+		roundedNumber = scientific.rounded;
+		mantissa += Math.abs(exponent);
+	} else if (section.exponential) {
+		let significand = Math.abs(numericValue);
+		if (significand) exponent = getExponent(significand, section.int_max);
+		if (numericValue && !section.integer) exponent++;
+		significand = getSignificand(significand, exponent);
+		if (section.int_max === 1 && legacyRound(significand, section.frac_max) === 10) {
+			significand = 1;
+			exponent++;
+		}
+		numericValue = numericValue < 0 ? -significand : significand;
+		renderValue = numericValue;
+		mantissa += Math.abs(exponent);
+	}
+	const requiresDecimalRounding = !Number.isSafeInteger(numericValue) || Boolean(section.scaleExponent);
+	roundedNumber = roundedNumber || (decimal && requiresDecimalRounding && !section.date && !section.fractions && !section.exponential && (section.integer || section.dec_fractions) ? roundDecimal(decimal, section.frac_max) : null);
+	if (section.integer) if (roundedNumber) integer = roundedNumber.integer === "0" ? "" : roundedNumber.integer;
+	else {
+		const places = section.fractions ? 1 : section.frac_max;
+		const roundedInteger = Math.abs(Number.isSafeInteger(numericValue) && places === 0 ? numericValue : legacyRound(numericValue, places));
+		integer += roundedInteger < 1 ? "" : Math.floor(roundedInteger);
+	}
+	const primaryGroup = (_options$grouping$ = options.grouping[0]) !== null && _options$grouping$ !== void 0 ? _options$grouping$ : 3;
+	const secondaryGroup = (_options$grouping$2 = options.grouping[1]) !== null && _options$grouping$2 !== void 0 ? _options$grouping$2 : primaryGroup;
+	if (section.dec_fractions) fraction = roundedNumber ? roundedNumber.fraction : String(legacyRound(numericValue, section.frac_max)).split(".")[1] || "";
+	const fixedSlash = !section.error && (section.num_p.includes("0") || section.den_p.includes("0"));
+	let haveFraction = fixedSlash;
+	if (section.fractions) {
+		haveFraction = fixedSlash || !!(numericValue % 1);
+		const decimal = Math.abs(section.integer ? numericValue % 1 : numericValue);
+		if (decimal) {
+			haveFraction = true;
+			if (section.denominator && Number.isFinite(section.denominator)) {
+				denominator += section.denominator;
+				numerator += legacyRound(decimal * section.denominator);
+				if (numerator === "0") {
+					numerator = "";
+					denominator = "";
+					haveFraction = fixedSlash;
+				}
+			} else {
+				const fractionParts = dec2frac(decimal, Infinity, section.den_max);
+				numerator += fractionParts[0];
+				denominator += fractionParts[1];
+				if (section.integer && numerator === "0") {
+					numerator = "";
+					denominator = "";
+					haveFraction = fixedSlash;
+				}
+			}
+		} else if (!numericValue && !section.integer) {
+			haveFraction = true;
+			numerator = "0";
+			denominator = "1";
+		}
+		if (section.integer && !haveFraction && !Math.trunc(numericValue)) integer = "0";
+	}
+	if (section.date) {
+		date = Math.trunc(numericValue);
+		const rawTime = DAYSIZE$1 * (numericValue - date);
+		time = Math.floor(rawTime);
+		subsec = rawTime - time;
+		if (Math.abs(subsec) < 1e-6) subsec = 0;
+		else if (subsec > .9999) {
+			subsec = 0;
+			time += 1;
+			if (time === DAYSIZE$1) {
+				time = 0;
+				date += 1;
+			}
+		}
+		if (subsec) {
+			const minimumUnit = section.date & 512 || section.date & 256 || section.date & 128;
+			if (minimumUnit === 512 && subsec > .9995 || minimumUnit === 256 && subsec > .995 || minimumUnit === 128 && subsec > .95 || !minimumUnit && subsec >= .5) {
+				time++;
+				subsec = 0;
+			}
+		}
+		if (date || section.date_system) {
+			const dateOutput = toYMD(numericValue, section.date_system, options.leap1900);
+			year = dateOutput[0];
+			month = dateOutput[1];
+			day = dateOutput[2];
+		}
+		if (time) {
+			const normalizedTime = time < 0 ? DAYSIZE$1 + time : time;
+			second = Math.floor(normalizedTime) % 60;
+			minute = Math.floor(normalizedTime / 60) % 60;
+			hour = Math.floor(normalizedTime / 60 / 60) % 60;
+		}
+		weekday = (6 + date) % 7;
+		if (section.date_eval && dateOverflows(numericValue, date + time / DAYSIZE$1, options.dateSpanLarge)) {
+			if (options.dateErrorThrows) throw new Error("Date out of bounds");
+			if (options.dateErrorNumber) return general(numericValue < 0 ? [l10n.negative] : [], {}, numericValue, l10n, decimal).join("");
+			return options.overflow;
+		}
+	}
+	const questionPadding = pad$1("?", options.nbsp);
+	if (exponent < 0) mantissaSign = "-";
+	else if (section.exp_plus) mantissaSign = "+";
+	const output = [];
+	const digitsStart = (numberString, pattern, tokenPattern, offset) => {
+		let normalizedOffset = offset;
+		const length = !normalizedOffset && numberString.length > pattern.length ? tokenPattern.length + numberString.length - pattern.length : tokenPattern.length;
+		if (numberString.length < pattern.length) normalizedOffset += numberString.length - pattern.length;
+		for (let index = 0; index < length; index++) output.push(numberString[index + normalizedOffset] || pad$1(tokenPattern[index], options.nbsp));
+		return length;
+	};
+	let denominatorFixed = false;
+	const counter = {
+		int: 0,
+		frac: 0,
+		man: 0,
+		num: 0,
+		den: 0
+	};
+	for (let tokenIndex = 0, tokenLength = section.tokens.length; tokenIndex < tokenLength; tokenIndex++) {
+		const token = section.tokens[tokenIndex];
+		const tokenType = token.type;
+		const length = token.num ? token.num.length : 0;
+		if (tokenType === "string") {
+			const tokenValue = token.value;
+			if (token.rule) {
+				if (token.rule === "num") {
+					if (haveFraction) output.push(tokenValue.replace(/ /g, questionPadding));
+					else if (section.num_min > 0 || section.den_min > 0) output.push(tokenValue.replace(/./g, questionPadding));
+				} else if (token.rule === "num+int") {
+					if (haveFraction && integer) output.push(tokenValue.replace(/ /g, questionPadding));
+					else if (section.den_min > 0 && (integer || section.num_min)) output.push(tokenValue.replace(/./g, questionPadding));
+				} else if (token.rule === "den") {
+					if (haveFraction) output.push(tokenValue.replace(/ /g, questionPadding));
+					else if (section.den_min > 0) output.push(tokenValue.replace(/./g, questionPadding));
+				}
+			} else output.push(tokenValue.replace(/ /g, questionPadding));
+		} else if (tokenType === "space") if (token.rule === "num+int") {
+			if ((haveFraction || section.num_min || section.den_min) && (integer || section.num_min)) output.push(questionPadding);
+		} else output.push(questionPadding);
+		else if (tokenType === "error") output.push(options.invalid);
+		else if (tokenType === "point") output.push(section.date ? token.value : l10n.decimal);
+		else if (tokenType === "general") general(output, section, renderValue, l10n, decimal);
+		else if (tokenType === "exp") output.push(l10n.exponent);
+		else if (tokenType === "minus") if (token.volatile && section.date) {} else if (token.volatile && roundedNumber) {
+			if (roundedNumber.negative && !roundedNumber.zero) output.push(l10n.negative);
+		} else if (token.volatile && (numericValue >= 0 || typeof renderValue !== "number")) {} else if (token.volatile && !section.fractions && (section.integer || section.dec_fractions)) {
+			if (numericValue < 0 && !!integer && integer !== "0" || fraction) output.push(l10n.negative);
+		} else output.push(l10n.negative);
+		else if (tokenType === "plus") output.push(l10n.positive);
+		else if (tokenType === "text") output.push(renderValue);
+		else if (tokenType === "fill") {
+			if (options.fillChar) output.push(options.fillChar, token.value);
+		} else if (tokenType === "skip") if (options.skipChar) output.push(options.skipChar, token.value);
+		else output.push(options.nbsp ? "\xA0" : " ");
+		else if (tokenType === "div") if (haveFraction) output.push("/");
+		else if (section.num_min > 0 || section.den_min > 0) output.push(questionPadding);
+		else output.push(pad$1("#", options.nbsp));
+		else if (tokenType === "int") if (section.int_pattern.length === 1) {
+			const pattern = section.int_p;
+			const length = Math.max(section.int_min, integer.length);
+			let digits = "";
+			for (let index = length; index > 0; index--) {
+				const digit = integer.charAt(integer.length - index);
+				const patternDigit = digit ? "" : pattern.charAt(pattern.length - index) || pattern[0];
+				let separator = "";
+				if (section.grouping) {
+					const groupIndex = index - 1 - primaryGroup;
+					if (groupIndex >= 0 && !(groupIndex % secondaryGroup)) separator = digit || patternDigit === "0" ? l10n.group : pad$1("?", options.nbsp);
+				}
+				digits += (digit || pad$1(patternDigit, options.nbsp)) + separator;
+			}
+			output.push(digits);
+		} else counter.int += digitsStart(integer, section.int_p, token.num, counter.int);
+		else if (tokenType === "frac") {
+			const offset = counter.frac;
+			for (let index = 0; index < length; index++) output.push(fraction[index + offset] || pad$1(token.num[index], options.nbsp));
+			counter.frac += length;
+		} else if (tokenType === "man") {
+			if (!counter[tokenType] && !counter.man) output.push(mantissaSign);
+			counter.man += digitsStart(mantissa, section.man_p, token.num, counter.man);
+		} else if (tokenType === "num") counter.num += digitsStart(numerator, section.num_p, token.num, counter.num);
+		else if (tokenType === "den") {
+			const offset = counter.den;
+			for (let index = 0; index < length; index++) {
+				let digit = denominator[index + offset];
+				if (!digit) {
+					const char = token.num[index];
+					if ("123456789".includes(char) || denominatorFixed && char === "0") {
+						denominatorFixed = true;
+						digit = options.nbsp ? "\xA0" : " ";
+					} else if (!denominatorFixed && index === length - 1 && char === "0" && !denominator) digit = "1";
+					else digit = pad$1(char, options.nbsp);
+				}
+				output.push(digit);
+			}
+			counter.den += length;
+		} else if (tokenType === "year") {
+			if (year < 0) output.push(l10n.negative);
+			output.push(String(Math.abs(year)).padStart(4, "0"));
+		} else if (tokenType === "year-short") {
+			const shortYear = year % 100;
+			output.push(shortYear < 10 ? "0" : "", shortYear);
+		} else if (tokenType === "month") output.push(token.pad && month < 10 ? "0" : "", month);
+		else if (tokenType === "monthname-single") if (section.date_system === 6) output.push(l10n.mmmm6[month - 1].charAt(0));
+		else output.push(l10n.mmmm[month - 1].charAt(0));
+		else if (tokenType === "monthname-short") if (section.date_system === 6) output.push(l10n.mmm6[month - 1]);
+		else output.push(l10n.mmm[month - 1]);
+		else if (tokenType === "monthname") if (section.date_system === 6) output.push(l10n.mmmm6[month - 1]);
+		else output.push(l10n.mmmm[month - 1]);
+		else if (token.type === "weekday-short") output.push(l10n.ddd[weekday]);
+		else if (tokenType === "weekday") output.push(l10n.dddd[weekday]);
+		else if (tokenType === "day") output.push(token.pad && day < 10 ? "0" : "", day);
+		else if (tokenType === "hour") {
+			const displayHour = hour % section.clock || (section.clock < 24 ? section.clock : 0);
+			output.push(token.pad && displayHour < 10 ? "0" : "", displayHour);
+		} else if (tokenType === "min") output.push(token.pad && minute < 10 ? "0" : "", minute);
+		else if (tokenType === "sec") output.push(token.pad && second < 10 ? "0" : "", second);
+		else if (tokenType === "subsec") {
+			output.push(l10n.decimal);
+			const formattedSubseconds = subsec.toFixed(section.sec_decimals);
+			output.push(formattedSubseconds.slice(2, 2 + token.decimals));
+		} else if (tokenType === "ampm") {
+			const index = hour < 12 ? 0 : 1;
+			if (token.short && !locale) output.push("AP"[index]);
+			else output.push(l10n.ampm[index]);
+		} else if (tokenType === "hour-elap") {
+			if (numericValue < 0) output.push(l10n.negative);
+			const elapsedHours = date * 24 + Math.floor(Math.abs(time) / 3600);
+			output.push(String(Math.abs(elapsedHours)).padStart(token.pad, "0"));
+		} else if (tokenType === "min-elap") {
+			if (numericValue < 0) output.push(l10n.negative);
+			const elapsedMinutes = date * 1440 + Math.floor(Math.abs(time) / 60);
+			output.push(String(Math.abs(elapsedMinutes)).padStart(token.pad, "0"));
+		} else if (tokenType === "sec-elap") {
+			if (numericValue < 0) output.push(l10n.negative);
+			const elapsedSeconds = date * DAYSIZE$1 + Math.abs(time);
+			output.push(String(Math.abs(elapsedSeconds)).padStart(token.pad, "0"));
+		} else if (tokenType === "b-year") output.push(year + 543);
+		else if (tokenType === "b-year-short") {
+			const shortYear = (year + 543) % 100;
+			output.push(shortYear < 10 ? "0" : "", shortYear);
+		}
+	}
+	return output.join("");
+}
+
+//#endregion
+//#region src/shared/numfmt/format-number.ts
+const defaultText = parseFormatSection([{
+	type: TOKEN_TEXT,
+	value: "@",
+	raw: "@"
+}]);
+function isParsedSection(part) {
+	return !!part && "scale" in part;
+}
+function getPart(value, parts) {
+	for (let partIndex = 0; partIndex < 3; partIndex++) {
+		const part = parts[partIndex];
+		if (isParsedSection(part)) {
+			let condition;
+			if (part.condition) {
+				const operator = part.condition[0];
+				const operand = part.condition[1];
+				if (operator === "=") condition = value === operand;
+				else if (operator === ">") condition = value > operand;
+				else if (operator === "<") condition = value < operand;
+				else if (operator === ">=") condition = value >= operand;
+				else if (operator === "<=") condition = value <= operand;
+				else if (operator === "<>") condition = value !== operand;
+			} else condition = true;
+			if (condition) return part;
+		} else if (part) return part;
+	}
+}
+function formatColor$1(value, pattern, options) {
+	const parts = pattern.partitions;
+	let part = parts[3];
+	let color = null;
+	if ((typeof value === "number" || typeof value === "bigint") && isFinite(value)) part = getPart(value, parts);
+	if (isParsedSection(part) && part.color) color = part.color;
+	if (color && typeof color === "number" && options.indexColors) color = indexColors[color - 1] || "#000";
+	return color;
+}
+function formatValue(value, pattern, options) {
+	const parts = pattern.partitions;
+	const locale = getLocale(pattern.locale || options.locale);
+	let renderValue = value;
+	const textPart = parts[3] ? parts[3] : defaultText;
+	if (typeof renderValue === "boolean") renderValue = (locale || defaultLocale).bool[renderValue ? 0 : 1];
+	if (renderValue == null) return "";
+	const isBigInt = typeof renderValue === "bigint";
+	if (typeof renderValue !== "number" && !isBigInt) return runPart(renderValue, textPart, options, locale);
+	if (!isBigInt && !Number.isFinite(renderValue)) {
+		const resolvedLocale = locale || defaultLocale;
+		if (Number.isNaN(renderValue)) return resolvedLocale.nan;
+		return (renderValue < 0 ? resolvedLocale.negative : "") + resolvedLocale.infinity;
+	}
+	const part = getPart(value, parts);
+	const decimalValue = part && typeof value === "number" && Number.isFinite(value) ? decimalFromNumber(value) : null;
+	return part ? runPart(value, part, options, locale, decimalValue) : options.overflow;
+}
+
+//#endregion
+//#region src/shared/numfmt/options.ts
+const defaultOptions = {
+	overflow: "######",
+	dateErrorThrows: false,
+	dateErrorNumber: true,
+	bigintErrorNumber: false,
+	dateSpanLarge: true,
+	leap1900: true,
+	nbsp: false,
+	throws: true,
+	invalid: "######",
+	locale: "",
+	ignoreTimezone: false,
+	grouping: [3, 3],
+	indexColors: true,
+	skipChar: "",
+	fillChar: ""
+};
+
+//#endregion
+//#region src/shared/numfmt/tokenize.ts
+const tokenHandlers = [
+	[
+		TOKEN_GENERAL,
+		/^General/i,
+		0
+	],
+	[
+		TOKEN_HASH,
+		/^#/,
+		0
+	],
+	[
+		TOKEN_ZERO,
+		/^0/,
+		0
+	],
+	[
+		TOKEN_QMARK,
+		/^\?/,
+		0
+	],
+	[
+		TOKEN_SLASH,
+		/^\//,
+		0
+	],
+	[
+		TOKEN_BREAK,
+		/^;/,
+		0
+	],
+	[
+		TOKEN_TEXT,
+		/^@/,
+		0
+	],
+	[
+		TOKEN_PLUS,
+		/^\+/,
+		0
+	],
+	[
+		TOKEN_MINUS,
+		/^-/,
+		0
+	],
+	[
+		TOKEN_POINT,
+		/^\./,
+		0
+	],
+	[
+		TOKEN_SPACE,
+		/^ /,
+		0
+	],
+	[
+		TOKEN_PERCENT,
+		/^%/,
+		0
+	],
+	[
+		TOKEN_DIGIT,
+		/^[1-9]/,
+		0
+	],
+	[
+		TOKEN_CALENDAR,
+		/^(?:B[12])/i,
+		0
+	],
+	[
+		TOKEN_ERROR,
+		/^B$/,
+		0
+	],
+	[
+		TOKEN_DATETIME,
+		/^(?:[hH]+|[mM]+|[sS]+|[yY]+|[bB]+|[dD]+|[gG]+|[aA]{3,}|e+)/,
+		0
+	],
+	[
+		TOKEN_DURATION,
+		/^(?:\[(h+|m+|s+)\])/i,
+		1
+	],
+	[
+		TOKEN_CONDITION,
+		/^\[(<[=>]?|>=?|=)\s*(-?[.\d]+)\]/,
+		[1, 2]
+	],
+	[
+		TOKEN_DBNUM,
+		/^\[(DBNum[0-4]?\d)\]/i,
+		1
+	],
+	[
+		TOKEN_NATNUM,
+		/^\[(NatNum[0-4]?\d)\]/i,
+		1
+	],
+	[
+		TOKEN_LOCALE,
+		/^\[\$([^\]]+)\]/,
+		1
+	],
+	[
+		TOKEN_COLOR,
+		/^\[(black|blue|cyan|green|magenta|red|white|yellow|color\s*\d+)\]/i,
+		1
+	],
+	[
+		TOKEN_MODIFIER,
+		/^\[([^\]]+)\]/,
+		1
+	],
+	[
+		TOKEN_AMPM,
+		/^(?:AM\/PM|am\/pm|A\/P)/,
+		0
+	],
+	[
+		TOKEN_ESCAPED,
+		/^\\(.)/,
+		1
+	],
+	[
+		TOKEN_STRING,
+		/^"([^"]*?)"/,
+		1
+	],
+	[
+		TOKEN_SKIP,
+		/^_(\\.|.)/,
+		1
+	],
+	[
+		"exp",
+		/^[Ee]([+-])/,
+		1
+	],
+	[
+		TOKEN_FILL,
+		/^\*(\\.|.)/,
+		1
+	],
+	[
+		TOKEN_PAREN,
+		/^[()]/,
+		0
+	],
+	[
+		TOKEN_ERROR,
+		/^[EÈÉÊËèéêëĒēĔĕĖėĘęĚěȄȅȆȇȨȩNnÑñŃńŅņŇňǸǹ["*/\\_]/,
+		0
+	],
+	[
+		TOKEN_CHAR,
+		/^./,
+		0
+	]
+];
+const CODE_QMRK = 63;
+const CODE_HASH = 35;
+const CODE_ZERO = 48;
+const CODE_NINE = 57;
+const isNumOp = (char) => {
+	const code = (char || "\0").charCodeAt(0);
+	return code === CODE_QMRK || code === CODE_HASH || code >= CODE_ZERO && code <= CODE_NINE;
+};
+/**
+* Breaks a format pattern string into a list of tokens.
+*/
+function tokenize(pattern) {
+	let index = 0;
+	const tokens = [];
+	const unresolvedCommas = [];
+	while (index < pattern.length) {
+		const current = pattern.slice(index);
+		let step = 0;
+		const commaMatch = /^(,+)(.)?/.exec(current);
+		if (commaMatch) {
+			const raw = commaMatch[1];
+			step = raw.length;
+			const lookBehind = pattern[index - 1] || "";
+			let maybeGroup = false;
+			let maybeScale = false;
+			if (isNumOp(lookBehind)) {
+				maybeGroup = true;
+				maybeScale = true;
+			} else if (lookBehind === ".") maybeScale = true;
+			const lookAhead = commaMatch[2] || "";
+			if (maybeGroup && (!lookAhead || lookAhead === ";")) maybeGroup = false;
+			if (maybeScale && isNumOp(lookAhead)) maybeScale = false;
+			if (maybeGroup && !maybeScale) tokens.push({
+				type: TOKEN_GROUP,
+				value: ",",
+				raw
+			});
+			else if (!maybeGroup && maybeScale) tokens.push({
+				type: TOKEN_SCALE,
+				value: ",",
+				raw
+			});
+			else if (maybeGroup && maybeScale) {
+				const token = {
+					type: TOKEN_SCALE,
+					value: ",",
+					raw
+				};
+				tokens.push(token);
+				unresolvedCommas.push(token);
+			} else tokens.push({
+				type: TOKEN_COMMA,
+				value: ",",
+				raw
+			});
+		} else {
+			let token;
+			for (const [type, expression, group] of tokenHandlers) {
+				const match = expression.exec(current);
+				if (match) {
+					token = {
+						type,
+						value: typeof group !== "number" ? group.map((matchIndex) => match[matchIndex]) : match[group || 0],
+						raw: match[0]
+					};
+					tokens.push(token);
+					step = match[0].length;
+					break;
+				}
+			}
+			if (unresolvedCommas.length && (token === null || token === void 0 ? void 0 : token.raw) === ";") unresolvedCommas.length = 0;
+			if (unresolvedCommas.length && isNumOp(token === null || token === void 0 ? void 0 : token.raw)) {
+				unresolvedCommas.forEach((unresolved) => unresolved.type = TOKEN_GROUP);
+				unresolvedCommas.length = 0;
+			}
+		}
+		if (!step) {
+			const raw = current[0];
+			step = 1;
+			tokens.push({
+				type: TOKEN_CHAR,
+				value: raw,
+				raw
+			});
+		}
+		index += step;
+	}
+	return tokens;
+}
+
+//#endregion
+//#region src/shared/numfmt/parse-pattern.ts
+function maybeAddMinus(part) {
+	var _part$condition, _part$condition2;
+	const operator = (_part$condition = part.condition) === null || _part$condition === void 0 ? void 0 : _part$condition[0];
+	const value = (_part$condition2 = part.condition) === null || _part$condition2 === void 0 ? void 0 : _part$condition2[1];
+	if (!(typeof value === "number" && value < 0 && (operator === "<" || operator === "<=" || operator === "=") || value === 0 && operator === "<")) part.tokens.unshift({
+		type: "minus",
+		volatile: true
+	});
+}
+function clonePart(part, prefixToken = null) {
+	const result = {
+		...part,
+		int_pattern: [...part.int_pattern],
+		frac_pattern: [...part.frac_pattern],
+		man_pattern: [...part.man_pattern],
+		den_pattern: [...part.den_pattern],
+		num_pattern: [...part.num_pattern],
+		tokens: [...part.tokens]
+	};
+	if (part.condition) result.condition = [...part.condition];
+	if (prefixToken) result.tokens.unshift(prefixToken);
+	result.generated = true;
+	return result;
+}
+function parsePattern(pattern) {
+	const partitions = [];
+	let conditional = false;
+	let localeOverride;
+	let textPartition = null;
+	let more = 0;
+	let index = 0;
+	let conditions = 0;
+	let tokens = tokenize(pattern);
+	do {
+		var _tokens$part$tokensUs;
+		const part = parseFormatSection(tokens);
+		if ((part.date || part.general) && (part.int_pattern.length || part.frac_pattern.length || part.scale !== 1 || part.text)) throw new Error("Illegal format");
+		if (part.condition) {
+			conditions++;
+			conditional = true;
+		}
+		if (part.text) {
+			if (textPartition) throw new Error("Unexpected partition");
+			textPartition = part;
+		}
+		if (part.locale) localeOverride = resolveLocale(part.locale);
+		partitions.push(part);
+		more = ((_tokens$part$tokensUs = tokens[part.tokensUsed]) === null || _tokens$part$tokensUs === void 0 ? void 0 : _tokens$part$tokensUs.type) === "break" ? 1 : 0;
+		tokens = tokens.slice(part.tokensUsed + more);
+		index++;
+	} while (more && index < 4 && conditions < 3);
+	if (more) throw new Error("Unexpected partition");
+	if (conditions > 2) throw new Error("Unexpected condition");
+	const fourthPart = partitions[3];
+	if (fourthPart && (fourthPart.int_pattern.length || fourthPart.frac_pattern.length || fourthPart.date)) throw new Error("Unexpected partition");
+	if (conditional) {
+		if (!partitions[0].condition) partitions[0].condition = [">", 0];
+		const numberOfParts = partitions.length;
+		if (numberOfParts === 1) {
+			const fallback = parseFormatSection(tokenize("General"));
+			fallback.generated = true;
+			partitions[1] = fallback;
+		}
+		if (numberOfParts <= 2) {}
+		if (numberOfParts < 3) {
+			const firstPart = partitions[0];
+			const secondPart = partitions[1];
+			maybeAddMinus(firstPart);
+			if (secondPart.condition) maybeAddMinus(secondPart);
+			else {
+				const condition = firstPart.condition;
+				if ((condition === null || condition === void 0 ? void 0 : condition[0]) === "=" || typeof (condition === null || condition === void 0 ? void 0 : condition[1]) === "number" && condition[1] >= 0 && (condition[0] === ">" || condition[0] === ">=")) secondPart.tokens.unshift({
+					type: "minus",
+					volatile: true
+				});
+			}
+		} else partitions.forEach(maybeAddMinus);
+	} else {
+		if (partitions.length < 4 && textPartition) {
+			for (let partitionIndex = 0, length = partitions.length; partitionIndex < length; partitionIndex++) if (partitions[partitionIndex] === textPartition) partitions.splice(partitionIndex, 1);
+		}
+		if (partitions.length < 1 && textPartition) {
+			const positive = parseFormatSection(tokenize("General"));
+			positive.generated = true;
+			partitions[0] = positive;
+		}
+		if (partitions.length < 2) partitions.push(clonePart(partitions[0], {
+			type: "minus",
+			volatile: true
+		}));
+		if (partitions.length < 3) partitions.push(clonePart(partitions[0]));
+		if (partitions.length < 4) if (textPartition) partitions.push(textPartition);
+		else {
+			const text = parseFormatSection(tokenize("@"));
+			text.generated = true;
+			partitions.push(text);
+		}
+		partitions[0].condition = [">", 0];
+		partitions[1].condition = ["<", 0];
+		partitions[2].condition = null;
+	}
+	return {
+		pattern,
+		partitions,
+		locale: localeOverride
+	};
+}
+
+//#endregion
+//#region src/shared/numfmt/serial-date.ts
+const floor = Math.floor;
+const DAYSIZE = 86400;
+const dateUTC = Date.UTC;
+/**
+* Convert a native JavaScript Date, or array to a spreadsheet serial date.
+*
+* Returns a serial date number if input was a Date object or an array of
+* numbers, or null.
+*/
+function dateToSerial(date, options) {
+	let timestamp = null;
+	if (Array.isArray(date)) {
+		const [year, month, day, hours, minutes, seconds] = date;
+		timestamp = dateUTC(year, month == null ? 0 : month - 1, day !== null && day !== void 0 ? day : 1, hours || 0, minutes || 0, seconds || 0);
+	} else if (date instanceof Date) {
+		timestamp = date.getTime();
+		if (!(options === null || options === void 0 ? void 0 : options.ignoreTimezone)) {
+			const localDate = /* @__PURE__ */ new Date();
+			localDate.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+			localDate.setUTCHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+			timestamp = localDate.getTime();
+		}
+	}
+	if (timestamp != null && Number.isFinite(timestamp)) {
+		const days = timestamp / 864e5;
+		return days - (days <= -25509 ? -25568 : -25569);
+	}
+	return null;
+}
+/**
+* Convert a spreadsheet serial date to an array of date parts, accurate to a
+* second.
 */
-function getCellInfoInMergeData(row, column, mergeData) {
-	let isMerged = false;
-	let isMergedMainCell = false;
-	let newEndRow = row;
-	let newEndColumn = column;
-	let mergeRow = row;
-	let mergeColumn = column;
-	if (mergeData == null) return {
-		actualRow: row,
-		actualColumn: column,
-		isMergedMainCell,
-		isMerged,
-		endRow: newEndRow,
-		endColumn: newEndColumn,
-		startRow: mergeRow,
-		startColumn: mergeColumn
-	};
-	for (let i = 0; i < mergeData.length; i++) {
-		const { startRow: startRowMarge, endRow: endRowMarge, startColumn: startColumnMarge, endColumn: endColumnMarge } = mergeData[i];
-		if (row === startRowMarge && column === startColumnMarge) {
-			newEndRow = endRowMarge;
-			newEndColumn = endColumnMarge;
-			mergeRow = startRowMarge;
-			mergeColumn = startColumnMarge;
-			isMergedMainCell = true;
-			break;
+function dateFromSerial(serial, options) {
+	let date = serial | 0;
+	const fractionalSeconds = DAYSIZE * (serial - date);
+	let time = floor(fractionalSeconds);
+	if (fractionalSeconds - time > .9999) {
+		time += 1;
+		if (time === DAYSIZE) {
+			time = 0;
+			date += 1;
+		}
+	}
+	const normalizedTime = time < 0 ? DAYSIZE + time : time;
+	const [year, month, day] = toYMD(serial, 0, options === null || options === void 0 ? void 0 : options.leap1900);
+	return [
+		year,
+		month,
+		day,
+		floor(normalizedTime / 60 / 60) % 60,
+		floor(normalizedTime / 60) % 60,
+		floor(normalizedTime) % 60
+	];
+}
+
+//#endregion
+//#region src/shared/numfmt/parse-value.ts
+const okDateFormats = [
+	"!d-m-y",
+	"!d-m-Y",
+	"!j-m-y",
+	"!j-m-Y",
+	"!d-n-y",
+	"!d-n-Y",
+	"!j-n-y",
+	"!j-n-Y",
+	"?m-d-y",
+	"?m-d-Y",
+	"?m-j-y",
+	"?m-j-Y",
+	"?n-d-y",
+	"?n-d-Y",
+	"?n-j-y",
+	"?n-j-Y",
+	"d-M-y",
+	"d-M-Y",
+	"j-M-y",
+	"j-M-Y",
+	"M-d-y",
+	"M-d-Y",
+	"M-j-y",
+	"M-j-Y",
+	"d-F-y",
+	"d-F-Y",
+	"F-d-y",
+	"F-d-Y",
+	"F-j-y",
+	"F-j-Y",
+	"j-F-y",
+	"j-F-Y",
+	"y-F-d",
+	"y-F-j",
+	"y-M-d",
+	"y-M-j",
+	"Y-F-d",
+	"Y-F-j",
+	"Y-M-d",
+	"Y-m-d",
+	"Y-M-j",
+	"Y-m-j",
+	"Y-n-d",
+	"Y-n-j",
+	"j-F",
+	"j-M",
+	"d-F",
+	"d-M",
+	"n-d",
+	"n-j",
+	"n-Y",
+	"m-d",
+	"m-j",
+	"m-Y",
+	"M-Y",
+	"M-y",
+	"F-y",
+	"F-Y",
+	"Y-M",
+	"Y-n",
+	"Y-m",
+	"Y-F",
+	"Y-M"
+];
+const tx0 = {
+	j: "d",
+	d: "d",
+	D: "ddd",
+	l: "dddd",
+	n: "m",
+	m: "m",
+	M: "mmm",
+	F: "mmmm",
+	y: "yy",
+	Y: "yyyy"
+};
+const tx00 = {
+	j: "dd",
+	d: "dd",
+	D: "ddd",
+	l: "dddd",
+	n: "mm",
+	m: "mm",
+	M: "mmm",
+	F: "mmmm",
+	y: "yy",
+	Y: "yyyy"
+};
+const dateTrieDM = {};
+const dateTrieMD = {};
+function packDate(format, node, allowType = 1) {
+	if (format) {
+		const char = format[0];
+		const next = format.slice(1);
+		if (char === "!") packDate(next, node, 4);
+		else if (char === "?") packDate(next, node, 2);
+		else {
+			let branch = node[char];
+			if (typeof branch !== "object") {
+				branch = {};
+				node[char] = branch;
+			}
+			packDate(next, branch, allowType);
+		}
+	} else node.$ = allowType;
+}
+function addFormatToTrie(format, trie) {
+	packDate(format, trie);
+	packDate(`${format} x`, trie);
+	packDate(`${format} l`, trie);
+	packDate(`${format} l x`, trie);
+	packDate(`l ${format}`, trie);
+	packDate(`l ${format} x`, trie);
+	packDate(`${format} D`, trie);
+	packDate(`${format} D x`, trie);
+	packDate(`D ${format}`, trie);
+	packDate(`D ${format} x`, trie);
+}
+okDateFormats.forEach((format) => {
+	if (!format.startsWith("?")) addFormatToTrie(format, dateTrieDM);
+	if (!format.startsWith("!")) addFormatToTrie(format, dateTrieMD);
+});
+const currentYear = (/* @__PURE__ */ new Date()).getUTCFullYear();
+const PT = ".";
+const CM = ",";
+const SP = " ";
+const NS = "\xA0";
+const NN = " ";
+const AP = "'";
+const AG = "٬";
+const dec2group = {
+	".": [
+		CM,
+		NS,
+		NN,
+		AP,
+		AG
+	],
+	",": [
+		PT,
+		NS,
+		NN,
+		AP,
+		AG
+	],
+	"٫": [
+		PT,
+		NS,
+		NN,
+		AP,
+		AG
+	]
+};
+const isDigit = (digit) => (digit === null || digit === void 0 ? void 0 : digit.length) === 1 && digit >= "0" && digit <= "9";
+/** Parse a numeric string and return its value and inferred format. */
+function parseNumber(value, options = {}) {
+	const l10n = getLocale(options.locale || "") || defaultLocale;
+	const decimal = l10n.decimal;
+	const groupingChars = [...dec2group[decimal] || [AP, AG]];
+	if (!groupingChars.includes(l10n.group) && l10n.group !== SP && l10n.group !== decimal) groupingChars.push(l10n.group);
+	let number = "";
+	let exponent = "";
+	let sign = 1;
+	let format = "";
+	let minus = false;
+	let openParen = false;
+	let closeParen = false;
+	let percent = false;
+	let currency = false;
+	let currencySymbol = "";
+	let currencyTrailing = false;
+	let index = 0;
+	const prefixChars = [
+		SP,
+		NS,
+		NN,
+		"+",
+		"%",
+		"(",
+		"-"
+	].concat(currencySymbols$1);
+	while (prefixChars.includes(value.charAt(index))) {
+		const char = value.charAt(index);
+		if (char === "-") {
+			if (minus || openParen) return null;
+			minus = true;
+			sign = -1;
+		} else if (reCurrencySymbols.test(char)) {
+			if (currency) return null;
+			currency = true;
+			currencySymbol = char;
+		} else if (char === "(") {
+			if (openParen || minus) return null;
+			openParen = true;
+			sign = -1;
+		} else if (char === "%") {
+			if (percent) return null;
+			percent = true;
+		}
+		index++;
+	}
+	let haveDecimal = false;
+	let grouping;
+	if (value.charAt(index) === decimal || isDigit(value.charAt(index))) while (index < value.length) {
+		const char = value.charAt(index);
+		if (!grouping && groupingChars.includes(char)) grouping = char;
+		else if (grouping && grouping === char) {} else if (char === decimal) {
+			if (haveDecimal) break;
+			number += ".";
+			haveDecimal = true;
+		} else if (isDigit(char)) number += char;
+		else break;
+		index++;
+	}
+	if (value.charAt(index) === "e" || value.charAt(index) === "E") {
+		exponent += value.charAt(index);
+		index++;
+		if (value.charAt(index) === "+" || value.charAt(index) === "-") {
+			exponent += value.charAt(index);
+			index++;
 		}
-		if (row >= startRowMarge && row <= endRowMarge && column >= startColumnMarge && column <= endColumnMarge) {
-			newEndRow = endRowMarge;
-			newEndColumn = endColumnMarge;
-			mergeRow = startRowMarge;
-			mergeColumn = startColumnMarge;
-			isMerged = true;
-			break;
+		const exponentStart = index;
+		while (isDigit(value.charAt(index))) {
+			exponent += value.charAt(index);
+			index++;
 		}
+		if (exponentStart === index) return null;
+	}
+	const suffixChars = [
+		SP,
+		NS,
+		NN,
+		"%",
+		"$",
+		")"
+	].concat(currencySymbols$1);
+	while (suffixChars.includes(value.charAt(index))) {
+		const char = value.charAt(index);
+		if (reCurrencySymbols.test(char)) {
+			if (currency) return null;
+			currency = true;
+			currencySymbol = char;
+			currencyTrailing = true;
+		} else if (char === ")") {
+			if (closeParen || !openParen) return null;
+			closeParen = true;
+		} else if (char === "%") {
+			if (percent) return null;
+			percent = true;
+		}
+		index++;
+	}
+	if (index !== value.length) return null;
+	let numberValue = Number.parseFloat(number + exponent);
+	if (!Number.isFinite(numberValue)) return null;
+	if (exponent) {
+		if (percent || currency) return null;
+		format = "0.00E+00";
+	} else if (percent) {
+		if (currency) return null;
+		format = number.includes(".") ? "0.00%" : "0%";
+		numberValue *= .01;
+	} else if (currency) {
+		const currencyFormat = number.includes(".") ? "#,##0.00" : "#,##0";
+		format = currencyTrailing ? currencyFormat + currencySymbol : currencySymbol + currencyFormat;
+	} else if (grouping) format = number.includes(".") ? "#,##0.00" : "#,##0";
+	const result = { v: numberValue * sign };
+	if (format) result.z = format;
+	return result;
+}
+function isValidDate(year, month, day) {
+	if (day < 1) return false;
+	if (month < 1 || month > 12) return false;
+	if (month === 2) {
+		if (day > (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 || year === 1900 ? 29 : 28)) return false;
+	} else if ((month === 4 || month === 6 || month === 9 || month === 11) && day > 30 || (month === 1 || month === 3 || month === 5 || month === 7 || month === 8 || month === 10 || month === 12) && day > 31) return false;
+	return true;
+}
+const matchRec = (string, data, skipPeriod = false) => {
+	for (const item of data) if (string.startsWith(item[0])) {
+		let length = item[0].length;
+		if (skipPeriod && (item[2] === "D" || item[2] === "M") && string[length] === ".") length++;
+		return [string.slice(0, length), item];
+	}
+	return ["", null];
+};
+const nextToken = (string, node, data, localeData) => {
+	const path = data.path || "";
+	const matchOrder = Object.keys(node);
+	for (const token of matchOrder) {
+		const branch = node[token];
+		let result;
+		if (!branch) continue;
+		if (token === "$" || token === "€") {
+			if (!string) result = data;
+		} else {
+			if (typeof branch !== "object") continue;
+			if (token === "-") {
+				const match = /^(\s*([./-]|,\s)\s*|\s+)/.exec(string);
+				if (match) {
+					const separator = match[1] === "-" || match[1] === "/" || match[1] === "." ? match[1] : " ";
+					if (!data.sep || data.sep === separator) {
+						const normalizedSeparator = match[0].replace(/\s+/g, " ");
+						result = nextToken(string.slice(match[0].length), branch, {
+							...data,
+							sep: separator,
+							path: path + normalizedSeparator
+						}, localeData);
+					}
+				}
+			} else if (token === " ") {
+				const match = /^[,.]?\s+/.exec(string);
+				if (match) {
+					const normalizedSeparator = match[0].replace(/\s+/g, " ");
+					result = nextToken(string.slice(match[0].length), branch, {
+						...data,
+						path: path + normalizedSeparator
+					}, localeData);
+				}
+			} else if (token === "j" || token === "d") {
+				const match = /^(0?[1-9]|1\d|2\d|3[01])\b/.exec(string);
+				if (match) result = nextToken(string.slice(match[0].length), branch, {
+					...data,
+					day: match[0],
+					path: path + token
+				}, localeData);
+			} else if (token === "n" || token === "m") {
+				const match = /^(0?[1-9]|1[012])\b/.exec(string);
+				if (match) result = nextToken(string.slice(match[0].length), branch, {
+					...data,
+					month: +match[0],
+					_mon: match[0],
+					path: path + token
+				}, localeData);
+			} else if (token === "F" || token === "M") {
+				const [matchedText, match] = matchRec(string, localeData.mon, localeData.mp);
+				if ((match === null || match === void 0 ? void 0 : match[2]) === token) result = nextToken(string.slice(matchedText.length), branch, {
+					...data,
+					month: match[1],
+					_mon: matchedText,
+					path: path + token
+				}, localeData);
+			} else if (token === "l" || token === "D") {
+				const [matchedText, match] = matchRec(string, localeData.day, localeData.dp);
+				if ((match === null || match === void 0 ? void 0 : match[2]) === token) result = nextToken(string.slice(matchedText.length), branch, {
+					...data,
+					path: path + token
+				}, localeData);
+			} else if (token === "y") {
+				const match = /^\d\d\b/.exec(string);
+				if (match) {
+					const year = +match[0] >= 30 ? +match[0] + 1900 : +match[0] + 2e3;
+					result = nextToken(string.slice(match[0].length), branch, {
+						...data,
+						year,
+						path: path + token
+					}, localeData);
+				}
+			} else if (token === "Y") {
+				const match = /^\d\d\d\d\b/.exec(string);
+				if (match) result = nextToken(string.slice(match[0].length), branch, {
+					...data,
+					year: +match[0],
+					path: path + token
+				}, localeData);
+			} else if (token === "x") {
+				const time = parseTime(string, { locale: localeData.locale });
+				if (time) result = nextToken("", branch, {
+					...data,
+					time: time.v,
+					tf: time.z,
+					path: path + token
+				}, localeData);
+			} else throw new Error(`Unknown date token "${token}"`);
+		}
+		if (result && isValidDate(data.year || 1916, data.month || 1, data.day ? +data.day : 1)) return result;
 	}
+};
+const normDateStr = (string) => string.replace(/\s+/g, " ").trim().replace(/’/, "'").replace(/\.$/, "").toLowerCase();
+const getLookups = (values, symbol) => {
+	const lookups = values.map((value, index) => [
+		normDateStr(value),
+		index + 1,
+		symbol
+	]);
+	lookups.sort((a, b) => b[0].length - a[0].length);
+	return lookups;
+};
+/** Parse a date or datetime string and return its serial value and format. */
+function parseDate(value, options = {}) {
+	var _date$year, _date$day;
+	const l10n = getLocale(options.locale || "") || defaultLocale;
+	const localeData = {
+		mon: getLookups(l10n.mmmm, "F").concat(getLookups(l10n.mmm, "M")),
+		mp: l10n.mmm[0].at(-1) === ".",
+		day: getLookups(l10n.dddd, "l").concat(getLookups(l10n.ddd, "D")),
+		dp: l10n.ddd[0].at(-1) === ".",
+		locale: options.locale
+	};
+	const date = nextToken(normDateStr(value), l10n.preferMDY ? dateTrieMD : dateTrieDM, { path: "" }, localeData);
+	if (!date) return null;
+	if (date.sep === "." && date.path.length === 3) return null;
+	if (date.month == null || date._mon == null) return null;
+	const year = +((_date$year = date.year) !== null && _date$year !== void 0 ? _date$year : currentYear);
+	const day = (_date$day = date.day) !== null && _date$day !== void 0 ? _date$day : "1";
+	let epoch = -Infinity;
+	if (year < 1900) return null;
+	else if (year <= 1900 && date.month <= 2) epoch = 25568;
+	else if (year < 1e4) epoch = 25569;
+	const dateValue = Date.UTC(year, date.month - 1, +day) / 864e5 + epoch + (date.time || 0);
+	if (dateValue < 0 || dateValue > 2958465) return null;
+	const lead0 = date._mon[0] === "0" || day[0] === "0" || date._mon.length === 2 && day.length === 2;
 	return {
-		actualRow: row,
-		actualColumn: column,
-		isMergedMainCell,
-		isMerged,
-		endRow: newEndRow,
-		endColumn: newEndColumn,
-		startRow: mergeRow,
-		startColumn: mergeColumn
+		v: dateValue,
+		z: date.path.replace(/[jdlDnmMFyYx]/g, (token) => {
+			if (token === "x") return date.tf || "";
+			return (lead0 ? tx00[token] : tx0[token]) || token;
+		})
 	};
 }
-let CellModeEnum = /* @__PURE__ */ function(CellModeEnum) {
-	CellModeEnum["Raw"] = "raw";
-	CellModeEnum["Intercepted"] = "intercepted";
-	CellModeEnum["Both"] = "both";
-	return CellModeEnum;
-}({});
+const normAMPMStr = (string) => string.replace(/\s+/g, "").trim().replace(/\./g, "").toLowerCase();
+/** Parse a time string and return its day fraction and inferred format. */
+function parseTime(value, options = {}) {
+	const l10n = getLocale(options.locale || "") || defaultLocale;
+	const parts = /^\s*([10]?\d|2[0-4])(?::([0-5]\d|\d))?(?::([0-5]\d|\d))?(\.\d{1,10})?(?=\s*[^\s\d]|$)/.exec(value);
+	let ampm = "";
+	if (parts) {
+		const tail = normAMPMStr(value.slice(parts[0].length));
+		if (tail === normAMPMStr(l10n.ampm[0]) || tail === "a" || tail === "am") ampm = "a";
+		else if (tail === normAMPMStr(l10n.ampm[1]) || tail === "p" || tail === "pm") ampm = "p";
+		else if (tail === ":") {
+			if (!parts[3]) parts[3] = "0";
+			if (!parts[2]) parts[2] = "0";
+		} else if (tail) return null;
+	}
+	if (!parts) return null;
+	const [, hoursPart, minutesPart, secondsPart, fractionPart] = parts;
+	if (fractionPart && !secondsPart) return null;
+	if (!ampm && !minutesPart && !secondsPart) return null;
+	let hours = +(hoursPart || 0);
+	if (ampm) {
+		if (hours >= 13) return null;
+		if (ampm === "a") {
+			if (hours === 12) hours = 0;
+		} else if (ampm === "p" && hours !== 12) hours += 12;
+	}
+	const minutes = +(minutesPart || 0);
+	const seconds = +(secondsPart || 0);
+	const milliseconds = +(fractionPart || 0);
+	const hourFormat = hoursPart.length === 2 ? "hh" : "h";
+	const secondsFormat = secondsPart ? ":ss" : "";
+	const ampmFormat = ampm ? " AM/PM" : "";
+	return {
+		v: (hours * 60 * 60 + minutes * 60 + seconds + milliseconds) / (3600 * 24),
+		z: `${hourFormat}:mm${secondsFormat}${ampmFormat}`
+	};
+}
+/** Parse a localized or English boolean string. */
+function parseBool(value, options = {}) {
+	const l10n = getLocale(options.locale || "") || defaultLocale;
+	const normalizedValue = value.trim().toLowerCase();
+	const localizedTrue = l10n.bool[0].toLowerCase();
+	if (normalizedValue === "true" || normalizedValue === localizedTrue) return { v: true };
+	const localizedFalse = l10n.bool[1].toLowerCase();
+	if (normalizedValue === "false" || normalizedValue === localizedFalse) return { v: false };
+	return null;
+}
+/** Parse a spreadsheet input as a number, date, time, or boolean. */
+function parseValue(value, options) {
+	var _ref, _ref2, _parseNumber;
+	return (_ref = (_ref2 = (_parseNumber = parseNumber(value, options)) !== null && _parseNumber !== void 0 ? _parseNumber : parseDate(value, options)) !== null && _ref2 !== void 0 ? _ref2 : parseTime(value, options)) !== null && _ref !== void 0 ? _ref : parseBool(value, options);
+}
 
 //#endregion
-//#region src/types/const/theme-color-map.ts
-const THEME_COLORS = { ["Office"]: {
-	[4]: "#4472C4",
-	[5]: "#ED7D31",
-	[6]: "#A5A5A5",
-	[7]: "#70AD47",
-	[8]: "#5B9BD5",
-	[9]: "#70AD47",
-	[0]: "#000000",
-	[2]: "#44546A",
-	[1]: "#FFFFFF",
-	[3]: "#E7E6E6",
-	[10]: "#0563C1",
-	[11]: "#954F72"
-} };
+//#region src/shared/numfmt/api.ts
+var api_exports = /* @__PURE__ */ __exportAll({
+	addLocale: () => addLocale,
+	dateFromSerial: () => dateFromSerial,
+	dateToSerial: () => dateToSerial,
+	dec2frac: () => dec2frac,
+	format: () => format,
+	formatColor: () => formatColor,
+	getFormatDateInfo: () => getFormatDateInfo,
+	getFormatInfo: () => getFormatInfo,
+	getLocale: () => getLocale,
+	isDateFormat: () => isDateFormat,
+	isPercentFormat: () => isPercentFormat,
+	isTextFormat: () => isTextFormat$1,
+	isValidFormat: () => isValidFormat,
+	parseBool: () => parseBool,
+	parseDate: () => parseDate,
+	parseLocale: () => parseLocale,
+	parseNumber: () => parseNumber,
+	parseTime: () => parseTime,
+	parseValue: () => parseValue,
+	round: () => round,
+	tokenTypes: () => tokenTypes,
+	tokenize: () => tokenize
+});
+const parseDataCache = Object.create({});
+function prepareFormatterData(pattern, shouldThrow = false) {
+	const normalizedPattern = pattern || "General";
+	let parseData = parseDataCache[normalizedPattern];
+	if (!parseData) try {
+		parseData = parsePattern(normalizedPattern);
+		parseDataCache[normalizedPattern] = parseData;
+	} catch (error) {
+		if (shouldThrow) throw error;
+		const message = error instanceof Error ? error.message : String(error);
+		const errorPart = {
+			tokens: [{ type: "error" }],
+			error: message
+		};
+		parseData = {
+			pattern: normalizedPattern,
+			partitions: [
+				errorPart,
+				errorPart,
+				errorPart,
+				errorPart
+			],
+			error: message,
+			locale: null
+		};
+	}
+	return parseData;
+}
+/**
+* Formats a value as a string and returns the result.
+*/
+function format(pattern, value, options = {}) {
+	var _handleDates;
+	const resolvedOptions = Object.assign({}, defaultOptions, options);
+	const data = prepareFormatterData(pattern, resolvedOptions.throws);
+	return formatValue((_handleDates = dateToSerial(value, resolvedOptions)) !== null && _handleDates !== void 0 ? _handleDates : value, data, resolvedOptions);
+}
+/**
+* Find the color appropriate to a value as dictated by a format pattern.
+*/
+function formatColor(pattern, value, options) {
+	var _handleDates2;
+	const resolvedOptions = Object.assign({}, defaultOptions, options);
+	const data = prepareFormatterData(pattern, resolvedOptions.throws);
+	return formatColor$1((_handleDates2 = dateToSerial(value, resolvedOptions)) !== null && _handleDates2 !== void 0 ? _handleDates2 : value, data, resolvedOptions);
+}
+/** Determine if a given format pattern is a date pattern. */
+function isDateFormat(pattern) {
+	return isDate(prepareFormatterData(pattern, false).partitions);
+}
+/** Determine if a given format pattern is a percentage pattern. */
+function isPercentFormat(pattern) {
+	return isPercent(prepareFormatterData(pattern, false).partitions);
+}
+/** Determine if a given format pattern is a text only pattern. */
+function isTextFormat$1(pattern) {
+	return isText(prepareFormatterData(pattern, false).partitions);
+}
+/** Determine if a given format pattern is valid. */
+function isValidFormat(pattern) {
+	try {
+		prepareFormatterData(pattern, true);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Returns metadata describing a parsed format pattern. */
+function getFormatInfo(pattern, options = {}) {
+	const data = prepareFormatterData(pattern, false);
+	if (!data.info) data.info = info(data.partitions, options === null || options === void 0 ? void 0 : options.currency);
+	return data.info;
+}
+/** Gets information about date codes used in a format string. */
+function getFormatDateInfo(pattern) {
+	const data = prepareFormatterData(pattern, false);
+	if (!data.dateInfo) data.dateInfo = dateInfo(data.partitions);
+	return data.dateInfo;
+}
+/** A dictionary of the types used to identify token variants. */
+const tokenTypes = Object.freeze({
+	AMPM: TOKEN_AMPM,
+	BREAK: TOKEN_BREAK,
+	CALENDAR: TOKEN_CALENDAR,
+	CHAR: TOKEN_CHAR,
+	COLOR: TOKEN_COLOR,
+	COMMA: TOKEN_COMMA,
+	CONDITION: TOKEN_CONDITION,
+	DATETIME: TOKEN_DATETIME,
+	DBNUM: TOKEN_DBNUM,
+	DIGIT: TOKEN_DIGIT,
+	DURATION: TOKEN_DURATION,
+	ERROR: TOKEN_ERROR,
+	ESCAPED: TOKEN_ESCAPED,
+	EXP: "exp",
+	FILL: TOKEN_FILL,
+	GENERAL: TOKEN_GENERAL,
+	GROUP: TOKEN_GROUP,
+	HASH: TOKEN_HASH,
+	LOCALE: TOKEN_LOCALE,
+	MINUS: TOKEN_MINUS,
+	MODIFIER: TOKEN_MODIFIER,
+	NATNUM: TOKEN_NATNUM,
+	PAREN: TOKEN_PAREN,
+	PERCENT: TOKEN_PERCENT,
+	PLUS: TOKEN_PLUS,
+	POINT: TOKEN_POINT,
+	QMARK: TOKEN_QMARK,
+	SCALE: TOKEN_SCALE,
+	SKIP: TOKEN_SKIP,
+	SLASH: TOKEN_SLASH,
+	SPACE: TOKEN_SPACE,
+	STRING: TOKEN_STRING,
+	TEXT: TOKEN_TEXT,
+	ZERO: TOKEN_ZERO
+});
 
 //#endregion
 //#region src/common/regexp/factory.ts
@@ -4291,22 +7739,7 @@ const regexp = {
 };
 
 //#endregion
-//#region src/shared/numfmt.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+//#region src/shared/numfmt/utils.ts
 const DEFAULT_TEXT_FORMAT = "@@@";
 const DEFAULT_TEXT_FORMAT_EXCEL = "@";
 const DEFAULT_NUMBER_FORMAT = "General";
@@ -4324,22 +7757,22 @@ function isDefaultFormat(pattern) {
 const isPatternEqualWithoutDecimal = (patternA, patternB) => {
 	if (patternA && !patternB || !patternA && patternB) return false;
 	const getStringWithoutDecimal = (pattern) => {
-		const tokens = numfmt.tokenize(pattern);
+		const tokens = tokenize(pattern);
 		let result = "";
 		let isDecimalPart = false;
 		let isColorBefore = false;
 		for (const token of tokens) {
-			if (token.type === numfmt.tokenTypes.POINT) {
+			if (token.type === tokenTypes.POINT) {
 				isDecimalPart = true;
 				continue;
 			}
-			if (isColorBefore && token.type === numfmt.tokenTypes.MINUS) continue;
-			if (token.type === numfmt.tokenTypes.SKIP) continue;
-			if (token.type === numfmt.tokenTypes.COLOR) {
+			if (isColorBefore && token.type === tokenTypes.MINUS) continue;
+			if (token.type === tokenTypes.SKIP) continue;
+			if (token.type === tokenTypes.COLOR) {
 				isColorBefore = true;
 				continue;
 			} else isColorBefore = false;
-			if (isDecimalPart && token.type === numfmt.tokenTypes.ZERO) continue;
+			if (isDecimalPart && token.type === tokenTypes.ZERO) continue;
 			else isDecimalPart = false;
 			if (!isDecimalPart) result += token.value || "";
 		}
@@ -4389,8 +7822,8 @@ const CURRENCY_SYMBOL_PREFIX_REG = new RegExp(`^${regexp.charset(...Array.from(n
 * Get the numfmt parse value, and filter out the parse error.
 */
 const getNumfmtParseValueFilter = (value) => {
-	var _ref, _numfmt$parseDate;
-	const parseData = (_ref = (_numfmt$parseDate = numfmt.parseDate(value)) !== null && _numfmt$parseDate !== void 0 ? _numfmt$parseDate : numfmt.parseTime(value)) !== null && _ref !== void 0 ? _ref : numfmt.parseNumber(value);
+	var _ref, _parseDate;
+	const parseData = (_ref = (_parseDate = parseDate(value)) !== null && _parseDate !== void 0 ? _parseDate : parseTime(value)) !== null && _ref !== void 0 ? _ref : parseNumber(value);
 	if (!parseData) return null;
 	const { z } = parseData;
 	if (z) {
@@ -6840,6 +10273,7 @@ const STYLE_KEYS = defineExactKeys()([
 	"cl",
 	"va",
 	"n",
+	"stf",
 	"tr",
 	"td",
 	"ht",
@@ -14339,6 +17773,7 @@ _defineProperty(BuildTextUtils, "drawing", { add: addDrawing });
 
 //#endregion
 //#region src/docs/data-model/rich-text-builder.ts
+const NON_EDITABLE_RICH_TEXT_TOKENS = new Set(Object.values(DataStreamTreeTokenType).filter((token) => token !== "" && token !== " "));
 function normalizeBody$1(body) {
 	if (!body.customRanges) body.customRanges = [];
 	if (!body.paragraphs) {
@@ -15948,9 +19383,158 @@ var RichTextBuilder = class RichTextBuilder extends RichTextValue {
 	constructor(data) {
 		super(data);
 		_defineProperty(this, "_doc", void 0);
+		_defineProperty(this, "_trackedRanges", /* @__PURE__ */ new Set());
 		this._doc = new DocumentDataModel(data);
 	}
 	/**
+	* Returns editable paragraph handles backed by this detached rich-text builder.
+	*
+	* Paragraph boundaries come from the document model rather than splitting plain text. Each handle stays aligned
+	* when text in this builder grows or shrinks, so callers can safely iterate from the first paragraph to the last.
+	*
+	* @returns Editable paragraphs in document order.
+	* @example
+	* ```ts
+	* const richText = univerAPI.newRichText()
+	*   .text('Quarterly Review')
+	*   .paragraph()
+	*   .text('Revenue increased by 18%.');
+	* for (const paragraph of richText.getParagraphs()) {
+	*   console.log(paragraph.getText());
+	* }
+	* ```
+	*/
+	getParagraphs() {
+		var _body$paragraphs;
+		const body = this._data.body;
+		if (!body) return [];
+		const startOffsets = getParagraphContentStartOffsets(body);
+		return ((_body$paragraphs = body.paragraphs) !== null && _body$paragraphs !== void 0 ? _body$paragraphs : []).map((paragraph) => {
+			var _startOffsets$get;
+			return this._createParagraphBuilder(paragraph.paragraphId, (_startOffsets$get = startOffsets.get(paragraph.startIndex)) !== null && _startOffsets$get !== void 0 ? _startOffsets$get : 0, paragraph.startIndex);
+		});
+	}
+	/**
+	* Returns editable text-run handles for all paragraph text in this builder.
+	*
+	* Unlike the read-only value API, this method also returns unstyled gaps. Paragraph and section markers are never
+	* exposed as text runs. Prefer `getParagraphs()` when paragraph context matters.
+	*
+	* @returns Editable text runs in document order.
+	* @example
+	* ```ts
+	* const richText = univerAPI.newRichText()
+	*   .text('Status: ')
+	*   .span('Ready', { bold: true, color: '#16a34a' });
+	* for (const run of richText.getTextRuns()) {
+	*   console.log(run.getText(), run.getTextStyle()?.getValue());
+	* }
+	* ```
+	*/
+	getTextRuns() {
+		return this.getParagraphs().flatMap((paragraph) => paragraph.getTextRuns());
+	}
+	/** @internal */
+	_createTextRunBuilders(range) {
+		var _body$textRuns, _body$customRanges, _body$customDecoratio;
+		const body = this._data.body;
+		if (!body || range.startOffset >= range.endOffset) return [];
+		const boundaries = /* @__PURE__ */ new Set([range.startOffset, range.endOffset]);
+		const addRangeBoundaries = (startOffset, endOffset) => {
+			const start = Math.max(startOffset, range.startOffset);
+			const end = Math.min(endOffset, range.endOffset);
+			if (start < end) {
+				boundaries.add(start);
+				boundaries.add(end);
+			}
+		};
+		for (const textRun of (_body$textRuns = body.textRuns) !== null && _body$textRuns !== void 0 ? _body$textRuns : []) addRangeBoundaries(textRun.st, textRun.ed);
+		for (const customRange of (_body$customRanges = body.customRanges) !== null && _body$customRanges !== void 0 ? _body$customRanges : []) addRangeBoundaries(customRange.startIndex, customRange.endIndex + 1);
+		for (const decoration of (_body$customDecoratio = body.customDecorations) !== null && _body$customDecoratio !== void 0 ? _body$customDecoratio : []) addRangeBoundaries(decoration.startIndex, decoration.endIndex + 1);
+		for (let offset = range.startOffset; offset < range.endOffset; offset++) if (NON_EDITABLE_RICH_TEXT_TOKENS.has(body.dataStream[offset])) {
+			boundaries.add(offset);
+			boundaries.add(offset + 1);
+		}
+		const offsets = [...boundaries].sort((left, right) => left - right);
+		const runs = [];
+		for (let index = 0; index < offsets.length - 1; index++) {
+			var _body$textRuns2;
+			const startOffset = offsets[index];
+			const endOffset = offsets[index + 1];
+			if (startOffset >= endOffset || endOffset - startOffset === 1 && NON_EDITABLE_RICH_TEXT_TOKENS.has(body.dataStream[startOffset])) continue;
+			const sourceRun = ((_body$textRuns2 = body.textRuns) !== null && _body$textRuns2 !== void 0 ? _body$textRuns2 : []).find((textRun) => textRun.st <= startOffset && textRun.ed >= endOffset);
+			runs.push(new RichTextRunBuilder(this, this._trackRange(startOffset, endOffset), sourceRun === null || sourceRun === void 0 ? void 0 : sourceRun.ts, sourceRun === null || sourceRun === void 0 ? void 0 : sourceRun.sId, Boolean(sourceRun)));
+		}
+		return runs;
+	}
+	/** @internal */
+	_replaceTextRun(range, text, textStyle, styleId, hasExplicitTextStyle) {
+		var _sourceBody$customRan, _sourceBody$customDec;
+		if (text.includes("\r") || text.includes("\n")) throw new RangeError("Rich text run replacement cannot contain paragraph or section breaks.");
+		const body = this._doc.getBody();
+		if (!body) throw new Error("Rich text body is not available.");
+		const { startOffset, endOffset } = range;
+		if (body.dataStream.slice(startOffset, endOffset) === text) return;
+		const sourceBody = getBodySlice(body, startOffset, endOffset);
+		const replacementBody = { dataStream: text };
+		if (text && hasExplicitTextStyle) replacementBody.textRuns = [{
+			st: 0,
+			ed: text.length,
+			sId: styleId,
+			ts: Tools.deepClone(textStyle)
+		}];
+		if (text && ((_sourceBody$customRan = sourceBody.customRanges) === null || _sourceBody$customRan === void 0 ? void 0 : _sourceBody$customRan.length)) replacementBody.customRanges = sourceBody.customRanges.map((customRange) => ({
+			...Tools.deepClone(customRange),
+			startIndex: 0,
+			endIndex: text.length - 1
+		}));
+		if (text && ((_sourceBody$customDec = sourceBody.customDecorations) === null || _sourceBody$customDec === void 0 ? void 0 : _sourceBody$customDec.length)) replacementBody.customDecorations = sourceBody.customDecorations.map((decoration) => ({
+			...Tools.deepClone(decoration),
+			startIndex: 0,
+			endIndex: text.length - 1
+		}));
+		const textX = BuildTextUtils.selection.replace({
+			doc: this._doc,
+			selection: {
+				startOffset,
+				endOffset,
+				collapsed: startOffset === endOffset
+			},
+			body: replacementBody
+		});
+		if (!textX) throw new Error("Replace rich text run failed.");
+		TextX.apply(body, textX.serialize());
+		this._rebaseTrackedRanges(startOffset, endOffset, text.length);
+	}
+	_createParagraphBuilder(paragraphId, startOffset, endOffset) {
+		return new RichTextParagraphBuilder(this, paragraphId, this._trackRange(startOffset, endOffset));
+	}
+	_trackRange(startOffset, endOffset) {
+		const range = {
+			startOffset,
+			endOffset
+		};
+		this._trackedRanges.add(range);
+		return range;
+	}
+	_rebaseTrackedRanges(startOffset, endOffset, replacementLength) {
+		const delta = replacementLength - (endOffset - startOffset);
+		const mapStart = (offset) => {
+			if (offset <= startOffset) return offset;
+			if (offset >= endOffset) return offset + delta;
+			return startOffset;
+		};
+		const mapEnd = (offset) => {
+			if (offset <= startOffset) return offset;
+			if (offset >= endOffset) return offset + delta;
+			return startOffset + replacementLength;
+		};
+		for (const trackedRange of this._trackedRanges) {
+			trackedRange.startOffset = mapStart(trackedRange.startOffset);
+			trackedRange.endOffset = mapEnd(trackedRange.endOffset);
+		}
+	}
+	/**
 	* Appends plain text to the rich text.
 	*
 	* This is an agent-friendly alias of `insertText(text)`. Use it when building rich text from left to right for
@@ -16005,6 +19589,58 @@ var RichTextBuilder = class RichTextBuilder extends RichTextValue {
 		return this;
 	}
 	/**
+	* Sets the column layout for this rich-text document.
+	*
+	* Columns are stored in the rich-text document section layout. This creates text-flow columns, not table columns.
+	* The host renderer must support rich-text columns for the layout to be visible.
+	*
+	* @param options The column layout options.
+	* @param options.count The number of text columns. Must be a positive integer. Use `1` to clear multi-column layout.
+	* @param options.spacing The spacing between columns, in px. Defaults to `0`.
+	* @returns The current builder for chaining.
+	*
+	* @example
+	* ```ts
+	* const presentation = univerAPI.getActivePresentation();
+	* if (!presentation) throw new Error('No active presentation');
+	*
+	* const slide = presentation.getSlideByIndex(0);
+	* if (!slide) throw new Error('The presentation has no slides');
+	* const richText = univerAPI.newRichText()
+	*   .columns({ count: 2, spacing: 12 })
+	*   .text('Column text');
+	*
+	* const shapeInfo = slide.newShape()
+	*   .setRichText(richText)
+	*   .setAbsolutePosition(80, 80)
+	*   .setSize(360, 160)
+	*   .build();
+	*
+	* slide.insertShape(shapeInfo);
+	* ```
+	*/
+	columns(options) {
+		var _this$_data2, _this$_data2$body, _body$sectionBreaks, _options$spacing;
+		if (!Number.isInteger(options.count) || options.count < 1) throw new RangeError("Rich text column count must be a positive integer.");
+		const body = (_this$_data2$body = (_this$_data2 = this._data).body) !== null && _this$_data2$body !== void 0 ? _this$_data2$body : _this$_data2.body = { dataStream: "\r\n" };
+		const sectionBreaks = (_body$sectionBreaks = body.sectionBreaks) !== null && _body$sectionBreaks !== void 0 ? _body$sectionBreaks : body.sectionBreaks = [];
+		if (!sectionBreaks.length) {
+			var _body$dataStream$leng, _body$dataStream;
+			sectionBreaks.push({
+				sectionId: createSectionId(/* @__PURE__ */ new Set()),
+				startIndex: Math.max(0, ((_body$dataStream$leng = (_body$dataStream = body.dataStream) === null || _body$dataStream === void 0 ? void 0 : _body$dataStream.length) !== null && _body$dataStream$leng !== void 0 ? _body$dataStream$leng : 0) - 1)
+			});
+		}
+		const spacing = Math.max(0, (_options$spacing = options.spacing) !== null && _options$spacing !== void 0 ? _options$spacing : 0);
+		const columns = options.count === 1 ? void 0 : Array.from({ length: options.count }, (_, index) => ({
+			width: 0,
+			paddingEnd: index === options.count - 1 ? 0 : spacing
+		}));
+		for (const sectionBreak of sectionBreaks) if (columns) sectionBreak.columnProperties = columns.map((column) => ({ ...column }));
+		else delete sectionBreak.columnProperties;
+		return this;
+	}
+	/**
 	* Appends one text span with explicit style.
 	*
 	* Prefer this method when combining multiple styles, because the style object is local to the inserted text and does
@@ -16383,6 +20019,174 @@ var RichTextBuilder = class RichTextBuilder extends RichTextValue {
 		return typeof start === "number" ? this.insertRichText(start, rich) : this.insertRichText(rich);
 	}
 };
+/**
+* An editable paragraph handle owned by a detached {@link RichTextBuilder}.
+*
+* The paragraph is resolved by its persisted paragraph id, while its tracked range is rebased after every run edit.
+* This keeps paragraph traversal safe when earlier translated text becomes longer or shorter.
+*/
+var RichTextParagraphBuilder = class extends RichTextValue {
+	/** @hideconstructor */
+	constructor(_owner, _paragraphId, _range) {
+		super(createParagraphSnapshot(_owner.getData(), _paragraphId, _range));
+		this._owner = _owner;
+		this._paragraphId = _paragraphId;
+		this._range = _range;
+	}
+	/** Returns the persisted paragraph id. */
+	getId() {
+		return this._paragraphId;
+	}
+	/** Returns the current paragraph range without its trailing paragraph marker. */
+	getRange() {
+		return { ...this._range };
+	}
+	/**
+	* Returns the current paragraph text without its trailing paragraph marker.
+	* @example
+	* ```ts
+	* const richText = univerAPI.newRichText().text('Quarterly Review');
+	* const paragraph = richText.getParagraphs()[0];
+	* console.log(paragraph.getText());
+	* ```
+	*/
+	getText() {
+		var _this$_owner$getData$, _this$_owner$getData$2;
+		return ((_this$_owner$getData$ = (_this$_owner$getData$2 = this._owner.getData().body) === null || _this$_owner$getData$2 === void 0 ? void 0 : _this$_owner$getData$2.dataStream) !== null && _this$_owner$getData$ !== void 0 ? _this$_owner$getData$ : "").slice(this._range.startOffset, this._range.endOffset);
+	}
+	toPlainText() {
+		return this.getText();
+	}
+	/**
+	* Returns editable runs that cover all text in this paragraph, including unstyled gaps.
+	* @returns Editable text runs in document order.
+	*/
+	getTextRuns() {
+		return this._owner._createTextRunBuilders(this._range);
+	}
+	getParagraphStyle() {
+		return ParagraphStyleValue.create(this._getParagraph().paragraphStyle);
+	}
+	getParagraphBullet() {
+		return this._getParagraph().bullet;
+	}
+	getLinks() {
+		var _this$getData$body$cu, _this$getData$body;
+		return (_this$getData$body$cu = (_this$getData$body = this.getData().body) === null || _this$getData$body === void 0 || (_this$getData$body = _this$getData$body.customRanges) === null || _this$getData$body === void 0 ? void 0 : _this$getData$body.filter((range) => range.rangeType === 0)) !== null && _this$getData$body$cu !== void 0 ? _this$getData$body$cu : [];
+	}
+	/** Agent-friendly alias of `getParagraphBullet()`. */
+	getBullet() {
+		return this.getParagraphBullet();
+	}
+	getData() {
+		return createParagraphSnapshot(this._owner.getData(), this._paragraphId, this._range);
+	}
+	copy() {
+		return RichTextBuilder.create(Tools.deepClone(this.getData()));
+	}
+	_getParagraph() {
+		var _this$_owner$getData$3;
+		const paragraph = (_this$_owner$getData$3 = this._owner.getData().body) === null || _this$_owner$getData$3 === void 0 || (_this$_owner$getData$3 = _this$_owner$getData$3.paragraphs) === null || _this$_owner$getData$3 === void 0 ? void 0 : _this$_owner$getData$3.find((item) => item.paragraphId === this._paragraphId);
+		if (!paragraph) throw new Error(`Rich text paragraph "${this._paragraphId}" was not found.`);
+		return paragraph;
+	}
+};
+/**
+* An editable text-run handle owned by a detached {@link RichTextBuilder}.
+*
+* Calling {@link setText} replaces only the run text. The builder automatically updates this run, every later run,
+* paragraph indexes, hyperlinks, decorations, and other offset-based document metadata through TextX.
+*/
+var RichTextRunBuilder = class {
+	/** @hideconstructor */
+	constructor(_owner, _range, _textStyle, _styleId, _hasExplicitTextStyle) {
+		this._owner = _owner;
+		this._range = _range;
+		this._textStyle = _textStyle;
+		this._styleId = _styleId;
+		this._hasExplicitTextStyle = _hasExplicitTextStyle;
+		_defineProperty(this, "_active", true);
+	}
+	/** Inclusive start offset, kept for compatibility with existing `getTextRuns()` callers. */
+	get st() {
+		return this._range.startOffset;
+	}
+	/** Exclusive end offset, automatically updated after text replacement. */
+	get ed() {
+		return this._range.endOffset;
+	}
+	/** Optional persisted style id. This is not a stable run identity. */
+	get sId() {
+		return this._styleId;
+	}
+	/** Existing text-style value property exposed by `getTextRuns()`. */
+	get ts() {
+		return this._textStyle ? TextStyleValue.create(this._textStyle) : null;
+	}
+	/** Returns the current run range. */
+	getRange() {
+		return { ...this._range };
+	}
+	/** Returns the current run text. */
+	getText() {
+		var _this$_owner$getData$4, _this$_owner$getData$5;
+		return ((_this$_owner$getData$4 = (_this$_owner$getData$5 = this._owner.getData().body) === null || _this$_owner$getData$5 === void 0 ? void 0 : _this$_owner$getData$5.dataStream) !== null && _this$_owner$getData$4 !== void 0 ? _this$_owner$getData$4 : "").slice(this._range.startOffset, this._range.endOffset);
+	}
+	/** Returns this run's explicit text style, or `null` for an unstyled text segment. */
+	getTextStyle() {
+		return this.ts;
+	}
+	/** Returns whether this segment is backed by an explicit document text run. */
+	hasTextStyle() {
+		return this._hasExplicitTextStyle;
+	}
+	/**
+	* Replaces this run's text without changing its style or paragraph structure.
+	*
+	* Replacement text may be longer or shorter than the original. Offsets are updated automatically, so handles
+	* returned in the same `getTextRuns()` call remain safe to use in forward order. Paragraph and section breaks are
+	* rejected because a text run cannot create or remove paragraphs.
+	*
+	* @param text New text for this run.
+	* @returns This run handle for chaining. A handle becomes invalid after it is replaced with an empty string.
+	* @example
+	* ```ts
+	* const richText = univerAPI.newRichText()
+	*   .span('标题', { bold: true, fontSize: 24 })
+	*   .paragraph()
+	*   .text('正文内容');
+	* const replacements = ['Quarterly Review', 'Revenue increased by 18%.'];
+	* let index = 0;
+	* for (const run of richText.getTextRuns()) {
+	*   const replacement = replacements[index++];
+	*   if (replacement !== undefined) run.setText(replacement);
+	* }
+	* console.log(richText.toPlainText());
+	* ```
+	*/
+	setText(text) {
+		if (!this._active) throw new Error("Rich text run handle is no longer valid.");
+		this._owner._replaceTextRun(this._range, text, this._textStyle, this._styleId, this._hasExplicitTextStyle);
+		if (!text) this._active = false;
+		return this;
+	}
+};
+function createParagraphSnapshot(data, paragraphId, range) {
+	var _body$paragraphs2;
+	const { body, ...documentData } = data;
+	if (!body) throw new Error("Rich text body is not available.");
+	const paragraph = (_body$paragraphs2 = body.paragraphs) === null || _body$paragraphs2 === void 0 ? void 0 : _body$paragraphs2.find((item) => item.paragraphId === paragraphId);
+	if (!paragraph) throw new Error(`Rich text paragraph "${paragraphId}" was not found.`);
+	const paragraphBody = getBodySlice(body, range.startOffset, range.endOffset);
+	paragraphBody.paragraphs = [{
+		...Tools.deepClone(paragraph),
+		startIndex: range.endOffset - range.startOffset
+	}];
+	return {
+		...Tools.deepClone(documentData),
+		body: paragraphBody
+	};
+}
 
 //#endregion
 //#region src/docs/data-model/subdocument.ts
@@ -22982,6 +26786,8 @@ Object.defineProperty(exports, 'ResourceManagerService', {
   }
 });
 exports.RichTextBuilder = RichTextBuilder;
+exports.RichTextParagraphBuilder = RichTextParagraphBuilder;
+exports.RichTextRunBuilder = RichTextRunBuilder;
 exports.RichTextValue = RichTextValue;
 exports.RxDisposable = RxDisposable;
 exports.SECTION_ID_PREFIX = SECTION_ID_PREFIX;
@@ -23164,6 +26970,7 @@ exports.getCellValueType = getCellValueType;
 exports.getCellWithCoordByIndexCore = getCellWithCoordByIndexCore;
 exports.getColorStyle = getColorStyle;
 exports.getColumnGroupRangeInterval = getColumnGroupRangeInterval;
+exports.getCustomBlockIdsInSelections = getCustomBlockIdsInSelections;
 exports.getCustomBlockInterval = getCustomBlockInterval;
 exports.getCustomBlockSlice = getCustomBlockSlice;
 exports.getCustomDecorationSlice = getCustomDecorationSlice;
@@ -23309,7 +27116,7 @@ exports.numberToListABC = numberToListABC;
 Object.defineProperty(exports, 'numfmt', {
   enumerable: true,
   get: function () {
-    return numfmt;
+    return api_exports;
   }
 });
 exports.queryObjectMatrix = queryObjectMatrix;