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

package/lib/es/index.js

@@ -2,8 +2,7 @@ import { BehaviorSubject, Observable, ReplaySubject, Subject, Subscription, comb
 import { ObjectScope, UnitRole, UniverType as UniverInstanceType } from "@univerjs/protocol";
 import { debounceTime as debounceTime$1, filter as filter$1, first, map as map$1 } from "rxjs/operators";
 import { Inject, Inject as Inject$1, InjectSelf, Injector, Injector as Injector$1, LookUp, Many, Optional, Quantity, RediError, Self, SkipSelf, WithNew, createIdentifier, createIdentifier as createIdentifier$1, forwardRef, isAsyncDependencyItem, isAsyncHook, isClassDependencyItem, isCtor, isDisposable, isFactoryDependencyItem, isValueDependencyItem, setDependencies } from "@wendellhu/redi";
-import { debounce, get, merge, mergeWith, mergeWith as mergeWith$1, set } from "lodash-es";
-import * as numfmt from "numfmt";
+import { debounce, get, merge, mergeWith, set } from "lodash-es";
 import RBush, { default as RBush$1 } from "rbush";
 import AsyncLock from "async-lock";
 import * as json1 from "ot-json1";
@@ -11,6 +10,23 @@ import fastDiff from "fast-diff";
 import { defaultTheme } from "@univerjs/themes";
 import KDBush from "kdbush";
 
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+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;
+};
+
+//#endregion
 //#region src/common/shims.ts
 /**
 * Copyright 2023-present DreamNum Co., Ltd.
@@ -1698,7 +1714,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.5";
 
 //#endregion
 //#region src/common/array.ts
@@ -3869,79 +3885,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
@@ -4257,22 +7710,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";
@@ -4290,22 +7728,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 || "";
 		}
@@ -4355,8 +7793,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) {
@@ -6806,6 +10244,7 @@ const STYLE_KEYS = defineExactKeys()([
 	"cl",
 	"va",
 	"n",
+	"stf",
 	"tr",
 	"td",
 	"ht",
@@ -13218,7 +16657,7 @@ function createDocumentSnapshot(snapshot) {
 	};
 	const defaultSnapshot = getEmptySnapshot$1(snapshot.id, snapshot.locale, snapshot.title, (_snapshot$documentSty = snapshot.documentStyle) === null || _snapshot$documentSty === void 0 ? void 0 : _snapshot$documentSty.documentFlavor);
 	if (Tools.isEmptyObject(snapshot)) return defaultSnapshot;
-	const mergedSnapshot = mergeWith$1({}, defaultSnapshot, snapshot, (_objValue, srcValue, key) => {
+	const mergedSnapshot = mergeWith({}, defaultSnapshot, snapshot, (_objValue, srcValue, key) => {
 		if (Array.isArray(srcValue)) return srcValue;
 		if (key === "body" && srcValue != null && typeof srcValue === "object") return srcValue;
 	});
@@ -14305,6 +17744,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) {
@@ -15914,9 +19354,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
@@ -15971,6 +19560,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
@@ -16349,6 +19990,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
@@ -22643,4 +26452,4 @@ function createUniverInjector(parentInjector, override) {
 installShims();
 
 //#endregion
-export { ABCToNumber, AUTO_HEIGHT_FOR_MERGED_CELLS, AbsoluteRefType, ActionIterator, AlignTypeH, AlignTypeV, ArrangeTypeEnum, AsyncInterceptorManager, AsyncLock, AuthzIoLocalService, AutoFillSeries, BORDER_KEYS, BORDER_STYLE_KEYS, BaseDataModel, BaseFieldType, BaseFilterConjunction, BaseFilterOperator, BaseSortDirection, BaseViewType, BaselineOffset, BlockType, BooleanNumber, BorderStyleTypes, BorderType, BuildTextUtils, BulletAlignment, COLORS, COLOR_STYLE_KEYS, COMMAND_LOG_EXECUTION_CONFIG_KEY, CanceledError, CellModeEnum, CellValueType, ColorKit, ColorType, ColumnLayoutType, ColumnResponsiveType, ColumnSeparatorType, CommandService, CommandType, CommonHideTypes, ConfigService, ContextService, CopyPasteType, CustomCommandExecutionError, CustomDecorationType, CustomRangeType, DEFAULT_CELL, DEFAULT_DOC, DEFAULT_DOCUMENT_PARAGRAPH_LINE_SPACING, DEFAULT_DOCUMENT_PARAGRAPH_SPACE_ABOVE, DEFAULT_DOCUMENT_PARAGRAPH_SPACE_BELOW, DEFAULT_DOCUMENT_SUB_COMPONENT_ID, DEFAULT_EMPTY_DOCUMENT_VALUE, DEFAULT_NUMBER_FORMAT, DEFAULT_RANGE, DEFAULT_RANGE_ARRAY, DEFAULT_SELECTION, DEFAULT_STYLES, DEFAULT_TEXT_FORMAT, DEFAULT_TEXT_FORMAT_EXCEL, DEFAULT_WORKSHEET_COLUMN_COUNT, DEFAULT_WORKSHEET_COLUMN_COUNT_KEY, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT_KEY, DEFAULT_WORKSHEET_COLUMN_WIDTH, DEFAULT_WORKSHEET_COLUMN_WIDTH_KEY, DEFAULT_WORKSHEET_ROW_COUNT, DEFAULT_WORKSHEET_ROW_COUNT_KEY, DEFAULT_WORKSHEET_ROW_HEIGHT, DEFAULT_WORKSHEET_ROW_HEIGHT_KEY, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH_KEY, DOCS_COMMENT_EDITOR_UNIT_ID_KEY, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, DOC_DRAWING_PRINTING_COMPONENT_KEY, DOC_RANGE_TYPE, DashStyleType, DataStreamTreeNodeType, DataStreamTreeTokenType, DataValidationErrorStyle, DataValidationImeMode, DataValidationOperator, DataValidationRenderMode, DataValidationStatus, DataValidationType, DeleteDirection, DependentOn, DesktopLogService, DeveloperMetadataVisibility, Dimension, Direction, Disposable, DisposableCollection, DocStyleType, DocumentBlockRangeType, DocumentBlockType, DocumentDataModel, DocumentFlavor, DrawingTypeEnum, EDITOR_ACTIVATED, EXTENSION_NAMES, ErrorService, EventState, EventSubject, FOCUSING_COMMENT_EDITOR, FOCUSING_COMMON_DRAWINGS, FOCUSING_DOC, FOCUSING_EDITOR_BUT_HIDDEN, FOCUSING_EDITOR_INPUT_FORMULA, FOCUSING_EDITOR_STANDALONE, FOCUSING_FX_BAR_EDITOR, FOCUSING_PANEL_EDITOR, FOCUSING_SHAPE_TEXT_EDITOR, FOCUSING_SHEET, FOCUSING_SLIDE, FOCUSING_UNIT, FOCUSING_UNIVER_EDITOR, FOCUSING_UNIVER_EDITOR_STANDALONE_SINGLE_MODE, FORMULA_EDITOR_ACTIVATED, FollowNumberWithType, FontItalic, FontStyleType, FontWeight, GridType, HorizontalAlign, IAuthzIoService, ICommandService, IConfigService, IConfirmService, IContextService, IImageIoService, ILocalStorageService, ILogService, IMentionIOService, IPermissionService, IResourceLoaderService, IResourceManagerService, IS_ROW_STYLE_PRECEDE_COLUMN_STYLE, IURLImageService, IUndoRedoService, IUniverInstanceService, ImageCacheMap, ImageSourceType, ImageUploadStatusType, Inject, InjectSelf, Injector, InterceptorEffectEnum, InterceptorManager, InterpolationPointType, json1 as JSON1, JSONX, LOCALE_META, LRUHelper, LRUMap, LifecycleService, LifecycleStages, LifecycleUnreachableError, ListGlyphType, LocalUndoRedoService, LocaleService, LocaleType, LogLevel, LookUp, MAX_COLUMN_COUNT, MAX_ROW_COUNT, MODERN_DOCUMENT_DEFAULT_MARGIN, MODERN_DOCUMENT_WIDTH, MOVE_BUFFER_VALUE, Many, MemoryCursor, MentionIOLocalService, MentionType, ModernDocumentWidthMode, NAMED_STYLE_MAP, NAMED_STYLE_SPACE_MAP, NamedStyleType, NilCommand, NumberUnitType, ObjectMatrix, ObjectRelativeFromH, ObjectRelativeFromV, Optional, PADDING_KEYS, PAGE_SIZE, PAPER_TYPES, PARAGRAPH_ID_PREFIX, PRESERVE_INSERTED_PARAGRAPH_IDS, PRESET_LIST_TYPE, PageOrientType, PaperType, ParagraphElementType, ParagraphStyleBuilder, ParagraphStyleValue, PermissionService, PermissionStatus, Plugin, PluginService, PositionedObjectLayoutType, PresetListType, ProtectionType, Quantity, QuickListType, QuickListTypeMap, RANGE_DIRECTION, RANGE_TYPE, RBush, RCDisposable, RESTORE_INSERTED_PARAGRAPH_IDS, RGBA_PAREN, RGB_PAREN, ROTATE_BUFFER_VALUE, RTree, Range, Rectangle, RediError, RedoCommand, RedoCommandId, RefAlias, Registry, RegistryAsMap, RelativeDate, ResourceManagerService, RichTextBuilder, RichTextValue, RxDisposable, SECTION_ID_PREFIX, SHEET_EDITOR_UNITS, STYLE_KEYS, SectionType, Self, SheetSkeleton, SheetTypes, SheetViewModel, Skeleton, SkipSelf, SliceBodyType, SpacingRule, Styles, TEXT_DECORATION_KEYS, TEXT_ROTATION_KEYS, THEME_COLORS, TabStopAlignment, TableAlignmentType, TableLayoutType, TableRowHeightRule, TableSizeType, TableTextWrapType, TestConfirmService, TextDecoration, TextDecorationBuilder, TextDirection, TextDirectionType, TextStyleBuilder, TextStyleValue, TextX, TextXActionType, ThemeColorType, ThemeColors, ThemeService, Tools, UndoCommand, UndoCommandId, UnitModel, Univer, UniverInstanceService, UniverInstanceType, UpdateDocsAttributeType, UserManagerService, VerticalAlign, VerticalAlignmentType, WithNew, Workbook, Worksheet, WrapStrategy, WrapTextType, addLinkToDocumentModel, afterInitApply, afterTime, awaitTime, binSearchFirstGreaterThanTarget, binarySearchArray, bufferDebounceTime, cellToRange, characterSpacingControlType, checkForSubstrings, checkIfMove, checkParagraphHasBullet, checkParagraphHasIndent, checkParagraphHasIndentByStyle, cloneBodyWithFreshParagraphIds, cloneCellData, cloneCellDataMatrix, cloneCellDataWithSpanAndDisplay, cloneParagraphWithId, cloneSectionBreakWithId, cloneValue, cloneWorksheetData, codeToBlob, columnLabelToNumber, composeBody, composeInterceptors, composeStyles, concatMatrixArray, containsInteriorInsertionOffset, containsStreamIndex, convertCellToRange, convertObservableToBehaviorSubject, covertCellValue, covertCellValues, createAsyncInterceptorKey, createDefaultBaseTableSnapshot, createDefaultUser, createDocumentModelWithStyle, createIdentifier, createInterceptorKey, createInternalEditorID, createParagraphId, createRandomId, createRowColIter, createSectionId, createSheetGapTestConfig, currencySymbols, customNameCharacterCheck, dateKit, debounce, dedupe, dedupeBy, deepCompare, delayAnimationFrame, deleteContent, extractPureTextFromCell, forwardRef, fromCallback, fromEventSubject, generateIntervalsByPoints, generateRandomId, get, getArrayLength, getEmptySnapshot as getBasesEmptySnapshot, getBlockRangeInterval, getBodySlice, getBodySliceForSplitTextXAction, getBodySliceForTextXAction, getBorderStyleType, getCellCoordByIndexSimple, getCellInfoInMergeData, getCellValueType, getCellWithCoordByIndexCore, getColorStyle, getColumnGroupRangeInterval, getCustomBlockInterval, getCustomBlockSlice, getCustomDecorationSlice, getCustomRangeInterval, getCustomRangeSlice, getDisplayValueFromCell, getEmptySnapshot$1 as getDocsEmptySnapshot, getDocsUpdateBody, getEmptyCell, getExclusiveRangeInterval, getInclusiveRangeInterval, getIntersectRange, getNumfmtParseValueFilter, getOriginCellValue, getParagraphContentStartOffset, getParagraphContentStartOffsets, getParagraphFollowingBlockOffset, getParagraphsSlice, getPlainText, getReverseDirection, getRichTextEditPath, getSectionBreakSlice, getSectionHeaderFooterReferenceKey, getEmptySnapshot$2 as getSheetsEmptySnapshot, getSingleDataStreamChange, getTableCellTokenInterval, getTableRangeInterval, getTableRowTokenInterval, getTableSlice, getTextRunSlice, getTransformOffsetX, getTransformOffsetY, getWorksheetUID, groupBy, handleStyleToString, hashAlgorithm, horizontalLineSegmentsSubtraction, insertMatrixArray, insertTextToContent, intersectsOperationalIntervals, invertColorByHSL, invertColorByMatrix, isAsyncDependencyItem, isAsyncHook, isBlackColor, isBooleanString, isCellCoverable, isCellV, isClassDependencyItem, isCommentEditorID, isCtor, isDefaultFormat, isDisposable, isEmptyCell, isFactoryDependencyItem, isFormulaId, isFormulaString, isICellData, isInternalEditorID, isNodeEnv, isNotNullOrUndefined, isNullCell, isNumeric, isPatternEqualWithoutDecimal, isRangesEqual, isRealNum, isSafeNumeric, isSafeUrl, isSameStyleTextRun, isTextFormat, isUnitRangesEqual, isValidRange, isValueDependencyItem, isWhiteColor, makeArray, makeCellRangeToRangeData, makeCellToSelection, makeCustomRangeStream, mapObjectMatrix, merge, mergeIntervals, mergeLocales, mergeOverrideWithDependencies, mergeSets, mergeWith, mergeWorksheetSnapshotWithDefault, mixinClass, moveMatrixArray, moveRangeByOffset, nameCharacterCheck, noop, normalizeBody, normalizeInsertedSectionIdsForDocument, normalizeTextRuns, normalizeUrl, numberToABC, numberToListABC, numfmt, queryObjectMatrix, regexp, registerDependencies, remove, repeatStringNumTimes, replaceInDocumentBody, requestImmediateMacroTask, resolveDocumentParagraphStyle, resolveSectionHeaderFooterReference, resolveSectionHeaderFooterReferences, resolveWithBasePath, rotate, searchArray, searchInOrderedArray, selectionToArray, sequence, sequenceAsync, sequenceExecute, sequenceExecuteAsync, set, setDependencies, shallowEqual, shiftExclusiveRangeOnDelete, shiftExclusiveRangeOnInsert, shiftInclusiveRangeOnDelete, shiftInclusiveRangeOnInsert, skipParseTagNames, sliceMatrixArray, sortRules, sortRulesByDesc, sortRulesFactory, spliceArray, splitIntoGrid, takeAfter, throttle, toDisposable, touchDependencies, updateAttributeByDelete, updateAttributeByInsert, validateDocBodyStructure, validateDocumentStructure, willLoseNumericPrecision };
+export { ABCToNumber, AUTO_HEIGHT_FOR_MERGED_CELLS, AbsoluteRefType, ActionIterator, AlignTypeH, AlignTypeV, ArrangeTypeEnum, AsyncInterceptorManager, AsyncLock, AuthzIoLocalService, AutoFillSeries, BORDER_KEYS, BORDER_STYLE_KEYS, BaseDataModel, BaseFieldType, BaseFilterConjunction, BaseFilterOperator, BaseSortDirection, BaseViewType, BaselineOffset, BlockType, BooleanNumber, BorderStyleTypes, BorderType, BuildTextUtils, BulletAlignment, COLORS, COLOR_STYLE_KEYS, COMMAND_LOG_EXECUTION_CONFIG_KEY, CanceledError, CellModeEnum, CellValueType, ColorKit, ColorType, ColumnLayoutType, ColumnResponsiveType, ColumnSeparatorType, CommandService, CommandType, CommonHideTypes, ConfigService, ContextService, CopyPasteType, CustomCommandExecutionError, CustomDecorationType, CustomRangeType, DEFAULT_CELL, DEFAULT_DOC, DEFAULT_DOCUMENT_PARAGRAPH_LINE_SPACING, DEFAULT_DOCUMENT_PARAGRAPH_SPACE_ABOVE, DEFAULT_DOCUMENT_PARAGRAPH_SPACE_BELOW, DEFAULT_DOCUMENT_SUB_COMPONENT_ID, DEFAULT_EMPTY_DOCUMENT_VALUE, DEFAULT_NUMBER_FORMAT, DEFAULT_RANGE, DEFAULT_RANGE_ARRAY, DEFAULT_SELECTION, DEFAULT_STYLES, DEFAULT_TEXT_FORMAT, DEFAULT_TEXT_FORMAT_EXCEL, DEFAULT_WORKSHEET_COLUMN_COUNT, DEFAULT_WORKSHEET_COLUMN_COUNT_KEY, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT_KEY, DEFAULT_WORKSHEET_COLUMN_WIDTH, DEFAULT_WORKSHEET_COLUMN_WIDTH_KEY, DEFAULT_WORKSHEET_ROW_COUNT, DEFAULT_WORKSHEET_ROW_COUNT_KEY, DEFAULT_WORKSHEET_ROW_HEIGHT, DEFAULT_WORKSHEET_ROW_HEIGHT_KEY, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH_KEY, DOCS_COMMENT_EDITOR_UNIT_ID_KEY, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, DOC_DRAWING_PRINTING_COMPONENT_KEY, DOC_RANGE_TYPE, DashStyleType, DataStreamTreeNodeType, DataStreamTreeTokenType, DataValidationErrorStyle, DataValidationImeMode, DataValidationOperator, DataValidationRenderMode, DataValidationStatus, DataValidationType, DeleteDirection, DependentOn, DesktopLogService, DeveloperMetadataVisibility, Dimension, Direction, Disposable, DisposableCollection, DocStyleType, DocumentBlockRangeType, DocumentBlockType, DocumentDataModel, DocumentFlavor, DrawingTypeEnum, EDITOR_ACTIVATED, EXTENSION_NAMES, ErrorService, EventState, EventSubject, FOCUSING_COMMENT_EDITOR, FOCUSING_COMMON_DRAWINGS, FOCUSING_DOC, FOCUSING_EDITOR_BUT_HIDDEN, FOCUSING_EDITOR_INPUT_FORMULA, FOCUSING_EDITOR_STANDALONE, FOCUSING_FX_BAR_EDITOR, FOCUSING_PANEL_EDITOR, FOCUSING_SHAPE_TEXT_EDITOR, FOCUSING_SHEET, FOCUSING_SLIDE, FOCUSING_UNIT, FOCUSING_UNIVER_EDITOR, FOCUSING_UNIVER_EDITOR_STANDALONE_SINGLE_MODE, FORMULA_EDITOR_ACTIVATED, FollowNumberWithType, FontItalic, FontStyleType, FontWeight, GridType, HorizontalAlign, IAuthzIoService, ICommandService, IConfigService, IConfirmService, IContextService, IImageIoService, ILocalStorageService, ILogService, IMentionIOService, IPermissionService, IResourceLoaderService, IResourceManagerService, IS_ROW_STYLE_PRECEDE_COLUMN_STYLE, IURLImageService, IUndoRedoService, IUniverInstanceService, ImageCacheMap, ImageSourceType, ImageUploadStatusType, Inject, InjectSelf, Injector, InterceptorEffectEnum, InterceptorManager, InterpolationPointType, json1 as JSON1, JSONX, LOCALE_META, LRUHelper, LRUMap, LifecycleService, LifecycleStages, LifecycleUnreachableError, ListGlyphType, LocalUndoRedoService, LocaleService, LocaleType, LogLevel, LookUp, MAX_COLUMN_COUNT, MAX_ROW_COUNT, MODERN_DOCUMENT_DEFAULT_MARGIN, MODERN_DOCUMENT_WIDTH, MOVE_BUFFER_VALUE, Many, MemoryCursor, MentionIOLocalService, MentionType, ModernDocumentWidthMode, NAMED_STYLE_MAP, NAMED_STYLE_SPACE_MAP, NamedStyleType, NilCommand, NumberUnitType, ObjectMatrix, ObjectRelativeFromH, ObjectRelativeFromV, Optional, PADDING_KEYS, PAGE_SIZE, PAPER_TYPES, PARAGRAPH_ID_PREFIX, PRESERVE_INSERTED_PARAGRAPH_IDS, PRESET_LIST_TYPE, PageOrientType, PaperType, ParagraphElementType, ParagraphStyleBuilder, ParagraphStyleValue, PermissionService, PermissionStatus, Plugin, PluginService, PositionedObjectLayoutType, PresetListType, ProtectionType, Quantity, QuickListType, QuickListTypeMap, RANGE_DIRECTION, RANGE_TYPE, RBush, RCDisposable, RESTORE_INSERTED_PARAGRAPH_IDS, RGBA_PAREN, RGB_PAREN, ROTATE_BUFFER_VALUE, RTree, Range, Rectangle, RediError, RedoCommand, RedoCommandId, RefAlias, Registry, RegistryAsMap, RelativeDate, ResourceManagerService, RichTextBuilder, RichTextParagraphBuilder, RichTextRunBuilder, RichTextValue, RxDisposable, SECTION_ID_PREFIX, SHEET_EDITOR_UNITS, STYLE_KEYS, SectionType, Self, SheetSkeleton, SheetTypes, SheetViewModel, Skeleton, SkipSelf, SliceBodyType, SpacingRule, Styles, TEXT_DECORATION_KEYS, TEXT_ROTATION_KEYS, THEME_COLORS, TabStopAlignment, TableAlignmentType, TableLayoutType, TableRowHeightRule, TableSizeType, TableTextWrapType, TestConfirmService, TextDecoration, TextDecorationBuilder, TextDirection, TextDirectionType, TextStyleBuilder, TextStyleValue, TextX, TextXActionType, ThemeColorType, ThemeColors, ThemeService, Tools, UndoCommand, UndoCommandId, UnitModel, Univer, UniverInstanceService, UniverInstanceType, UpdateDocsAttributeType, UserManagerService, VerticalAlign, VerticalAlignmentType, WithNew, Workbook, Worksheet, WrapStrategy, WrapTextType, addLinkToDocumentModel, afterInitApply, afterTime, awaitTime, binSearchFirstGreaterThanTarget, binarySearchArray, bufferDebounceTime, cellToRange, characterSpacingControlType, checkForSubstrings, checkIfMove, checkParagraphHasBullet, checkParagraphHasIndent, checkParagraphHasIndentByStyle, cloneBodyWithFreshParagraphIds, cloneCellData, cloneCellDataMatrix, cloneCellDataWithSpanAndDisplay, cloneParagraphWithId, cloneSectionBreakWithId, cloneValue, cloneWorksheetData, codeToBlob, columnLabelToNumber, composeBody, composeInterceptors, composeStyles, concatMatrixArray, containsInteriorInsertionOffset, containsStreamIndex, convertCellToRange, convertObservableToBehaviorSubject, covertCellValue, covertCellValues, createAsyncInterceptorKey, createDefaultBaseTableSnapshot, createDefaultUser, createDocumentModelWithStyle, createIdentifier, createInterceptorKey, createInternalEditorID, createParagraphId, createRandomId, createRowColIter, createSectionId, createSheetGapTestConfig, currencySymbols, customNameCharacterCheck, dateKit, debounce, dedupe, dedupeBy, deepCompare, delayAnimationFrame, deleteContent, extractPureTextFromCell, forwardRef, fromCallback, fromEventSubject, generateIntervalsByPoints, generateRandomId, get, getArrayLength, getEmptySnapshot as getBasesEmptySnapshot, getBlockRangeInterval, getBodySlice, getBodySliceForSplitTextXAction, getBodySliceForTextXAction, getBorderStyleType, getCellCoordByIndexSimple, getCellInfoInMergeData, getCellValueType, getCellWithCoordByIndexCore, getColorStyle, getColumnGroupRangeInterval, getCustomBlockIdsInSelections, getCustomBlockInterval, getCustomBlockSlice, getCustomDecorationSlice, getCustomRangeInterval, getCustomRangeSlice, getDisplayValueFromCell, getEmptySnapshot$1 as getDocsEmptySnapshot, getDocsUpdateBody, getEmptyCell, getExclusiveRangeInterval, getInclusiveRangeInterval, getIntersectRange, getNumfmtParseValueFilter, getOriginCellValue, getParagraphContentStartOffset, getParagraphContentStartOffsets, getParagraphFollowingBlockOffset, getParagraphsSlice, getPlainText, getReverseDirection, getRichTextEditPath, getSectionBreakSlice, getSectionHeaderFooterReferenceKey, getEmptySnapshot$2 as getSheetsEmptySnapshot, getSingleDataStreamChange, getTableCellTokenInterval, getTableRangeInterval, getTableRowTokenInterval, getTableSlice, getTextRunSlice, getTransformOffsetX, getTransformOffsetY, getWorksheetUID, groupBy, handleStyleToString, hashAlgorithm, horizontalLineSegmentsSubtraction, insertMatrixArray, insertTextToContent, intersectsOperationalIntervals, invertColorByHSL, invertColorByMatrix, isAsyncDependencyItem, isAsyncHook, isBlackColor, isBooleanString, isCellCoverable, isCellV, isClassDependencyItem, isCommentEditorID, isCtor, isDefaultFormat, isDisposable, isEmptyCell, isFactoryDependencyItem, isFormulaId, isFormulaString, isICellData, isInternalEditorID, isNodeEnv, isNotNullOrUndefined, isNullCell, isNumeric, isPatternEqualWithoutDecimal, isRangesEqual, isRealNum, isSafeNumeric, isSafeUrl, isSameStyleTextRun, isTextFormat, isUnitRangesEqual, isValidRange, isValueDependencyItem, isWhiteColor, makeArray, makeCellRangeToRangeData, makeCellToSelection, makeCustomRangeStream, mapObjectMatrix, merge, mergeIntervals, mergeLocales, mergeOverrideWithDependencies, mergeSets, mergeWith, mergeWorksheetSnapshotWithDefault, mixinClass, moveMatrixArray, moveRangeByOffset, nameCharacterCheck, noop, normalizeBody, normalizeInsertedSectionIdsForDocument, normalizeTextRuns, normalizeUrl, numberToABC, numberToListABC, api_exports as numfmt, queryObjectMatrix, regexp, registerDependencies, remove, repeatStringNumTimes, replaceInDocumentBody, requestImmediateMacroTask, resolveDocumentParagraphStyle, resolveSectionHeaderFooterReference, resolveSectionHeaderFooterReferences, resolveWithBasePath, rotate, searchArray, searchInOrderedArray, selectionToArray, sequence, sequenceAsync, sequenceExecute, sequenceExecuteAsync, set, setDependencies, shallowEqual, shiftExclusiveRangeOnDelete, shiftExclusiveRangeOnInsert, shiftInclusiveRangeOnDelete, shiftInclusiveRangeOnInsert, skipParseTagNames, sliceMatrixArray, sortRules, sortRulesByDesc, sortRulesFactory, spliceArray, splitIntoGrid, takeAfter, throttle, toDisposable, touchDependencies, updateAttributeByDelete, updateAttributeByInsert, validateDocBodyStructure, validateDocumentStructure, willLoseNumericPrecision };