@saykit/config 0.7.0 → 0.9.0

package/dist/commands/index.cjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-const require_storage = require("../storage-DqhzA5H8.cjs");
-const require_loader = require("../loader-BdCeoj3-.cjs");
+const require_storage = require("../storage-DSdC-TYq.cjs");
+const require_loader = require("../loader-XE7SprlF.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");
@@ -76,12 +76,6 @@ async function extractMessagesFromFile(path, bucket) {
 }
 //#endregion
 //#region src/features/watch.ts
-/**
-* Expand a buckets include and exclude patterns into a flat list of file paths.
-*
-* We stat each match instead of using `glob`'s `withFileTypes` option, which
-* Bun's `node:fs/promises` compatibility layer does not yet support.
-*/
 async function globBucket(bucket) {
 	const paths = [];
 	for await (const path of (0, node_fs_promises.glob)(bucket.include, { exclude: bucket.exclude })) try {
@@ -91,14 +85,6 @@ async function globBucket(bucket) {
 	}
 	return paths;
 }
-/**
-* Watches a path for changes, emitting a debounced event every set delay.
-*
-* Unlike Node's native `fs.watch` method, this:
-*  - coalesces rapid consecutive events per file
-*  - emits only the final event after `delay` ms of inactivity
-*  - deduplicates events by filename
-*/
 async function* watchDebounced(path, options, delay = 300) {
 	const timers = /* @__PURE__ */ new Map();
 	const queue = /* @__PURE__ */ new Map();

package/dist/commands/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as mergeExtractedMessages, i as expandBucketOutputPath, n as writeCatalogueMessages, o as pruneLocaleMessages, t as readCatalogueMessages } from "../storage-B6mn0s3V.mjs";
-import { t as resolveConfig } from "../loader-DwF1lM3f.mjs";
+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 { Command, program } from "@commander-js/extra-typings";
 import { access, glob, readFile, stat, watch } from "node:fs/promises";
 import { join, relative } from "node:path";
@@ -76,12 +76,6 @@ async function extractMessagesFromFile(path, bucket) {
 }
 //#endregion
 //#region src/features/watch.ts
-/**
-* Expand a buckets include and exclude patterns into a flat list of file paths.
-*
-* We stat each match instead of using `glob`'s `withFileTypes` option, which
-* Bun's `node:fs/promises` compatibility layer does not yet support.
-*/
 async function globBucket(bucket) {
 	const paths = [];
 	for await (const path of glob(bucket.include, { exclude: bucket.exclude })) try {
@@ -91,14 +85,6 @@ async function globBucket(bucket) {
 	}
 	return paths;
 }
-/**
-* Watches a path for changes, emitting a debounced event every set delay.
-*
-* Unlike Node's native `fs.watch` method, this:
-*  - coalesces rapid consecutive events per file
-*  - emits only the final event after `delay` ms of inactivity
-*  - deduplicates events by filename
-*/
 async function* watchDebounced(path, options, delay = 300) {
 	const timers = /* @__PURE__ */ new Map();
 	const queue = /* @__PURE__ */ new Map();

package/dist/features/catalogue/index.cjs

@@ -1,13 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_hash = require("../../hash-51ce8YiG.cjs");
-const require_storage = require("../../storage-DqhzA5H8.cjs");
+const require_storage = require("../../storage-DSdC-TYq.cjs");
 let node_path = require("node:path");
 //#region src/features/catalogue/record.ts
-/**
-* Resolve the fallback chain for a locale, most specific first. The source
-* locale (the first configured locale) is always the final fallback, so an
-* untranslated key ultimately resolves to the source string.
-*/
 function resolveFallbackChain(config, locale) {
 	const source = config.locales[0];
 	const configured = config.fallbackLocales?.[locale];
@@ -18,11 +13,6 @@ function resolveFallbackChain(config, locale) {
 		source
 	]));
 }
-/**
-* Resolve the catalogue files that contribute to a locale module, most specific
-* first. When the path does not map to a configured locale it is loaded on its
-* own.
-*/
 function resolveCatalogueSources(config, bucket, path) {
 	const resolved = (0, node_path.resolve)(path);
 	const locale = config.locales.find((l) => require_storage.expandBucketOutputPath(bucket, l) === resolved);
@@ -31,12 +21,6 @@ function resolveCatalogueSources(config, bucket, path) {
 		sources: locale ? resolveFallbackChain(config, locale).map((l) => require_storage.expandBucketOutputPath(bucket, l)) : [resolved]
 	};
 }
-/**
-* Assemble a `{ id: string }` record from catalogue file contents. `contents`
-* must be aligned with the `sources` returned by {@link resolveCatalogueSources}
-* (most specific first): more specific locales override their fallbacks, and any
-* key still untranslated falls back to its source message.
-*/
 function assembleCatalogueRecord(bucket, contents) {
 	const record = {};
 	for (const content of [...contents].reverse()) {

package/dist/features/catalogue/index.mjs

@@ -1,12 +1,7 @@
 import { t as generateHash } from "../../hash-DvzpieJD.mjs";
-import { a as mergeExtractedMessages, i as expandBucketOutputPath, n as writeCatalogueMessages, o as pruneLocaleMessages, r as declarationPathFor, t as readCatalogueMessages } from "../../storage-B6mn0s3V.mjs";
+import { a as mergeExtractedMessages, i as expandBucketOutputPath, n as writeCatalogueMessages, o as pruneLocaleMessages, r as declarationPathFor, t as readCatalogueMessages } from "../../storage-8485YdBh.mjs";
 import { resolve } from "node:path";
 //#region src/features/catalogue/record.ts
-/**
-* Resolve the fallback chain for a locale, most specific first. The source
-* locale (the first configured locale) is always the final fallback, so an
-* untranslated key ultimately resolves to the source string.
-*/
 function resolveFallbackChain(config, locale) {
 	const source = config.locales[0];
 	const configured = config.fallbackLocales?.[locale];
@@ -17,11 +12,6 @@ function resolveFallbackChain(config, locale) {
 		source
 	]));
 }
-/**
-* Resolve the catalogue files that contribute to a locale module, most specific
-* first. When the path does not map to a configured locale it is loaded on its
-* own.
-*/
 function resolveCatalogueSources(config, bucket, path) {
 	const resolved = resolve(path);
 	const locale = config.locales.find((l) => expandBucketOutputPath(bucket, l) === resolved);
@@ -30,12 +20,6 @@ function resolveCatalogueSources(config, bucket, path) {
 		sources: locale ? resolveFallbackChain(config, locale).map((l) => expandBucketOutputPath(bucket, l)) : [resolved]
 	};
 }
-/**
-* Assemble a `{ id: string }` record from catalogue file contents. `contents`
-* must be aligned with the `sources` returned by {@link resolveCatalogueSources}
-* (most specific first): more specific locales override their fallbacks, and any
-* key still untranslated falls back to its source message.
-*/
 function assembleCatalogueRecord(bucket, contents) {
 	const record = {};
 	for (const content of [...contents].reverse()) {

package/dist/features/loader/index.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_loader = require("../../loader-BdCeoj3-.cjs");
+const require_loader = require("../../loader-XE7SprlF.cjs");
 exports.resolveConfig = require_loader.resolveConfig;
 exports.resolveConfigFile = require_loader.resolveConfigFile;

package/dist/features/loader/index.mjs

@@ -1,2 +1,2 @@
-import { n as resolveConfigFile, t as resolveConfig } from "../../loader-DwF1lM3f.mjs";
+import { n as resolveConfigFile, t as resolveConfig } from "../../loader-C6XxYhMl.mjs";
 export { resolveConfig, resolveConfigFile };

package/dist/features/messages/index.cjs

@@ -1,5 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_hash = require("../../hash-51ce8YiG.cjs");
+let _messageformat_date_skeleton = require("@messageformat/date-skeleton");
+let _messageformat_number_skeleton = require("@messageformat/number-skeleton");
+//#region src/features/messages/escape.ts
+function escapeIcuLiteral(text, hash = false) {
+	return text.replace(/'/gu, "''").replace(hash ? /[{}#]+/gu : /[{}]+/gu, (run) => `'${run}'`);
+}
+//#endregion
 //#region src/features/messages/types.ts
 var Base = class {
 	toICUString() {
@@ -74,40 +81,12 @@ var CompositeMessage = class extends Base {
 //#endregion
 //#region src/features/messages/identifier.ts
 const AUTO_INCREMENT_IDENTIFIER = Symbol("auto-increment");
-/**
-* An ICU case, either an exact value or a key. ICU reserves its own pattern
-* syntax, so a key carries no punctuation and no whitespace.
-*/
 const BRANCH_PATTERN = /^(?:=\d+|[^\p{Pattern_Syntax}\p{Pattern_White_Space}]+)$/u;
-/**
-* The ICU case a branch is written as.
-*
-* Under `plural` and `ordinal` a number names an exact value, spelled `=0`, and
-* so is distinct from the CLDR category that would otherwise match it. `select`
-* has no such syntax — its cases are literal string matches, and `=0` there is
-* a parse error — so a numeric key stays bare, where it matches both `0` and
-* `'0'`.
-*
-* Digits are read literally rather than coerced, because everything JavaScript
-* is willing to call a number is not: `''`, `' '`, and `'+0'` all coerce to
-* `=0`, which would pass for a key that selects zero and quietly leave the
-* author's own key out of the catalogue. Anything else stays a key, where the
-* whitespace or punctuation that made it numeric-looking is caught.
-*/
 function getBranchCase(kind, identifier) {
 	const key = String(identifier);
 	if (kind === "select") return key;
 	return /^\d+$/u.test(key) ? `=${+key}` : key;
 }
-/**
-* Reject a branch key ICU cannot express, while the key is still attached to a
-* file and a line.
-*
-* A hyphenated string union is ordinary application code and typechecks,
-* builds, and extracts to a catalogue entry that looks perfectly normal — the
-* only sign of trouble is a parse error at format time, in a message whose
-* source is long gone.
-*/
 function validateBranchIdentifier(kind, identifier) {
 	if (typeof identifier !== "string") return;
 	const branch = getBranchCase(kind, identifier);
@@ -117,12 +96,6 @@ function validateBranchIdentifier(kind, identifier) {
 	}
 	if (kind === "select" && /^=\d+$/u.test(branch)) throw new Error(`Invalid select branch key '${identifier}', an exact value is only meaningful to 'plural' and 'ordinal', write it as '${branch.slice(1)}'`);
 }
-/**
-* The nearest identifier-safe form of a key, so the error names the fix as well
-* as the problem. The constraint comes from ICU rather than from anything the
-* author wrote, and camel case is how the rest of the codebase already spells a
-* name of more than one word.
-*/
 function suggestBranchIdentifier(identifier) {
 	const suggestion = identifier.split(/[^\p{L}\p{N}]+/u).filter(Boolean).map((word, index) => index === 0 ? word : word[0].toUpperCase() + word.slice(1)).join("");
 	if (!BRANCH_PATTERN.test(suggestion) || !Number.isNaN(+suggestion)) return void 0;
@@ -135,9 +108,20 @@ function assignSequenceIdentifiers(message, sequence = { current: 0 }, equivalen
 		while (reserved.has(identifier)) identifier = `${sequence.current++}`;
 		return identifier;
 	}
+	const numbered = {
+		tags: [],
+		values: []
+	};
+	function number(assigned, expression) {
+		const seen = assigned.find(([e]) => equivalent(e, expression));
+		if (seen) return seen[1];
+		const identifier = next();
+		assigned.push([expression, identifier]);
+		return identifier;
+	}
 	function walk(message) {
 		if (message instanceof ArgumentMessage || message instanceof ElementMessage || message instanceof ChoiceMessage) {
-			if (message.identifier === AUTO_INCREMENT_IDENTIFIER) message.identifier = next();
+			if (message.identifier === AUTO_INCREMENT_IDENTIFIER) message.identifier = number(message instanceof ElementMessage ? numbered.tags : numbered.values, message.expression);
 		}
 		if (message instanceof CompositeMessage || message instanceof ElementMessage) for (const child of message.children) walk(child);
 		if (message instanceof ChoiceMessage) for (const branch of message.branches) {
@@ -147,16 +131,6 @@ function assignSequenceIdentifiers(message, sequence = { current: 0 }, equivalen
 	}
 	walk(message);
 }
-/**
-* Collect the identifiers already assigned before this pass runs, so generated
-* sequence numbers never shadow an explicit one (e.g. an element tagged `0`).
-*
-* A name is claimed by what produced it, not by the name alone. Two that differ
-* each compile to their own prop, and a translator moving them around a sentence
-* has to be able to tell them apart, so they are a build error. Repeats are fine
-* when nothing distinguishes them: the same variable interpolated twice is one
-* value, and two identical elements are one tag.
-*/
 function collectAssignedIdentifiers(message, equivalent) {
 	const tags = /* @__PURE__ */ new Map();
 	const values = /* @__PURE__ */ new Map();
@@ -177,10 +151,11 @@ function collectAssignedIdentifiers(message, equivalent) {
 //#endregion
 //#region src/features/messages/convert.ts
 function convertMessageToIcu(message) {
-	function internalConvertMessageToIcu(message) {
+	function internalConvertMessageToIcu(message, hash) {
 		switch (true) {
-			case message instanceof LiteralMessage: return String(message.text);
+			case message instanceof LiteralMessage: return escapeIcuLiteral(String(message.text), hash !== void 0);
 			case message instanceof ArgumentMessage: {
+				if (!message.format && hash !== void 0 && String(message.identifier) === hash) return "#";
 				const parts = [String(message.identifier)];
 				if (message.format) parts.push(message.format.type);
 				if (message.format?.style) parts.push(message.format.style);
@@ -188,39 +163,27 @@ function convertMessageToIcu(message) {
 			}
 			case message instanceof ElementMessage: {
 				if (message.children.length === 0) return `<${String(message.identifier)}/>`;
-				const children = message.children.map((m) => internalConvertMessageToIcu(m)).join("");
+				const children = message.children.map((m) => internalConvertMessageToIcu(m, hash)).join("");
 				return `<${String(message.identifier)}>${children}</${String(message.identifier)}>`;
 			}
 			case message instanceof ChoiceMessage: {
+				const scope = message.kind === "select" ? hash : String(message.identifier);
 				const branches = message.branches.map(({ identifier, value }) => ({
 					identifier: getBranchCase(message.kind, identifier),
-					value: internalConvertMessageToIcu(value)
+					value: internalConvertMessageToIcu(value, scope)
 				})).map(({ identifier, value }) => `  ${identifier} {${value}}\n`).join("");
 				const format = message.kind === "ordinal" ? "selectordinal" : message.kind;
 				const offset = message.offset === void 0 || message.kind === "select" ? "" : ` offset:${message.offset}`;
 				return `{${String(message.identifier)}, ${format},${offset}\n${branches}}`;
 			}
-			case message instanceof CompositeMessage: return Object.entries(message.children).map(([, m]) => internalConvertMessageToIcu(m)).join("");
+			case message instanceof CompositeMessage: return Object.entries(message.children).map(([, m]) => internalConvertMessageToIcu(m, hash)).join("");
 			default: throw new Error("Unknown message type", { cause: message });
 		}
 	}
-	return internalConvertMessageToIcu(message).trim();
+	return internalConvertMessageToIcu(message, void 0).trim();
 }
 //#endregion
 //#region src/features/messages/format.ts
-/**
-* The ICU argument types a macro can author, and the named styles each accepts.
-*
-* `currency` is deliberately absent from `number`. MF1 has nowhere to write the
-* currency code — it comes from the formatter's configuration, not the message
-* — so `{price, number, currency}` formats as a literal `{$price}` at runtime
-* rather than an amount. Currency belongs to number skeletons, which the
-* formatter does not accept yet either.
-*
-* `spellout`, RBNF `ordinal`, and `choice` are absent by decision rather than
-* oversight: the first two are ICU4J/ICU4C rule-based formats with no `Intl`
-* equivalent, and the third is deprecated in ICU itself in favour of `plural`.
-*/
 const ARGUMENT_STYLES = {
 	number: ["integer", "percent"],
 	date: [
@@ -240,36 +203,32 @@ const ARGUMENT_TYPES = Object.keys(ARGUMENT_STYLES);
 function isArgumentType(kind) {
 	return Object.hasOwn(ARGUMENT_STYLES, kind);
 }
-/**
-* A literal `NumberFormat` pattern, e.g. `#,##0.00`.
-*
-* A pattern has to carry a digit placeholder — `#` or `0` — because that is
-* what makes it a pattern rather than a word. Without that requirement any
-* brace-free string qualifies, which quietly readmits the named styles this
-* module exists to reject: `currency` would sail through as a "pattern" and
-* extract to the `{price, number, currency}` the formatter cannot honour, and
-* so would a plain typo.
-*
-* Braces are excluded separately: ICU reserves them for its own pattern syntax,
-* so a style carrying one would close the argument early and take the rest of
-* the message with it.
-*/
 const LITERAL_STYLE_PATTERN = /^[^{}\r\n]*[#0][^{}\r\n]*$/;
-/**
-* Reject an argument style the formatter cannot honour, while the style is
-* still attached to a file and a line.
-*
-* A style is a bare string in the source and a bare string in the catalogue, so
-* nothing between here and the runtime has an opinion about it. Left unchecked,
-* a typo like `{d, date, meduim}` extracts to a catalogue entry that looks
-* perfectly normal and only misformats once it reaches a user.
-*/
+const SKELETON = "::";
+function invalidSkeleton(type, skeleton) {
+	if (skeleton === "") return "it names no fields";
+	const errors = [];
+	if (type === "number") {
+		(0, _messageformat_number_skeleton.getNumberFormatOptions)((0, _messageformat_number_skeleton.parseNumberSkeleton)(skeleton, (error) => errors.push(String(error))), (stem) => {
+			if (stem !== "scale") errors.push(`unsupported stem '${stem}'`);
+		});
+		return errors[0];
+	}
+	const options = (0, _messageformat_date_skeleton.getDateTimeFormatOptions)((0, _messageformat_date_skeleton.parseDateTokens)(skeleton), (_type, message) => errors.push(message));
+	if (errors.length > 0) return errors[0];
+	if (Object.keys(options).length === 0) return "it names no fields";
+}
 function validateArgumentStyle(type, style) {
 	const named = ARGUMENT_STYLES[type];
 	if (named.includes(style)) return;
+	if (style.startsWith(SKELETON)) {
+		const reason = invalidSkeleton(type, style.slice(2));
+		if (!reason) return;
+		throw new Error(`Invalid ${type} skeleton '${style}': ${reason}`);
+	}
 	if (type === "number" && LITERAL_STYLE_PATTERN.test(style)) return;
 	const expected = named.map((s) => `'${s}'`).join(", ");
-	throw new Error(`Invalid ${type} style '${style}', expected ${expected}` + (type === "number" ? ", or a literal number pattern such as #,##0.00" : ""));
+	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" : ""));
 }
 //#endregion
 exports.ARGUMENT_STYLES = ARGUMENT_STYLES;
@@ -282,6 +241,7 @@ exports.ElementMessage = ElementMessage;
 exports.LiteralMessage = LiteralMessage;
 exports.assignSequenceIdentifiers = assignSequenceIdentifiers;
 exports.convertMessageToIcu = convertMessageToIcu;
+exports.escapeIcuLiteral = escapeIcuLiteral;
 exports.generateHash = require_hash.generateHash;
 exports.getBranchCase = getBranchCase;
 exports.isArgumentType = isArgumentType;

package/dist/features/messages/index.d.cts

@@ -2,11 +2,14 @@
 /**
  * The ICU argument types a macro can author, and the named styles each accepts.
  *
+ * A style may also be a skeleton, which is where the formats these names have
+ * no word for live — see {@link validateArgumentStyle}.
+ *
  * `currency` is deliberately absent from `number`. MF1 has nowhere to write the
  * currency code — it comes from the formatter's configuration, not the message
- * — so `{price, number, currency}` formats as a literal `{$price}` at runtime
- * rather than an amount. Currency belongs to number skeletons, which the
- * formatter does not accept yet either.
+ * — so `{price, number, currency}` formats as a bare number at runtime rather
+ * than an amount. Currency belongs to a skeleton, `::currency/EUR`, which names
+ * the code and which the formatter does honour.
  *
  * `spellout`, RBNF `ordinal`, and `choice` are absent by decision rather than
  * oversight: the first two are ICU4J/ICU4C rule-based formats with no `Intl`
@@ -28,6 +31,9 @@ declare function isArgumentType(kind: string): kind is ArgumentType;
  * nothing between here and the runtime has an opinion about it. Left unchecked,
  * a typo like `{d, date, meduim}` extracts to a catalogue entry that looks
  * perfectly normal and only misformats once it reaches a user.
+ *
+ * Three forms are accepted: a named style, a `::`-prefixed skeleton, and — for
+ * a number — a literal pattern such as `#,##0.00`.
  */
 declare function validateArgumentStyle(type: ArgumentType, style: string): void;
 //#endregion
@@ -147,7 +153,41 @@ type Message = LiteralMessage | ArgumentMessage | ElementMessage | ChoiceMessage
 //#region src/features/messages/convert.d.ts
 declare function convertMessageToIcu(message: Message): string;
 //#endregion
+//#region src/features/messages/escape.d.ts
+/**
+ * Quoting for text that has to survive a message format unchanged.
+ *
+ * This lives beside the converter rather than in a transform because it belongs
+ * to the format being written, not to the syntax being read. A literal is the
+ * same literal whether it came from a template literal or from JSX, and the
+ * moment there is a second target format its reserved characters — and the way
+ * it spells an escape — are its own.
+ */
+/**
+ * Escape literal text so ICU MessageFormat 1 reads it as the text it is.
+ *
+ * MF1 escapes with an apostrophe: a run wrapped in one is taken literally, and a
+ * doubled apostrophe is a single apostrophe. The subtlety is that an apostrophe
+ * only opens a quoted run when a character that needs quoting follows it —
+ * anything else and the apostrophe is itself literal. So `'#'` is a real escape
+ * inside a plural and the three characters `'#'` anywhere else, which is why
+ * `hash` has to be told rather than assumed.
+ *
+ * @param text Literal text as the author wrote it
+ * @param hash Whether `#` stands for a number here, i.e. whether some `plural`
+ *   or `ordinal` encloses this text
+ */
+declare function escapeIcuLiteral(text: string, hash?: boolean): string;
+//#endregion
 //#region src/features/messages/hash.d.ts
+/**
+ * Hashed in userland rather than with `node:crypto`, because this runs wherever
+ * a bundler runs it. `createHash` is one of the entry points `unenv` leaves
+ * unimplemented — "[unenv] crypto.createHash is not implemented yet!" — so a
+ * plugin reaching for it throws in a Nitro or workerd build. The Web Crypto
+ * equivalent, `subtle.digest`, is async, and an id is resolved from a
+ * synchronous extraction pass.
+ */
 declare function generateHash(input: string, context?: string): string;
 //#endregion
-export { ARGUMENT_STYLES, ARGUMENT_TYPES, AUTO_INCREMENT_IDENTIFIER, ArgumentFormat, ArgumentMessage, ArgumentType, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, Message, PlaceholderEquivalence, assignSequenceIdentifiers, convertMessageToIcu, generateHash, getBranchCase, isArgumentType, validateArgumentStyle, validateBranchIdentifier };
+export { ARGUMENT_STYLES, ARGUMENT_TYPES, AUTO_INCREMENT_IDENTIFIER, ArgumentFormat, ArgumentMessage, ArgumentType, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, Message, PlaceholderEquivalence, assignSequenceIdentifiers, convertMessageToIcu, escapeIcuLiteral, generateHash, getBranchCase, isArgumentType, validateArgumentStyle, validateBranchIdentifier };

package/dist/features/messages/index.d.mts

@@ -2,11 +2,14 @@
 /**
  * The ICU argument types a macro can author, and the named styles each accepts.
  *
+ * A style may also be a skeleton, which is where the formats these names have
+ * no word for live — see {@link validateArgumentStyle}.
+ *
  * `currency` is deliberately absent from `number`. MF1 has nowhere to write the
  * currency code — it comes from the formatter's configuration, not the message
- * — so `{price, number, currency}` formats as a literal `{$price}` at runtime
- * rather than an amount. Currency belongs to number skeletons, which the
- * formatter does not accept yet either.
+ * — so `{price, number, currency}` formats as a bare number at runtime rather
+ * than an amount. Currency belongs to a skeleton, `::currency/EUR`, which names
+ * the code and which the formatter does honour.
  *
  * `spellout`, RBNF `ordinal`, and `choice` are absent by decision rather than
  * oversight: the first two are ICU4J/ICU4C rule-based formats with no `Intl`
@@ -28,6 +31,9 @@ declare function isArgumentType(kind: string): kind is ArgumentType;
  * nothing between here and the runtime has an opinion about it. Left unchecked,
  * a typo like `{d, date, meduim}` extracts to a catalogue entry that looks
  * perfectly normal and only misformats once it reaches a user.
+ *
+ * Three forms are accepted: a named style, a `::`-prefixed skeleton, and — for
+ * a number — a literal pattern such as `#,##0.00`.
  */
 declare function validateArgumentStyle(type: ArgumentType, style: string): void;
 //#endregion
@@ -147,7 +153,41 @@ type Message = LiteralMessage | ArgumentMessage | ElementMessage | ChoiceMessage
 //#region src/features/messages/convert.d.ts
 declare function convertMessageToIcu(message: Message): string;
 //#endregion
+//#region src/features/messages/escape.d.ts
+/**
+ * Quoting for text that has to survive a message format unchanged.
+ *
+ * This lives beside the converter rather than in a transform because it belongs
+ * to the format being written, not to the syntax being read. A literal is the
+ * same literal whether it came from a template literal or from JSX, and the
+ * moment there is a second target format its reserved characters — and the way
+ * it spells an escape — are its own.
+ */
+/**
+ * Escape literal text so ICU MessageFormat 1 reads it as the text it is.
+ *
+ * MF1 escapes with an apostrophe: a run wrapped in one is taken literally, and a
+ * doubled apostrophe is a single apostrophe. The subtlety is that an apostrophe
+ * only opens a quoted run when a character that needs quoting follows it —
+ * anything else and the apostrophe is itself literal. So `'#'` is a real escape
+ * inside a plural and the three characters `'#'` anywhere else, which is why
+ * `hash` has to be told rather than assumed.
+ *
+ * @param text Literal text as the author wrote it
+ * @param hash Whether `#` stands for a number here, i.e. whether some `plural`
+ *   or `ordinal` encloses this text
+ */
+declare function escapeIcuLiteral(text: string, hash?: boolean): string;
+//#endregion
 //#region src/features/messages/hash.d.ts
+/**
+ * Hashed in userland rather than with `node:crypto`, because this runs wherever
+ * a bundler runs it. `createHash` is one of the entry points `unenv` leaves
+ * unimplemented — "[unenv] crypto.createHash is not implemented yet!" — so a
+ * plugin reaching for it throws in a Nitro or workerd build. The Web Crypto
+ * equivalent, `subtle.digest`, is async, and an id is resolved from a
+ * synchronous extraction pass.
+ */
 declare function generateHash(input: string, context?: string): string;
 //#endregion
-export { ARGUMENT_STYLES, ARGUMENT_TYPES, AUTO_INCREMENT_IDENTIFIER, ArgumentFormat, ArgumentMessage, ArgumentType, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, Message, PlaceholderEquivalence, assignSequenceIdentifiers, convertMessageToIcu, generateHash, getBranchCase, isArgumentType, validateArgumentStyle, validateBranchIdentifier };
+export { ARGUMENT_STYLES, ARGUMENT_TYPES, AUTO_INCREMENT_IDENTIFIER, ArgumentFormat, ArgumentMessage, ArgumentType, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, Message, PlaceholderEquivalence, assignSequenceIdentifiers, convertMessageToIcu, escapeIcuLiteral, generateHash, getBranchCase, isArgumentType, validateArgumentStyle, validateBranchIdentifier };

package/dist/features/messages/index.mjs

@@ -1,4 +1,11 @@
 import { t as generateHash } from "../../hash-DvzpieJD.mjs";
+import { getDateTimeFormatOptions, parseDateTokens } from "@messageformat/date-skeleton";
+import { getNumberFormatOptions, parseNumberSkeleton } from "@messageformat/number-skeleton";
+//#region src/features/messages/escape.ts
+function escapeIcuLiteral(text, hash = false) {
+	return text.replace(/'/gu, "''").replace(hash ? /[{}#]+/gu : /[{}]+/gu, (run) => `'${run}'`);
+}
+//#endregion
 //#region src/features/messages/types.ts
 var Base = class {
 	toICUString() {
@@ -73,40 +80,12 @@ var CompositeMessage = class extends Base {
 //#endregion
 //#region src/features/messages/identifier.ts
 const AUTO_INCREMENT_IDENTIFIER = Symbol("auto-increment");
-/**
-* An ICU case, either an exact value or a key. ICU reserves its own pattern
-* syntax, so a key carries no punctuation and no whitespace.
-*/
 const BRANCH_PATTERN = /^(?:=\d+|[^\p{Pattern_Syntax}\p{Pattern_White_Space}]+)$/u;
-/**
-* The ICU case a branch is written as.
-*
-* Under `plural` and `ordinal` a number names an exact value, spelled `=0`, and
-* so is distinct from the CLDR category that would otherwise match it. `select`
-* has no such syntax — its cases are literal string matches, and `=0` there is
-* a parse error — so a numeric key stays bare, where it matches both `0` and
-* `'0'`.
-*
-* Digits are read literally rather than coerced, because everything JavaScript
-* is willing to call a number is not: `''`, `' '`, and `'+0'` all coerce to
-* `=0`, which would pass for a key that selects zero and quietly leave the
-* author's own key out of the catalogue. Anything else stays a key, where the
-* whitespace or punctuation that made it numeric-looking is caught.
-*/
 function getBranchCase(kind, identifier) {
 	const key = String(identifier);
 	if (kind === "select") return key;
 	return /^\d+$/u.test(key) ? `=${+key}` : key;
 }
-/**
-* Reject a branch key ICU cannot express, while the key is still attached to a
-* file and a line.
-*
-* A hyphenated string union is ordinary application code and typechecks,
-* builds, and extracts to a catalogue entry that looks perfectly normal — the
-* only sign of trouble is a parse error at format time, in a message whose
-* source is long gone.
-*/
 function validateBranchIdentifier(kind, identifier) {
 	if (typeof identifier !== "string") return;
 	const branch = getBranchCase(kind, identifier);
@@ -116,12 +95,6 @@ function validateBranchIdentifier(kind, identifier) {
 	}
 	if (kind === "select" && /^=\d+$/u.test(branch)) throw new Error(`Invalid select branch key '${identifier}', an exact value is only meaningful to 'plural' and 'ordinal', write it as '${branch.slice(1)}'`);
 }
-/**
-* The nearest identifier-safe form of a key, so the error names the fix as well
-* as the problem. The constraint comes from ICU rather than from anything the
-* author wrote, and camel case is how the rest of the codebase already spells a
-* name of more than one word.
-*/
 function suggestBranchIdentifier(identifier) {
 	const suggestion = identifier.split(/[^\p{L}\p{N}]+/u).filter(Boolean).map((word, index) => index === 0 ? word : word[0].toUpperCase() + word.slice(1)).join("");
 	if (!BRANCH_PATTERN.test(suggestion) || !Number.isNaN(+suggestion)) return void 0;
@@ -134,9 +107,20 @@ function assignSequenceIdentifiers(message, sequence = { current: 0 }, equivalen
 		while (reserved.has(identifier)) identifier = `${sequence.current++}`;
 		return identifier;
 	}
+	const numbered = {
+		tags: [],
+		values: []
+	};
+	function number(assigned, expression) {
+		const seen = assigned.find(([e]) => equivalent(e, expression));
+		if (seen) return seen[1];
+		const identifier = next();
+		assigned.push([expression, identifier]);
+		return identifier;
+	}
 	function walk(message) {
 		if (message instanceof ArgumentMessage || message instanceof ElementMessage || message instanceof ChoiceMessage) {
-			if (message.identifier === AUTO_INCREMENT_IDENTIFIER) message.identifier = next();
+			if (message.identifier === AUTO_INCREMENT_IDENTIFIER) message.identifier = number(message instanceof ElementMessage ? numbered.tags : numbered.values, message.expression);
 		}
 		if (message instanceof CompositeMessage || message instanceof ElementMessage) for (const child of message.children) walk(child);
 		if (message instanceof ChoiceMessage) for (const branch of message.branches) {
@@ -146,16 +130,6 @@ function assignSequenceIdentifiers(message, sequence = { current: 0 }, equivalen
 	}
 	walk(message);
 }
-/**
-* Collect the identifiers already assigned before this pass runs, so generated
-* sequence numbers never shadow an explicit one (e.g. an element tagged `0`).
-*
-* A name is claimed by what produced it, not by the name alone. Two that differ
-* each compile to their own prop, and a translator moving them around a sentence
-* has to be able to tell them apart, so they are a build error. Repeats are fine
-* when nothing distinguishes them: the same variable interpolated twice is one
-* value, and two identical elements are one tag.
-*/
 function collectAssignedIdentifiers(message, equivalent) {
 	const tags = /* @__PURE__ */ new Map();
 	const values = /* @__PURE__ */ new Map();
@@ -176,10 +150,11 @@ function collectAssignedIdentifiers(message, equivalent) {
 //#endregion
 //#region src/features/messages/convert.ts
 function convertMessageToIcu(message) {
-	function internalConvertMessageToIcu(message) {
+	function internalConvertMessageToIcu(message, hash) {
 		switch (true) {
-			case message instanceof LiteralMessage: return String(message.text);
+			case message instanceof LiteralMessage: return escapeIcuLiteral(String(message.text), hash !== void 0);
 			case message instanceof ArgumentMessage: {
+				if (!message.format && hash !== void 0 && String(message.identifier) === hash) return "#";
 				const parts = [String(message.identifier)];
 				if (message.format) parts.push(message.format.type);
 				if (message.format?.style) parts.push(message.format.style);
@@ -187,39 +162,27 @@ function convertMessageToIcu(message) {
 			}
 			case message instanceof ElementMessage: {
 				if (message.children.length === 0) return `<${String(message.identifier)}/>`;
-				const children = message.children.map((m) => internalConvertMessageToIcu(m)).join("");
+				const children = message.children.map((m) => internalConvertMessageToIcu(m, hash)).join("");
 				return `<${String(message.identifier)}>${children}</${String(message.identifier)}>`;
 			}
 			case message instanceof ChoiceMessage: {
+				const scope = message.kind === "select" ? hash : String(message.identifier);
 				const branches = message.branches.map(({ identifier, value }) => ({
 					identifier: getBranchCase(message.kind, identifier),
-					value: internalConvertMessageToIcu(value)
+					value: internalConvertMessageToIcu(value, scope)
 				})).map(({ identifier, value }) => `  ${identifier} {${value}}\n`).join("");
 				const format = message.kind === "ordinal" ? "selectordinal" : message.kind;
 				const offset = message.offset === void 0 || message.kind === "select" ? "" : ` offset:${message.offset}`;
 				return `{${String(message.identifier)}, ${format},${offset}\n${branches}}`;
 			}
-			case message instanceof CompositeMessage: return Object.entries(message.children).map(([, m]) => internalConvertMessageToIcu(m)).join("");
+			case message instanceof CompositeMessage: return Object.entries(message.children).map(([, m]) => internalConvertMessageToIcu(m, hash)).join("");
 			default: throw new Error("Unknown message type", { cause: message });
 		}
 	}
-	return internalConvertMessageToIcu(message).trim();
+	return internalConvertMessageToIcu(message, void 0).trim();
 }
 //#endregion
 //#region src/features/messages/format.ts
-/**
-* The ICU argument types a macro can author, and the named styles each accepts.
-*
-* `currency` is deliberately absent from `number`. MF1 has nowhere to write the
-* currency code — it comes from the formatter's configuration, not the message
-* — so `{price, number, currency}` formats as a literal `{$price}` at runtime
-* rather than an amount. Currency belongs to number skeletons, which the
-* formatter does not accept yet either.
-*
-* `spellout`, RBNF `ordinal`, and `choice` are absent by decision rather than
-* oversight: the first two are ICU4J/ICU4C rule-based formats with no `Intl`
-* equivalent, and the third is deprecated in ICU itself in favour of `plural`.
-*/
 const ARGUMENT_STYLES = {
 	number: ["integer", "percent"],
 	date: [
@@ -239,36 +202,32 @@ const ARGUMENT_TYPES = Object.keys(ARGUMENT_STYLES);
 function isArgumentType(kind) {
 	return Object.hasOwn(ARGUMENT_STYLES, kind);
 }
-/**
-* A literal `NumberFormat` pattern, e.g. `#,##0.00`.
-*
-* A pattern has to carry a digit placeholder — `#` or `0` — because that is
-* what makes it a pattern rather than a word. Without that requirement any
-* brace-free string qualifies, which quietly readmits the named styles this
-* module exists to reject: `currency` would sail through as a "pattern" and
-* extract to the `{price, number, currency}` the formatter cannot honour, and
-* so would a plain typo.
-*
-* Braces are excluded separately: ICU reserves them for its own pattern syntax,
-* so a style carrying one would close the argument early and take the rest of
-* the message with it.
-*/
 const LITERAL_STYLE_PATTERN = /^[^{}\r\n]*[#0][^{}\r\n]*$/;
-/**
-* Reject an argument style the formatter cannot honour, while the style is
-* still attached to a file and a line.
-*
-* A style is a bare string in the source and a bare string in the catalogue, so
-* nothing between here and the runtime has an opinion about it. Left unchecked,
-* a typo like `{d, date, meduim}` extracts to a catalogue entry that looks
-* perfectly normal and only misformats once it reaches a user.
-*/
+const SKELETON = "::";
+function invalidSkeleton(type, skeleton) {
+	if (skeleton === "") return "it names no fields";
+	const errors = [];
+	if (type === "number") {
+		getNumberFormatOptions(parseNumberSkeleton(skeleton, (error) => errors.push(String(error))), (stem) => {
+			if (stem !== "scale") errors.push(`unsupported stem '${stem}'`);
+		});
+		return errors[0];
+	}
+	const options = getDateTimeFormatOptions(parseDateTokens(skeleton), (_type, message) => errors.push(message));
+	if (errors.length > 0) return errors[0];
+	if (Object.keys(options).length === 0) return "it names no fields";
+}
 function validateArgumentStyle(type, style) {
 	const named = ARGUMENT_STYLES[type];
 	if (named.includes(style)) return;
+	if (style.startsWith(SKELETON)) {
+		const reason = invalidSkeleton(type, style.slice(2));
+		if (!reason) return;
+		throw new Error(`Invalid ${type} skeleton '${style}': ${reason}`);
+	}
 	if (type === "number" && LITERAL_STYLE_PATTERN.test(style)) return;
 	const expected = named.map((s) => `'${s}'`).join(", ");
-	throw new Error(`Invalid ${type} style '${style}', expected ${expected}` + (type === "number" ? ", or a literal number pattern such as #,##0.00" : ""));
+	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" : ""));
 }
 //#endregion
-export { ARGUMENT_STYLES, ARGUMENT_TYPES, AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, assignSequenceIdentifiers, convertMessageToIcu, generateHash, getBranchCase, isArgumentType, validateArgumentStyle, validateBranchIdentifier };
+export { ARGUMENT_STYLES, ARGUMENT_TYPES, AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, assignSequenceIdentifiers, convertMessageToIcu, escapeIcuLiteral, generateHash, getBranchCase, isArgumentType, validateArgumentStyle, validateBranchIdentifier };

package/dist/index.cjs

@@ -43,11 +43,6 @@ const Transformer = zod.object({
 	extract: zod.custom((v) => typeof v === "function"),
 	transform: zod.custom((v) => typeof v === "function")
 });
-/**
-* A message declared in the config rather than found in source. The shorthand
-* is the source string; the object form adds the metadata a descriptor would
-* otherwise carry.
-*/
 const DeclaredMessage = zod.string().or(zod.object({
 	message: zod.string(),
 	context: zod.string().optional(),
@@ -62,13 +57,6 @@ const Bucket = zod.object({
 		zod.string(),
 		".{extension}"
 	]),
-	/**
-	* Messages that belong in the catalogue but have no call site to extract
-	* them from — strings owned by a non-JavaScript artefact such as a manifest,
-	* a store listing, or an email subject. Keyed by id, so the id is stable and
-	* hand-written by definition, and merged into every extraction alongside
-	* whatever the transformers find.
-	*/
 	messages: zod.record(zod.string(), DeclaredMessage).optional(),
 	formatter: Formatter,
 	transformer: Transformer.transform((t) => [t]).or(Transformer.array()).transform((t) => ({
@@ -94,12 +82,6 @@ const Bucket = zod.object({
 }));
 const Config = zod.object({
 	locales: zod.tuple([zod.string()], zod.string()),
-	/**
-	* Per-locale fallback chains, most specific first, e.g.
-	* `{ 'en-NZ': ['en-GB'], 'es-MX': 'es' }`. The source locale (the first entry
-	* in {@link Config.locales}) is always appended as the final fallback, so an
-	* untranslated key ultimately resolves to the source string.
-	*/
 	fallbackLocales: zod.record(zod.string(), zod.string().or(zod.string().array())).optional(),
 	buckets: Bucket.array()
 });

package/dist/index.mjs

@@ -18,11 +18,6 @@ const Transformer = z.object({
 	extract: z.custom((v) => typeof v === "function"),
 	transform: z.custom((v) => typeof v === "function")
 });
-/**
-* A message declared in the config rather than found in source. The shorthand
-* is the source string; the object form adds the metadata a descriptor would
-* otherwise carry.
-*/
 const DeclaredMessage = z.string().or(z.object({
 	message: z.string(),
 	context: z.string().optional(),
@@ -37,13 +32,6 @@ const Bucket = z.object({
 		z.string(),
 		".{extension}"
 	]),
-	/**
-	* Messages that belong in the catalogue but have no call site to extract
-	* them from — strings owned by a non-JavaScript artefact such as a manifest,
-	* a store listing, or an email subject. Keyed by id, so the id is stable and
-	* hand-written by definition, and merged into every extraction alongside
-	* whatever the transformers find.
-	*/
 	messages: z.record(z.string(), DeclaredMessage).optional(),
 	formatter: Formatter,
 	transformer: Transformer.transform((t) => [t]).or(Transformer.array()).transform((t) => ({
@@ -69,12 +57,6 @@ const Bucket = z.object({
 }));
 const Config = z.object({
 	locales: z.tuple([z.string()], z.string()),
-	/**
-	* Per-locale fallback chains, most specific first, e.g.
-	* `{ 'en-NZ': ['en-GB'], 'es-MX': 'es' }`. The source locale (the first entry
-	* in {@link Config.locales}) is always appended as the final fallback, so an
-	* untranslated key ultimately resolves to the source string.
-	*/
 	fallbackLocales: z.record(z.string(), z.string().or(z.string().array())).optional(),
 	buckets: Bucket.array()
 });

package/dist/{loader-DwF1lM3f.mjs → loader-C6XxYhMl.mjs}

@@ -22,7 +22,6 @@ function findConfigFile(moduleName, projectDir) {
 }
 //#endregion
 //#region src/features/loader/module.ts
-/** Requires `path` without leaving it in (or reading it from) the require cache. */
 function requireFresh(require, path) {
 	const resolved = require.resolve(path);
 	delete require.cache[resolved];
@@ -35,11 +34,6 @@ const TYPESCRIPT = /* @__PURE__ */ new Set([
 	".mts",
 	".cts"
 ]);
-/**
-* Adds what the runtime cannot: why a config it could not read is one it will
-* never read. Everything else is the config's own problem, and its error
-* already describes that better than we could.
-*/
 function diagnose(error, path) {
 	const code = error?.code;
 	if (code === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX") return "Enums, namespaces and parameter properties are not erasable, so no runtime will read them.";
@@ -47,12 +41,6 @@ function diagnose(error, path) {
 	if ((code === "ERR_UNKNOWN_FILE_EXTENSION" || !code && error instanceof SyntaxError) && TYPESCRIPT.has(extname(path).toLowerCase())) return "Reading this config needs Node 22.18+, or a runtime that loads TypeScript itself (Bun, Deno, tsx).";
 	return null;
 }
-/**
-* Loads a config file as it sits on disk, leaving the runtime to deal with the
-* extension. Nothing is copied or rewritten, so `__dirname`,
-* `import.meta.dirname`, relative specifiers and `require.resolve` all resolve
-* against the config's own directory.
-*/
 function loadModule(path) {
 	try {
 		return requireFresh(createRequire(path), path);
@@ -73,11 +61,6 @@ const configLoaders = Object.freeze({
 });
 //#endregion
 //#region src/features/loader/resolve.ts
-/**
-* The config file {@link resolveConfig} would load, for callers that need the
-* path itself rather than its contents — salting a bundler's cache key with it,
-* for one, since what a catalogue assembles into depends on the config.
-*/
 function resolveConfigFile(name = "saykit") {
 	const file = findConfigFile(name, process.cwd());
 	if (!file) throw new Error(`Could not find config file for "${name}"`);

package/dist/{loader-BdCeoj3-.cjs → loader-XE7SprlF.cjs}

@@ -22,7 +22,6 @@ function findConfigFile(moduleName, projectDir) {
 }
 //#endregion
 //#region src/features/loader/module.ts
-/** Requires `path` without leaving it in (or reading it from) the require cache. */
 function requireFresh(require, path) {
 	const resolved = require.resolve(path);
 	delete require.cache[resolved];
@@ -35,11 +34,6 @@ const TYPESCRIPT = /* @__PURE__ */ new Set([
 	".mts",
 	".cts"
 ]);
-/**
-* Adds what the runtime cannot: why a config it could not read is one it will
-* never read. Everything else is the config's own problem, and its error
-* already describes that better than we could.
-*/
 function diagnose(error, path) {
 	const code = error?.code;
 	if (code === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX") return "Enums, namespaces and parameter properties are not erasable, so no runtime will read them.";
@@ -47,12 +41,6 @@ function diagnose(error, path) {
 	if ((code === "ERR_UNKNOWN_FILE_EXTENSION" || !code && error instanceof SyntaxError) && TYPESCRIPT.has((0, node_path.extname)(path).toLowerCase())) return "Reading this config needs Node 22.18+, or a runtime that loads TypeScript itself (Bun, Deno, tsx).";
 	return null;
 }
-/**
-* Loads a config file as it sits on disk, leaving the runtime to deal with the
-* extension. Nothing is copied or rewritten, so `__dirname`,
-* `import.meta.dirname`, relative specifiers and `require.resolve` all resolve
-* against the config's own directory.
-*/
 function loadModule(path) {
 	try {
 		return requireFresh((0, node_module.createRequire)(path), path);
@@ -73,11 +61,6 @@ const configLoaders = Object.freeze({
 });
 //#endregion
 //#region src/features/loader/resolve.ts
-/**
-* The config file {@link resolveConfig} would load, for callers that need the
-* path itself rather than its contents — salting a bundler's cache key with it,
-* for one, since what a catalogue assembles into depends on the config.
-*/
 function resolveConfigFile(name = "saykit") {
 	const file = findConfigFile(name, process.cwd());
 	if (!file) throw new Error(`Could not find config file for "${name}"`);

package/dist/{storage-B6mn0s3V.mjs → storage-8485YdBh.mjs}

@@ -30,14 +30,6 @@ function pruneLocaleMessages(existingMessages, sourceMessages) {
 function expandBucketOutputPath(bucket, locale, extension = bucket.formatter.extension) {
 	return resolve(bucket.output.replaceAll("{locale}", locale).replaceAll("{extension}", extension.slice(1)));
 }
-/**
-* The declaration file that types a catalogue, e.g. `en.json` -> `en.d.json.ts`.
-*
-* TypeScript resolves `./en.json` by stripping the extension and looking for
-* `en.d.json.ts`; the `en.json.d.ts` form is only consulted for extensions the
-* resolver does not recognise. Non-JS extensions additionally require
-* `allowArbitraryExtensions` in the consumer's tsconfig.
-*/
 function declarationPathFor(cataloguePath) {
 	const { dir, name, ext } = parse(cataloguePath);
 	return resolve(dir, `${name}.d${ext}.ts`);

package/dist/{storage-DqhzA5H8.cjs → storage-DSdC-TYq.cjs}

@@ -30,14 +30,6 @@ function pruneLocaleMessages(existingMessages, sourceMessages) {
 function expandBucketOutputPath(bucket, locale, extension = bucket.formatter.extension) {
 	return (0, node_path.resolve)(bucket.output.replaceAll("{locale}", locale).replaceAll("{extension}", extension.slice(1)));
 }
-/**
-* The declaration file that types a catalogue, e.g. `en.json` -> `en.d.json.ts`.
-*
-* TypeScript resolves `./en.json` by stripping the extension and looking for
-* `en.d.json.ts`; the `en.json.d.ts` form is only consulted for extensions the
-* resolver does not recognise. Non-JS extensions additionally require
-* `allowArbitraryExtensions` in the consumer's tsconfig.
-*/
 function declarationPathFor(cataloguePath) {
 	const { dir, name, ext } = (0, node_path.parse)(cataloguePath);
 	return (0, node_path.resolve)(dir, `${name}.d${ext}.ts`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saykit/config",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "CLI and configuration tooling for saykit",
   "keywords": [
     "cli",
@@ -74,6 +74,8 @@
   },
   "dependencies": {
     "@commander-js/extra-typings": "^15.0.0",
+    "@messageformat/date-skeleton": "2.0.0-0",
+    "@messageformat/number-skeleton": "2.0.0-0",
     "commander": "^15.0.0",
     "js-sha256": "^0.12.0",
     "picomatch": "^4.0.5",