saykit 0.8.0 → 0.9.0

package/dist/runtime.d.mts

@@ -31,22 +31,30 @@ interface SelectOptions<Branch = string> {
   other: Branch;
   [match: string | number]: Branch;
 }
+/**
+ * An ICU skeleton: a `::`-prefixed description of the parts a value is written
+ * with, rather than a name for a whole format. `::currency/EUR` and
+ * `::yyyyMMdd` say what to show and leave the arrangement to the locale.
+ *
+ * A skeleton is where the formats the named styles have no word for live —
+ * currency, compact notation, a year and month with no day — so every argument
+ * type accepts one alongside its named styles.
+ */
+type Skeleton = `::${string}`;
 /**
  * Formatting for a `{arg, number}` placeholder.
  *
- * `currency` is not offered: MF1 has nowhere to write the currency code, so
- * `{price, number, currency}` formats as a literal `{$price}` rather than an
- * amount. A literal pattern such as `#,##0.00` is accepted for the cases the
- * named styles do not cover.
+ * A literal `NumberFormat` pattern such as `#,##0.00` is also accepted, for the
+ * cases neither the named styles nor a skeleton spell more clearly.
  */
 interface NumberOptions {
-  style?: 'integer' | 'percent' | (string & {});
+  style?: 'integer' | 'percent' | Skeleton | (string & {});
 }
 /**
  * Formatting for a `{arg, date}` or `{arg, time}` placeholder.
  */
 interface DateTimeOptions {
-  style?: 'short' | 'medium' | 'long' | 'full';
+  style?: 'short' | 'medium' | 'long' | 'full' | Skeleton;
 }
 //#endregion
 //#region src/runtime.d.ts
@@ -259,10 +267,12 @@ declare class Say<Locale extends string = string, Loader extends Say.Loader<Loca
    * say`You have ${say.number(items.length)} items`
    * say`Battery at ${say.number(level, { style: 'percent' })}`
    * say`Total: ${say.number({ cartTotal: getTotal() }, { style: '#,##0.00' })}`
+   * say`Total: ${say.number(total, { style: '::currency/EUR' })}`
    * ```
    *
    * @param _ Number to format
-   * @param options Formatting style, either a named style or a literal number pattern
+   * @param options Formatting style: a named style, an ICU skeleton such as
+   *   `::currency/EUR`, or a literal number pattern such as `#,##0.00`
    * @returns The formatted number
    * @remark This is a macro and must be used with the relevant saykit plugin
    */
@@ -274,10 +284,12 @@ declare class Say<Locale extends string = string, Loader extends Say.Loader<Loca
    * ```ts
    * say`Published ${say.date(post.publishedAt)}`
    * say`Published ${say.date(post.publishedAt, { style: 'full' })}`
+   * say`Published ${say.date(post.publishedAt, { style: '::yMMMM' })}`
    * ```
    *
    * @param _ Date to format
-   * @param options Formatting style
+   * @param options Formatting style, either a named style or an ICU skeleton
+   *   such as `::yyyyMMdd`
    * @returns The formatted date
    * @remark This is a macro and must be used with the relevant saykit plugin
    */
@@ -289,14 +301,16 @@ declare class Say<Locale extends string = string, Loader extends Say.Loader<Loca
    * ```ts
    * say`Doors open at ${say.time(opensAt)}`
    * say`Doors open at ${say.time(opensAt, { style: 'short' })}`
+   * say`Doors open at ${say.time(opensAt, { style: '::Hm' })}`
    * ```
    *
    * @param _ Date to format
-   * @param options Formatting style
+   * @param options Formatting style, either a named style or an ICU skeleton
+   *   such as `::Hm`
    * @returns The formatted time
    * @remark This is a macro and must be used with the relevant saykit plugin
    */
   time(_: Date | number | Named<Date | number>, options?: Disallow<DateTimeOptions, 'id' | 'context'>): string;
 }
 //#endregion
-export { Awaitable, DateTimeOptions, Disallow, Named, NumberOptions, NumeralOptions, ReadonlySay, Say, SelectOptions, Tuple };
+export { Awaitable, DateTimeOptions, Disallow, Named, NumberOptions, NumeralOptions, ReadonlySay, Say, SelectOptions, Skeleton, Tuple };

package/dist/runtime.mjs

@@ -1,117 +1,466 @@
-import { mf1ToMessage } from "@messageformat/icu-messageformat-1";
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/checkPrivateRedeclaration.js
-function _checkPrivateRedeclaration(e, t) {
-	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+import { parse } from "@messageformat/parser";
+import { MessageFormat } from "messageformat";
+import { getDateTimeFormatOptions, parseDateTokens } from "@messageformat/date-skeleton";
+import { getNumberFormatOptions, parseNumberPattern, parseNumberSkeleton } from "@messageformat/number-skeleton";
+import { getLocaleDir } from "messageformat/functions";
+//#region src/messageformat/options.ts
+const literal = (value) => ({
+	type: "literal",
+	value
+});
+function options(value) {
+	return typeof value === "object" && value !== null ? value : {};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/classPrivateMethodInitSpec.js
-function _classPrivateMethodInitSpec(e, a) {
-	_checkPrivateRedeclaration(e, a), a.add(e);
+//#region src/messageformat/styles.ts
+var StyleError = class extends Error {};
+const DATE_STYLES = {
+	short: {
+		year: "numeric",
+		month: "numeric",
+		day: "numeric"
+	},
+	medium: {
+		year: "numeric",
+		month: "short",
+		day: "numeric"
+	},
+	long: {
+		year: "numeric",
+		month: "long",
+		day: "numeric"
+	},
+	full: {
+		year: "numeric",
+		month: "long",
+		day: "numeric",
+		weekday: "long"
+	}
+};
+const TIME_STYLES = {
+	short: {
+		hour: "numeric",
+		minute: "numeric"
+	},
+	medium: {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	},
+	long: {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric",
+		timeZoneName: "short"
+	},
+	full: {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric",
+		timeZoneName: "long"
+	}
+};
+function dateTimeStyle(kind, style) {
+	const named = kind === "date" ? DATE_STYLES : TIME_STYLES;
+	if (style.startsWith("::")) {
+		const errors = [];
+		const opt = getDateTimeFormatOptions(parseDateTokens(style.slice(2)), (_type, message) => errors.push(message));
+		if (errors.length > 0) throw new StyleError(errors[0]);
+		if (Object.keys(opt).length === 0) throw new StyleError(`Empty skeleton ${style}`);
+		return opt;
+	}
+	if (style === "") return named.medium;
+	if (Object.hasOwn(named, style)) return named[style];
+	throw new StyleError(`Unsupported ${kind} style ${style}`);
 }
-//#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/classPrivateFieldInitSpec.js
-function _classPrivateFieldInitSpec(e, t, a) {
-	_checkPrivateRedeclaration(e, t), t.set(e, a);
+function numberStyle(style) {
+	if (style === "") return {};
+	if (style === "integer") return { maximumFractionDigits: 0 };
+	if (style === "percent") return { style: "percent" };
+	const errors = [];
+	const onError = (error) => errors.push(String(error));
+	const skeleton = style.startsWith("::") ? parseNumberSkeleton(style.slice(2), onError) : parseNumberPattern(style, "XXX", onError);
+	let scale;
+	const opt = getNumberFormatOptions(skeleton, (stem, option) => {
+		if (stem === "scale") scale = Number(option);
+		else errors.push(`Unsupported number stem ${stem}`);
+	});
+	if (errors.length > 0) throw new StyleError(errors[0]);
+	return scale === void 0 ? opt : {
+		...opt,
+		scale
+	};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/assertClassBrand.js
-function _assertClassBrand(e, t, n) {
-	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
-	throw new TypeError("Private element is not present on this object");
+//#region src/messageformat/convert.ts
+const isSelect = (token) => token.type === "plural" || token.type === "select" || token.type === "selectordinal";
+const asKey = (key) => /^=\d+$/.test(key) ? Number(key.slice(1)) : key;
+function functionRef(token) {
+	let style = "";
+	for (const part of token.param ?? []) {
+		if (part.type !== "content") throw new Error(`Unsupported style part: ${part.type}`);
+		style += part.value;
+	}
+	style = style.trim();
+	const ref = (name, value) => ({
+		type: "function",
+		name,
+		...value === void 0 ? {} : { options: { options: literal(value) } }
+	});
+	try {
+		switch (token.key) {
+			case "date":
+			case "time": return ref("say:datetime", dateTimeStyle(token.key, style));
+			case "number": return ref("say:number", numberStyle(style));
+			case "duration": return ref("say:duration");
+			default: throw new StyleError(`Unsupported argument type ${token.key}`);
+		}
+	} catch (error) {
+		/* v8 ignore next */
+		if (!(error instanceof StyleError)) throw error;
+		switch (token.key) {
+			case "date":
+			case "time": return ref("say:datetime", dateTimeStyle(token.key, ""));
+			case "number": return ref("say:number", {});
+			default: return ref("say:string");
+		}
+	}
+}
+function toPart(token, plural) {
+	switch (token.type) {
+		case "content": return token.value;
+		case "argument": return {
+			type: "expression",
+			arg: {
+				type: "variable",
+				name: token.arg
+			}
+		};
+		case "function": return {
+			type: "expression",
+			arg: {
+				type: "variable",
+				name: token.arg
+			},
+			functionRef: functionRef(token)
+		};
+		case "octothorpe":
+ /* v8 ignore next */
+		return plural ? {
+			type: "expression",
+			arg: {
+				type: "variable",
+				name: plural
+			}
+		} : "#";
+		/* v8 ignore next 2 -- the token union has no other members */
+		default: throw new Error(`Unsupported token type: ${token.type}`);
+	}
+}
+const sameSelector = (a) => (b) => a.arg === b.arg && a.type === b.type && a.offset === b.offset;
+function findSelectors(tokens) {
+	const selectors = [];
+	const add = (selector) => {
+		const existing = selectors.find(sameSelector(selector));
+		if (existing) {
+			existing.keys.push(...selector.keys);
+			return;
+		}
+		const taken = selectors.filter((s) => s.arg === selector.arg).length;
+		const name = taken === 0 ? selector.arg : `${selector.arg}#${taken}`;
+		selectors.push({
+			...selector,
+			name
+		});
+	};
+	for (const token of tokens) {
+		if (!isSelect(token)) continue;
+		add({
+			arg: token.arg,
+			type: token.type,
+			offset: token.pluralOffset ?? 0,
+			keys: token.cases.map((c) => token.type === "select" ? c.key : asKey(c.key))
+		});
+		for (const c of token.cases) for (const inner of findSelectors(c.tokens)) add(inner);
+	}
+	return selectors;
+}
+function declaration({ arg, name, type, offset }) {
+	const functionRef = type === "select" ? {
+		type: "function",
+		name: "say:string"
+	} : {
+		type: "function",
+		name: "say:plural",
+		options: { options: literal({
+			offset,
+			ordinal: type === "selectordinal"
+		}) }
+	};
+	const value = {
+		type: "expression",
+		arg: {
+			type: "variable",
+			name: arg
+		},
+		functionRef
+	};
+	return name === arg ? {
+		type: "input",
+		name,
+		value
+	} : {
+		type: "local",
+		name,
+		value
+	};
+}
+function sortKeys(keys) {
+	const rank = (key) => typeof key === "number" ? 0 : key === "other" ? 2 : 1;
+	return Array.from(new Set(keys)).sort((a, b) => rank(a) - rank(b));
+}
+function toMessage(ast) {
+	const selectors = findSelectors(ast);
+	if (selectors.length === 0) return {
+		type: "message",
+		declarations: [],
+		pattern: ast.map((t) => toPart(t, null))
+	};
+	let tuples = [[]];
+	for (const selector of selectors) {
+		const keys = sortKeys(selector.keys);
+		tuples = tuples.flatMap((tuple) => keys.map((key) => [...tuple, key]));
+	}
+	const variants = tuples.map((tuple) => ({
+		keys: tuple.map((key) => key === "other" ? { type: "*" } : {
+			type: "literal",
+			quoted: false,
+			value: String(key)
+		}),
+		value: []
+	}));
+	function fill(tokens, plural, filter) {
+		for (const token of tokens) {
+			if (isSelect(token)) {
+				const index = selectors.findIndex(sameSelector({
+					arg: token.arg,
+					type: token.type,
+					offset: token.pluralOffset ?? 0
+				}));
+				const inner = token.type === "select" ? plural : selectors[index].name;
+				for (const c of token.cases) {
+					const key = token.type === "select" ? c.key : asKey(c.key);
+					fill(c.tokens, inner, [...filter, {
+						index,
+						key
+					}]);
+				}
+				continue;
+			}
+			for (const variant of variants) {
+				if (!filter.every(({ index, key }) => {
+					const vk = variant.keys[index];
+					return vk.type === "*" ? key === "other" : String(key) === vk.value;
+				})) continue;
+				const part = toPart(token, plural);
+				const last = variant.value.length - 1;
+				if (typeof part === "string" && typeof variant.value[last] === "string") variant.value[last] += part;
+				else variant.value.push(part);
+			}
+		}
+	}
+	fill(ast, null, []);
+	return {
+		type: "select",
+		declarations: selectors.map(declaration),
+		selectors: selectors.map((s) => ({
+			type: "variable",
+			name: s.name
+		})),
+		variants
+	};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/classPrivateFieldSet2.js
-function _classPrivateFieldSet2(s, a, r) {
-	return s.set(_assertClassBrand(s, a), r), r;
+//#region src/messageformat/values.ts
+function part(type, locale, parts) {
+	const dir = getLocaleDir(locale);
+	/* v8 ignore next 3 */
+	return dir === "ltr" || dir === "rtl" ? {
+		type,
+		dir,
+		locale,
+		parts
+	} : {
+		type,
+		locale,
+		parts
+	};
+}
+function numeric(operand) {
+	const value = typeof operand === "object" && operand !== null ? operand.valueOf() : operand;
+	if (typeof value === "bigint") return value;
+	const number = Number(value);
+	if (Number.isNaN(number) && value !== void 0) throw new Error("Input is not numeric");
+	return number;
+}
+function temporal(operand) {
+	let value = operand;
+	if (typeof value === "object" && value !== null && !(value instanceof Date)) value = value.valueOf();
+	if (typeof value === "number" || typeof value === "string") value = new Date(value);
+	if (!(value instanceof Date) || Number.isNaN(value.getTime())) throw new Error("Input is not a valid date");
+	return value;
 }
+function number(locales, value, opt) {
+	let nf;
+	let locale;
+	const format = () => nf ??= new Intl.NumberFormat(locales, opt);
+	const resolved = () => locale ??= format().resolvedOptions().locale;
+	return {
+		type: "number",
+		get dir() {
+			return getLocaleDir(resolved());
+		},
+		get options() {
+			return { ...opt };
+		},
+		toParts: () => [part("number", resolved(), format().formatToParts(value))],
+		toString: () => format().format(value),
+		valueOf: () => value
+	};
+}
+function datetime(locales, value, opt) {
+	let dtf;
+	let locale;
+	const format = () => dtf ??= new Intl.DateTimeFormat(locales, opt);
+	const resolved = () => locale ??= format().resolvedOptions().locale;
+	return {
+		type: "datetime",
+		get dir() {
+			return getLocaleDir(resolved());
+		},
+		get options() {
+			return { ...opt };
+		},
+		toParts: () => [part("datetime", resolved(), format().formatToParts(value))],
+		toString: () => format().format(value),
+		valueOf: () => value
+	};
+}
+function duration(seconds) {
+	if (!Number.isFinite(seconds)) return String(seconds);
+	const sign = seconds < 0 ? "-" : "";
+	const total = Math.round(Math.abs(seconds) * 1e3) / 1e3;
+	const secs = total % 60;
+	const minutes = Math.floor(total / 60);
+	const hours = Math.floor(minutes / 60);
+	const written = Math.round(secs) === secs ? String(secs) : secs.toFixed(3);
+	const parts = hours > 0 ? [
+		hours,
+		minutes % 60,
+		written
+	] : [minutes, written];
+	const first = parts.shift();
+	const pad = (n) => Number(n) < 10 ? `0${n}` : String(n);
+	return sign + [first, ...parts.map(pad)].join(":");
+}
+//#endregion
+//#region src/messageformat/functions.ts
+const functions = {
+	"say:number": (ctx, opt, operand) => {
+		const { scale, ...nf } = options(opt.options);
+		const value = numeric(operand);
+		return number(ctx.locales, scale ? Number(value) * scale : value, nf);
+	},
+	"say:datetime": (ctx, opt, operand) => datetime(ctx.locales, temporal(operand), options(opt.options)),
+	"say:duration": (_ctx, _opt, operand) => {
+		const value = Number(numeric(operand));
+		const str = duration(value);
+		return {
+			type: "say:duration",
+			toParts: () => [{
+				type: "say:duration",
+				value: str
+			}],
+			toString: () => str,
+			valueOf: () => value
+		};
+	},
+	"say:plural": (ctx, opt, operand) => {
+		const { offset = 0, ordinal = false } = options(opt.options);
+		const value = numeric(operand);
+		const shifted = typeof value === "bigint" ? value - BigInt(offset) : value - offset;
+		const result = number(ctx.locales, shifted, {});
+		result.valueOf = () => value;
+		let rules;
+		result.selectKey = (keys) => {
+			const exact = String(value);
+			if (keys.has(exact)) return exact;
+			rules ??= new Intl.PluralRules(ctx.locales, {
+				localeMatcher: ctx.localeMatcher,
+				type: ordinal ? "ordinal" : "cardinal"
+			});
+			const category = rules.select(Number(shifted));
+			return keys.has(category) ? category : null;
+		};
+		return result;
+	},
+	"say:string": (_ctx, _opt, operand) => {
+		const str = operand === void 0 ? "" : String(operand);
+		return {
+			type: "string",
+			selectKey: (keys) => keys.has(str) ? str : null,
+			toParts: () => [{
+				type: "string",
+				value: str
+			}],
+			toString: () => str,
+			valueOf: () => str
+		};
+	}
+};
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/classPrivateFieldGet2.js
-function _classPrivateFieldGet2(s, a) {
-	return s.get(_assertClassBrand(s, a));
+//#region src/messageformat/index.ts
+function compile(locale, source) {
+	return new MessageFormat(locale, toMessage(parse(source)), { functions });
 }
 //#endregion
 //#region src/runtime.ts
-let _Symbol$iterator;
-let _Symbol$for;
-/**
-* Map a descriptor's keys back to the placeholders the message names. The
-* transform emits every value with one underscore in front, which keeps a
-* message's values out of the descriptor's own namespace, so stripping exactly
-* one is the whole inverse — `_0` is `0`, and `__total` is a placeholder named
-* `_total`. Keys without one are passed through, so a hand-written
-* `call({ id, name })` still formats `{name}`.
-*
-* Built from the descriptor's own entries so a value named `__proto__` stays a
-* placeholder rather than reaching through to the prototype.
-*/
 function resolveDescriptorValues(descriptor) {
 	return Object.fromEntries(Object.entries(descriptor).filter(([key]) => key !== "id").map(([key, value]) => [key.startsWith("_") ? key.slice(1) : key, value]));
 }
-var _locales = /* @__PURE__ */ new WeakMap();
-var _loader = /* @__PURE__ */ new WeakMap();
-var _messages = /* @__PURE__ */ new WeakMap();
-var _formats = /* @__PURE__ */ new WeakMap();
-var _active = /* @__PURE__ */ new WeakMap();
-var _Say_brand = /* @__PURE__ */ new WeakSet();
-_Symbol$iterator = Symbol.iterator;
-_Symbol$for = Symbol.for("nodejs.util.inspect.custom");
 var Say = class Say {
+	#locales;
+	#loader;
+	#messages;
+	#formats;
+	#active;
 	constructor(options) {
-		_classPrivateMethodInitSpec(this, _Say_brand);
-		_classPrivateFieldInitSpec(this, _locales, void 0);
-		_classPrivateFieldInitSpec(this, _loader, void 0);
-		_classPrivateFieldInitSpec(this, _messages, void 0);
-		_classPrivateFieldInitSpec(this, _formats, void 0);
-		_classPrivateFieldInitSpec(this, _active, void 0);
-		_classPrivateFieldSet2(_locales, this, options.locales);
-		_classPrivateFieldSet2(_loader, this, options.loader);
-		_classPrivateFieldSet2(_messages, this, /* @__PURE__ */ new Map());
-		_classPrivateFieldSet2(_formats, this, /* @__PURE__ */ new Map());
+		this.#locales = options.locales;
+		this.#loader = options.loader;
+		this.#messages = /* @__PURE__ */ new Map();
+		this.#formats = /* @__PURE__ */ new Map();
 		if (options.messages) this.assign(options.messages);
 	}
-	/**
-	* The currently active locale.
-	*
-	* @throws If no locale is active
-	*/
 	get locale() {
-		if (!_classPrivateFieldGet2(_active, this)) throw new Error("No active locale");
-		return _classPrivateFieldGet2(_active, this);
+		if (!this.#active) throw new Error("No active locale");
+		return this.#active;
 	}
-	/**
-	* All available messages mapped by locale.
-	*
-	* @throws If no locale is active
-	* @throws If no messages are available for the active locale
-	*/
 	get messages() {
 		/* v8 ignore next */
-		if (!_classPrivateFieldGet2(_messages, this).has(this.locale)) throw new Error("No messages loaded for locale");
-		return _classPrivateFieldGet2(_messages, this).get(this.locale);
+		if (!this.#messages.has(this.locale)) throw new Error("No messages loaded for locale");
+		return this.#messages.get(this.locale);
 	}
-	/**
-	* All available locales.
-	*/
 	get locales() {
-		return _classPrivateFieldGet2(_locales, this);
+		return this.#locales;
 	}
-	/**
-	* Loads messages for the given locales.
-	* If no locales are provided, all available locales are loaded.
-	* Requires a {@link Say.Loader} to be provided.
-	* If `loader` returns a promise, so will this method.
-	*
-	* @param locales Locales to load messages for, defaults to {@link Say.locales}
-	* @returns This
-	*/
 	load(...locales) {
 		if (Object.isFrozen(this)) throw new Error("Cannot load messages on a frozen Say");
-		if (locales.length === 0) locales = _classPrivateFieldGet2(_locales, this);
+		if (locales.length === 0) locales = this.#locales;
 		const tasks = [];
 		for (const locale of locales) {
-			if (_classPrivateFieldGet2(_messages, this).has(locale)) continue;
-			if (!_classPrivateFieldGet2(_loader, this)) throw new Error("No loader provided, cannot load messages");
-			const result = _classPrivateFieldGet2(_loader, this).call(this, locale);
+			if (this.#messages.has(locale)) continue;
+			if (!this.#loader) throw new Error("No loader provided, cannot load messages");
+			const result = this.#loader(locale);
 			if (result instanceof Promise) {
 				const task = result.then((m) => this.assign(locale, m));
 				tasks.push(task);
@@ -121,209 +470,75 @@ var Say = class Say {
 	}
 	assign(localeOrMessages, maybeMessages) {
 		if (Object.isFrozen(this)) throw new Error("Cannot assign messages on a frozen Say");
-		if (typeof localeOrMessages === "string") _classPrivateFieldGet2(_messages, this).set(localeOrMessages, maybeMessages);
-		else for (const locale in localeOrMessages) _classPrivateFieldGet2(_messages, this).set(locale, localeOrMessages[locale]);
+		if (typeof localeOrMessages === "string") this.#messages.set(localeOrMessages, maybeMessages);
+		else for (const locale in localeOrMessages) this.#messages.set(locale, localeOrMessages[locale]);
 		return this;
 	}
-	/**
-	* Set the active locale.
-	*
-	* @param locale Locale to set
-	* @returns This
-	* @throws If locale is not available
-	*/
 	activate(locale) {
 		if (Object.isFrozen(this)) throw new Error("Cannot activate locale on a frozen Say");
-		if (!_classPrivateFieldGet2(_messages, this).has(locale)) throw new Error("No messages loaded for locale");
-		_classPrivateFieldSet2(_active, this, locale);
+		if (!this.#messages.has(locale)) throw new Error("No messages loaded for locale");
+		this.#active = locale;
 		return this;
 	}
-	/**
-	* Creates a clone of the Say instance, with the same locales and messages.
-	*
-	* @returns A clone of the Say instance
-	*/
 	clone() {
 		const copy = new Say({
-			locales: _classPrivateFieldGet2(_locales, this),
-			messages: Object.fromEntries(_classPrivateFieldGet2(_messages, this)),
-			loader: _classPrivateFieldGet2(_loader, this)
+			locales: this.#locales,
+			messages: Object.fromEntries(this.#messages),
+			loader: this.#loader
 		});
-		_classPrivateFieldSet2(_active, copy, _classPrivateFieldGet2(_active, this));
+		copy.#active = this.#active;
 		return copy;
 	}
-	/**
-	* Make this `Say` instance immutable.
-	*/
 	freeze() {
 		return Object.freeze(this);
 	}
-	*[_Symbol$iterator]() {
-		for (const l of _classPrivateFieldGet2(_locales, this)) yield [this.clone().activate(l).freeze(), l];
+	*[Symbol.iterator]() {
+		for (const l of this.#locales) yield [this.clone().activate(l).freeze(), l];
 	}
-	/**
-	* Matches the best locale from a list of guesses.
-	*
-	* @param guesses List of locale guesses
-	*
-	* @returns The best matching locale, or the first locale if no matches are found
-	*/
 	match(...guesses) {
 		const flat = guesses.flat();
-		if (flat.length === 0) return _classPrivateFieldGet2(_locales, this)[0];
+		if (flat.length === 0) return this.#locales[0];
 		for (const guess of flat) {
-			if (_classPrivateFieldGet2(_locales, this).includes(guess)) return guess;
+			if (this.#locales.includes(guess)) return guess;
 			const prefix = guess.split("-")[0];
 			if (!prefix) continue;
-			const match = _classPrivateFieldGet2(_locales, this).find((l) => l.startsWith(prefix));
+			const match = this.#locales.find((l) => l.startsWith(prefix));
 			if (match) return match;
 		}
-		return _classPrivateFieldGet2(_locales, this)[0];
+		return this.#locales[0];
 	}
-	/**
-	* Get the translation for a descriptor.
-	*
-	* @param descriptor Descriptor to get the translation for
-	* @returns The translation string for the descriptor
-	* @throws If no locale is active
-	* @throws If no messages are available for the active locale
-	* @throws If descriptor id is not found
-	*/
 	call(descriptor) {
-		return _assertClassBrand(_Say_brand, this, _call).call(this, this.locale, this.messages, descriptor);
+		return this.#call(this.locale, this.messages, descriptor);
 	}
-	[_Symbol$for](_depth, context, inspect) {
-		if (_classPrivateFieldGet2(_active, this)) return `${this.constructor.name}<${inspect(_classPrivateFieldGet2(_active, this), context)}> {}`;
+	#call(locale, messages, descriptor) {
+		const message = messages[descriptor.id];
+		if (typeof message !== "string") throw new Error(`Message for ${descriptor.id} is not a string`);
+		const key = `${locale}:${descriptor.id}`;
+		const format = this.#formats.get(key) ?? this.#formats.set(key, compile(locale, message)).get(key);
+		return String(format.format(resolveDescriptorValues(descriptor)));
+	}
+	[Symbol.for("nodejs.util.inspect.custom")](_depth, context, inspect) {
+		if (this.#active) return `${this.constructor.name}<${inspect(this.#active, context)}> {}`;
 		else return `${this.constructor.name} {}`;
 	}
-	/**
-	* Define a pluralised message.
-	*
-	* @example
-	* ```ts
-	* say.plural(count, {
-	*   one: 'You have 1 item',
-	*   other: `You have ${count} items`,
-	* })
-	* ```
-	*
-	* Interpolating the selector into a branch extracts as ICU's `#`, the number
-	* the message branched on. A `#` you write yourself is text.
-	* @param _ Number to determine the plural form of
-	* @param options Pluralisation rules keyed by CLDR categories or specific numbers
-	* @returns The plural form of the number
-	* @remark This is a macro and must be used with the relevant saykit plugin
-	*/
 	plural(_, options) {
 		throw new Error("'Say#plural' is a macro and must be used with the relevant saykit plugin");
 	}
-	/**
-	* Define an ordinal message (e.g. "1st", "2nd", "3rd").
-	*
-	* Interpolating the selector into a branch extracts as ICU's `#`, the number
-	* the message branched on. A `#` you write yourself is text.
-	*
-	* @example
-	* ```ts
-	* say.ordinal(position, {
-	*   1: `${position}st`,
-	*   2: `${position}nd`,
-	*   3: `${position}rd`,
-	*   other: `${position}th`,
-	* })
-	* ```
-	*
-	* @param _ Number to determine the ordinal form of
-	* @param options Ordinal rules keyed by CLDR categories or specific numbers
-	* @returns The ordinal form of the number
-	* @remark This is a macro and must be used with the relevant saykit plugin
-	*/
 	ordinal(_, options) {
 		throw new Error("'Say#ordinal' is a macro and must be used with the relevant saykit plugin");
 	}
-	/**
-	* Define a select message, useful for handling gender, status, or other categories.
-	*
-	* @example
-	* ```ts
-	* say.select(gender, {
-	*   male: 'He',
-	*   female: 'She',
-	*   other: 'They',
-	* })
-	* ```
-	*
-	* @param _ Selector value to determine which option is chosen
-	* @param options A mapping of possible selector values to message strings
-	* @returns The select form of the value
-	* @remark This is a macro and must be used with the relevant saykit plugin
-	*/
 	select(_, options) {
 		throw new Error("'Say#select' is a macro and must be used with the relevant saykit plugin");
 	}
-	/**
-	* Format a number the way the active locale writes one, with its own grouping
-	* separators and decimal mark.
-	*
-	* Unlike `plural`, `ordinal`, and `select`, this is a fragment rather than a
-	* whole message, and is normally written inside one.
-	*
-	* @example
-	* ```ts
-	* say`You have ${say.number(items.length)} items`
-	* say`Battery at ${say.number(level, { style: 'percent' })}`
-	* say`Total: ${say.number({ cartTotal: getTotal() }, { style: '#,##0.00' })}`
-	* ```
-	*
-	* @param _ Number to format
-	* @param options Formatting style, either a named style or a literal number pattern
-	* @returns The formatted number
-	* @remark This is a macro and must be used with the relevant saykit plugin
-	*/
 	number(_, options) {
 		throw new Error("'Say#number' is a macro and must be used with the relevant saykit plugin");
 	}
-	/**
-	* Format the date portion of a value the way the active locale writes one.
-	*
-	* @example
-	* ```ts
-	* say`Published ${say.date(post.publishedAt)}`
-	* say`Published ${say.date(post.publishedAt, { style: 'full' })}`
-	* ```
-	*
-	* @param _ Date to format
-	* @param options Formatting style
-	* @returns The formatted date
-	* @remark This is a macro and must be used with the relevant saykit plugin
-	*/
 	date(_, options) {
 		throw new Error("'Say#date' is a macro and must be used with the relevant saykit plugin");
 	}
-	/**
-	* Format the time portion of a value the way the active locale writes one.
-	*
-	* @example
-	* ```ts
-	* say`Doors open at ${say.time(opensAt)}`
-	* say`Doors open at ${say.time(opensAt, { style: 'short' })}`
-	* ```
-	*
-	* @param _ Date to format
-	* @param options Formatting style
-	* @returns The formatted time
-	* @remark This is a macro and must be used with the relevant saykit plugin
-	*/
 	time(_, options) {
 		throw new Error("'Say#time' is a macro and must be used with the relevant saykit plugin");
 	}
 };
-function _call(locale, messages, descriptor) {
-	const message = messages[descriptor.id];
-	if (typeof message !== "string") throw new Error(`Message for ${descriptor.id} is not a string`);
-	const key = `${locale}:${descriptor.id}`;
-	const format = _classPrivateFieldGet2(_formats, this).get(key) ?? _classPrivateFieldGet2(_formats, this).set(key, mf1ToMessage(locale, message)).get(key);
-	return String(format.format(resolveDescriptorValues(descriptor)));
-}
 //#endregion
 export { Say };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saykit",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Type-safe i18n library with compile-time macro transforms",
   "keywords": [
     "i18n",
@@ -25,6 +25,7 @@
     "!dist/**/*.map"
   ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/runtime.d.mts",
@@ -36,7 +37,10 @@
     "provenance": true
   },
   "dependencies": {
-    "@messageformat/icu-messageformat-1": "^0.12.0"
+    "@messageformat/date-skeleton": "2.0.0-0",
+    "@messageformat/number-skeleton": "2.0.0-0",
+    "@messageformat/parser": "^5.1.1",
+    "messageformat": "^4.0.0"
   },
   "scripts": {
     "check": "tsc --noEmit",