@saykit/config 0.11.0 → 0.12.0

package/README.md

@@ -4,7 +4,7 @@
 
 [![Coverage](https://codecov.io/gh/k0d13/saykit/graph/badge.svg?flag=config)](https://codecov.io/gh/k0d13/saykit?flags%5B0%5D=config)
 
-Provides the `defineConfig` helper, the Zod-validated schema for `saykit.config.ts`, and the `saykit` CLI used to extract messages from your source.
+Provides the `defineConfig` helper, the Zod-validated schema for `saykit.config.ts`, and the `saykit` CLI that extracts messages from your source and compiles catalogues into the modules your app imports.
 
 ## Install
 
@@ -43,6 +43,7 @@ export default defineConfig({
 ```sh
 saykit extract           # extract messages once
 saykit extract --watch   # extract and watch for changes
+saykit compile           # compile catalogues to {locale}.js modules
 saykit clean             # prune dead entries from other locales
 ```
 
@@ -50,9 +51,10 @@ Extraction only writes the **source** locale (the first entry in `locales`). Loc
 have a file yet are bootstrapped with an empty, header-only catalogue so a TMS can register them;
 existing translation files are left untouched. Translated content is owned by your TMS.
 
-At load time (via the unplugin or Babel plugin), each locale module is filled from its fallback
-chain, so an untranslated key resolves to a fallback locale and ultimately the source string, the
-runtime still loads a single locale.
+`saykit compile` (which `extract` also runs) writes a `{locale}.js` beside each catalogue, filled
+from its fallback chain so an untranslated key resolves to a fallback locale and ultimately the
+source string. Ignore the `.js` modules in git and compile before dev and build; commit the
+`{locale}.d.ts` beside them.
 
 `saykit clean` only ever subtracts from non-source locales: it drops entries that no longer exist in
 the source catalogue and entries with an empty translation, and leaves everything else exactly as it

package/dist/commands/index.cjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-const require_storage = require("../storage-DSdC-TYq.cjs");
-const require_loader = require("../loader-XE7SprlF.cjs");
+const require_emit = require("../emit-NFgnvdzK.cjs");
+const require_loader = require("../loader-V92j1gfD.cjs");
 let _commander_js_extra_typings = require("@commander-js/extra-typings");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 let node_async_hooks = require("node:async_hooks");
-//#region src/features/logger.ts
+// src/features/logger.ts
 const RESET = "\x1B[0m";
 const DIM = "\x1B[2m";
 const BRIGHT = "\x1B[1m";
@@ -43,28 +43,54 @@ var Logger = class {
 	}
 };
 new node_async_hooks.AsyncLocalStorage({ defaultValue: new Logger() });
-//#endregion
-//#region src/commands/clean.ts
+// src/commands/clean.ts
 var clean_default = new _commander_js_extra_typings.Command("clean").description("Remove orphaned and untranslated entries from non-source locale files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
 	const config = require_loader.resolveConfig();
 	const logger = new Logger(options);
 	logger.header("🧹 Cleaning Locales");
 	const [sourceLocale, ...otherLocales] = config.locales;
 	for (const bucket of config.buckets) {
-		const sourceMessages = await require_storage.readCatalogueMessages(bucket, sourceLocale);
+		const sourceMessages = await require_emit.readCatalogueMessages(bucket, sourceLocale);
 		logger.info(`Cleaning ${otherLocales.length} locale(s) against ${sourceLocale}`);
 		for (const locale of otherLocales) {
 			logger.step(`Cleaning ${locale}`);
-			const existingMessages = await require_storage.readCatalogueMessages(bucket, locale);
-			const prunedMessages = require_storage.pruneLocaleMessages(existingMessages, sourceMessages);
+			const existingMessages = await require_emit.readCatalogueMessages(bucket, locale);
+			const prunedMessages = require_emit.pruneLocaleMessages(existingMessages, sourceMessages);
 			logger.step(`Removed ${existingMessages.length - prunedMessages.length} entries from ${locale}`);
-			await require_storage.writeCatalogueMessages(bucket, locale, prunedMessages);
+			await require_emit.writeCatalogueMessages(bucket, locale, prunedMessages);
 		}
 	}
 	logger.success("Locales cleaned");
 });
-//#endregion
-//#region src/features/catalogue/extractor.ts
+// src/features/workers/shared.ts
+function normalisePathForLogs(path) {
+	return (0, node_path.relative)(process.cwd(), path).replaceAll("\\", "/");
+}
+var BucketWorker = class {
+	config;
+	bucket;
+	logger;
+	constructor(config, bucket, logger) {
+		this.config = config;
+		this.bucket = bucket;
+		this.logger = logger;
+	}
+};
+// src/commands/compile.ts
+var compile_default = new _commander_js_extra_typings.Command("compile").description("Compile catalogues into locale modules").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
+	const config = require_loader.resolveConfig();
+	const logger = new Logger(options);
+	logger.header("⚙ Compiling Catalogues");
+	for (const bucket of config.buckets) {
+		logger.info(`Compiling ${config.locales.length} locale(s): ${bucket.include}`);
+		for (const locale of config.locales) {
+			const { path, count } = await require_emit.emitCatalogueModule(config, bucket, locale);
+			logger.step(`Wrote ${count} message(s) to ${normalisePathForLogs(path)}`);
+		}
+	}
+	logger.success("Catalogues compiled");
+});
+// src/features/catalogue/extractor.ts
 async function extractMessagesFromFile(path, bucket) {
 	const content = await (0, node_fs_promises.readFile)(path, "utf8").catch(() => "");
 	if (!content) return [];
@@ -74,8 +100,7 @@ async function extractMessagesFromFile(path, bucket) {
 		references: message.references.map((reference) => (0, node_path.relative)(process.cwd(), reference).replaceAll("\\", "/"))
 	}));
 }
-//#endregion
-//#region src/features/watch.ts
+// src/features/watch.ts
 async function globBucket(bucket) {
 	const paths = [];
 	for await (const path of (0, node_fs_promises.glob)(bucket.include, { exclude: bucket.exclude })) try {
@@ -107,23 +132,7 @@ async function* watchDebounced(path, options, delay = 300) {
 		yield next;
 	} else await new Promise((r) => setTimeout(r, 10));
 }
-//#endregion
-//#region src/features/workers/shared.ts
-function normalisePathForLogs(path) {
-	return (0, node_path.relative)(process.cwd(), path).replaceAll("\\", "/");
-}
-var BucketWorker = class {
-	config;
-	bucket;
-	logger;
-	constructor(config, bucket, logger) {
-		this.config = config;
-		this.bucket = bucket;
-		this.logger = logger;
-	}
-};
-//#endregion
-//#region src/features/workers/extract-worker.ts
+// src/features/workers/extract-worker.ts
 function exists(path) {
 	return (0, node_fs_promises.access)(path).then(() => true, () => false);
 }
@@ -158,21 +167,28 @@ var BucketExtractWorker = class extends BucketWorker {
 		this.logger.info(`Total extracted messages: ${extracted}`);
 	}
 	async write() {
-		const mergedMessages = require_storage.mergeExtractedMessages(this.#indexedMessages);
+		const mergedMessages = require_emit.mergeExtractedMessages(this.#indexedMessages);
 		const [sourceLocale, ...otherLocales] = this.config.locales;
 		this.logger.info(`Writing ${mergedMessages.length} messages to ${sourceLocale}`);
 		this.logger.step(`Writing locale file for ${sourceLocale} to disk`);
-		await require_storage.writeCatalogueMessages(this.bucket, sourceLocale, mergedMessages);
+		await require_emit.writeCatalogueMessages(this.bucket, sourceLocale, mergedMessages);
 		for (const locale of otherLocales) {
-			if (await exists(require_storage.expandBucketOutputPath(this.bucket, locale))) {
+			if (await exists(require_emit.expandBucketOutputPath(this.bucket, locale))) {
 				this.logger.step(`Skipping existing locale file for ${locale}`);
 				continue;
 			}
 			this.logger.step(`Creating empty locale file for ${locale}`);
-			await require_storage.writeCatalogueMessages(this.bucket, locale, []);
+			await require_emit.writeCatalogueMessages(this.bucket, locale, []);
 		}
+		await this.compile();
 		this.logger.success(`Extraction complete for bucket: ${this.bucket.include}`);
 	}
+	async compile() {
+		for (const locale of this.config.locales) {
+			const { path, count } = await require_emit.emitCatalogueModule(this.config, this.bucket, locale);
+			this.logger.step(`Compiled ${count} message(s) to ${normalisePathForLogs(path)}`);
+		}
+	}
 	async update(path) {
 		const changed = await this.#indexPath(path);
 		if (changed) await this.write();
@@ -181,14 +197,17 @@ var BucketExtractWorker = class extends BucketWorker {
 	async watch() {
 		this.logger.header(`👀 Watching bucket for changes: ${this.bucket.include}`);
 		for await (const event of watchDebounced(".", { recursive: true })) {
-			if (!event.filename || !this.bucket.match(event.filename)) continue;
+			if (!event.filename) continue;
 			const path = (0, node_path.join)(process.cwd(), event.filename);
-			await this.update(path);
+			if (this.bucket.output.match(event.filename)) {
+				await this.compile();
+				continue;
+			}
+			if (this.bucket.match(event.filename)) await this.update(path);
 		}
 	}
 };
-//#endregion
-//#region src/commands/extract.ts
+// src/commands/extract.ts
 var extract_default = new _commander_js_extra_typings.Command("extract").description("Extract messages from source files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).option("-w, --watch", "watch source files for changes", false).action(async (options) => {
 	const config = require_loader.resolveConfig();
 	const logger = new Logger(options);
@@ -197,7 +216,5 @@ var extract_default = new _commander_js_extra_typings.Command("extract").descrip
 	await Promise.all(workers.map((w) => w.scan().then(() => w.write())));
 	if (options.watch) await Promise.all(workers.map((w) => w.watch()));
 });
-//#endregion
-//#region src/commands/index.ts
-_commander_js_extra_typings.program.name("saykit").helpOption("-h, --help", "Display help for command").helpCommand("help [command]", "Display help for command").addCommand(extract_default).addCommand(clean_default).parse();
-//#endregion
+// src/commands/index.ts
+_commander_js_extra_typings.program.name("saykit").helpOption("-h, --help", "Display help for command").helpCommand("help [command]", "Display help for command").addCommand(extract_default).addCommand(compile_default).addCommand(clean_default).parse();

package/dist/commands/index.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { a as mergeExtractedMessages, i as expandBucketOutputPath, n as writeCatalogueMessages, o as pruneLocaleMessages, t as readCatalogueMessages } from "../storage-8485YdBh.mjs";
-import { t as resolveConfig } from "../loader-C6XxYhMl.mjs";
+import { c as writeCatalogueMessages, d as pruneLocaleMessages, l as expandBucketOutputPath, s as readCatalogueMessages, t as emitCatalogueModule, u as mergeExtractedMessages } from "../emit-q78c-G_t.mjs";
+import { t as resolveConfig } from "../loader-1PBbw7yb.mjs";
 import { Command, program } from "@commander-js/extra-typings";
 import { access, glob, readFile, stat, watch } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
-//#region src/features/logger.ts
+// src/features/logger.ts
 const RESET = "\x1B[0m";
 const DIM = "\x1B[2m";
 const BRIGHT = "\x1B[1m";
@@ -43,8 +43,7 @@ var Logger = class {
 	}
 };
 new AsyncLocalStorage({ defaultValue: new Logger() });
-//#endregion
-//#region src/commands/clean.ts
+// src/commands/clean.ts
 var clean_default = new Command("clean").description("Remove orphaned and untranslated entries from non-source locale files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
 	const config = resolveConfig();
 	const logger = new Logger(options);
@@ -63,8 +62,35 @@ var clean_default = new Command("clean").description("Remove orphaned and untran
 	}
 	logger.success("Locales cleaned");
 });
-//#endregion
-//#region src/features/catalogue/extractor.ts
+// src/features/workers/shared.ts
+function normalisePathForLogs(path) {
+	return relative(process.cwd(), path).replaceAll("\\", "/");
+}
+var BucketWorker = class {
+	config;
+	bucket;
+	logger;
+	constructor(config, bucket, logger) {
+		this.config = config;
+		this.bucket = bucket;
+		this.logger = logger;
+	}
+};
+// src/commands/compile.ts
+var compile_default = new Command("compile").description("Compile catalogues into locale modules").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
+	const config = resolveConfig();
+	const logger = new Logger(options);
+	logger.header("⚙ Compiling Catalogues");
+	for (const bucket of config.buckets) {
+		logger.info(`Compiling ${config.locales.length} locale(s): ${bucket.include}`);
+		for (const locale of config.locales) {
+			const { path, count } = await emitCatalogueModule(config, bucket, locale);
+			logger.step(`Wrote ${count} message(s) to ${normalisePathForLogs(path)}`);
+		}
+	}
+	logger.success("Catalogues compiled");
+});
+// src/features/catalogue/extractor.ts
 async function extractMessagesFromFile(path, bucket) {
 	const content = await readFile(path, "utf8").catch(() => "");
 	if (!content) return [];
@@ -74,8 +100,7 @@ async function extractMessagesFromFile(path, bucket) {
 		references: message.references.map((reference) => relative(process.cwd(), reference).replaceAll("\\", "/"))
 	}));
 }
-//#endregion
-//#region src/features/watch.ts
+// src/features/watch.ts
 async function globBucket(bucket) {
 	const paths = [];
 	for await (const path of glob(bucket.include, { exclude: bucket.exclude })) try {
@@ -107,23 +132,7 @@ async function* watchDebounced(path, options, delay = 300) {
 		yield next;
 	} else await new Promise((r) => setTimeout(r, 10));
 }
-//#endregion
-//#region src/features/workers/shared.ts
-function normalisePathForLogs(path) {
-	return relative(process.cwd(), path).replaceAll("\\", "/");
-}
-var BucketWorker = class {
-	config;
-	bucket;
-	logger;
-	constructor(config, bucket, logger) {
-		this.config = config;
-		this.bucket = bucket;
-		this.logger = logger;
-	}
-};
-//#endregion
-//#region src/features/workers/extract-worker.ts
+// src/features/workers/extract-worker.ts
 function exists(path) {
 	return access(path).then(() => true, () => false);
 }
@@ -171,8 +180,15 @@ var BucketExtractWorker = class extends BucketWorker {
 			this.logger.step(`Creating empty locale file for ${locale}`);
 			await writeCatalogueMessages(this.bucket, locale, []);
 		}
+		await this.compile();
 		this.logger.success(`Extraction complete for bucket: ${this.bucket.include}`);
 	}
+	async compile() {
+		for (const locale of this.config.locales) {
+			const { path, count } = await emitCatalogueModule(this.config, this.bucket, locale);
+			this.logger.step(`Compiled ${count} message(s) to ${normalisePathForLogs(path)}`);
+		}
+	}
 	async update(path) {
 		const changed = await this.#indexPath(path);
 		if (changed) await this.write();
@@ -181,14 +197,17 @@ var BucketExtractWorker = class extends BucketWorker {
 	async watch() {
 		this.logger.header(`👀 Watching bucket for changes: ${this.bucket.include}`);
 		for await (const event of watchDebounced(".", { recursive: true })) {
-			if (!event.filename || !this.bucket.match(event.filename)) continue;
+			if (!event.filename) continue;
 			const path = join(process.cwd(), event.filename);
-			await this.update(path);
+			if (this.bucket.output.match(event.filename)) {
+				await this.compile();
+				continue;
+			}
+			if (this.bucket.match(event.filename)) await this.update(path);
 		}
 	}
 };
-//#endregion
-//#region src/commands/extract.ts
+// src/commands/extract.ts
 var extract_default = new Command("extract").description("Extract messages from source files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).option("-w, --watch", "watch source files for changes", false).action(async (options) => {
 	const config = resolveConfig();
 	const logger = new Logger(options);
@@ -197,8 +216,6 @@ var extract_default = new Command("extract").description("Extract messages from
 	await Promise.all(workers.map((w) => w.scan().then(() => w.write())));
 	if (options.watch) await Promise.all(workers.map((w) => w.watch()));
 });
-//#endregion
-//#region src/commands/index.ts
-program.name("saykit").helpOption("-h, --help", "Display help for command").helpCommand("help [command]", "Display help for command").addCommand(extract_default).addCommand(clean_default).parse();
-//#endregion
+// src/commands/index.ts
+program.name("saykit").helpOption("-h, --help", "Display help for command").helpCommand("help [command]", "Display help for command").addCommand(extract_default).addCommand(compile_default).addCommand(clean_default).parse();
 export {};

package/dist/compile-BrwRUqtQ.cjs

@@ -0,0 +1,286 @@
+let js_sha256 = require("js-sha256");
+let _messageformat_parser = require("@messageformat/parser");
+let _messageformat_date_skeleton = require("@messageformat/date-skeleton");
+let _messageformat_number_skeleton = require("@messageformat/number-skeleton");
+// src/features/messages/hash.ts
+function generateHash(input, context) {
+	const hasher = js_sha256.sha256.create();
+	hasher.update(`${input}\u{001F}${context || ""}`);
+	const elements = hasher.toString().match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) || [];
+	const bytes = Uint8Array.from(elements);
+	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "").slice(0, 6);
+}
+// src/features/messages/styles.ts
+const ARGUMENT_STYLES = {
+	number: ["integer", "percent"],
+	date: [
+		"short",
+		"medium",
+		"long",
+		"full"
+	],
+	time: [
+		"short",
+		"medium",
+		"long",
+		"full"
+	]
+};
+const ARGUMENT_TYPES = Object.keys(ARGUMENT_STYLES);
+function isArgumentType(kind) {
+	return Object.hasOwn(ARGUMENT_STYLES, kind);
+}
+var StyleError = class extends Error {};
+const SKELETON = "::";
+const LITERAL_STYLE_PATTERN = /^[^{}\r\n]*[#0][^{}\r\n]*$/;
+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(SKELETON)) {
+		const errors = [];
+		const tokens = (0, _messageformat_date_skeleton.parseDateTokens)(style.slice(2));
+		const opt = (0, _messageformat_date_skeleton.getDateTimeFormatOptions)(tokens, (_type, message) => errors.push(message));
+		if (errors.length > 0) throw new StyleError(errors[0]);
+		if (Object.keys(opt).length === 0) throw new StyleError("it names no fields");
+		return opt;
+	}
+	if (style === "") return named.medium;
+	if (Object.hasOwn(named, style)) return named[style];
+	throw new StyleError(`Unsupported ${kind} style ${style}`);
+}
+function numberStyle(style) {
+	if (style === "") return {};
+	if (style === "integer") return { maximumFractionDigits: 0 };
+	if (style === "percent") return { style: "percent" };
+	if (style === SKELETON) throw new StyleError("it names no fields");
+	const errors = [];
+	const onError = (error) => errors.push(String(error));
+	const skeleton = style.startsWith(SKELETON) ? (0, _messageformat_number_skeleton.parseNumberSkeleton)(style.slice(2), onError) : (0, _messageformat_number_skeleton.parseNumberPattern)(style, "XXX", onError);
+	let scale;
+	const opt = (0, _messageformat_number_skeleton.getNumberFormatOptions)(skeleton, (stem, option) => {
+		if (stem === "scale") scale = Number(option);
+		else errors.push(`unsupported stem '${stem}'`);
+	});
+	if (errors.length > 0) throw new StyleError(errors[0]);
+	return scale === void 0 ? opt : {
+		...opt,
+		scale
+	};
+}
+function validateArgumentStyle(type, style) {
+	const named = ARGUMENT_STYLES[type];
+	if (named.includes(style)) return;
+	const skeleton = style.startsWith(SKELETON);
+	if (skeleton || type === "number" && LITERAL_STYLE_PATTERN.test(style)) try {
+		if (type === "number") numberStyle(style);
+		else dateTimeStyle(type, style);
+		return;
+	} catch (error) {
+		if (!(error instanceof StyleError)) throw error;
+		throw new Error(`Invalid ${type} ${skeleton ? "skeleton" : "pattern"} '${style}': ${error.message}`);
+	}
+	const expected = named.map((s) => `'${s}'`).join(", ");
+	throw new Error(`Invalid ${type} style '${style}', expected ${expected}, or a skeleton such as ` + (type === "number" ? "::currency/EUR" : "::yyyyMMdd") + (type === "number" ? ", or a literal number pattern such as #,##0.00" : ""));
+}
+// src/features/messages/compile.ts
+const Kind = {
+	Value: 0,
+	Number: 1,
+	DateTime: 2,
+	Plural: 3,
+	Ordinal: 4,
+	Select: 5,
+	Hash: 6
+};
+const EXACT = /^=\d+$/;
+function key(argument) {
+	return `_${argument}`;
+}
+function concat(nodes) {
+	if (nodes.length === 0) return "";
+	if (nodes.length === 1) return nodes[0];
+	return nodes;
+}
+function compileMessage(icu) {
+	function argument(token) {
+		const value = key(token.arg);
+		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 resolve = (read, fallback) => {
+			try {
+				return read(style);
+			} catch (error) {
+				if (!(error instanceof StyleError)) throw error;
+				return fallback();
+			}
+		};
+		switch (token.key) {
+			case "date":
+			case "time": {
+				const kind = token.key;
+				const options = resolve((s) => dateTimeStyle(kind, s), () => dateTimeStyle(kind, ""));
+				return [
+					Kind.DateTime,
+					value,
+					options
+				];
+			}
+			case "number": {
+				const { scale, ...options } = resolve(numberStyle, () => ({}));
+				if (scale !== void 0) return [
+					Kind.Number,
+					value,
+					options,
+					scale
+				];
+				return Object.keys(options).length === 0 ? [Kind.Number, value] : [
+					Kind.Number,
+					value,
+					options
+				];
+			}
+			default: return [Kind.Value, value];
+		}
+	}
+	function choice(token) {
+		const value = key(token.arg);
+		const cases = Object.create(null);
+		for (const branch of token.cases) {
+			const key = EXACT.test(branch.key) ? `=${Number(branch.key.slice(1))}` : branch.key;
+			if (!Object.hasOwn(cases, key)) cases[key] = pattern(branch.tokens);
+		}
+		if (token.type === "select") return [
+			Kind.Select,
+			value,
+			cases
+		];
+		const kind = token.type === "selectordinal" ? Kind.Ordinal : Kind.Plural;
+		const offset = token.pluralOffset ?? 0;
+		return offset === 0 ? [
+			kind,
+			value,
+			cases
+		] : [
+			kind,
+			value,
+			cases,
+			offset
+		];
+	}
+	function fragment(token) {
+		switch (token.type) {
+			case "content": return token.value;
+			case "argument": return [Kind.Value, key(token.arg)];
+			case "function": return argument(token);
+			case "octothorpe": return [Kind.Hash];
+			default: return choice(token);
+		}
+	}
+	function pattern(tokens) {
+		return concat(tokens.map(fragment));
+	}
+	return pattern((0, _messageformat_parser.parse)(icu));
+}
+Object.defineProperty(exports, "ARGUMENT_STYLES", {
+	enumerable: true,
+	get: function() {
+		return ARGUMENT_STYLES;
+	}
+});
+Object.defineProperty(exports, "ARGUMENT_TYPES", {
+	enumerable: true,
+	get: function() {
+		return ARGUMENT_TYPES;
+	}
+});
+Object.defineProperty(exports, "StyleError", {
+	enumerable: true,
+	get: function() {
+		return StyleError;
+	}
+});
+Object.defineProperty(exports, "compileMessage", {
+	enumerable: true,
+	get: function() {
+		return compileMessage;
+	}
+});
+Object.defineProperty(exports, "dateTimeStyle", {
+	enumerable: true,
+	get: function() {
+		return dateTimeStyle;
+	}
+});
+Object.defineProperty(exports, "generateHash", {
+	enumerable: true,
+	get: function() {
+		return generateHash;
+	}
+});
+Object.defineProperty(exports, "isArgumentType", {
+	enumerable: true,
+	get: function() {
+		return isArgumentType;
+	}
+});
+Object.defineProperty(exports, "numberStyle", {
+	enumerable: true,
+	get: function() {
+		return numberStyle;
+	}
+});
+Object.defineProperty(exports, "validateArgumentStyle", {
+	enumerable: true,
+	get: function() {
+		return validateArgumentStyle;
+	}
+});