@vizejs/composable 0.426.3 → 0.427.0

package/dist/icu-message.d.mts

@@ -0,0 +1,235 @@
+//#region src/icu-message.d.ts
+/**
+ * ICU MessageFormat support: a type-level parameter extractor and a small
+ * runtime parser/formatter built on `Intl`.
+ *
+ * The type-level parser reads message string literals and produces the
+ * parameter object a message needs, so a typo in a parameter name or a
+ * wrong value type fails to compile. The runtime implements the same
+ * grammar subset: simple arguments, `number`, `date`, `time`, `plural`
+ * (with `offset:` and `=N` cases), `selectordinal`, `select`, nesting, and
+ * ICU apostrophe quoting.
+ */
+/** Whitespace characters skipped around ICU tokens. */
+type Whitespace = " " | "\n" | "\t" | "\r";
+/** Remove leading and trailing whitespace from a string literal. */
+type Trim<Text extends string> = Text extends `${Whitespace}${infer Rest}` ? Trim<Rest> : Text extends `${infer Rest}${Whitespace}` ? Trim<Rest> : Text;
+/** Characters that start a quoted literal after an apostrophe. */
+type QuoteStarter = "{" | "}" | "#" | "|";
+/**
+ * One parameter occurrence found while scanning: `[name, value type,
+ * whether the occurrence carries a format type]`.
+ */
+type Occurrence = readonly [name: string, value: unknown, typed: boolean];
+/** Value type required by an argument's format type. */
+type ArgumentValue<Kind extends string> = Kind extends "number" | "spellout" | "ordinal" | "duration" ? number : Kind extends "date" | "time" ? Date | number : string;
+/** Skip a quoted literal (the text after `'`) up to its closing apostrophe. */
+type SkipQuoted<Text extends string> = Text extends `${string}'${infer Rest}` ? Rest : "";
+/**
+ * Scan message text, collecting argument occurrences. Plain text is skipped
+ * in one step up to the next `{` unless it contains an apostrophe, in which
+ * case quoting is handled character by character.
+ */
+type Scan<Text extends string, Found extends Occurrence> = Text extends `${infer Plain}{${infer Rest}` ? Plain extends `${string}'${string}` ? ScanChars<Text, Found> : ScanArgument<Rest, Found> : Found;
+/** Character-level scan used around apostrophes. */
+type ScanChars<Text extends string, Found extends Occurrence> = Text extends `''${infer Rest}` ? ScanChars<Rest, Found> : Text extends `'${infer Next}${infer Rest}` ? Next extends QuoteStarter ? Scan<SkipQuoted<Rest>, Found> : ScanChars<`${Next}${Rest}`, Found> : Text extends `{${infer Rest}` ? ScanArgument<Rest, Found> : Text extends `${string}${infer Rest}` ? Text extends "" ? Found : ScanChars<Rest, Found> : Found;
+/** Parse the argument that starts after a `{`. */
+type ScanArgument<Text extends string, Found extends Occurrence> = Text extends `${infer Head}}${infer AfterSimple}` ? Head extends `${string},${string}` ? Text extends `${infer Name},${infer AfterName}` ? ScanFormat<Trim<Name>, AfterName, Found> : Found : Scan<AfterSimple, Found | readonly [Trim<Head>, string, false]> : Found;
+/** Parse `type[, style]}` or `type, cases}` after an argument name. */
+type ScanFormat<Name extends string, Text extends string, Found extends Occurrence> = Text extends `${infer Kind},${infer AfterKind}` ? Kind extends `${string}}${string}` ? ScanSimpleFormat<Name, Text, Found> : Trim<Kind> extends "plural" | "selectordinal" ? ScanCases<SkipOffset<AfterKind>, Name, number, never, Found> : Trim<Kind> extends "select" ? ScanCases<AfterKind, Name, never, never, Found> : AfterKind extends `${string}}${infer Rest}` ? Scan<Rest, Found | readonly [Name, ArgumentValue<Trim<Kind>>, true]> : Found : ScanSimpleFormat<Name, Text, Found>;
+/** Parse `type}` (a format type without style). */
+type ScanSimpleFormat<Name extends string, Text extends string, Found extends Occurrence> = Text extends `${infer Kind}}${infer Rest}` ? Scan<Rest, Found | readonly [Name, ArgumentValue<Trim<Kind>>, true]> : Found;
+/** Drop a plural `offset:N` prefix. */
+type SkipOffset<Text extends string> = Trim<Text> extends `offset:${infer Rest}` ? Rest extends `${infer _Digits}${Whitespace}${infer Cases}` ? Cases : Rest : Text;
+/**
+ * Parse `key {content} key {content} ... }`. `Value` is the fixed argument
+ * type (`number` for plural kinds); for `select` it stays `never` and the
+ * case keys are collected in `Keys` instead.
+ */
+type ScanCases<Text extends string, Name extends string, Value, Keys extends string, Found extends Occurrence> = Trim<Text> extends `}${infer Rest}` ? Scan<Rest, Found | readonly [Name, [Value] extends [never] ? Keys : Value, true]> : Trim<Text> extends `${infer Key}{${infer Body}` ? TakeBalanced<Body, "", []> extends [infer Content extends string, infer Rest extends string] ? ScanCases<Rest, Name, Value, Keys | Trim<Key>, Found | Scan<Content, never>> : Found : Found;
+/**
+ * Split `content}rest` at the `}` that closes the current case, honoring
+ * nested braces and apostrophe quoting. Returns `[content, rest]`.
+ */
+type TakeBalanced<Text extends string, Taken extends string, Depth extends readonly unknown[]> = Text extends `''${infer Rest}` ? TakeBalanced<Rest, `${Taken}''`, Depth> : Text extends `'${infer Next}${infer Rest}` ? Next extends QuoteStarter ? Rest extends `${infer Quoted}'${infer After}` ? TakeBalanced<After, `${Taken}'${Next}${Quoted}'`, Depth> : [`${Taken}'${Next}${Rest}`, ""] : TakeBalanced<`${Next}${Rest}`, `${Taken}'`, Depth> : Text extends `{${infer Rest}` ? TakeBalanced<Rest, `${Taken}{`, [...Depth, unknown]> : Text extends `}${infer Rest}` ? Depth extends readonly [unknown, ...infer Outer] ? TakeBalanced<Rest, `${Taken}}`, Outer> : [Taken, Rest] : Text extends `${infer Char}${infer Rest}` ? TakeBalanced<Rest, `${Taken}${Char}`, Depth> : [Taken, ""];
+/** Flatten an intersection into a single object type. */
+type Simplify<Value> = { [Key in keyof Value]: Value[Key] } & {};
+/** Intersect the members of a union. */
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends ((value: infer Intersection) => void) ? Intersection : never;
+/**
+ * Value type of one parameter: typed occurrences win over plain `{name}`
+ * occurrences and are intersected with each other.
+ */
+type ResolveOccurrences<Entries extends Occurrence> = [Extract<Entries, readonly [string, unknown, true]>] extends [never] ? string : UnionToIntersection<BoxTypedValue<Entries>> extends infer Merged ? Merged extends {
+  readonly value: unknown;
+} ? Merged["value"] : never : never;
+/** Box the value of each typed occurrence (distributive over `Entry`). */
+type BoxTypedValue<Entry extends Occurrence> = Entry extends readonly [string, infer Value, true] ? {
+  readonly value: Value;
+} : never;
+/**
+ * Every argument occurrence of a message literal as a union of
+ * `[name, value type, typed]` tuples. Exposed so that several messages (for
+ * example the translations of one key) can be merged with the same
+ * "typed occurrence wins" rule through {@link ResolveMessageArguments}.
+ */
+type MessageArguments<Message extends string> = Scan<Message, never>;
+/**
+ * Turn a union of {@link MessageArguments} into a parameter object. Typed
+ * occurrences win over plain `{name}` ones; conflicting typed occurrences
+ * intersect (and become `never` when incompatible).
+ */
+type ResolveMessageArguments<Entries extends Occurrence> = Simplify<CollectValues<Entries>>;
+/** One argument occurrence: `[name, value type, whether it is typed]`. */
+type MessageArgument = Occurrence;
+/** Distribute a union of occurrences into one value type per name. */
+type CollectValues<Entries extends Occurrence> = { [Name in Entries[0]]: ResolveOccurrences<Extract<Entries, readonly [Name, unknown, boolean]>> };
+/**
+ * Parameters a single ICU message needs, extracted from its string literal.
+ *
+ * - `{name}` → `string`
+ * - `{n, number}` (also `spellout`, `ordinal`, `duration`) → `number`
+ * - `{d, date}` / `{d, time}` → `Date | number`
+ * - `{n, plural, …}` / `{n, selectordinal, …}` → `number`
+ * - `{g, select, a {…} b {…} other {…}}` → `"a" | "b" | "other"`
+ *
+ * Nested arguments inside plural/select cases are collected as well. When
+ * a name occurs both plainly and with a type, the typed occurrence wins.
+ * A non-literal `string` yields `Record<string, unknown>`.
+ *
+ * @example
+ * ```ts
+ * type P = MessageParams<"Hi {name}, {count, plural, one {# item} other {# items}}">;
+ * //   ^? { name: string; count: number }
+ * ```
+ */
+type MessageParams<Message extends string> = string extends Message ? Record<string, unknown> : Simplify<CollectValues<Scan<Message, never>>>;
+/** Whether a message literal takes no parameters. */
+type HasNoParams<Message extends string> = keyof MessageParams<Message> extends never ? true : false;
+/** Node of a parsed ICU message. */
+type MessageNode = {
+  readonly kind: "text";
+  readonly value: string;
+} | {
+  readonly kind: "pound";
+} | {
+  readonly kind: "argument";
+  readonly name: string;
+} | {
+  readonly kind: "number" | "date" | "time";
+  readonly name: string;
+  readonly style: string | undefined;
+} | {
+  readonly kind: "plural" | "selectordinal";
+  readonly name: string;
+  readonly offset: number;
+  readonly cases: Readonly<Record<string, readonly MessageNode[]>>;
+} | {
+  readonly kind: "select";
+  readonly name: string;
+  readonly cases: Readonly<Record<string, readonly MessageNode[]>>;
+};
+/** Error code carried by {@link MessageSyntaxError}. */
+type MessageSyntaxErrorCode = "VIZE_COMPOSE_ICU_SYNTAX";
+/** Thrown by {@link parseMessage} for malformed ICU messages. */
+interface MessageSyntaxError extends SyntaxError {
+  /** Stable machine-readable code. */
+  readonly code: MessageSyntaxErrorCode;
+  /** Character offset of the problem. */
+  readonly offset: number;
+}
+/**
+ * Parse an ICU MessageFormat string into an AST.
+ *
+ * Supports simple arguments, `number`/`date`/`time` with an optional style,
+ * `plural` and `selectordinal` (with `offset:` and `=N` cases), `select`,
+ * nesting, `#` inside plural cases, and apostrophe quoting (`''` is a
+ * literal apostrophe; `'{…}'` is literal text). Pure and deterministic.
+ *
+ * @example
+ * ```ts
+ * parseMessage("{n, plural, one {# item} other {# items}}");
+ * ```
+ *
+ * @param message ICU message source.
+ * @throws {@link MessageSyntaxError} tagged `VIZE_COMPOSE_ICU_SYNTAX` for
+ * malformed messages, including a plural or select without an `other` case.
+ * @returns The parsed nodes.
+ */
+declare function parseMessage(message: string): MessageNode[];
+/** Options for {@link formatMessage} and {@link createMessageFormatter}. */
+interface FormatMessageOptions {
+  /**
+   * IANA time zone for `date` and `time` arguments. Fixed by default so
+   * server and client render identically.
+   *
+   * @default "UTC"
+   */
+  readonly timeZone?: string;
+  /**
+   * Named `number` styles usable as `{n, number, name}`.
+   *
+   * @default {}
+   */
+  readonly numberFormats?: Readonly<Record<string, Intl.NumberFormatOptions>>;
+  /**
+   * Named `date`/`time` styles usable as `{d, date, name}`.
+   *
+   * @default {}
+   */
+  readonly dateTimeFormats?: Readonly<Record<string, Intl.DateTimeFormatOptions>>;
+}
+/** Formats parsed messages for one locale, caching `Intl` objects. */
+interface MessageFormatter {
+  /** Locale the formatter renders in. */
+  readonly locale: string;
+  /**
+   * Render a message source or pre-parsed nodes.
+   *
+   * @returns The formatted string.
+   */
+  readonly format: (message: string | readonly MessageNode[], params?: Readonly<Record<string, unknown>>) => string;
+}
+/**
+ * Create a caching formatter for one locale.
+ *
+ * Parsed messages and `Intl` formatters are cached inside the returned
+ * object only (no module state), so one formatter per request or per
+ * i18n instance keeps server rendering isolated.
+ *
+ * @example
+ * ```ts
+ * const formatter = createMessageFormatter("en");
+ * formatter.format("{n, plural, one {# file} other {# files}}", { n: 3 }); // "3 files"
+ * ```
+ *
+ * @param locale BCP 47 locale.
+ * @param options Time zone and named formats.
+ * @default options {}
+ * @returns The formatter.
+ */
+declare function createMessageFormatter(locale: string, options?: FormatMessageOptions): MessageFormatter;
+/**
+ * Format one ICU message with typed parameters.
+ *
+ * Parameters are checked against the message literal at compile time via
+ * {@link MessageParams}. For repeated formatting prefer
+ * {@link createMessageFormatter}, which caches parsing and `Intl` objects.
+ * Deterministic: `date`/`time` arguments use `timeZone` (UTC by default).
+ *
+ * @example
+ * ```ts
+ * formatMessage("en", "Hello {name}!", { name: "Ada" }); // "Hello Ada!"
+ * ```
+ *
+ * @param locale BCP 47 locale.
+ * @param message ICU message.
+ * @param params Values for the message's arguments.
+ * @param options Time zone and named formats.
+ * @default options {}
+ * @throws {@link MessageSyntaxError} for malformed messages.
+ * @returns The formatted string.
+ */
+declare function formatMessage<const Message extends string>(locale: string, message: Message, params: MessageParams<Message>, options?: FormatMessageOptions): string;
+//#endregion
+export { FormatMessageOptions, HasNoParams, MessageArgument, MessageArguments, MessageFormatter, MessageNode, MessageParams, MessageSyntaxError, MessageSyntaxErrorCode, ResolveMessageArguments, createMessageFormatter, formatMessage, parseMessage };

package/dist/icu-message.mjs

@@ -0,0 +1,343 @@
+//#region src/icu-message.ts
+function syntaxError(message, offset) {
+	return Object.assign(/* @__PURE__ */ new SyntaxError(`[VIZE_COMPOSE_ICU_SYNTAX] ${message} at offset ${String(offset)}`), {
+		code: "VIZE_COMPOSE_ICU_SYNTAX",
+		offset
+	});
+}
+const quoteStarters = new Set([
+	"{",
+	"}",
+	"#",
+	"|"
+]);
+/**
+* Parse an ICU MessageFormat string into an AST.
+*
+* Supports simple arguments, `number`/`date`/`time` with an optional style,
+* `plural` and `selectordinal` (with `offset:` and `=N` cases), `select`,
+* nesting, `#` inside plural cases, and apostrophe quoting (`''` is a
+* literal apostrophe; `'{…}'` is literal text). Pure and deterministic.
+*
+* @example
+* ```ts
+* parseMessage("{n, plural, one {# item} other {# items}}");
+* ```
+*
+* @param message ICU message source.
+* @throws {@link MessageSyntaxError} tagged `VIZE_COMPOSE_ICU_SYNTAX` for
+* malformed messages, including a plural or select without an `other` case.
+* @returns The parsed nodes.
+*/
+function parseMessage(message) {
+	let position = 0;
+	const skipSpace = () => {
+		while (position < message.length && /\s/.test(message.charAt(position))) position += 1;
+	};
+	const readIdentifier = (stops) => {
+		const start = position;
+		while (position < message.length && !stops.includes(message.charAt(position))) position += 1;
+		return message.slice(start, position).trim();
+	};
+	const expect = (char) => {
+		if (message.charAt(position) !== char) throw syntaxError(`expected "${char}"`, position);
+		position += 1;
+	};
+	const parseNodes = (inPlural, nested) => {
+		const nodes = [];
+		let text = "";
+		const flush = () => {
+			if (text !== "") nodes.push({
+				kind: "text",
+				value: text
+			});
+			text = "";
+		};
+		while (position < message.length) {
+			const char = message.charAt(position);
+			if (char === "'") {
+				const next = message.charAt(position + 1);
+				if (next === "'") {
+					text += "'";
+					position += 2;
+				} else if (quoteStarters.has(next)) {
+					const end = message.indexOf("'", position + 1);
+					text += message.slice(position + 1, end === -1 ? message.length : end);
+					position = end === -1 ? message.length : end + 1;
+				} else {
+					text += "'";
+					position += 1;
+				}
+			} else if (char === "{") {
+				flush();
+				position += 1;
+				nodes.push(parseArgument());
+			} else if (char === "}") {
+				if (!nested) throw syntaxError("unexpected \"}\"", position);
+				break;
+			} else if (char === "#" && inPlural) {
+				flush();
+				nodes.push({ kind: "pound" });
+				position += 1;
+			} else {
+				text += char;
+				position += 1;
+			}
+		}
+		flush();
+		return nodes;
+	};
+	const parseCases = (inPlural) => {
+		const cases = {};
+		for (;;) {
+			skipSpace();
+			if (message.charAt(position) === "}") break;
+			const key = readIdentifier("{}");
+			if (key === "" || /\s/.test(key)) throw syntaxError("invalid case key", position);
+			expect("{");
+			cases[key] = parseNodes(inPlural, true);
+			expect("}");
+		}
+		if (cases["other"] === void 0) throw syntaxError("missing \"other\" case", position);
+		return cases;
+	};
+	const parseArgument = () => {
+		skipSpace();
+		const name = readIdentifier(",}");
+		if (name === "") throw syntaxError("empty argument name", position);
+		if (message.charAt(position) === "}") {
+			position += 1;
+			return {
+				kind: "argument",
+				name
+			};
+		}
+		expect(",");
+		const kind = readIdentifier(",}");
+		let node;
+		if (kind === "plural" || kind === "selectordinal") {
+			expect(",");
+			skipSpace();
+			let offset = 0;
+			const match = /^offset:\s*(\d+)/.exec(message.slice(position));
+			if (match?.[1] !== void 0) {
+				offset = Number(match[1]);
+				position += match[0].length;
+			}
+			node = {
+				kind,
+				name,
+				offset,
+				cases: parseCases(true)
+			};
+		} else if (kind === "select") {
+			expect(",");
+			node = {
+				kind,
+				name,
+				cases: parseCases(false)
+			};
+		} else if (kind === "number" || kind === "date" || kind === "time") {
+			let style;
+			if (message.charAt(position) === ",") {
+				position += 1;
+				style = readIdentifier("}");
+			}
+			node = {
+				kind,
+				name,
+				style
+			};
+		} else throw syntaxError(`unsupported argument type "${kind}"`, position);
+		skipSpace();
+		expect("}");
+		return node;
+	};
+	return parseNodes(false, false);
+}
+const dateStyles = new Set([
+	"short",
+	"medium",
+	"long",
+	"full"
+]);
+function numberOptions(style, named) {
+	if (style === void 0) return {};
+	const custom = named[style];
+	if (custom !== void 0) return custom;
+	if (style === "integer") return { maximumFractionDigits: 0 };
+	if (style === "percent") return { style: "percent" };
+	if (!style.startsWith("::")) return {};
+	const options = {};
+	for (const token of style.slice(2).trim().split(/\s+/)) if (token.startsWith("currency/")) Object.assign(options, {
+		style: "currency",
+		currency: token.slice(9)
+	});
+	else if (token === "percent") Object.assign(options, { style: "percent" });
+	else if (token === "compact-short" || token === "K") Object.assign(options, {
+		notation: "compact",
+		compactDisplay: "short"
+	});
+	else if (token === "compact-long" || token === "KK") Object.assign(options, {
+		notation: "compact",
+		compactDisplay: "long"
+	});
+	else if (token === "group-off" || token === ",_") Object.assign(options, { useGrouping: false });
+	else if (/^\.0*#*$/.test(token)) {
+		const minimum = token.slice(1).replaceAll("#", "").length;
+		Object.assign(options, {
+			minimumFractionDigits: minimum,
+			maximumFractionDigits: token.length - 1
+		});
+	}
+	return options;
+}
+function dateTimeOptions(kind, style, named) {
+	const custom = style === void 0 ? void 0 : named[style];
+	if (custom !== void 0) return custom;
+	const resolved = style !== void 0 && dateStyles.has(style) ? style : "medium";
+	const value = resolved === "short" || resolved === "long" || resolved === "full" ? resolved : "medium";
+	return kind === "date" ? { dateStyle: value } : { timeStyle: value };
+}
+/** Stringify an argument value; plain objects use JSON rather than `[object Object]`. */
+function stringify(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "bigint" || typeof value === "boolean" || typeof value === "symbol") return value.toString();
+	return typeof value === "function" ? "[function]" : JSON.stringify(value);
+}
+/**
+* Create a caching formatter for one locale.
+*
+* Parsed messages and `Intl` formatters are cached inside the returned
+* object only (no module state), so one formatter per request or per
+* i18n instance keeps server rendering isolated.
+*
+* @example
+* ```ts
+* const formatter = createMessageFormatter("en");
+* formatter.format("{n, plural, one {# file} other {# files}}", { n: 3 }); // "3 files"
+* ```
+*
+* @param locale BCP 47 locale.
+* @param options Time zone and named formats.
+* @default options {}
+* @returns The formatter.
+*/
+function createMessageFormatter(locale, options = {}) {
+	const timeZone = options.timeZone ?? "UTC";
+	const numberFormats = options.numberFormats ?? {};
+	const dateTimeFormats = options.dateTimeFormats ?? {};
+	const parsed = /* @__PURE__ */ new Map();
+	const numbers = /* @__PURE__ */ new Map();
+	const dates = /* @__PURE__ */ new Map();
+	const plurals = /* @__PURE__ */ new Map();
+	const number = (style) => {
+		const key = style ?? "";
+		let formatter = numbers.get(key);
+		if (formatter === void 0) {
+			formatter = new Intl.NumberFormat(locale, numberOptions(style, numberFormats));
+			numbers.set(key, formatter);
+		}
+		return formatter;
+	};
+	const dateTime = (kind, style) => {
+		const key = `${kind}:${style ?? ""}`;
+		let formatter = dates.get(key);
+		if (formatter === void 0) {
+			formatter = new Intl.DateTimeFormat(locale, {
+				...dateTimeOptions(kind, style, dateTimeFormats),
+				timeZone
+			});
+			dates.set(key, formatter);
+		}
+		return formatter;
+	};
+	const pluralRules = (type) => {
+		let rules = plurals.get(type);
+		if (rules === void 0) {
+			rules = new Intl.PluralRules(locale, { type });
+			plurals.set(type, rules);
+		}
+		return rules;
+	};
+	const toNumber = (value) => typeof value === "number" ? value : Number(value);
+	const toDate = (value) => value instanceof Date ? value : new Date(typeof value === "number" ? value : String(value));
+	const render = (nodes, params, pound) => {
+		let output = "";
+		for (const node of nodes) switch (node.kind) {
+			case "text":
+				output += node.value;
+				break;
+			case "pound":
+				output += pound === void 0 ? "#" : number(void 0).format(pound);
+				break;
+			case "argument": {
+				const value = params[node.name];
+				output += value instanceof Date ? dateTime("date", void 0).format(value) : typeof value === "number" ? number(void 0).format(value) : value === void 0 || value === null ? `{${node.name}}` : stringify(value);
+				break;
+			}
+			case "number":
+				output += number(node.style).format(toNumber(params[node.name]));
+				break;
+			case "date":
+			case "time":
+				output += dateTime(node.kind, node.style).format(toDate(params[node.name]));
+				break;
+			case "plural":
+			case "selectordinal": {
+				const value = toNumber(params[node.name]);
+				const exact = node.cases[`=${String(value)}`];
+				const shifted = value - node.offset;
+				const category = pluralRules(node.kind === "plural" ? "cardinal" : "ordinal").select(shifted);
+				const branch = exact ?? node.cases[category] ?? node.cases["other"] ?? [];
+				output += render(branch, params, shifted);
+				break;
+			}
+			case "select": {
+				const value = String(params[node.name]);
+				const branch = node.cases[value] ?? node.cases["other"] ?? [];
+				output += render(branch, params, pound);
+				break;
+			}
+		}
+		return output;
+	};
+	return {
+		locale,
+		format: (message, params = {}) => {
+			let nodes;
+			if (typeof message === "string") {
+				const cached = parsed.get(message);
+				nodes = cached ?? parseMessage(message);
+				if (cached === void 0) parsed.set(message, nodes);
+			} else nodes = message;
+			return render(nodes, params, void 0);
+		}
+	};
+}
+/**
+* Format one ICU message with typed parameters.
+*
+* Parameters are checked against the message literal at compile time via
+* {@link MessageParams}. For repeated formatting prefer
+* {@link createMessageFormatter}, which caches parsing and `Intl` objects.
+* Deterministic: `date`/`time` arguments use `timeZone` (UTC by default).
+*
+* @example
+* ```ts
+* formatMessage("en", "Hello {name}!", { name: "Ada" }); // "Hello Ada!"
+* ```
+*
+* @param locale BCP 47 locale.
+* @param message ICU message.
+* @param params Values for the message's arguments.
+* @param options Time zone and named formats.
+* @default options {}
+* @throws {@link MessageSyntaxError} for malformed messages.
+* @returns The formatted string.
+*/
+function formatMessage(locale, message, params, options = {}) {
+	return createMessageFormatter(locale, options).format(message, params);
+}
+//#endregion
+export { createMessageFormatter, formatMessage, parseMessage };

package/dist/idle.d.mts

@@ -0,0 +1,79 @@
+import { t as TimeoutScheduler } from "./timeout-scheduler-CI8RVLZs.mjs";
+import { MaybeRefOrGetter, Ref } from "vue";
+
+//#region src/idle.d.ts
+/** Window-like capability observed by {@link useIdle}. */
+interface IdleHost extends EventTarget {
+  /** Document whose visibility changes count as activity when it becomes visible. */
+  readonly document?: EventTarget & {
+    readonly hidden?: boolean;
+  };
+}
+/** Default activity events. */
+declare const DEFAULT_IDLE_EVENTS: readonly ["mousemove", "mousedown", "resize", "keydown", "touchstart", "wheel"];
+/** Options for {@link useIdle}. */
+interface UseIdleOptions {
+  /**
+   * Window events that count as activity.
+   *
+   * @default DEFAULT_IDLE_EVENTS
+   */
+  readonly events?: readonly string[];
+  /**
+   * Treat the document becoming visible again as activity.
+   *
+   * @default true
+   */
+  readonly listenForVisibilityChange?: boolean;
+  /**
+   * Idle state exposed during server rendering and before the timer starts.
+   *
+   * @default false
+   */
+  readonly initialState?: boolean;
+  /**
+   * Clock used for `lastActive`.
+   *
+   * @default Date.now
+   */
+  readonly now?: () => number;
+  /**
+   * Owns the idle timer.
+   *
+   * @default globalThis timer functions
+   */
+  readonly scheduler?: TimeoutScheduler;
+  /**
+   * Reactive window capability for alternate runtimes and tests.
+   *
+   * @default globalThis.window when available
+   */
+  readonly host?: MaybeRefOrGetter<IdleHost | null | undefined>;
+}
+/** Reactive idle state returned by {@link useIdle}. */
+interface IdleControls {
+  /** Whether no activity happened within the timeout. */
+  readonly idle: Readonly<Ref<boolean>>;
+  /** Epoch milliseconds of the latest activity; `null` until tracking starts on the client. */
+  readonly lastActive: Readonly<Ref<number | null>>;
+  /** Record activity now and restart the timer. No-op until tracking starts on the client. */
+  readonly reset: () => void;
+}
+/**
+ * Detect user inactivity.
+ *
+ * Any configured activity event resets a single timer; when it fires, `idle`
+ * becomes `true` until the next activity. No timer runs during server
+ * rendering (`idle` is `initialState`, `lastActive` is `null`), so the
+ * output is hydration-stable. Listeners and the timer are released with the
+ * owning reactive scope.
+ *
+ * @param timeout Inactivity window in milliseconds.
+ * @param options Activity events, clock, scheduler, and window capability.
+ * @default timeout 60000
+ * @default options {}
+ * @returns Reactive idle flag, last activity time, and a reset action.
+ */
+declare function useIdle(timeout?: number, options?: UseIdleOptions): IdleControls;
+//#endregion
+export { DEFAULT_IDLE_EVENTS, IdleControls, IdleHost, UseIdleOptions, useIdle };