saykit 0.11.1 → 0.13.0

package/dist/index.mjs

@@ -1,453 +1,205 @@
-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 : {};
+// src/runtime.ts
+const formatters = /* @__PURE__ */ new Map();
+function memoise(key, make) {
+	let formatter = formatters.get(key);
+	if (formatter === void 0) formatters.set(key, formatter = make());
+	return formatter;
 }
-//#endregion
-//#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}`);
+function numberFormat(locale, options) {
+	return memoise(`n${locale}${JSON.stringify(options ?? null)}`, () => new Intl.NumberFormat(locale, options));
 }
-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
-	};
+function dateTimeFormat(locale, options) {
+	return memoise(`d${locale}${JSON.stringify(options ?? null)}`, () => new Intl.DateTimeFormat(locale, options));
 }
-//#endregion
-//#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 pluralRules(locale, type) {
+	return memoise(`p${locale}${type}`, () => new Intl.PluralRules(locale, { type }));
 }
-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}`);
-	}
+function toNumeric(value) {
+	const raw = typeof value === "object" && value !== null ? value.valueOf() : value;
+	if (typeof raw === "bigint") return raw;
+	if (raw === null || raw === "") return void 0;
+	const number = Number(raw);
+	return Number.isNaN(number) ? void 0 : number;
 }
-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 toDate(value) {
+	let raw = value;
+	if (typeof raw === "object" && raw !== null && !(raw instanceof Date)) raw = raw.valueOf();
+	if (typeof raw === "number" || typeof raw === "string") raw = new Date(raw);
+	return raw instanceof Date && !Number.isNaN(raw.getTime()) ? raw : void 0;
 }
-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
-	};
+// src/message.ts
+const Kind = {
+	Value: 0,
+	Number: 1,
+	DateTime: 2,
+	Plural: 3,
+	Ordinal: 4,
+	Select: 5,
+	Hash: 6
+};
+const FSI = String.fromCharCode(8296);
+const RLI = String.fromCharCode(8295);
+const PDI = String.fromCharCode(8297);
+const RTL = /* @__PURE__ */ new Set([
+	"Adlm",
+	"Arab",
+	"Hebr",
+	"Mand",
+	"Nkoo",
+	"Rohg",
+	"Syrc",
+	"Thaa"
+]);
+function localeDir(locale) {
+	try {
+		const script = new Intl.Locale(locale).maximize().script;
+		if (script) return RTL.has(script) ? "rtl" : "ltr";
+	} catch {}
+	return "auto";
 }
-//#endregion
-//#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 isolate(ctx, written, localised) {
+	if (!ctx.dir) return written;
+	if (!localised) return FSI + written + PDI;
+	if (ctx.dir === "ltr") return written;
+	return (ctx.dir === "rtl" ? RLI : FSI) + written + PDI;
 }
-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 unformattable(kind, value, error) {
+	console.warn(`saykit: cannot format ${String(value)} as a ${kind}`, ...error ? [error] : []);
+	return String(value);
 }
-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 prepare(kind, make) {
+	try {
+		return make();
+	} catch (error) {
+		console.warn(`saykit: cannot build a ${kind} formatter`, error);
+		return;
+	}
 }
-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 formatNumber(ctx, value, out, options, scale) {
+	const format = prepare("number", () => numberFormat(ctx.locale, options));
+	return (values) => {
+		const raw = value(values);
+		if (raw === void 0) return void 0;
+		const number = toNumeric(raw);
+		if (number === void 0 || !format) return unformattable("number", raw);
+		let scaled = number;
+		if (scale !== void 0) scaled = typeof number === "bigint" && Number.isInteger(scale) ? number * BigInt(scale) : Number(number) * scale;
+		return out ? isolate(ctx, format.format(scaled), true) : format.format(scaled);
 	};
 }
-function datetime(locales, value, opt) {
-	let dtf;
-	let locale;
-	const format = () => dtf ??= new Intl.DateTimeFormat(locales, opt);
-	const resolved = () => locale ??= format().resolvedOptions().locale;
+function arms(cases, ctx, out) {
+	const built = /* @__PURE__ */ new Map();
+	for (const [key, node] of Object.entries(cases)) built.set(key, build(node, ctx, out));
 	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
+		built,
+		other: built.get("other")
 	};
 }
-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
+function build(node, ctx, out) {
+	if (typeof node === "string") return () => node;
+	if (typeof node[0] !== "number") {
+		const parts = node.map((part) => build(part, ctx, out));
+		return (values) => {
+			let written = "";
+			for (const part of parts) written += part(values) ?? "";
+			return written;
 		};
 	}
-};
-//#endregion
-//#region src/messageformat/index.ts
-function compile(locale, source, options) {
-	return new MessageFormat(locale, toMessage(parse(source)), {
-		...options,
-		functions
-	});
+	const read = (key) => (values) => values[key];
+	switch (node[0]) {
+		case Kind.Value: {
+			const key = node[1];
+			if (!out) return read(key);
+			return (values) => {
+				const value = values[key];
+				return value === void 0 ? value : isolate(ctx, String(value), false);
+			};
+		}
+		case Kind.Number: return formatNumber(ctx, read(node[1]), out, node[2], node[3]);
+		case Kind.DateTime: {
+			const value = read(node[1]);
+			const format = prepare("date", () => dateTimeFormat(ctx.locale, node[2]));
+			return (values) => {
+				const raw = value(values);
+				if (raw === void 0) return void 0;
+				const date = toDate(raw);
+				if (!date || !format) return unformattable("date", raw);
+				return out ? isolate(ctx, format.format(date), true) : format.format(date);
+			};
+		}
+		case Kind.Plural:
+		case Kind.Ordinal: {
+			const value = read(node[1]);
+			const offset = node[3] ?? 0;
+			const rules = pluralRules(ctx.locale, node[0] === Kind.Ordinal ? "ordinal" : "cardinal");
+			const shift = (number) => offset === 0 ? number : typeof number === "bigint" ? number - BigInt(offset) : number - offset;
+			const hash = (values) => {
+				const number = toNumeric(value(values));
+				return number === void 0 ? void 0 : shift(number);
+			};
+			const { built, other } = arms(node[2], {
+				...ctx,
+				hash
+			}, out);
+			return (values) => {
+				const number = toNumeric(value(values));
+				let arm;
+				if (number !== void 0) {
+					arm = built.get(`=${String(number)}`);
+					arm ??= built.get(rules.select(Number(shift(number))));
+				}
+				return (arm ?? other)?.(values);
+			};
+		}
+		case Kind.Select: {
+			const value = read(node[1]);
+			const { built, other } = arms(node[2], ctx, out);
+			return (values) => {
+				const raw = value(values);
+				return ((raw === void 0 ? void 0 : built.get(String(raw))) ?? other)?.(values);
+			};
+		}
+		default:
+			if (!ctx.hash) return () => "#";
+			return formatNumber(ctx, ctx.hash, out);
+	}
 }
-//#endregion
-//#region src/view.ts
-function resolveDescriptorValues(descriptor) {
-	return Object.fromEntries(Object.entries(descriptor).filter(([key]) => key !== "id" && key !== "message").map(([key, value]) => [key.startsWith("_") ? key.slice(1) : key, value]));
+function compileMessage(message, locale, options = {}) {
+	if (typeof message === "string") return () => message;
+	const formatter = build(message, {
+		locale,
+		dir: options.bidiIsolation === "none" ? void 0 : localeDir(locale),
+		hash: void 0
+	}, true);
+	return (values) => String(formatter(values) ?? "");
 }
+// src/view.ts
 function macro(name) {
 	throw new Error(`'say.${name}' is a macro and must be used with the relevant saykit plugin`);
 }
+function snapshot(value) {
+	if (typeof value !== "object" || value === null) return value;
+	if (Array.isArray(value)) return Object.freeze(value.map(snapshot));
+	return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, node]) => [key, snapshot(node)])));
+}
 function createView(locale, messages, options = {}) {
 	const { bidiIsolation } = options;
 	const ownOptions = Object.freeze(bidiIsolation ? { bidiIsolation } : {});
-	const own = Object.freeze({ ...messages });
-	const formats = /* @__PURE__ */ new Map();
+	const own = snapshot(messages);
 	const say = (() => {
 		throw new Error("'say' is a macro and must be used with the relevant saykit plugin");
 	});
+	const compiled = /* @__PURE__ */ new Map();
 	function call(descriptor) {
-		const { id, message = own[id] } = descriptor;
-		if (typeof message !== "string") throw new Error(`Message for ${id} is not a string`);
-		let format = formats.get(message);
-		if (!format) formats.set(message, format = compile(locale, message, { bidiIsolation }));
-		return String(format.format(resolveDescriptorValues(descriptor)));
+		const { id, message } = descriptor;
+		if (message !== void 0) return compileMessage(message, locale, ownOptions)(descriptor);
+		let format = compiled.get(id);
+		if (!format) {
+			const message = Object.hasOwn(own, id) ? own[id] : void 0;
+			if (message === void 0) throw new Error(`No message for ${id} in locale '${locale}'`);
+			compiled.set(id, format = compileMessage(message, locale, ownOptions));
+		}
+		return format(descriptor);
 	}
 	return Object.freeze(Object.defineProperties(say, {
 		locale: {
@@ -472,19 +224,23 @@ function createView(locale, messages, options = {}) {
 		[Symbol.for("nodejs.util.inspect.custom")]: { value: (_depth, context, inspect) => `View<${inspect(locale, context)}> {}` }
 	}));
 }
-//#endregion
-//#region src/catalogue.ts
+// src/catalogue.ts
 function createCatalogue(messages, options = {}) {
 	const { bidiIsolation } = options;
 	const sources = Object.assign(Object.create(null), messages);
 	const keys = Object.freeze(Object.keys(sources));
 	if (keys.length === 0) throw new Error("A catalogue needs at least one locale, none were given");
 	const locales = keys;
+	const tags = locales.flatMap((locale) => {
+		const tag = parseTag(locale);
+		return tag ? [[locale, tag]] : [];
+	});
 	const store = /* @__PURE__ */ new Map();
 	const views = /* @__PURE__ */ new Map();
 	const loading = /* @__PURE__ */ new Map();
 	function fill(locale, produced) {
-		const messages = typeof produced.default === "object" ? produced.default : produced;
+		const { default: inner } = produced;
+		const messages = typeof inner === "object" && !Array.isArray(inner) ? inner : produced;
 		if (!store.has(locale)) store.set(locale, messages);
 		return catalogue.locale(locale);
 	}
@@ -519,14 +275,15 @@ function createCatalogue(messages, options = {}) {
 			return task;
 		},
 		match(...guesses) {
-			const flat = guesses.flat().filter((guess) => typeof guess === "string" && guess !== "");
-			if (flat.length === 0) return locales[0];
-			for (const guess of flat) {
-				if (locales.includes(guess)) return guess;
-				const prefix = guess.split("-")[0];
-				if (!prefix) continue;
-				const match = locales.find((l) => l.startsWith(prefix));
-				if (match) return match;
+			for (const guess of guesses.flat()) {
+				if (typeof guess !== "string" || guess === "") continue;
+				const tag = parseTag(guess);
+				if (!tag) {
+					if (locales.includes(guess)) return guess;
+					continue;
+				}
+				const found = tags.find(([, t]) => t.canonical === tag.canonical) ?? (tag.script ? tags.find(([, t]) => t.language === tag.language && t.script === tag.script) : void 0) ?? tags.find(([, t]) => t.language === tag.language);
+				if (found) return found[0];
 			}
 			return locales[0];
 		},
@@ -540,8 +297,26 @@ function createCatalogue(messages, options = {}) {
 	}
 	return Object.freeze(catalogue);
 }
-//#endregion
-//#region src/scope.ts
+function parseTag(input) {
+	let canonical;
+	try {
+		[canonical] = Intl.getCanonicalLocales(input);
+	} catch {
+		return;
+	}
+	if (!canonical) return void 0;
+	const language = canonical.split("-")[0];
+	let script;
+	try {
+		script = new Intl.Locale(canonical).maximize().script;
+	} catch {}
+	return {
+		canonical,
+		language,
+		script
+	};
+}
+// src/scope.ts
 const NO_VIEW = "No view is in scope for 'say'. Run the work inside 'scope.run(view, callback)', or establish one with 'scope.use(store)'.";
 function createVariableStorage() {
 	let running;
@@ -612,8 +387,7 @@ function createScope(storage = createVariableStorage()) {
 		return `Scope<${view ? inspect(view.locale, context) : "unset"}> {}`;
 	} } }));
 }
-//#endregion
-//#region src/store.ts
+// src/store.ts
 function createStore(catalogue, locale = catalogue.locales[0]) {
 	let current = catalogue.locale(locale);
 	const listeners = /* @__PURE__ */ new Set();
@@ -666,5 +440,4 @@ function createStore(catalogue, locale = catalogue.locales[0]) {
 		}
 	}, { [Symbol.for("nodejs.util.inspect.custom")]: { value: (_depth, context, inspect) => `Store<${inspect(current.locale, context)}> {}` } }));
 }
-//#endregion
-export { createCatalogue, createScope, createStore, createView };
+export { Kind, compileMessage, createCatalogue, createScope, createStore, createView };