@wzo/calc 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1324 @@
+//#region src/utils/config.ts
+/** Default configuration values. */
+const DEFAULT_CONFIG = {
+	_error: "-",
+	_fmt: void 0,
+	_precision: 50
+};
+const config = { ...DEFAULT_CONFIG };
+/**
+* Partially updates the global configuration (only the provided fields are overwritten).
+*
+* @param patch Configuration fields to update
+* @example
+* setConfig({ _precision: 10, _fmt: { decimals: 2 } })
+*/
+const setConfig = (patch) => {
+	Object.assign(config, patch);
+};
+/**
+* Resets the global configuration to its default values.
+*
+* @example
+* resetConfig()
+*/
+const resetConfig = () => {
+	Object.assign(config, DEFAULT_CONFIG);
+};
+/**
+* Returns the current global configuration object (by reference — do not mutate directly; use {@link setConfig}).
+*
+* @returns The current {@link IGlobalConfig}
+*/
+const getConfig = () => config;
+/** Returns the global config; if `_precision` is provided, returns a copy with that field overridden without mutating the global singleton. */
+const configWithPrecision = (opt) => opt?._precision != null ? {
+	...config,
+	_precision: opt._precision
+} : config;
+
+//#endregion
+//#region src/utils/precision.ts
+const TEN = 10n;
+const POW10 = [1n];
+const pow10 = (n) => {
+	for (let i = POW10.length; i <= n; i++) POW10[i] = POW10[i - 1] * TEN;
+	return POW10[n];
+};
+const RE_SCI = /^([+-]?\d+(?:\.\d+)?)e([+-]?\d+)$/i;
+const RE_NUM = /^\d+(?:\.\d+)?$/;
+const RE_TRAIL_ZERO$1 = /0+$/;
+/** Shifts the decimal point of `"1.23"` left or right by `n` positions → string. */
+const shiftDecimalPoint = (s, n) => {
+	let sign = "";
+	if (s.startsWith("-")) {
+		sign = "-";
+		s = s.slice(1);
+	} else if (s.startsWith("+")) s = s.slice(1);
+	const dot = s.indexOf(".");
+	const allDigits = dot === -1 ? s : s.slice(0, dot) + s.slice(dot + 1);
+	const dotPos = (dot === -1 ? s.length : dot) + n;
+	if (dotPos <= 0) return `${sign}0.${"0".repeat(-dotPos)}${allDigits}`;
+	if (dotPos >= allDigits.length) return sign + allDigits + "0".repeat(dotPos - allDigits.length);
+	return `${sign}${allDigits.slice(0, dotPos)}.${allDigits.slice(dotPos)}`;
+};
+/**
+* Parses a string, number, or bigint into the internal {@link IDecimal} representation.
+*
+* Supports standard decimals (`"1.23"`, `-0.5`) and scientific notation (`"1.2e-3"`).
+*
+* @param input Value to parse, e.g. `"3.14"`, `42`, `-1n`, `"1e10"`
+* @returns Parsed {@link IDecimal} (`digits` is always >= 0; sign is carried by `sign`)
+* @throws When the string is not a valid number
+* @example
+* parse('1.23') // { sign: 1, digits: 123n, exp: 2 }
+* parse('-5')   // { sign: -1, digits: 5n, exp: 0 }
+*/
+const parse = (input) => {
+	if (typeof input === "bigint") return {
+		sign: input < 0n ? -1 : 1,
+		digits: input < 0n ? -input : input,
+		exp: 0
+	};
+	let s = String(input).trim();
+	if (s === "" || s === "-" || s === "+") throw new Error(`Cannot parse number: "${input}"`);
+	const expMatch = RE_SCI.exec(s);
+	if (expMatch) {
+		const base = expMatch[1];
+		s = shiftDecimalPoint(base, Number.parseInt(expMatch[2], 10));
+	}
+	let sign = 1;
+	if (s.startsWith("+")) s = s.slice(1);
+	else if (s.startsWith("-")) {
+		sign = -1;
+		s = s.slice(1);
+	}
+	if (!RE_NUM.test(s)) throw new Error(`Cannot parse number: "${input}"`);
+	const dot = s.indexOf(".");
+	const digitStr = dot === -1 ? s : s.slice(0, dot) + s.slice(dot + 1);
+	const exp = dot === -1 ? 0 : s.length - dot - 1;
+	const digits = BigInt(digitStr || "0");
+	if (digits === 0n) return {
+		sign: 1,
+		digits: 0n,
+		exp: 0
+	};
+	return {
+		sign,
+		digits,
+		exp
+	};
+};
+/**
+* Converts an {@link IDecimal} back to a canonical decimal string (trailing zeros are stripped automatically).
+*
+* @param d The {@link IDecimal} to format
+* @returns Canonical string; zero is always returned as `"0"`
+* @example
+* format({ sign: 1, digits: 1230n, exp: 3 }) // '1.23'
+*/
+const format = (d) => {
+	if (d.digits === 0n) return "0";
+	let raw = d.digits.toString();
+	if (d.exp > 0) {
+		if (raw.length <= d.exp) raw = "0".repeat(d.exp - raw.length + 1) + raw;
+		const intPart = raw.slice(0, raw.length - d.exp);
+		const fracPart = raw.slice(raw.length - d.exp).replace(RE_TRAIL_ZERO$1, "");
+		raw = fracPart ? `${intPart}.${fracPart}` : intPart;
+	}
+	return (d.sign < 0 ? "-" : "") + raw;
+};
+/** Aligns the digits of two numbers to the same exp (using the larger of the two). */
+const align = (a, b) => {
+	if (a.exp === b.exp) return {
+		aN: a.digits,
+		bN: b.digits,
+		exp: a.exp
+	};
+	if (a.exp > b.exp) return {
+		aN: a.digits,
+		bN: b.digits * TEN ** BigInt(a.exp - b.exp),
+		exp: a.exp
+	};
+	return {
+		aN: a.digits * TEN ** BigInt(b.exp - a.exp),
+		bN: b.digits,
+		exp: b.exp
+	};
+};
+const fromBig = (n, exp) => {
+	if (n === 0n) return {
+		sign: 1,
+		digits: 0n,
+		exp: 0
+	};
+	return {
+		sign: n < 0n ? -1 : 1,
+		digits: n < 0n ? -n : n,
+		exp
+	};
+};
+const MAX_SAFE = Number.MAX_SAFE_INTEGER;
+const POW10F = [
+	1,
+	10,
+	100,
+	1e3,
+	1e4,
+	1e5,
+	1e6,
+	1e7,
+	1e8,
+	1e9,
+	1e10,
+	1e11,
+	0xe8d4a51000,
+	0x9184e72a000,
+	0x5af3107a4000,
+	0x38d7ea4c68000
+];
+/** Parses input into `int / 10^scale` (int is a safe integer); returns `null` when safe representation is not possible, signalling the caller to fall back. */
+const parseFast = (input) => {
+	const s = typeof input === "string" ? input : String(input);
+	let i = 0;
+	let neg$1 = false;
+	const c0 = s.charCodeAt(0);
+	if (c0 === 45) {
+		neg$1 = true;
+		i = 1;
+	} else if (c0 === 43) i = 1;
+	let hasDot = false;
+	let scale = 0;
+	let digits = "";
+	for (; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (c === 46) {
+			if (hasDot || digits === "") return null;
+			hasDot = true;
+		} else if (c >= 48 && c <= 57) {
+			digits += s[i];
+			if (hasDot) scale++;
+		} else return null;
+	}
+	if (digits === "" || hasDot && scale === 0) return null;
+	if (digits.length > 15 || scale >= POW10F.length) return null;
+	const int = Number(digits);
+	return {
+		int: neg$1 ? -int : int,
+		scale
+	};
+};
+/** Formats `int / 10^scale` as a canonical string, output identical to {@link format} (trailing zeros stripped, zero returns `'0'`). */
+const fmtIntFast = (int, scale) => {
+	if (int === 0) return "0";
+	const neg$1 = int < 0;
+	let s = (neg$1 ? -int : int).toString();
+	if (scale === 0) return neg$1 ? `-${s}` : s;
+	if (s.length <= scale) s = "0".repeat(scale - s.length + 1) + s;
+	const cut = s.length - scale;
+	let end = s.length;
+	while (end > cut && s.charCodeAt(end - 1) === 48) end--;
+	const out = end === cut ? s.slice(0, cut) : `${s.slice(0, cut)}.${s.slice(cut, end)}`;
+	return neg$1 ? `-${out}` : out;
+};
+/** Fast path for addition/subtraction: `op` is `1` (add) or `-1` (subtract); returns `null` when unavailable. */
+const fastAddSub = (a, b, op) => {
+	const pa = parseFast(a);
+	if (pa === null) return null;
+	const pb = parseFast(b);
+	if (pb === null) return null;
+	const scale = pa.scale > pb.scale ? pa.scale : pb.scale;
+	const ia = pa.int * POW10F[scale - pa.scale];
+	const ib = pb.int * POW10F[scale - pb.scale];
+	if (ia > MAX_SAFE || ia < -MAX_SAFE || ib > MAX_SAFE || ib < -MAX_SAFE) return null;
+	const r = ia + op * ib;
+	if (r > MAX_SAFE || r < -MAX_SAFE) return null;
+	return fmtIntFast(r, scale);
+};
+/** Fast path for multiplication; returns `null` when unavailable. */
+const fastMul = (a, b) => {
+	const pa = parseFast(a);
+	if (pa === null) return null;
+	const pb = parseFast(b);
+	if (pb === null) return null;
+	const r = pa.int * pb.int;
+	if (r > MAX_SAFE || r < -MAX_SAFE) return null;
+	return fmtIntFast(r, pa.scale + pb.scale);
+};
+/**
+* High-precision addition `a + b`, computed entirely with BigInt — no floating-point errors.
+*
+* @param a Augend
+* @param b Addend
+* @returns Canonical string of the sum
+* @example
+* add('0.1', '0.2') // '0.3'
+*/
+const add$1 = (a, b) => {
+	const fast = fastAddSub(a, b, 1);
+	if (fast !== null) return fast;
+	const da = parse(a);
+	const db = parse(b);
+	const { aN, bN, exp } = align(da, db);
+	return format(fromBig(BigInt(da.sign) * aN + BigInt(db.sign) * bN, exp));
+};
+/**
+* High-precision subtraction `a - b`.
+*
+* @param a Minuend
+* @param b Subtrahend
+* @returns Canonical string of the difference
+* @example
+* sub('0.3', '0.1') // '0.2'
+*/
+const sub$1 = (a, b) => {
+	const fast = fastAddSub(a, b, -1);
+	if (fast !== null) return fast;
+	const da = parse(a);
+	const db = parse(b);
+	const { aN, bN, exp } = align(da, db);
+	return format(fromBig(BigInt(da.sign) * aN - BigInt(db.sign) * bN, exp));
+};
+/**
+* High-precision multiplication `a * b`.
+*
+* @param a Factor
+* @param b Factor
+* @returns Canonical string of the product
+* @example
+* mul('0.1', '0.2') // '0.02'
+*/
+const mul$1 = (a, b) => {
+	const fast = fastMul(a, b);
+	if (fast !== null) return fast;
+	const da = parse(a);
+	const db = parse(b);
+	const sign = da.sign * db.sign;
+	const digits = da.digits * db.digits;
+	const exp = da.exp + db.exp;
+	if (digits === 0n) return "0";
+	return format({
+		sign,
+		digits,
+		exp
+	});
+};
+/**
+* High-precision division `a / b`, result rounded to `precision` decimal places (half-up).
+*
+* @param a Dividend
+* @param b Divisor
+* @param precision Maximum decimal places to retain, defaults to `50`
+* @returns Canonical string of the quotient
+* @throws When the divisor is zero
+* @example
+* div('1', '3')      // '0.333...' (up to 50 places)
+* div('1', '3', 4)   // '0.3333'
+*/
+const div$1 = (a, b, precision = 50) => {
+	const da = parse(a);
+	const db = parse(b);
+	if (db.digits === 0n) throw new Error("Division by zero");
+	if (da.digits === 0n) return "0";
+	const sign = da.sign * db.sign;
+	if (da.digits % db.digits === 0n) {
+		const q$1 = da.digits / db.digits;
+		const e = da.exp - db.exp;
+		return format(e >= 0 ? {
+			sign,
+			digits: q$1,
+			exp: e
+		} : {
+			sign,
+			digits: q$1 * pow10(-e),
+			exp: 0
+		});
+	}
+	const shift = precision + 1 + db.exp - da.exp;
+	let num = da.digits;
+	let den = db.digits;
+	if (shift >= 0) num = num * pow10(shift);
+	else den = den * pow10(-shift);
+	const q = num / den;
+	const rounded = q % TEN >= 5n ? q / TEN + 1n : q / TEN;
+	return format(fromBig(sign === 1 ? rounded : -rounded, precision));
+};
+/**
+* Compares two numbers numerically.
+*
+* @param a Left operand
+* @param b Right operand
+* @returns `1` if `a > b`, `-1` if `a < b`, `0` if equal
+* @example
+* cmp('0.1', '0.2') // -1
+* cmp('2', '2.0')   // 0
+*/
+const cmp = (a, b) => {
+	const da = parse(a);
+	const db = parse(b);
+	if (da.digits === 0n && db.digits === 0n) return 0;
+	if (da.sign !== db.sign) return da.sign < db.sign ? -1 : 1;
+	const { aN, bN } = align(da, db);
+	if (aN === bN) return 0;
+	return da.sign === 1 ? aN > bN ? 1 : -1 : aN > bN ? -1 : 1;
+};
+/**
+* Returns the negation `-a`.
+*
+* @param a Input value
+* @returns Canonical string of the negation (`0` always returns `'0'`)
+* @example
+* neg('1.5')  // '-1.5'
+* neg('-2')   // '2'
+*/
+const neg = (a) => {
+	const d = parse(a);
+	if (d.digits === 0n) return "0";
+	return format({
+		...d,
+		sign: -d.sign
+	});
+};
+/**
+* Returns the absolute value `|a|`.
+*
+* @param a Input value
+* @returns Canonical string of the absolute value
+* @example
+* abs('-3.14') // '3.14'
+*/
+const abs = (a) => {
+	return format({
+		...parse(a),
+		sign: 1
+	});
+};
+/**
+* Truncates to N decimal places by discarding excess digits — **no rounding**.
+*
+* @param a Input value
+* @param decimals Number of decimal places to keep
+* @returns Canonical string after truncation
+* @example
+* truncate('1.2349', 2) // '1.23'
+* truncate('1.99', 0)   // '1'
+*/
+const truncate = (a, decimals) => {
+	const d = parse(a);
+	if (d.exp <= decimals) return format(d);
+	const drop = d.exp - decimals;
+	const newDigits = d.digits / TEN ** BigInt(drop);
+	if (newDigits === 0n) return "0";
+	return format({
+		sign: d.sign,
+		digits: newDigits,
+		exp: decimals
+	});
+};
+/**
+* Rounds to N decimal places using half-up rounding (rounds up when digit `>= 0.5`).
+*
+* @param a Input value
+* @param decimals Number of decimal places to keep
+* @returns Canonical string after rounding
+* @example
+* roundHalfUp('1.235', 2) // '1.24'
+* roundHalfUp('1.234', 2) // '1.23'
+*/
+const roundHalfUp = (a, decimals) => {
+	const d = parse(a);
+	if (d.exp <= decimals) return format(d);
+	const drop = d.exp - decimals;
+	const divisor = TEN ** BigInt(drop);
+	const halved = TEN ** BigInt(drop - 1) * 5n;
+	const remainder = d.digits % divisor;
+	let q = d.digits / divisor;
+	if (remainder >= halved) q += 1n;
+	if (q === 0n) return "0";
+	return format({
+		sign: d.sign,
+		digits: q,
+		exp: decimals
+	});
+};
+/**
+* Rounds away from zero to N decimal places (rounds up whenever there is any remainder).
+*
+* @param a Input value
+* @param decimals Number of decimal places to keep
+* @returns Canonical string after rounding
+* @example
+* roundCeil('1.231', 2)  // '1.24'
+* roundCeil('-1.231', 2) // '-1.24'
+*/
+const roundCeil = (a, decimals) => {
+	const d = parse(a);
+	if (d.exp <= decimals) return format(d);
+	const drop = d.exp - decimals;
+	const divisor = TEN ** BigInt(drop);
+	const remainder = d.digits % divisor;
+	let q = d.digits / divisor;
+	if (remainder !== 0n) q += 1n;
+	if (q === 0n) return "0";
+	return format({
+		sign: d.sign,
+		digits: q,
+		exp: decimals
+	});
+};
+/**
+* Banker's rounding (round half to even): when the discarded portion is exactly `0.5`,
+* rounds to the nearest even digit.
+*
+* @param a Input value
+* @param decimals Number of decimal places to keep
+* @returns Canonical string after rounding
+* @example
+* roundBanker('0.5', 0)  // '0'
+* roundBanker('1.5', 0)  // '2'
+* roundBanker('2.5', 0)  // '2'
+*/
+const roundBanker = (a, decimals) => {
+	const d = parse(a);
+	if (d.exp <= decimals) return format(d);
+	const drop = d.exp - decimals;
+	const divisor = TEN ** BigInt(drop);
+	const halved = TEN ** BigInt(drop - 1) * 5n;
+	const remainder = d.digits % divisor;
+	let q = d.digits / divisor;
+	if (remainder > halved) q += 1n;
+	else if (remainder === halved && q % 2n === 1n) q += 1n;
+	if (q === 0n) return "0";
+	return format({
+		sign: d.sign,
+		digits: q,
+		exp: decimals
+	});
+};
+
+//#endregion
+//#region src/utils/aggregate.ts
+const pickValues = (keyOrArr, list) => {
+	let raw;
+	if (Array.isArray(keyOrArr)) raw = keyOrArr;
+	else {
+		if (!list) throw new Error("list is required when keyOrArr is a field name");
+		raw = list.map((item) => item[keyOrArr]);
+	}
+	return raw.filter((v) => v != null).map((v) => String(v));
+};
+/** Internal sum core — invalid values throw and propagate to the caller. */
+const sumOf = (values) => {
+	if (values.length === 0) return "0";
+	let sum = values[0];
+	for (let i = 1; i < values.length; i++) sum = add$1(sum, values[i]);
+	return sum;
+};
+/**
+* Computes the sum. Accepts two call forms: a direct value array, or a field name with an array of objects.
+*
+* @param keyOrArr Value array (`[1, 2, 3]`) or the field name to sum (`'price'`)
+* @param list Array of objects, required when the first argument is a field name
+* @returns Total sum (`string`, high precision)
+* @example
+* calcSum([1, 2, 3])                              // '6'
+* calcSum('price', [{ price: 10 }, { price: 20 }]) // '30'
+*/
+const calcSum = (keyOrArr, list) => sumOf(pickValues(keyOrArr, list));
+/** Computes the average with the given config precision (shared by the default {@link calcAvg} export and per-call precision entry points). */
+const calcAvgWith = (cfg, keyOrArr, list) => {
+	const values = pickValues(keyOrArr, list);
+	if (values.length === 0) return "0";
+	return div$1(sumOf(values), String(values.length), cfg._precision);
+};
+function calcAvg(keyOrArr, listOrOpt, opt) {
+	const isFieldForm = Array.isArray(listOrOpt);
+	const list = isFieldForm ? listOrOpt : void 0;
+	return calcAvgWith(configWithPrecision(isFieldForm ? opt : listOrOpt), keyOrArr, list);
+}
+/**
+* Returns the maximum value (numeric comparison, not lexicographic).
+*
+* @param keyOrArr Value array or field name
+* @param list Array of objects, required when the first argument is a field name
+* @returns Maximum value (`string`); returns `'0'` for an empty collection
+* @example
+* calcMax([3, 10, 2]) // '10'
+*/
+const calcMax = (keyOrArr, list) => {
+	const values = pickValues(keyOrArr, list);
+	if (values.length === 0) return "0";
+	let max = values[0];
+	for (let i = 1; i < values.length; i++) if (cmp(values[i], max) > 0) max = values[i];
+	return max;
+};
+/**
+* Returns the minimum value (numeric comparison).
+*
+* @param keyOrArr Value array or field name
+* @param list Array of objects, required when the first argument is a field name
+* @returns Minimum value (`string`); returns `'0'` for an empty collection
+* @example
+* calcMin([3, 10, 2]) // '2'
+*/
+const calcMin = (keyOrArr, list) => {
+	const values = pickValues(keyOrArr, list);
+	if (values.length === 0) return "0";
+	let min = values[0];
+	for (let i = 1; i < values.length; i++) if (cmp(values[i], min) < 0) min = values[i];
+	return min;
+};
+
+//#endregion
+//#region src/utils/parser.ts
+const RE_WS = /\s/;
+const RE_DIGIT = /\d/;
+const RE_NUM_BODY = /[\d.]/;
+const RE_IDENT_START = /[a-z_$\u4E00-\u9FA5]/i;
+const RE_IDENT_BODY = /[\w$\u4E00-\u9FA5]/;
+const SINGLE_OPS = {
+	"+": "PLUS",
+	"-": "MINUS",
+	"*": "STAR",
+	"/": "SLASH",
+	"(": "LPAREN",
+	")": "RPAREN",
+	",": "COMMA"
+};
+const tokenize = (input) => {
+	const tokens = [];
+	let i = 0;
+	while (i < input.length) {
+		const c = input[i];
+		if (RE_WS.test(c)) {
+			i++;
+			continue;
+		}
+		if (RE_DIGIT.test(c) || c === "." && RE_DIGIT.test(input[i + 1] || "")) {
+			const start = i;
+			while (i < input.length && RE_NUM_BODY.test(input[i])) i++;
+			if (input[i] === "e" || input[i] === "E") {
+				i++;
+				if (input[i] === "+" || input[i] === "-") i++;
+				while (i < input.length && RE_DIGIT.test(input[i])) i++;
+			}
+			tokens.push({
+				type: "NUMBER",
+				value: input.slice(start, i),
+				pos: start
+			});
+			if (input[i] === "%" && input[i + 1] !== "%") {
+				tokens.push({
+					type: "UNIT",
+					value: "%",
+					pos: i
+				});
+				i++;
+			}
+			continue;
+		}
+		if (RE_IDENT_START.test(c)) {
+			const start = i;
+			i++;
+			while (i < input.length && RE_IDENT_BODY.test(input[i])) i++;
+			tokens.push({
+				type: "IDENT",
+				value: input.slice(start, i),
+				pos: start
+			});
+			continue;
+		}
+		if (c in SINGLE_OPS) {
+			tokens.push({
+				type: SINGLE_OPS[c],
+				value: c,
+				pos: i
+			});
+			i++;
+			continue;
+		}
+		throw new Error(`Illegal character at position ${i}: "${c}"`);
+	}
+	tokens.push({
+		type: "EOF",
+		value: "",
+		pos: input.length
+	});
+	return tokens;
+};
+/** Floor (toward -∞, same as Math.floor) */
+const mathFloor = (x) => {
+	const t = truncate(x, 0);
+	return cmp(x, "0") < 0 && cmp(x, t) !== 0 ? sub$1(t, "1") : t;
+};
+/** Ceiling (toward +∞, same as Math.ceil) */
+const mathCeil = (x) => {
+	const t = truncate(x, 0);
+	return cmp(x, "0") > 0 && cmp(x, t) !== 0 ? add$1(t, "1") : t;
+};
+/** Sign: -1 / 0 / 1 */
+const mathSign = (x) => {
+	const c = cmp(x, "0");
+	return c > 0 ? "1" : c < 0 ? "-1" : "0";
+};
+/** Integer exponentiation (exponent must be an integer; negative exponents use division) */
+const mathPow = (base, expStr, precision) => {
+	const e = Number(expStr);
+	if (!Number.isInteger(e)) throw new Error(`pow() exponent must be an integer: "${expStr}"`);
+	let r = "1";
+	for (let i = 0; i < Math.abs(e); i++) r = mul$1(r, base);
+	return e < 0 ? div$1("1", r, precision) : r;
+};
+/** Modulo (remainder has the same sign as the dividend, same as JS %) */
+const mathMod = (a, b, precision) => {
+	if (cmp(b, "0") === 0) throw new Error("mod division by zero");
+	return sub$1(a, mul$1(truncate(div$1(a, b, precision), 0), b));
+};
+/** Pick a value from args by comparison (used for min / max) */
+const pickBy = (name, args, keep) => {
+	if (args.length === 0) throw new Error(`${name}() requires at least 1 argument`);
+	let r = args[0];
+	for (let i = 1; i < args.length; i++) if (keep(cmp(args[i], r))) r = args[i];
+	return r;
+};
+const FN_ARITY = {
+	abs: 1,
+	sign: 1,
+	floor: 1,
+	ceil: 1,
+	round: 1,
+	trunc: 1,
+	pow: 2,
+	mod: 2,
+	clamp: 3
+};
+/** Built-in functions (available inside expressions) */
+const applyFn = (name, args, precision) => {
+	const arity = FN_ARITY[name];
+	if (arity !== void 0 && args.length !== arity) throw new Error(`${name}() expects ${arity} argument(s), got ${args.length}`);
+	switch (name) {
+		case "abs": return abs(args[0]);
+		case "sign": return mathSign(args[0]);
+		case "floor": return mathFloor(args[0]);
+		case "ceil": return mathCeil(args[0]);
+		case "round": return mathFloor(add$1(args[0], "0.5"));
+		case "trunc": return truncate(args[0], 0);
+		case "pow": return mathPow(args[0], args[1], precision);
+		case "mod": return mathMod(args[0], args[1], precision);
+		case "min": return pickBy("min", args, (c) => c < 0);
+		case "max": return pickBy("max", args, (c) => c > 0);
+		case "clamp": {
+			const [x, lo, hi] = args;
+			if (cmp(x, lo) < 0) return lo;
+			if (cmp(x, hi) > 0) return hi;
+			return x;
+		}
+		default: throw new Error(`Unknown function: "${name}()"`);
+	}
+};
+var Parser = class {
+	tokens;
+	pos = 0;
+	constructor(input, ctx) {
+		this.ctx = ctx;
+		this.tokens = tokenize(input);
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	consume() {
+		return this.tokens[this.pos++];
+	}
+	match(...types) {
+		if (types.includes(this.peek().type)) return this.consume();
+		return null;
+	}
+	expect(type) {
+		const t = this.peek();
+		if (t.type !== type) throw new Error(`Expected ${type} at position ${t.pos}, got ${t.type}("${t.value}")`);
+		return this.consume();
+	}
+	step(line) {
+		if (this.ctx.trace) this.ctx.trace.push(line);
+	}
+	parse() {
+		const v = this.addSub();
+		if (this.peek().type !== "EOF") {
+			const t = this.peek();
+			throw new Error(`Unexpected token "${t.value}" at position ${t.pos} — expression not fully parsed`);
+		}
+		return v;
+	}
+	addSub() {
+		let left = this.mulDiv();
+		while (true) {
+			const op = this.match("PLUS", "MINUS");
+			if (!op) break;
+			const right = this.mulDiv();
+			const prev = left;
+			left = op.type === "PLUS" ? add$1(left, right) : sub$1(left, right);
+			this.step(`${prev} ${op.value} ${right} = ${left}`);
+		}
+		return left;
+	}
+	mulDiv() {
+		let left = this.unary();
+		while (true) {
+			const op = this.match("STAR", "SLASH");
+			if (!op) break;
+			const right = this.unary();
+			const prev = left;
+			left = op.type === "STAR" ? mul$1(left, right) : div$1(left, right, this.ctx.precision);
+			this.step(`${prev} ${op.value} ${right} = ${left}`);
+		}
+		return left;
+	}
+	unary() {
+		if (this.match("PLUS")) return this.unary();
+		if (this.match("MINUS")) return neg(this.unary());
+		return this.primary();
+	}
+	primary() {
+		const t = this.peek();
+		if (t.type === "NUMBER") {
+			this.consume();
+			const val = t.value;
+			if (this.peek().type === "UNIT") {
+				if (this.consume().value === "%") {
+					if (this.ctx.unit) return val;
+					return div$1(val, "100", this.ctx.precision);
+				}
+			}
+			return val;
+		}
+		if (t.type === "IDENT") {
+			this.consume();
+			if (this.peek().type === "LPAREN") return this.callFn(t.value);
+			throw new Error(`Unknown identifier: "${t.value}" (calc supports arithmetic and math functions only; use template interpolation for values)`);
+		}
+		if (t.type === "LPAREN") {
+			this.consume();
+			const v = this.addSub();
+			this.expect("RPAREN");
+			return v;
+		}
+		throw new Error(`Unexpected token at position ${t.pos}: ${t.type}("${t.value}")`);
+	}
+	callFn(name) {
+		this.expect("LPAREN");
+		const args = [];
+		if (this.peek().type !== "RPAREN") {
+			args.push(this.addSub());
+			while (this.match("COMMA")) args.push(this.addSub());
+		}
+		this.expect("RPAREN");
+		const r = applyFn(name, args, this.ctx.precision);
+		this.step(`${name}(${args.join(", ")}) = ${r}`);
+		return r;
+	}
+};
+/**
+* Parse and evaluate an expression (the pure arithmetic part, without any format pipeline).
+*
+* Most callers should use {@link calc}; this is the low-level evaluator for cases where
+* direct control over the evaluation context is needed.
+*
+* @param expr Pure expression string (no format pipe)
+* @param ctx Evaluation context: unit mode flag and division precision
+* @returns Canonical string representation of the evaluated result
+* @throws Throws on lexical or syntax errors
+* @example
+* evaluate('1 + 2', { unit: false, precision: 50 }) // '3'
+*/
+const evaluate = (expr, ctx) => {
+	return new Parser(expr, ctx).parse();
+};
+
+//#endregion
+//#region src/utils/format.ts
+const ROUNDING_ALIAS = {
+	truncate: "truncate",
+	trunc: "truncate",
+	halfUp: "halfUp",
+	round: "halfUp",
+	banker: "banker",
+	halfEven: "banker",
+	ceil: "ceil"
+};
+const OUTPUT_FLAG = {
+	"percent": "percent",
+	"%%": "percent",
+	"fraction": "fraction",
+	"//": "fraction",
+	"scientific": "scientific",
+	"e": "scientific",
+	"number": "asNumber",
+	"num": "asNumber"
+};
+const RE_THOUSANDS_GROUPS = /\B(?=(?:\d{3})+(?!\d))/g;
+const RE_TRAIL_ZERO = /0+$/;
+const RE_DOT_END = /\.$/;
+const RE_ZERO_VAL = /^0+(?:\.0+)?$/;
+const RE_COMMA_GLOBAL = /,/g;
+const applyRounding = (value, decimals, mode) => {
+	switch (mode) {
+		case "halfUp": return roundHalfUp(value, decimals);
+		case "banker": return roundBanker(value, decimals);
+		case "ceil": return roundCeil(value, decimals);
+		case "truncate":
+		default: return truncate(value, decimals);
+	}
+};
+const applyThousands = (intStr, preset) => {
+	if (preset === "in") {
+		if (intStr.length <= 3) return intStr;
+		const last3 = intStr.slice(-3);
+		const restPart = intStr.slice(0, -3);
+		const parts = [];
+		let r = restPart;
+		while (r.length > 2) {
+			parts.unshift(r.slice(-2));
+			r = r.slice(0, -2);
+		}
+		if (r) parts.unshift(r);
+		return `${parts.join(",")},${last3}`;
+	}
+	return intStr.replace(RE_THOUSANDS_GROUPS, ",");
+};
+const COMPACT_PRESETS = {
+	default: [
+		{
+			scale: 12,
+			suffix: "T"
+		},
+		{
+			scale: 9,
+			suffix: "B"
+		},
+		{
+			scale: 6,
+			suffix: "M"
+		},
+		{
+			scale: 3,
+			suffix: "K"
+		}
+	],
+	zh: [
+		{
+			scale: 12,
+			suffix: "万亿"
+		},
+		{
+			scale: 8,
+			suffix: "亿"
+		},
+		{
+			scale: 4,
+			suffix: "万"
+		}
+	]
+};
+const applyCompact = (value, preset) => {
+	const presets = COMPACT_PRESETS[preset || "default"] || COMPACT_PRESETS.default;
+	const absValue = abs(value);
+	for (const p of presets) {
+		const threshold = `1${"0".repeat(p.scale)}`;
+		if (cmp(absValue, threshold) >= 0) return {
+			num: div$1(value, threshold, 20),
+			suffix: p.suffix
+		};
+	}
+	return {
+		num: value,
+		suffix: ""
+	};
+};
+const applyScientific = (value) => {
+	const d = parse(value);
+	if (d.digits === 0n) return "0e+0";
+	const digitStr = d.digits.toString();
+	const e = digitStr.length - 1 - d.exp;
+	const mantissa = digitStr.length === 1 ? digitStr : `${digitStr[0]}.${digitStr.slice(1).replace(RE_TRAIL_ZERO, "")}`.replace(RE_DOT_END, "");
+	return `${d.sign < 0 ? "-" : ""}${mantissa}e${e >= 0 ? "+" : ""}${e}`;
+};
+const gcd = (a, b) => b === 0n ? a : gcd(b, a % b);
+const applyFraction = (value) => {
+	const d = parse(value);
+	if (d.digits === 0n) return "0";
+	if (d.exp === 0) return d.sign < 0 ? `-${d.digits}/1` : `${d.digits}/1`;
+	let num = d.digits;
+	let den = 10n ** BigInt(d.exp);
+	const g = gcd(num, den);
+	num /= g;
+	den /= g;
+	return `${d.sign < 0 ? "-" : ""}${num}/${den}`;
+};
+const padDecimals = (v, n) => {
+	const dot = v.indexOf(".");
+	if (n === 0) return dot === -1 ? v : v.slice(0, dot);
+	if (dot === -1) return `${v}.${"0".repeat(n)}`;
+	const fracLen = v.length - dot - 1;
+	if (fracLen >= n) return v;
+	return v + "0".repeat(n - fracLen);
+};
+const padIntegerZeros = (v, n) => {
+	let sign = "";
+	let s = v;
+	if (s.startsWith("-")) {
+		sign = "-";
+		s = s.slice(1);
+	} else if (s.startsWith("+")) {
+		sign = "+";
+		s = s.slice(1);
+	}
+	const dot = s.indexOf(".");
+	const intPart = dot === -1 ? s : s.slice(0, dot);
+	const rest = dot === -1 ? "" : s.slice(dot);
+	if (intPart.length >= n) return sign + intPart + rest;
+	return sign + intPart.padStart(n, "0") + rest;
+};
+const applyThousandsAndPreset = (v, preset) => {
+	let sign = "";
+	let s = v;
+	if (s.startsWith("-")) {
+		sign = "-";
+		s = s.slice(1);
+	} else if (s.startsWith("+")) {
+		sign = "+";
+		s = s.slice(1);
+	}
+	const dot = s.indexOf(".");
+	const intPart = dot === -1 ? s : s.slice(0, dot);
+	const fracPart = dot === -1 ? "" : s.slice(dot + 1);
+	const grouped = applyThousands(intPart, preset);
+	if (preset === "eu") {
+		const groupedEu = grouped.replace(RE_COMMA_GLOBAL, ".");
+		return sign + groupedEu + (fracPart ? `,${fracPart}` : "");
+	}
+	return sign + grouped + (fracPart ? `.${fracPart}` : "");
+};
+const finalDecorate = (v, opts, compactSuffix) => {
+	let s = v;
+	if (compactSuffix) s += compactSuffix;
+	if (opts.percent) s += "%";
+	if (opts.asNumber) return Number(s);
+	return s;
+};
+/**
+* Formats a numeric string according to {@link IFormatOpts} (rounding, zero-padding,
+* thousands separator, compact notation, percent, etc.).
+*
+* Most callers should prefer {@link fmt}; this function accepts already-normalized flat options.
+*
+* @param value Canonical numeric string (e.g. the result of a precision arithmetic operation)
+* @param opts Formatting options produced by {@link normalizeFormat}
+* @returns Formatted result — `number` when `output: 'number'`, `string` otherwise
+*/
+const formatValue = (value, opts) => {
+	let v = value;
+	if (opts.clampMin !== void 0 && cmp(v, opts.clampMin) < 0) v = opts.clampMin;
+	if (opts.clampMax !== void 0 && cmp(v, opts.clampMax) > 0) v = opts.clampMax;
+	if (opts.percent) v = mul$1(v, "100");
+	let compactSuffix = "";
+	if (opts.compact) {
+		const c = applyCompact(v, opts.compactPreset);
+		v = c.num;
+		compactSuffix = c.suffix;
+	}
+	if (opts.fraction) return finalDecorate(applyFraction(v), opts, compactSuffix);
+	if (opts.scientific) return finalDecorate(applyScientific(v), opts, compactSuffix);
+	const rounding = opts.rounding || "truncate";
+	if (opts.fixed !== void 0) {
+		v = applyRounding(v, opts.fixed, rounding);
+		v = padDecimals(v, opts.fixed);
+	} else {
+		if (opts.max !== void 0) v = applyRounding(v, opts.max, rounding);
+		if (opts.min !== void 0) v = padDecimals(v, opts.min);
+	}
+	if (opts.intPad !== void 0) v = padIntegerZeros(v, opts.intPad);
+	if (opts.thousands) v = applyThousandsAndPreset(v, opts.thousandsPreset);
+	if (opts.plus && !v.startsWith("-") && !RE_ZERO_VAL.test(v)) v = `+${v}`;
+	return finalDecorate(v, opts, compactSuffix);
+};
+/**
+* Normalizes a high-level {@link IFormat} object into the internal flat options structure.
+*
+* @param format An {@link IFormat} object
+* @returns Flat {@link IFormatOpts}
+*/
+const normalizeFormat = (format$1) => {
+	if (!format$1) return {};
+	const o = {};
+	const f = format$1;
+	if (typeof f.decimals === "number") o.fixed = f.decimals;
+	else if (f.decimals) {
+		if (f.decimals.max !== void 0) o.max = f.decimals.max;
+		if (f.decimals.min !== void 0) o.min = f.decimals.min;
+	}
+	if (f.rounding) o.rounding = ROUNDING_ALIAS[f.rounding];
+	if (f.thousands) {
+		o.thousands = true;
+		if (f.thousands !== true) o.thousandsPreset = f.thousands;
+	}
+	if (f.compact) {
+		o.compact = true;
+		if (f.compact !== true) o.compactPreset = f.compact;
+	}
+	if (f.clamp) {
+		o.clampMin = String(f.clamp[0]);
+		o.clampMax = String(f.clamp[1]);
+	}
+	const outFlag = f.output && OUTPUT_FLAG[f.output];
+	if (outFlag) o[outFlag] = true;
+	if (f.plus) o.plus = true;
+	if (f.pad !== void 0) o.intPad = f.pad;
+	return o;
+};
+const RE_PERCENT = /%/;
+/**
+* Display-oriented formatting: the display counterpart of {@link calc} — same API,
+* **supports arithmetic** (the first argument may be an arithmetic expression string),
+* but **returns `_error` as a fallback on failure instead of throwing**, making it safe
+* for direct use in template rendering (e.g. `{{ fmt(`${price} * ${qty}`, { decimals: 2 }) }}`).
+*
+* - Pass a `string` ⇒ evaluate as an arithmetic expression, then format (`fmt('1 + 2 * 3')` ⇒ `'7'`)
+* - Pass a `number` / `bigint` ⇒ format directly
+* - On error (invalid expression, etc.) ⇒ return the `_error` fallback
+*   (local `options._error` takes precedence over the global default `'-'`)
+*
+* @returns Formatted result; the `_error` fallback value on failure
+* @example
+* fmt(1234.5, { decimals: 2, thousands: true }) // '1,234.50'
+* fmt('999.99 * 3', { decimals: 2 })            // '2,999.97' (evaluate first, then format)
+* fmt('bad expr')                               // '-' (fallback, does not throw)
+*/
+function fmtWith(cfg, value, options) {
+	try {
+		const v = typeof value === "string" ? evaluate(value, {
+			unit: !!options?._unit,
+			precision: options?._precision ?? cfg._precision,
+			trace: void 0
+		}) : format(parse(value));
+		const opts = normalizeFormat(options);
+		const out = formatValue(v, opts);
+		if (typeof value === "string" && options?._unit && RE_PERCENT.test(value) && typeof out === "string" && !opts.percent && !opts.fraction && !opts.scientific && !opts.asNumber) return `${out}%`;
+		return out;
+	} catch {
+		return options?._error !== void 0 ? options._error : cfg._error;
+	}
+}
+const fmt = (value, options) => fmtWith(getConfig(), value, options);
+
+//#endregion
+//#region src/utils/calc.ts
+const RE_HAS_PERCENT = /%/;
+const emitDebug = (info, debug) => {
+	if (typeof debug === "function") {
+		debug(info);
+		return;
+	}
+	console.log(`[calc] ${info.expr}\n${info.steps.length ? `${info.steps.map((s) => `  · ${s}`).join("\n")}\n` : ""}  = ${info.result}`);
+};
+/** Evaluate with an explicit config (the default export {@link calc} delegates to this). */
+function calcWith(cfg, expr, options = {}) {
+	const steps = options._debug ? [] : void 0;
+	const value = evaluate(expr, {
+		unit: !!options._unit,
+		precision: options._precision ?? cfg._precision,
+		trace: steps
+	});
+	const exprHasPercent = options._unit && RE_HAS_PERCENT.test(expr);
+	const fmtSpec = options._fmt || cfg._fmt;
+	const result = !fmtSpec ? exprHasPercent ? `${value}%` : value : formatValue(value, normalizeFormat(fmtSpec));
+	if (options._debug) emitDebug({
+		expr,
+		steps,
+		value,
+		result
+	}, options._debug);
+	return result;
+}
+/**
+* Main entry point: evaluates an arithmetic expression string and optionally formats the output.
+*
+* Expressions are pure arithmetic: the four basic operations, parentheses, and math functions
+* (`max`/`min`/`clamp`…). **Variables are not supported** — embed values directly in the
+* expression via template interpolation: `` calc(`${price} * ${qty}`) ``.
+* Formatting is specified via `options._fmt` (an {@link IFormat} object).
+*
+* `calc` is designed for **computation**: on error (invalid expression, etc.) it **throws
+* directly** and the caller is responsible for handling it.
+* For **display** scenarios that need a fallback on error, use {@link fmt} instead
+* (same API and supports arithmetic, but returns `_error` on failure rather than throwing).
+*
+* @param expr Arithmetic expression, e.g. `'1 + 2 * 3'`, `'(1 + 2) / 3'`
+* @param options Control options (see {@link ICalcOptions})
+* @returns Computation result (`string`; `number` when `_fmt.output` is `'number'`)
+* @throws Throws when the expression is invalid
+* @example
+* calc('1 + 2 * 3')                        // '7'
+* calc(`${price} * ${qty}`)                // use template interpolation instead of variables
+* calc('1 + 2', { _fmt: { decimals: 2 } }) // '3.00'
+*/
+const calc = (expr, options = {}) => calcWith(getConfig(), expr, options);
+
+//#endregion
+//#region src/utils/chain.ts
+/** Extracts a per-call precision option from the end of a variadic argument list (last element is an object ⇒ treated as {@link IPrecisionOption}). */
+const splitPrecision$1 = (args) => {
+	const last = args.at(-1);
+	if (last != null && typeof last === "object") return [args.slice(0, -1), last];
+	return [args, void 0];
+};
+const makeChain = (cfg, initial) => {
+	let value = initial;
+	const fn = ((format$1) => {
+		if (!format$1) return value;
+		return formatValue(value, normalizeFormat(format$1));
+	});
+	fn.add = (...args) => {
+		for (const a of args) value = add$1(value, a);
+		return fn;
+	};
+	fn.sub = (...args) => {
+		for (const a of args) value = sub$1(value, a);
+		return fn;
+	};
+	fn.mul = (...args) => {
+		for (const a of args) value = mul$1(value, a);
+		return fn;
+	};
+	fn.div = (...args) => {
+		for (const a of args) value = div$1(value, a, cfg._precision);
+		return fn;
+	};
+	return fn;
+};
+const reduceWith = (op, args) => {
+	if (args.length === 0) return "0";
+	let r = String(args[0]);
+	for (let i = 1; i < args.length; i++) r = op(r, args[i]);
+	return r;
+};
+const chainAddWith = (cfg, ...args) => makeChain(cfg, reduceWith(add$1, args));
+const chainSubWith = (cfg, ...args) => makeChain(cfg, reduceWith(sub$1, args));
+const chainMulWith = (cfg, ...args) => makeChain(cfg, reduceWith(mul$1, args));
+const chainDivWith = (cfg, ...args) => makeChain(cfg, reduceWith((a, b) => div$1(a, b, cfg._precision), args));
+/**
+* Starts a chaining computation with addition (`a + b + c ...`).
+*
+* @param args Initial values to accumulate via addition
+* @returns An {@link IChain} supporting further `.add().sub().mul().div()` calls
+* @example
+* chainAdd(1, 2).mul(3)()                // '9'
+* chainAdd(1, 2).mul(3)({ decimals: 2 }) // '9.00'
+*/
+const chainAdd = (...args) => chainAddWith(getConfig(), ...args);
+/**
+* Starts a chaining computation with subtraction (`a - b - c ...`).
+*
+* @param args Initial minuend and subtrahends
+* @returns An {@link IChain} supporting further chaining
+* @example
+* chainSub(10, 1, 2)() // '7'
+*/
+const chainSub = (...args) => chainSubWith(getConfig(), ...args);
+/**
+* Starts a chaining computation with multiplication (`a * b * c ...`).
+*
+* @param args Initial factors to multiply together
+* @returns An {@link IChain} supporting further chaining
+* @example
+* chainMul(2, 3).add(4)() // '10'
+*/
+const chainMul = (...args) => chainMulWith(getConfig(), ...args);
+function chainDiv(...args) {
+	const [values, opt] = splitPrecision$1(args);
+	return chainDivWith(configWithPrecision(opt), ...values);
+}
+
+//#endregion
+//#region src/utils/standalone.ts
+const reduce = (op, args) => {
+	if (args.length === 0) return "0";
+	let r = String(args[0]);
+	for (let i = 1; i < args.length; i++) r = op(r, args[i]);
+	return r;
+};
+/** Extracts a per-call precision option from the end of a variadic argument list (last element is an object ⇒ treated as {@link IPrecisionOption}; Val is always string/number/bigint so there is no ambiguity). */
+const splitPrecision = (args) => {
+	const last = args.at(-1);
+	if (last != null && typeof last === "object") return [args.slice(0, -1), last];
+	return [args, void 0];
+};
+/** Division using the precision from the given config (shared by the default {@link div} export and per-call precision entry points). */
+const divWith = (cfg, ...args) => Number(reduce((a, b) => div$1(a, b, cfg._precision), args));
+/** Division using the given config precision, string-returning variant (shared implementation). */
+const divStrWith = (cfg, ...args) => reduce((a, b) => div$1(a, b, cfg._precision), args);
+/**
+* High-precision addition, result converted to `number` (convenient for interop with native numbers).
+*
+* @param args Any number of addends, accumulated left to right
+* @returns Sum (`number`)
+* @example
+* add(0.1, 0.2)       // 0.3
+* add(1, 2, 3, 4)     // 10
+*/
+const add = (...args) => Number(reduce(add$1, args));
+/**
+* High-precision subtraction, result as `number`: `args[0] - args[1] - args[2] ...`.
+*
+* @param args Minuend followed by subtrahends
+* @returns Difference (`number`)
+* @example
+* sub(0.3, 0.1) // 0.2
+*/
+const sub = (...args) => Number(reduce(sub$1, args));
+/**
+* High-precision multiplication, result as `number`, factors multiplied left to right.
+*
+* @param args Any number of factors
+* @returns Product (`number`)
+* @example
+* mul(0.1, 0.2) // 0.02
+*/
+const mul = (...args) => Number(reduce(mul$1, args));
+function div(...args) {
+	const [values, opt] = splitPrecision(args);
+	return divWith(configWithPrecision(opt), ...values);
+}
+/**
+* High-precision addition, result returned as `string` (no precision loss; suitable for monetary values).
+*
+* @param args Any number of addends
+* @returns Sum (`string`)
+* @example
+* addStr('0.1', '0.2') // '0.3'
+*/
+const addStr = (...args) => reduce(add$1, args);
+/**
+* High-precision subtraction, result as `string`: `args[0] - args[1] - ...`.
+*
+* @param args Minuend followed by subtrahends
+* @returns Difference (`string`)
+* @example
+* subStr('0.3', '0.1') // '0.2'
+*/
+const subStr = (...args) => reduce(sub$1, args);
+/**
+* High-precision multiplication, result as `string`, factors multiplied left to right.
+*
+* @param args Any number of factors
+* @returns Product (`string`)
+* @example
+* mulStr('0.1', '0.2') // '0.02'
+*/
+const mulStr = (...args) => reduce(mul$1, args);
+function divStr(...args) {
+	const [values, opt] = splitPrecision(args);
+	return divStrWith(configWithPrecision(opt), ...values);
+}
+
+//#endregion
+export { abs, add, addStr, calc, calcAvg, calcMax, calcMin, calcSum, chainAdd, chainDiv, chainMul, chainSub, cmp, div, divStr, fmt, getConfig, mul, mulStr, neg, parse, div$1 as rawDiv, resetConfig, roundBanker, roundCeil, roundHalfUp, setConfig, sub, subStr, truncate };