bonsai-js 1.0.0 → 1.2.0

package/dist/functions/builtins.mjs

@@ -1,9 +1,9 @@
 import { BLOCKED_NAMES } from "../syntax/lexer.mjs";
-import { RegexSyntaxError, compileRegex, searchRegex } from "../runtime/regex.mjs";
 import { Duration, MS_PER_DAY, MS_PER_HOUR, MS_PER_MINUTE, MS_PER_SECOND, MS_PER_WEEK, chargeIndexKey, chargeKey, chargeSearch, contains, dateTime, describeKind, durationOf, equals, errorText, holdsKey, isMap, isTimestamp, isValidDuration, keyListCost, kindOf, mapBuildCost, order, shown, sortOrder, timeOf, toText, track } from "../runtime/values.mjs";
-import { addDays, addMonths, checkDatePattern, checked, formatTimestamp, fromWallClock, isoWeekday, parseTimestamp, wallClock } from "../runtime/time.mjs";
 import { isExact, t, unionOf, widen } from "../types.mjs";
 import { K, Out, T, U, define, fnType, overload } from "./define.mjs";
+import { RegexSyntaxError, compileRegex, searchRegex } from "../runtime/regex.mjs";
+import { addDays as addDays$1, addMonths as addMonths$1, checkDatePattern, checked, formatTimestamp, fromWallClock, isoWeekday, parseTimestamp, wallClock, warmZone } from "../runtime/time.mjs";
 //#region src/functions/builtins.ts
 /** What toNumber accepts: an optional sign, digits with an optional fraction, and an optional exponent. */
 const DECIMAL_TEXT = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/u;
@@ -14,17 +14,17 @@ const MAX_EXACT_INTEGER = Number.MAX_SAFE_INTEGER + 1;
 /** Where Number#toFixed switches to exponential notation. */
 const FIXED_NOTATION_LIMIT = 1e21;
 const MONTHS_PER_YEAR = 12;
-const any = t.any();
-const num = t.number();
-const str = t.string();
-const bool = t.boolean();
-const ts = t.timestamp();
-const dur = t.duration();
-const listT = t.list(T);
-const optT = t.optional(T);
-const optStr = t.optional(str);
-const predicate = fnType([T, num], bool);
-const primitiveText = t.union(str, num, bool, t.null());
+const any = /* @__PURE__ */ t.any();
+const num = /* @__PURE__ */ t.number();
+const str = /* @__PURE__ */ t.string();
+const bool = /* @__PURE__ */ t.boolean();
+const ts = /* @__PURE__ */ t.timestamp();
+const dur = /* @__PURE__ */ t.duration();
+const listT = /* @__PURE__ */ t.list(T);
+const optT = /* @__PURE__ */ t.optional(T);
+const optStr = /* @__PURE__ */ t.optional(str);
+const predicate = /* @__PURE__ */ fnType([T, num], bool);
+const primitiveText = /* @__PURE__ */ t.union(str, num, bool, t.null());
 function integer(value, what, site) {
 	if (typeof value !== "number" || !Number.isInteger(value)) throw site.state.error("INVALID_ARGUMENT", `${what} must be an integer, not ${typeof value === "number" ? String(value) : describeKind(value)}`, site.span);
 	return value;
@@ -532,16 +532,18 @@ function extreme(items, sign, site) {
 	return best;
 }
 /**
-* min and max of their arguments, one overload per kind a list can order, so
-* `max(a, b)` takes what `[a, b].max()` does (and, unlike the list, no nulls).
+* The overloads of min and max: of a list, then of their arguments, one
+* overload per kind a list can order, so `max(a, b)` takes what `[a, b].max()`
+* does (and, unlike the list, no nulls). Built in one call, not spread into a
+* literal, so an unused min or max stays a pure call that bundlers drop.
 */
-function spreadExtremes(sign) {
-	return [
+function extremes(sign) {
+	return [overload([listT], optT, ([l], site) => extreme(list(l), sign, site), { ordered: ["T"] }), ...[
 		num,
 		str,
 		ts,
 		dur
-	].map((kind) => overload([kind], kind, (args, site) => extreme(args, sign, site), { rest: kind }));
+	].map((kind) => overload([kind], kind, (args, site) => extreme(args, sign, site), { rest: kind }))];
 }
 function entryList(map, site) {
 	const listed = Object.keys(map);
@@ -558,203 +560,199 @@ function valueTypeOf(type) {
 	if (type.rest !== void 0) members.push(type.rest);
 	return members.length === 0 ? any : unionOf(members.map(widen));
 }
-const STRING_FUNCTIONS = [
-	define("toUpperCase", "Upper-cases text.", [overload([str], str, ([s]) => s.toUpperCase())]),
-	define("toLowerCase", "Lower-cases text.", [overload([str], str, ([s]) => s.toLowerCase())]),
-	define("trim", "Removes leading and trailing whitespace.", [overload([str], str, ([s]) => s.trim())]),
-	define("trimStart", "Removes leading whitespace.", [overload([str], str, ([s]) => s.trimStart())]),
-	define("trimEnd", "Removes trailing whitespace.", [overload([str], str, ([s]) => s.trimEnd())]),
-	define("startsWith", "Whether text starts with a prefix.", [overload([str, str], bool, ([s, p]) => s.startsWith(p))]),
-	define("endsWith", "Whether text ends with a suffix.", [overload([str, str], bool, ([s, p]) => s.endsWith(p))]),
-	define("includes", "Whether text contains a substring, or a list contains a value.", [overload([str, str], bool, ([s, p], site) => {
-		chargeSearch(site.state, s.length, p.length);
-		return s.includes(p);
-	}), overload([listT, any], bool, ([l, v], site) => contains(l, v, site.state, site.span))]),
-	define("indexOf", "Position of the first match, or -1.", [overload([str, str], num, ([s, p], site) => {
-		chargeSearch(site.state, s.length, p.length);
-		return s.indexOf(p);
-	}), overload([listT, any], num, ([l, v], site) => {
-		const items = list(l);
-		site.state.charge(items.length);
-		for (let i = 0; i < items.length; i++) if (equals(items[i], v, site.state, 0, site.span)) return i;
-		return -1;
-	})]),
-	define("lastIndexOf", "Position of the last match, or -1.", [overload([str, str], num, ([s, p], site) => {
-		chargeSearch(site.state, s.length, p.length);
-		return s.lastIndexOf(p);
-	}), overload([listT, any], num, ([l, v], site) => {
-		const items = list(l);
-		site.state.charge(items.length);
-		for (let i = items.length - 1; i >= 0; i--) if (equals(items[i], v, site.state, 0, site.span)) return i;
-		return -1;
-	})]),
-	define("slice", "A section of text or a list; negative positions count from the end.", [overload([
-		str,
-		num,
-		num
-	], str, ([s, a, b], site) => s.slice(integer(a, "Start", site), b === void 0 || b === null ? void 0 : integer(b, "End", site)), { required: 2 }), overload([
-		listT,
-		num,
-		num
-	], listT, ([l, a, b], site) => {
-		const items = list(l);
-		const [from, to] = slicePositions(items.length, integer(a, "Start", site), b === void 0 || b === null ? void 0 : integer(b, "End", site));
-		site.state.charge(to - from);
-		site.state.listLimit(to - from, site.span);
-		return made(copyOf(items, from, to), site);
-	}, { required: 2 })]),
-	define("split", "Splits text on a separator.", [overload([
-		str,
-		str,
-		num
-	], t.list(str), ([s, sep, limit], site) => {
-		const text = s;
-		site.state.charge(1 + (text.length >>> 4));
-		chargeSearch(site.state, text.length, sep.length);
-		const max = limit === void 0 || limit === null ? void 0 : nonNegativeInteger(limit, "Limit", site);
-		const cap = site.state.limits.maxListLength + 1;
-		const parts = text.split(sep, max === void 0 ? cap : Math.min(max, cap));
-		site.state.listLimit(parts.length, site.span);
-		site.state.charge(parts.length);
-		return parts;
-	}, { required: 2 })]),
-	define("replace", "Replaces the first occurrence of some text (no patterns).", [overload([
-		str,
-		str,
-		str
-	], str, ([s, f, r], site) => replaceText(s, f, r, false, site))]),
-	define("replaceAll", "Replaces every occurrence of some text (no patterns).", [overload([
-		str,
-		str,
-		str
-	], str, ([s, f, r], site) => replaceText(s, f, r, true, site))]),
-	define("padStart", "Pads text at the start to a length.", [overload([
-		str,
-		num,
-		str
-	], str, ([s, n, f], site) => pad(s, n, f, true, site), { required: 2 })]),
-	define("padEnd", "Pads text at the end to a length.", [overload([
-		str,
-		num,
-		str
-	], str, ([s, n, f], site) => pad(s, n, f, false, site), { required: 2 })]),
-	define("repeat", "Repeats text a number of times.", [overload([str, num], str, ([s, n], site) => {
-		const count = nonNegativeInteger(n, "Count", site);
-		const text = s;
-		site.state.stringLimit(text.length * count, site.span);
-		site.state.charge(1 + (text.length * count >>> 6));
-		return text.repeat(count);
-	})]),
-	define("at", "The item or character at a position; negative positions count from the end.", [overload([str, num], optStr, ([s, i], site) => s.at(integer(i, "Index", site)) ?? null), overload([listT, num], optT, ([l, i], site) => {
-		const items = list(l);
-		const index = integer(i, "Index", site);
-		const position = index < 0 ? items.length + index : index;
-		return position < 0 || position >= items.length ? null : items[position] ?? null;
-	})]),
-	define("matches", "Whether text contains a match for a regular expression (JavaScript syntax without backreferences or lookaround, linear time; anchor with ^ and $; prefix (?i) to ignore case).", [overload([str, str], bool, ([s, p], site) => {
-		const program = regexFor(p, site);
-		return searchRegex(program, s, (n) => {
-			site.state.charge(n);
-		});
-	}, { literals: ([, pattern]) => {
-		if (typeof pattern !== "string") return void 0;
-		try {
-			cachedRegex(pattern);
-			return;
-		} catch (error) {
-			return error instanceof Error ? error.message : String(error);
-		}
-	} })]),
-	define("toString", "Renders a value as text, as a template would.", [overload([t.union(primitiveText, ts, dur)], str, ([v], site) => textOf(v, site))]),
-	define("toNumber", "Parses decimal text as a number, e.g. \"-12.5\" or \"1e3\" (surrounding whitespace is ignored; 0x and other bases are not accepted).", [overload([t.union(str, num)], num, ([v], site) => {
-		if (typeof v === "number") return v;
-		const text = v.trim();
-		const value = DECIMAL_TEXT.test(text) ? Number(text) : NaN;
-		if (!Number.isFinite(value)) throw site.state.error("INVALID_ARGUMENT", `Cannot convert ${shown(v)} to a number`, site.span);
-		return value;
-	})])
-];
+const toUpperCase = /* @__PURE__ */ define("toUpperCase", [/* @__PURE__ */ overload([str], str, ([s]) => s.toUpperCase())]);
+const toLowerCase = /* @__PURE__ */ define("toLowerCase", [/* @__PURE__ */ overload([str], str, ([s]) => s.toLowerCase())]);
+const trim = /* @__PURE__ */ define("trim", [/* @__PURE__ */ overload([str], str, ([s]) => s.trim())]);
+const trimStart = /* @__PURE__ */ define("trimStart", [/* @__PURE__ */ overload([str], str, ([s]) => s.trimStart())]);
+const trimEnd = /* @__PURE__ */ define("trimEnd", [/* @__PURE__ */ overload([str], str, ([s]) => s.trimEnd())]);
+const startsWith = /* @__PURE__ */ define("startsWith", [/* @__PURE__ */ overload([str, str], bool, ([s, p]) => s.startsWith(p))]);
+const endsWith = /* @__PURE__ */ define("endsWith", [/* @__PURE__ */ overload([str, str], bool, ([s, p]) => s.endsWith(p))]);
+const includes = /* @__PURE__ */ define("includes", [/* @__PURE__ */ overload([str, str], bool, ([s, p], site) => {
+	chargeSearch(site.state, s.length, p.length);
+	return s.includes(p);
+}), /* @__PURE__ */ overload([listT, any], bool, ([l, v], site) => contains(l, v, site.state, site.span))]);
+const indexOf = /* @__PURE__ */ define("indexOf", [/* @__PURE__ */ overload([str, str], num, ([s, p], site) => {
+	chargeSearch(site.state, s.length, p.length);
+	return s.indexOf(p);
+}), /* @__PURE__ */ overload([listT, any], num, ([l, v], site) => {
+	const items = list(l);
+	site.state.charge(items.length);
+	for (let i = 0; i < items.length; i++) if (equals(items[i], v, site.state, 0, site.span)) return i;
+	return -1;
+})]);
+const lastIndexOf = /* @__PURE__ */ define("lastIndexOf", [/* @__PURE__ */ overload([str, str], num, ([s, p], site) => {
+	chargeSearch(site.state, s.length, p.length);
+	return s.lastIndexOf(p);
+}), /* @__PURE__ */ overload([listT, any], num, ([l, v], site) => {
+	const items = list(l);
+	site.state.charge(items.length);
+	for (let i = items.length - 1; i >= 0; i--) if (equals(items[i], v, site.state, 0, site.span)) return i;
+	return -1;
+})]);
+const slice = /* @__PURE__ */ define("slice", [/* @__PURE__ */ overload([
+	str,
+	num,
+	num
+], str, ([s, a, b], site) => s.slice(integer(a, "Start", site), b === void 0 || b === null ? void 0 : integer(b, "End", site)), { required: 2 }), /* @__PURE__ */ overload([
+	listT,
+	num,
+	num
+], listT, ([l, a, b], site) => {
+	const items = list(l);
+	const [from, to] = slicePositions(items.length, integer(a, "Start", site), b === void 0 || b === null ? void 0 : integer(b, "End", site));
+	site.state.charge(to - from);
+	site.state.listLimit(to - from, site.span);
+	return made(copyOf(items, from, to), site);
+}, { required: 2 })]);
+const split = /* @__PURE__ */ define("split", [/* @__PURE__ */ overload([
+	str,
+	str,
+	num
+], /* @__PURE__ */ t.list(str), ([s, sep, limit], site) => {
+	const text = s;
+	site.state.charge(1 + (text.length >>> 4));
+	chargeSearch(site.state, text.length, sep.length);
+	const max = limit === void 0 || limit === null ? void 0 : nonNegativeInteger(limit, "Limit", site);
+	const cap = site.state.limits.maxListLength + 1;
+	const parts = text.split(sep, max === void 0 ? cap : Math.min(max, cap));
+	site.state.listLimit(parts.length, site.span);
+	site.state.charge(parts.length);
+	return parts;
+}, { required: 2 })]);
+const replace = /* @__PURE__ */ define("replace", [/* @__PURE__ */ overload([
+	str,
+	str,
+	str
+], str, ([s, f, r], site) => replaceText(s, f, r, false, site))]);
+const replaceAll = /* @__PURE__ */ define("replaceAll", [/* @__PURE__ */ overload([
+	str,
+	str,
+	str
+], str, ([s, f, r], site) => replaceText(s, f, r, true, site))]);
+const padStart = /* @__PURE__ */ define("padStart", [/* @__PURE__ */ overload([
+	str,
+	num,
+	str
+], str, ([s, n, f], site) => pad(s, n, f, true, site), { required: 2 })]);
+const padEnd = /* @__PURE__ */ define("padEnd", [/* @__PURE__ */ overload([
+	str,
+	num,
+	str
+], str, ([s, n, f], site) => pad(s, n, f, false, site), { required: 2 })]);
+const repeat = /* @__PURE__ */ define("repeat", [/* @__PURE__ */ overload([str, num], str, ([s, n], site) => {
+	const count = nonNegativeInteger(n, "Count", site);
+	const text = s;
+	site.state.stringLimit(text.length * count, site.span);
+	site.state.charge(1 + (text.length * count >>> 6));
+	return text.repeat(count);
+})]);
+const at = /* @__PURE__ */ define("at", [/* @__PURE__ */ overload([str, num], optStr, ([s, i], site) => s.at(integer(i, "Index", site)) ?? null), /* @__PURE__ */ overload([listT, num], optT, ([l, i], site) => {
+	const items = list(l);
+	const index = integer(i, "Index", site);
+	const position = index < 0 ? items.length + index : index;
+	return position < 0 || position >= items.length ? null : items[position] ?? null;
+})]);
+const matches = /* @__PURE__ */ define("matches", [/* @__PURE__ */ overload([str, str], bool, ([s, p], site) => {
+	const program = regexFor(p, site);
+	return searchRegex(program, s, (n) => {
+		site.state.charge(n);
+	});
+}, { literals: ([, pattern]) => {
+	if (typeof pattern !== "string") return void 0;
+	try {
+		cachedRegex(pattern);
+		return;
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+} })]);
+const toString = /* @__PURE__ */ define("toString", [/* @__PURE__ */ overload([/* @__PURE__ */ t.union(primitiveText, ts, dur)], str, ([v], site) => textOf(v, site))]);
+const toNumber = /* @__PURE__ */ define("toNumber", [/* @__PURE__ */ overload([/* @__PURE__ */ t.union(str, num)], num, ([v], site) => {
+	if (typeof v === "number") return v;
+	const text = v.trim();
+	const value = DECIMAL_TEXT.test(text) ? Number(text) : NaN;
+	if (!Number.isFinite(value)) throw site.state.error("INVALID_ARGUMENT", `Cannot convert ${shown(v)} to a number`, site.span);
+	return value;
+})]);
 /** A built-in applying a number function whose result must be finite. */
-function math(name, description, apply) {
-	return define(name, description, [overload([num], num, ([n], site) => finite(apply(n), site))]);
+function math(name, apply) {
+	return define(name, [overload([num], num, ([n], site) => finite(apply(n), site))]);
 }
-const NUMBER_FUNCTIONS = [
-	define("round", "Rounds half away from zero, optionally to a number of decimal digits.", [overload([num, num], num, ([n, d], site) => roundTo(n, d === void 0 || d === null ? 0 : d, site), { required: 1 })]),
-	math("floor", "Rounds down.", Math.floor),
-	math("ceil", "Rounds up.", Math.ceil),
-	math("trunc", "Drops the fractional part.", Math.trunc),
-	define("abs", "Absolute value.", [overload([num], num, ([n], site) => finite(Math.abs(n), site)), overload([dur], dur, ([d]) => new Duration(Math.abs(d.ms)))]),
-	math("sqrt", "Square root.", Math.sqrt),
-	define("clamp", "Limits a number to a range.", [overload([
-		num,
-		num,
-		num
-	], num, ([n, lo, hi], site) => {
-		if (lo > hi) throw site.state.error("INVALID_ARGUMENT", "clamp: min is greater than max", site.span);
-		finite(n, site);
-		finite(lo, site);
-		finite(hi, site);
-		return finite(Math.min(Math.max(n, lo), hi), site);
-	})]),
-	define("toFixed", "Formats a number with a fixed number of decimals.", [overload([num, num], str, ([n, d], site) => {
-		const digits = nonNegativeInteger(d, "Digits", site);
-		if (digits > MAX_FIXED_DIGITS) throw site.state.error("INVALID_ARGUMENT", "Digits must be at most 100", site.span);
-		site.state.charge(digits >>> 2);
-		finite(n, site);
-		const value = digits <= MAX_ROUND_DIGITS ? roundTo(n, digits, site) : n;
-		if (Math.abs(value) >= FIXED_NOTATION_LIMIT) return `${BigInt(value).toString()}${digits > 0 ? `.${"0".repeat(digits)}` : ""}`;
-		return value.toFixed(digits);
-	})]),
-	define("formatNumber", "Formats a number with grouping, e.g. 1,234.5, with optional decimals and locale (default \"en-US\"; an unsupported locale is an error).", [overload([
-		num,
-		t.optional(num),
-		t.optional(str)
-	], str, ([n, d, locale], site) => {
-		const digits = d === void 0 || d === null ? void 0 : nonNegativeInteger(d, "Decimals", site);
-		if (digits !== void 0 && digits > MAX_INTL_DIGITS) throw site.state.error("INVALID_ARGUMENT", `Decimals must be at most ${MAX_INTL_DIGITS}`, site.span);
-		const options = digits === void 0 ? { maximumFractionDigits: MAX_INTL_DIGITS } : {
-			minimumFractionDigits: digits,
-			maximumFractionDigits: digits
-		};
-		finite(n, site);
-		const value = digits === void 0 || digits > MAX_ROUND_DIGITS ? n : roundTo(n, digits, site);
-		return numberFormat(typeof locale === "string" ? locale : "en-US", options, site).format(value);
-	}, {
-		required: 1,
-		literals: ([, , locale]) => formatProblem(locale, void 0)
-	})]),
-	define("formatCurrency", "Formats an amount in a currency (ISO 4217 code such as \"EUR\"; a code without a known symbol prints as the code), with an optional locale (default \"en-US\"; an unsupported locale is an error).", [overload([
-		num,
-		str,
-		t.optional(str)
-	], str, ([n, currency, locale], site) => numberFormat(typeof locale === "string" ? locale : "en-US", {
-		style: "currency",
-		currency
-	}, site).format(finite(n, site)), {
-		required: 2,
-		literals: ([, currency, locale]) => formatProblem(locale, currency)
-	})]),
-	define("min", "The smallest value (nulls are skipped); null for an empty list.", [overload([listT], optT, ([l], site) => extreme(list(l), -1, site), { ordered: ["T"] }), ...spreadExtremes(-1)]),
-	define("max", "The largest value (nulls are skipped); null for an empty list.", [overload([listT], optT, ([l], site) => extreme(list(l), 1, site), { ordered: ["T"] }), ...spreadExtremes(1)]),
-	define("sum", "The sum of the numbers in a list (nulls are skipped), added left to right as a + b + c is.", [overload([t.list(t.optional(num))], num, ([l], site) => {
-		const items = list(l);
-		if (isValidDuration(firstPresent(items))) return sumDurations(items, site);
-		let total = 0;
-		for (const n of numbersOf(items, "sum", site)) total += n;
-		return finite(total, site);
-	}), overload([t.list(t.optional(dur))], dur, ([l], site) => sumDurations(list(l), site))]),
-	define("avg", "The mean of the numbers or durations in a list (nulls are skipped, summed as sum does); null for an empty list.", [overload([t.list(t.optional(num))], t.optional(num), ([l], site) => {
-		const items = list(l);
-		if (isValidDuration(firstPresent(items))) return averageDuration(items, site);
-		const values = numbersOf(items, "avg", site);
-		if (values.length === 0) return null;
-		let total = 0;
-		for (const n of values) total += n;
-		return finite(total / values.length, site);
-	}), overload([t.list(t.optional(dur))], t.optional(dur), ([l], site) => averageDuration(list(l), site))])
-];
-function hof(name, description, result, run, runAsync, { lambda = predicate, extraParams = [], ordered = [] } = {}) {
-	return define(name, description, [overload([
+const round = /* @__PURE__ */ define("round", [/* @__PURE__ */ overload([num, num], num, ([n, d], site) => roundTo(n, d === void 0 || d === null ? 0 : d, site), { required: 1 })]);
+const floor = /* @__PURE__ */ math("floor", Math.floor);
+const ceil = /* @__PURE__ */ math("ceil", Math.ceil);
+const trunc = /* @__PURE__ */ math("trunc", Math.trunc);
+const abs = /* @__PURE__ */ define("abs", [/* @__PURE__ */ overload([num], num, ([n], site) => finite(Math.abs(n), site)), /* @__PURE__ */ overload([dur], dur, ([d]) => new Duration(Math.abs(d.ms)))]);
+const sqrt = /* @__PURE__ */ math("sqrt", Math.sqrt);
+const clamp = /* @__PURE__ */ define("clamp", [/* @__PURE__ */ overload([
+	num,
+	num,
+	num
+], num, ([n, lo, hi], site) => {
+	if (lo > hi) throw site.state.error("INVALID_ARGUMENT", "clamp: min is greater than max", site.span);
+	finite(n, site);
+	finite(lo, site);
+	finite(hi, site);
+	return finite(Math.min(Math.max(n, lo), hi), site);
+})]);
+const toFixed = /* @__PURE__ */ define("toFixed", [/* @__PURE__ */ overload([num, num], str, ([n, d], site) => {
+	const digits = nonNegativeInteger(d, "Digits", site);
+	if (digits > MAX_FIXED_DIGITS) throw site.state.error("INVALID_ARGUMENT", "Digits must be at most 100", site.span);
+	site.state.charge(digits >>> 2);
+	finite(n, site);
+	const value = digits <= MAX_ROUND_DIGITS ? roundTo(n, digits, site) : n;
+	if (Math.abs(value) >= FIXED_NOTATION_LIMIT) return `${BigInt(value).toString()}${digits > 0 ? `.${"0".repeat(digits)}` : ""}`;
+	return value.toFixed(digits);
+})]);
+const formatNumber = /* @__PURE__ */ define("formatNumber", [/* @__PURE__ */ overload([
+	num,
+	/* @__PURE__ */ t.optional(num),
+	/* @__PURE__ */ t.optional(str)
+], str, ([n, d, locale], site) => {
+	const digits = d === void 0 || d === null ? void 0 : nonNegativeInteger(d, "Decimals", site);
+	if (digits !== void 0 && digits > MAX_INTL_DIGITS) throw site.state.error("INVALID_ARGUMENT", `Decimals must be at most ${MAX_INTL_DIGITS}`, site.span);
+	const options = digits === void 0 ? { maximumFractionDigits: MAX_INTL_DIGITS } : {
+		minimumFractionDigits: digits,
+		maximumFractionDigits: digits
+	};
+	finite(n, site);
+	const value = digits === void 0 || digits > MAX_ROUND_DIGITS ? n : roundTo(n, digits, site);
+	return numberFormat(typeof locale === "string" ? locale : "en-US", options, site).format(value);
+}, {
+	required: 1,
+	literals: ([, , locale]) => formatProblem(locale, void 0)
+})]);
+const formatCurrency = /* @__PURE__ */ define("formatCurrency", [/* @__PURE__ */ overload([
+	num,
+	str,
+	/* @__PURE__ */ t.optional(str)
+], str, ([n, currency, locale], site) => numberFormat(typeof locale === "string" ? locale : "en-US", {
+	style: "currency",
+	currency
+}, site).format(finite(n, site)), {
+	required: 2,
+	literals: ([, currency, locale]) => formatProblem(locale, currency)
+})]);
+const min = /* @__PURE__ */ define("min", /* @__PURE__ */ extremes(-1));
+const max = /* @__PURE__ */ define("max", /* @__PURE__ */ extremes(1));
+const sum = /* @__PURE__ */ define("sum", [/* @__PURE__ */ overload([/* @__PURE__ */ t.list(/* @__PURE__ */ t.optional(num))], num, ([l], site) => {
+	const items = list(l);
+	if (isValidDuration(firstPresent(items))) return sumDurations(items, site);
+	let total = 0;
+	for (const n of numbersOf(items, "sum", site)) total += n;
+	return finite(total, site);
+}), /* @__PURE__ */ overload([/* @__PURE__ */ t.list(/* @__PURE__ */ t.optional(dur))], dur, ([l], site) => sumDurations(list(l), site))]);
+const avg = /* @__PURE__ */ define("avg", [/* @__PURE__ */ overload([/* @__PURE__ */ t.list(/* @__PURE__ */ t.optional(num))], /* @__PURE__ */ t.optional(num), ([l], site) => {
+	const items = list(l);
+	if (isValidDuration(firstPresent(items))) return averageDuration(items, site);
+	const values = numbersOf(items, "avg", site);
+	if (values.length === 0) return null;
+	let total = 0;
+	for (const n of values) total += n;
+	return finite(total / values.length, site);
+}), /* @__PURE__ */ overload([/* @__PURE__ */ t.list(/* @__PURE__ */ t.optional(dur))], /* @__PURE__ */ t.optional(dur), ([l], site) => averageDuration(list(l), site))]);
+function hof(name, result, run, runAsync, { lambda = predicate, extraParams = [], ordered = [] } = {}) {
+	return define(name, [overload([
 		listT,
 		lambda,
 		...extraParams
@@ -764,186 +762,180 @@ function hof(name, description, result, run, runAsync, { lambda = predicate, ext
 		...ordered.length === 0 ? {} : { ordered }
 	})]);
 }
-const LIST_FUNCTIONS = [
-	hof("map", "Transforms each item.", t.list(U), (items, fn, site) => {
-		const out = newList(items.length, site);
-		for (let i = 0; i < items.length; i++) out[i] = fn(items[i], i);
-		return made(out, site);
-	}, async (items, fn, site) => {
-		const out = newList(items.length, site);
-		for (let i = 0; i < items.length; i++) out[i] = ran(await fn(items[i], i));
-		return new Out(made(out, site));
-	}, { lambda: fnType([T, num], U) }),
-	hof("filter", "Keeps the items for which the lambda is true.", listT, (items, fn, site) => {
-		const out = [];
-		for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) push(out, items[i], site);
-		return made(out, site);
-	}, async (items, fn, site) => {
-		const out = [];
-		for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) push(out, items[i], site);
-		return new Out(made(out, site));
-	}),
-	hof("find", "The first item for which the lambda is true, or null.", optT, (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return items[i] ?? null;
-		return null;
-	}, async (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(items[i] ?? null);
-		return new Out(null);
-	}),
-	hof("findIndex", "The position of the first item for which the lambda is true, or -1.", num, (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return i;
-		return -1;
-	}, async (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(i);
-		return new Out(-1);
-	}),
-	hof("some", "Whether the lambda is true for at least one item.", bool, (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return true;
-		return false;
-	}, async (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(true);
-		return new Out(false);
-	}),
-	hof("every", "Whether the lambda is true for every item.", bool, (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (!truthy(fn(items[i], i), site)) return false;
-		return true;
-	}, async (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (!truthy(ran(await fn(items[i], i)), site)) return new Out(false);
-		return new Out(true);
-	}),
-	hof("none", "Whether the lambda is false for every item.", bool, (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return false;
-		return true;
-	}, async (items, fn, site) => {
-		for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(false);
-		return new Out(true);
-	}),
-	hof("flatMap", "Transforms each item and flattens list results one level.", t.list(U), (items, fn, site) => {
-		const out = [];
-		for (let i = 0; i < items.length; i++) appendFlat(out, fn(items[i], i), site);
-		return made(out, site);
-	}, async (items, fn, site) => {
-		const out = [];
-		for (let i = 0; i < items.length; i++) appendFlat(out, ran(await fn(items[i], i)), site);
-		return new Out(made(out, site));
-	}, { lambda: fnType([T, num], t.union(t.list(U), U)) }),
-	hof("sortBy", "Sorts by a key; pass \"desc\" to reverse. Nulls sort first (\"asc\") or last (\"desc\").", listT, (items, fn, site, [direction]) => {
-		const keys = newList(items.length, site);
-		for (let i = 0; i < items.length; i++) keys[i] = fn(items[i], i);
-		return sortKeyed(items, keys, direction, site);
-	}, async (items, fn, site, [direction]) => {
-		const keys = newList(items.length, site);
-		for (let i = 0; i < items.length; i++) keys[i] = ran(await fn(items[i], i));
-		return new Out(sortKeyed(items, keys, direction, site));
-	}, {
-		lambda: fnType([T, num], K),
-		extraParams: [t.enum("asc", "desc")],
-		ordered: ["K"]
-	}),
-	hof("groupBy", "Groups items into a map of lists by a key. Map keys are text, so a key is its text form: 1 and \"1\", or true and \"true\", share a group. A key must be a string, number, or boolean (null is an error). Keys are listed integer-like first, ascending, then in first-seen order.", t.record(listT), (items, fn, site) => {
-		const out = {};
-		for (let i = 0; i < items.length; i++) push(bucket(out, groupKey(fn(items[i], i), site)), items[i], site);
-		return madeGroups(out, site);
-	}, async (items, fn, site) => {
-		const out = {};
-		for (let i = 0; i < items.length; i++) push(bucket(out, groupKey(ran(await fn(items[i], i)), site)), items[i], site);
-		return new Out(madeGroups(out, site));
-	}, { lambda: fnType([T, num], t.union(str, num, bool)) }),
-	define("count", "The number of items, or of items for which the lambda is true.", [overload([listT], num, ([l]) => list(l).length), overload([listT, predicate], num, ([l, f], site) => {
-		const items = list(l);
-		const fn = asLambda(f);
-		let n = 0;
-		for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) n++;
-		return n;
-	}, { runAsync: async ([l, f], site) => {
-		const items = list(l);
-		const fn = asLambda(f);
-		let n = 0;
-		for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) n++;
-		return new Out(n);
-	} })]),
-	define("reduce", "Folds a list into one value: reduce(list, (acc, item) => ..., initial). Name both parameters; \".\" is not allowed, since the first one is the accumulator.", [overload([
-		listT,
-		fnType([U, T], U),
-		U
-	], U, ([l, f, initial]) => {
-		const items = list(l);
-		const fn = f;
-		let acc = initial;
-		for (let i = 0; i < items.length; i++) acc = fn(acc, items[i], i);
-		return acc;
-	}, { runAsync: async ([l, f, initial]) => {
-		const items = list(l);
-		const fn = f;
-		let acc = initial;
-		for (let i = 0; i < items.length; i++) acc = ran(await fn(acc, items[i], i));
-		return new Out(acc);
-	} })]),
-	define("sort", "Sorts numbers, text, timestamps, or durations; pass \"desc\" to reverse.", [overload([listT, t.enum("asc", "desc")], listT, ([l, d], site) => sortKeyed(list(l), list(l), d, site), {
-		required: 1,
-		ordered: ["T"]
-	})]),
-	define("reverse", "The items in reverse order.", [overload([listT], listT, ([l], site) => {
-		const items = list(l);
-		site.state.charge(items.length);
-		const out = newList(items.length, site);
-		for (let i = 0; i < items.length; i++) out[i] = items[items.length - 1 - i] ?? null;
-		return made(out, site);
-	})]),
-	define("unique", "The items without duplicates (by value), in first-seen order.", [overload([listT], listT, ([l], site) => uniqueOf(list(l), site))]),
-	define("flat", "Flattens nested lists one level.", [overload([t.list(any)], t.list(any), ([l], site) => flatten(list(l), site))]),
-	define("first", "The first item, or null.", [overload([listT], optT, ([l]) => list(l)[0] ?? null)]),
-	define("last", "The last item, or null.", [overload([listT], optT, ([l]) => {
-		const items = list(l);
-		return items.length === 0 ? null : items[items.length - 1] ?? null;
-	})]),
-	define("join", "Joins items into text with a separator (default \",\").", [overload([t.list(t.union(primitiveText, ts, dur)), str], str, ([l, sep], site) => joinText(list(l), sep, site), { required: 1 })]),
-	define("isEmpty", "Whether a list, text, or map has no items; null is empty.", [overload([t.union(t.list(any), str, t.record(any), t.null())], bool, ([v], site) => {
-		if (v === null || v === void 0) return true;
-		if (Array.isArray(v) || typeof v === "string") return v.length === 0;
-		const map = v;
-		const keys = Object.keys(map);
-		site.state.charge(keyListCost(keys.length));
-		return !keys.some((key) => holdsKey(map, key));
-	})])
-];
-const MAP_FUNCTIONS = [
-	define("keys", "The keys of a map.", [overload([t.record(any)], t.list(str), ([m], site) => entryList(m, site))]),
-	define("values", "The values of a map.", [overload([t.record(T)], listT, ([m], site) => {
-		const map = m;
-		return made(entryList(map, site).map((key) => map[key] ?? null), site);
-	})]),
-	define("entries", "The entries of a map, as a list of { key, value } maps (not [key, value] pairs as in JavaScript), e.g. m.entries().map(.key + \"=\" + .value).", [overload([t.record(T)], t.list(t.object({
-		key: str,
-		value: T
-	})), ([m], site) => {
-		const map = m;
-		const keys = entryList(map, site);
-		site.state.charge(keys.length);
-		return made(keys.map((key) => made({
-			key,
-			value: map[key] ?? null
-		}, site)), site);
-	})]),
-	define("type", "The kind of a value: \"null\", \"boolean\", \"number\", \"string\", \"list\", \"map\", \"timestamp\", \"duration\", or \"opaque\".", [overload([any], str, ([v]) => kindOf(v))])
-];
-const optZone = t.optional(str);
-/** The position of a built-in's time zone parameter, if it takes one. */
-function zoneParameter(def) {
-	for (const candidate of def.overloads) {
-		const index = candidate.params.indexOf(optZone);
-		if (index >= 0) return index;
-	}
-}
+const map = /* @__PURE__ */ hof("map", /* @__PURE__ */ t.list(U), (items, fn, site) => {
+	const out = newList(items.length, site);
+	for (let i = 0; i < items.length; i++) out[i] = fn(items[i], i);
+	return made(out, site);
+}, async (items, fn, site) => {
+	const out = newList(items.length, site);
+	for (let i = 0; i < items.length; i++) out[i] = ran(await fn(items[i], i));
+	return new Out(made(out, site));
+}, { lambda: /* @__PURE__ */ fnType([T, num], U) });
+const filter = /* @__PURE__ */ hof("filter", listT, (items, fn, site) => {
+	const out = [];
+	for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) push(out, items[i], site);
+	return made(out, site);
+}, async (items, fn, site) => {
+	const out = [];
+	for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) push(out, items[i], site);
+	return new Out(made(out, site));
+});
+const find = /* @__PURE__ */ hof("find", optT, (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return items[i] ?? null;
+	return null;
+}, async (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(items[i] ?? null);
+	return new Out(null);
+});
+const findIndex = /* @__PURE__ */ hof("findIndex", num, (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return i;
+	return -1;
+}, async (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(i);
+	return new Out(-1);
+});
+const some = /* @__PURE__ */ hof("some", bool, (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return true;
+	return false;
+}, async (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(true);
+	return new Out(false);
+});
+const every = /* @__PURE__ */ hof("every", bool, (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (!truthy(fn(items[i], i), site)) return false;
+	return true;
+}, async (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (!truthy(ran(await fn(items[i], i)), site)) return new Out(false);
+	return new Out(true);
+});
+const none = /* @__PURE__ */ hof("none", bool, (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) return false;
+	return true;
+}, async (items, fn, site) => {
+	for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) return new Out(false);
+	return new Out(true);
+});
+const flatMap = /* @__PURE__ */ hof("flatMap", /* @__PURE__ */ t.list(U), (items, fn, site) => {
+	const out = [];
+	for (let i = 0; i < items.length; i++) appendFlat(out, fn(items[i], i), site);
+	return made(out, site);
+}, async (items, fn, site) => {
+	const out = [];
+	for (let i = 0; i < items.length; i++) appendFlat(out, ran(await fn(items[i], i)), site);
+	return new Out(made(out, site));
+}, { lambda: /* @__PURE__ */ fnType([T, num], /* @__PURE__ */ t.union(/* @__PURE__ */ t.list(U), U)) });
+const sortBy = /* @__PURE__ */ hof("sortBy", listT, (items, fn, site, [direction]) => {
+	const keys = newList(items.length, site);
+	for (let i = 0; i < items.length; i++) keys[i] = fn(items[i], i);
+	return sortKeyed(items, keys, direction, site);
+}, async (items, fn, site, [direction]) => {
+	const keys = newList(items.length, site);
+	for (let i = 0; i < items.length; i++) keys[i] = ran(await fn(items[i], i));
+	return new Out(sortKeyed(items, keys, direction, site));
+}, {
+	lambda: /* @__PURE__ */ fnType([T, num], K),
+	extraParams: [/* @__PURE__ */ t.enum("asc", "desc")],
+	ordered: ["K"]
+});
+const groupBy = /* @__PURE__ */ hof("groupBy", /* @__PURE__ */ t.record(listT), (items, fn, site) => {
+	const out = {};
+	for (let i = 0; i < items.length; i++) push(bucket(out, groupKey(fn(items[i], i), site)), items[i], site);
+	return madeGroups(out, site);
+}, async (items, fn, site) => {
+	const out = {};
+	for (let i = 0; i < items.length; i++) push(bucket(out, groupKey(ran(await fn(items[i], i)), site)), items[i], site);
+	return new Out(madeGroups(out, site));
+}, { lambda: /* @__PURE__ */ fnType([T, num], /* @__PURE__ */ t.union(str, num, bool)) });
+const count = /* @__PURE__ */ define("count", [/* @__PURE__ */ overload([listT], num, ([l]) => list(l).length), /* @__PURE__ */ overload([listT, predicate], num, ([l, f], site) => {
+	const items = list(l);
+	const fn = asLambda(f);
+	let n = 0;
+	for (let i = 0; i < items.length; i++) if (truthy(fn(items[i], i), site)) n++;
+	return n;
+}, { runAsync: async ([l, f], site) => {
+	const items = list(l);
+	const fn = asLambda(f);
+	let n = 0;
+	for (let i = 0; i < items.length; i++) if (truthy(ran(await fn(items[i], i)), site)) n++;
+	return new Out(n);
+} })]);
+const reduce = /* @__PURE__ */ define("reduce", [/* @__PURE__ */ overload([
+	listT,
+	/* @__PURE__ */ fnType([U, T], U),
+	U
+], U, ([l, f, initial]) => {
+	const items = list(l);
+	const fn = f;
+	let acc = initial;
+	for (let i = 0; i < items.length; i++) acc = fn(acc, items[i], i);
+	return acc;
+}, { runAsync: async ([l, f, initial]) => {
+	const items = list(l);
+	const fn = f;
+	let acc = initial;
+	for (let i = 0; i < items.length; i++) acc = ran(await fn(acc, items[i], i));
+	return new Out(acc);
+} })]);
+const sort = /* @__PURE__ */ define("sort", [/* @__PURE__ */ overload([listT, /* @__PURE__ */ t.enum("asc", "desc")], listT, ([l, d], site) => sortKeyed(list(l), list(l), d, site), {
+	required: 1,
+	ordered: ["T"]
+})]);
+const reverse = /* @__PURE__ */ define("reverse", [/* @__PURE__ */ overload([listT], listT, ([l], site) => {
+	const items = list(l);
+	site.state.charge(items.length);
+	const out = newList(items.length, site);
+	for (let i = 0; i < items.length; i++) out[i] = items[items.length - 1 - i] ?? null;
+	return made(out, site);
+})]);
+const unique = /* @__PURE__ */ define("unique", [/* @__PURE__ */ overload([listT], listT, ([l], site) => uniqueOf(list(l), site))]);
+const flat = /* @__PURE__ */ define("flat", [/* @__PURE__ */ overload([/* @__PURE__ */ t.list(any)], /* @__PURE__ */ t.list(any), ([l], site) => flatten(list(l), site))]);
+const first = /* @__PURE__ */ define("first", [/* @__PURE__ */ overload([listT], optT, ([l]) => list(l)[0] ?? null)]);
+const last = /* @__PURE__ */ define("last", [/* @__PURE__ */ overload([listT], optT, ([l]) => {
+	const items = list(l);
+	return items.length === 0 ? null : items[items.length - 1] ?? null;
+})]);
+const join = /* @__PURE__ */ define("join", [/* @__PURE__ */ overload([/* @__PURE__ */ t.list(/* @__PURE__ */ t.union(primitiveText, ts, dur)), str], str, ([l, sep], site) => joinText(list(l), sep, site), { required: 1 })]);
+const isEmpty = /* @__PURE__ */ define("isEmpty", [/* @__PURE__ */ overload([/* @__PURE__ */ t.union(/* @__PURE__ */ t.list(any), str, /* @__PURE__ */ t.record(any), /* @__PURE__ */ t.null())], bool, ([v], site) => {
+	if (v === null || v === void 0) return true;
+	if (Array.isArray(v) || typeof v === "string") return v.length === 0;
+	const record = v;
+	const names = Object.keys(record);
+	site.state.charge(keyListCost(names.length));
+	return !names.some((key) => holdsKey(record, key));
+})]);
+const keys = /* @__PURE__ */ define("keys", [/* @__PURE__ */ overload([/* @__PURE__ */ t.record(any)], /* @__PURE__ */ t.list(str), ([m], site) => entryList(m, site))]);
+const values = /* @__PURE__ */ define("values", [/* @__PURE__ */ overload([/* @__PURE__ */ t.record(T)], listT, ([m], site) => {
+	const record = m;
+	return made(entryList(record, site).map((key) => record[key] ?? null), site);
+})]);
+const entries = /* @__PURE__ */ define("entries", [/* @__PURE__ */ overload([/* @__PURE__ */ t.record(T)], /* @__PURE__ */ t.list(/* @__PURE__ */ t.object({
+	key: str,
+	value: T
+})), ([m], site) => {
+	const record = m;
+	const names = entryList(record, site);
+	site.state.charge(names.length);
+	return made(names.map((key) => made({
+		key,
+		value: record[key] ?? null
+	}, site)), site);
+})]);
+const type = /* @__PURE__ */ define("type", [/* @__PURE__ */ overload([any], str, ([v]) => kindOf(v))]);
+const optZone = /* @__PURE__ */ t.optional(str);
+/** Where a built-in's time zone parameter is (see FunctionDef.zone). */
+const zoneAt = (position) => ({
+	at: position,
+	warm: warmZone
+});
 function zoneArg(value) {
 	return value === void 0 || value === null ? null : value;
 }
-function field(name, description, pick) {
-	return define(name, description, [overload([ts, optZone], num, ([d, z], site) => pick(wallClock(d, zoneArg(z), site)), { required: 1 })]);
+function field(name, pick) {
+	return define(name, [overload([ts, optZone], num, ([d, z], site) => pick(wallClock(d, zoneArg(z), site)), { required: 1 })], zoneAt(1));
 }
 /** Midnight at the start of the day, with `reset` fields of the wall clock set too. */
-function startOf(name, what, reset) {
-	return define(name, `${what}, in a time zone (default UTC).`, [overload([ts, optZone], ts, ([d, z], site) => {
+function startOf(name, reset) {
+	return define(name, [overload([ts, optZone], ts, ([d, z], site) => {
 		const midnight = {
 			...wallClock(d, zoneArg(z), site),
 			...reset,
@@ -953,7 +945,7 @@ function startOf(name, what, reset) {
 			millisecond: 0
 		};
 		return fromWallClock(midnight, zoneArg(z), site);
-	}, { required: 1 })]);
+	}, { required: 1 })], zoneAt(1));
 }
 /** Longest duration text duration() reads; longer text is never a valid duration in range. */
 const MAX_DURATION_TEXT = 64;
@@ -974,87 +966,85 @@ function isoDurationMs(text) {
 	const ms = part(weeks) * MS_PER_WEEK + part(days) * MS_PER_DAY + part(hours) * MS_PER_HOUR + part(minutes) * MS_PER_MINUTE + part(seconds) * MS_PER_SECOND + (fraction === void 0 ? 0 : Number(fraction.padEnd(3, "0")));
 	return sign === "-" ? -ms : ms;
 }
-function durationUnit(name, unitMs, description) {
-	return define(name, description, [overload([num], dur, ([n], site) => durationOf(n * unitMs, site.state, site.span))]);
+function durationUnit(name, unitMs) {
+	return define(name, [overload([num], dur, ([n], site) => durationOf(n * unitMs, site.state, site.span))]);
 }
-function durationIn(name, unitMs, description) {
-	return define(name, description, [overload([dur], num, ([d]) => d.ms / unitMs)]);
+function durationIn(name, unitMs) {
+	return define(name, [overload([dur], num, ([d]) => d.ms / unitMs)]);
 }
-const TIME_FUNCTIONS = [
-	define("now", "The current time, fixed for one evaluation.", [overload([], ts, (_, site) => site.state.now())]),
-	define("timestamp", "Parses ISO-8601 text (years 0000-9999, or six digits with a sign such as +012345, as a timestamp renders) or epoch milliseconds (a fraction is dropped toward zero, as Date does) into a timestamp.", [
-		overload([str], ts, ([s], site) => {
-			site.state.charge(PARSE_COST);
-			return parseTimestamp(s, site);
-		}),
-		overload([num], ts, ([n], site) => checked(n, site)),
-		overload([ts], ts, ([d], site) => {
-			timeOf(d, site.state, site.span);
-			return d;
-		})
-	]),
-	define("duration", "Parses ISO-8601 duration text in weeks, days, hours, minutes, and seconds (e.g. \"PT1H30M\", \"-P2DT0.5S\"), the text a duration renders as.", [overload([str], dur, ([s], site) => {
+const now = /* @__PURE__ */ define("now", [/* @__PURE__ */ overload([], ts, (_, site) => site.state.now())]);
+const timestamp = /* @__PURE__ */ define("timestamp", [
+	/* @__PURE__ */ overload([str], ts, ([s], site) => {
 		site.state.charge(PARSE_COST);
-		const ms = isoDurationMs(s);
-		if (typeof ms === "string") throw site.state.error("INVALID_ARGUMENT", ms, site.span);
-		return durationOf(ms, site.state, site.span);
-	}, { literals: ([text]) => {
-		if (typeof text !== "string") return void 0;
-		const ms = isoDurationMs(text);
-		return typeof ms === "string" ? ms : void 0;
-	} }), overload([dur], dur, ([d]) => d)]),
-	durationUnit("weeks", MS_PER_WEEK, "A duration of n weeks."),
-	durationUnit("days", MS_PER_DAY, "A duration of n days (24 hours each)."),
-	durationUnit("hours", MS_PER_HOUR, "A duration of n hours."),
-	durationUnit("minutes", MS_PER_MINUTE, "A duration of n minutes."),
-	durationUnit("seconds", MS_PER_SECOND, "A duration of n seconds."),
-	durationUnit("milliseconds", 1, "A duration of n milliseconds. Durations are whole milliseconds: a fraction rounds to the nearest one, halves away from zero."),
-	durationIn("inDays", MS_PER_DAY, "A duration as a (fractional) number of days."),
-	durationIn("inHours", MS_PER_HOUR, "A duration as a number of hours."),
-	durationIn("inMinutes", MS_PER_MINUTE, "A duration as a number of minutes."),
-	durationIn("inSeconds", MS_PER_SECOND, "A duration as a number of seconds."),
-	durationIn("inMilliseconds", 1, "A duration as a number of milliseconds."),
-	field("year", "The calendar year, in a time zone (default UTC).", (c) => c.year),
-	field("month", "The month 1-12, in a time zone (default UTC).", (c) => c.month),
-	field("day", "The day of the month, in a time zone (default UTC).", (c) => c.day),
-	field("hour", "The hour 0-23, in a time zone (default UTC).", (c) => c.hour),
-	field("minute", "The minute, in a time zone (default UTC).", (c) => c.minute),
-	field("second", "The second, in a time zone (default UTC).", (c) => c.second),
-	field("dayOfWeek", "The ISO weekday (Monday 1 to Sunday 7), in a time zone (default UTC).", isoWeekday),
-	startOf("startOfDay", "Midnight at the start of the day", {}),
-	startOf("startOfMonth", "Midnight on the first of the month", { day: 1 }),
-	startOf("startOfYear", "Midnight on January 1", {
-		month: 1,
-		day: 1
+		return parseTimestamp(s, site);
 	}),
-	define("addDays", "Adds calendar days (keeps the wall-clock time across DST), in a time zone.", [overload([
-		ts,
-		num,
-		optZone
-	], ts, ([d, n, z], site) => addDays(d, n, zoneArg(z), site), { required: 2 })]),
-	define("addMonths", "Adds calendar months, clamping the day to the month length.", [overload([
-		ts,
-		num,
-		optZone
-	], ts, ([d, n, z], site) => addMonths(d, n, zoneArg(z), site), { required: 2 })]),
-	define("addYears", "Adds calendar years (Feb 29 becomes Feb 28).", [overload([
-		ts,
-		num,
-		optZone
-	], ts, ([d, n, z], site) => addMonths(d, integer(n, "Years", site) * MONTHS_PER_YEAR, zoneArg(z), site), { required: 2 })]),
-	define("formatDate", "Formats a timestamp in a time zone (default UTC). Tokens: yyyy yy MMMM MMM MM M dd d EEEE EEE HH H hh h a mm m ss s SSS; quote literal text ('at'), and write '' for a quote ('it''s').", [overload([
-		ts,
-		str,
-		optZone
-	], str, ([d, p, z], site) => {
-		const text = formatTimestamp(d, p, zoneArg(z), site);
-		site.state.stringLimit(text.length, site.span);
-		return text;
-	}, {
-		required: 2,
-		literals: ([, pattern]) => typeof pattern === "string" ? checkDatePattern(pattern) : void 0
-	})])
-];
+	/* @__PURE__ */ overload([num], ts, ([n], site) => checked(n, site)),
+	/* @__PURE__ */ overload([ts], ts, ([d], site) => {
+		timeOf(d, site.state, site.span);
+		return d;
+	})
+]);
+const duration = /* @__PURE__ */ define("duration", [/* @__PURE__ */ overload([str], dur, ([s], site) => {
+	site.state.charge(PARSE_COST);
+	const ms = isoDurationMs(s);
+	if (typeof ms === "string") throw site.state.error("INVALID_ARGUMENT", ms, site.span);
+	return durationOf(ms, site.state, site.span);
+}, { literals: ([text]) => {
+	if (typeof text !== "string") return void 0;
+	const ms = isoDurationMs(text);
+	return typeof ms === "string" ? ms : void 0;
+} }), /* @__PURE__ */ overload([dur], dur, ([d]) => d)]);
+const weeks = /* @__PURE__ */ durationUnit("weeks", MS_PER_WEEK);
+const days = /* @__PURE__ */ durationUnit("days", MS_PER_DAY);
+const hours = /* @__PURE__ */ durationUnit("hours", MS_PER_HOUR);
+const minutes = /* @__PURE__ */ durationUnit("minutes", MS_PER_MINUTE);
+const seconds = /* @__PURE__ */ durationUnit("seconds", MS_PER_SECOND);
+const milliseconds = /* @__PURE__ */ durationUnit("milliseconds", 1);
+const inDays = /* @__PURE__ */ durationIn("inDays", MS_PER_DAY);
+const inHours = /* @__PURE__ */ durationIn("inHours", MS_PER_HOUR);
+const inMinutes = /* @__PURE__ */ durationIn("inMinutes", MS_PER_MINUTE);
+const inSeconds = /* @__PURE__ */ durationIn("inSeconds", MS_PER_SECOND);
+const inMilliseconds = /* @__PURE__ */ durationIn("inMilliseconds", 1);
+const year = /* @__PURE__ */ field("year", (c) => c.year);
+const month = /* @__PURE__ */ field("month", (c) => c.month);
+const day = /* @__PURE__ */ field("day", (c) => c.day);
+const hour = /* @__PURE__ */ field("hour", (c) => c.hour);
+const minute = /* @__PURE__ */ field("minute", (c) => c.minute);
+const second = /* @__PURE__ */ field("second", (c) => c.second);
+const dayOfWeek = /* @__PURE__ */ field("dayOfWeek", isoWeekday);
+const startOfDay = /* @__PURE__ */ startOf("startOfDay", {});
+const startOfMonth = /* @__PURE__ */ startOf("startOfMonth", { day: 1 });
+const startOfYear = /* @__PURE__ */ startOf("startOfYear", {
+	month: 1,
+	day: 1
+});
+const addDays = /* @__PURE__ */ define("addDays", [/* @__PURE__ */ overload([
+	ts,
+	num,
+	optZone
+], ts, ([d, n, z], site) => addDays$1(d, n, zoneArg(z), site), { required: 2 })], /* @__PURE__ */ zoneAt(2));
+const addMonths = /* @__PURE__ */ define("addMonths", [/* @__PURE__ */ overload([
+	ts,
+	num,
+	optZone
+], ts, ([d, n, z], site) => addMonths$1(d, n, zoneArg(z), site), { required: 2 })], /* @__PURE__ */ zoneAt(2));
+const addYears = /* @__PURE__ */ define("addYears", [/* @__PURE__ */ overload([
+	ts,
+	num,
+	optZone
+], ts, ([d, n, z], site) => addMonths$1(d, integer(n, "Years", site) * MONTHS_PER_YEAR, zoneArg(z), site), { required: 2 })], /* @__PURE__ */ zoneAt(2));
+const formatDate = /* @__PURE__ */ define("formatDate", [/* @__PURE__ */ overload([
+	ts,
+	str,
+	optZone
+], str, ([d, p, z], site) => {
+	const text = formatTimestamp(d, p, zoneArg(z), site);
+	site.state.stringLimit(text.length, site.span);
+	return text;
+}, {
+	required: 2,
+	literals: ([, pattern]) => typeof pattern === "string" ? checkDatePattern(pattern) : void 0
+})], /* @__PURE__ */ zoneAt(2));
 /** Result types that depend on argument types beyond simple type variables. */
 const RESULT_REFINERS = {
 	values: (args) => t.list(valueTypeOf(args[0])),
@@ -1070,14 +1060,101 @@ const RESULT_REFINERS = {
 		return t.list(unionOf(members.map((member) => member.kind === "list" ? member.element : member)));
 	}
 };
-const BUILTINS = new Map([
-	...STRING_FUNCTIONS,
-	...NUMBER_FUNCTIONS,
-	...LIST_FUNCTIONS,
-	...MAP_FUNCTIONS,
-	...TIME_FUNCTIONS
-].map((def) => [def.name, def]));
+/**
+* Every built-in by name, in the order descriptions.ts lists them. Each
+* built-in is also its own export, so a bundle that never reads this map
+* keeps only the built-ins it imports.
+*/
+const BUILTINS = /* @__PURE__ */ (() => new Map([
+	toUpperCase,
+	toLowerCase,
+	trim,
+	trimStart,
+	trimEnd,
+	startsWith,
+	endsWith,
+	includes,
+	indexOf,
+	lastIndexOf,
+	slice,
+	split,
+	replace,
+	replaceAll,
+	padStart,
+	padEnd,
+	repeat,
+	at,
+	matches,
+	toString,
+	toNumber,
+	round,
+	floor,
+	ceil,
+	trunc,
+	abs,
+	sqrt,
+	clamp,
+	toFixed,
+	formatNumber,
+	formatCurrency,
+	min,
+	max,
+	sum,
+	avg,
+	map,
+	filter,
+	find,
+	findIndex,
+	some,
+	every,
+	none,
+	flatMap,
+	sortBy,
+	groupBy,
+	count,
+	reduce,
+	sort,
+	reverse,
+	unique,
+	flat,
+	first,
+	last,
+	join,
+	isEmpty,
+	keys,
+	values,
+	entries,
+	type,
+	now,
+	timestamp,
+	duration,
+	weeks,
+	days,
+	hours,
+	minutes,
+	seconds,
+	milliseconds,
+	inDays,
+	inHours,
+	inMinutes,
+	inSeconds,
+	inMilliseconds,
+	year,
+	month,
+	day,
+	hour,
+	minute,
+	second,
+	dayOfWeek,
+	startOfDay,
+	startOfMonth,
+	startOfYear,
+	addDays,
+	addMonths,
+	addYears,
+	formatDate
+].map((def) => [def.name, def])))();
 //#endregion
-export { BUILTINS, RESULT_REFINERS, zoneParameter };
+export { BUILTINS, RESULT_REFINERS, abs, addDays, addMonths, addYears, at, avg, ceil, clamp, count, day, dayOfWeek, days, duration, endsWith, entries, every, filter, find, findIndex, first, flat, flatMap, floor, formatCurrency, formatDate, formatNumber, groupBy, hour, hours, inDays, inHours, inMilliseconds, inMinutes, inSeconds, includes, indexOf, isEmpty, join, keys, last, lastIndexOf, map, matches, max, milliseconds, min, minute, minutes, month, none, now, padEnd, padStart, reduce, repeat, replace, replaceAll, reverse, round, second, seconds, slice, some, sort, sortBy, split, sqrt, startOfDay, startOfMonth, startOfYear, startsWith, sum, timestamp, toFixed, toLowerCase, toNumber, toString, toUpperCase, trim, trimEnd, trimStart, trunc, type, unique, values, weeks, year };
 
 //# sourceMappingURL=builtins.mjs.map