@vouchington/utils 0.1.0 → 0.3.0

package/README.md

@@ -7,6 +7,8 @@ export: import the capability you use from an explicit subpath.
 import { createTokenSecrets } from '@vouchington/utils/token-secrets'
 import { createMoneyCatalog } from '@vouchington/utils/money'
 import { serializeCookie } from '@vouchington/utils/cookies'
+import { bestAcceptLanguageMatch } from '@vouchington/utils/language-tags'
+import { createMessageTranslator } from '@vouchington/utils/message-catalog'
 ```
 
 ## Subpaths
@@ -27,6 +29,8 @@ import { serializeCookie } from '@vouchington/utils/cookies'
   caller to supply every policy attribute. `SameSite=None` requires `Secure`.
 - `collections`, `async`, and `stable-json`: collection deduplication/merging, bounded async mapping,
   and deterministic JSON serialization.
+- `feature-flags`: base64 JSON feature-flag cookie parsing and serialization with caller-injected
+  codecs, cookie names, and size policy.
 - `dates`, `format`, `strings`, and `text-metrics`: UTC-day, duration, formatting, text normalization,
   title casing, and word/sentence helpers.
 - `gtin`, `bigint-ids`, and `validation`: GTIN predicates, canonical positive PostgreSQL bigint IDs,
@@ -35,6 +39,20 @@ import { serializeCookie } from '@vouchington/utils/cookies'
   query-string serialization. Cursor parsing intentionally belongs to `@vouchington/pagination`.
 - `slugs` and `urls`: ASCII-only slugification and URL/hostname primitives. URL hostname helpers
   return `null` for invalid input; `normalizeAsciiHostname` names its ASCII-only contract directly.
+  `matchesHostnamePattern` supports exact and inclusive `*.` hostname patterns.
+- `language-tags`: caller-configured locale normalization and strict `Accept-Language` parsing and
+  best matching. HTTP ranges reject malformed syntax and quality parameters; explicit `q=0` ranges
+  exclude a candidate when they tie for that candidate's most-specific matching range, so `en;q=0`
+  overrides an equal `en;q=1`, while `en-US;q=1` overrides broader `en;q=0` for supported `en-US`.
+  A truncated fallback (`en-US` to supported `en`) instead uses the ranges that match `en`, so `en;q=0`
+  or `*;q=0` excludes it. Matching compares an exact supported tag,
+  then truncates the _request_ (`en-US` can match supported `en`); it never expands `en` to an
+  arbitrary regional supported tag. Invalid configured tags are ignored. This subpath has no default
+  locale or supported-tag policy.
+- `message-catalog`: typed nested catalog translation for string, plural, and select-plural JSON
+  descriptors. Catalog segments cannot contain dots because dots delimit nested keys. Plural values
+  and configured number parameters must be finite numbers; callers own catalog content, locale
+  choice, and number formatting.
 - `observability`: SDK-free URL, request, event, and span scrubbing. Callers provide credential
   headers and environment or spike policy; this package has no product defaults.
 

package/dist/collections.d.mts

@@ -3,6 +3,9 @@ export declare function dedupeByLast<T, K>(items: readonly T[], key: (item: T) =
 export declare function dedupeById<T extends {
     id: string;
 }>(items: readonly T[]): T[];
+export declare function indexById<T extends {
+    id: string;
+}>(values: readonly (T | null | undefined)[]): Record<string, T>;
 export declare function mergePageResultsById<T extends {
     id: string;
 }>(pages?: readonly ({

package/dist/collections.mjs

@@ -14,6 +14,20 @@ export function dedupeByLast(items, key) {
 export function dedupeById(items) {
     return dedupeBy(items, (item) => item.id);
 }
+export function indexById(values) {
+    const indexed = {};
+    for (const value of values) {
+        if (value === null || value === undefined)
+            continue;
+        Object.defineProperty(indexed, value.id, {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true,
+        });
+    }
+    return indexed;
+}
 export function mergePageResultsById(pages) {
     return dedupeById((pages ?? []).flatMap((page) => page?.results ?? []));
 }

package/dist/feature-flags.d.mts

@@ -0,0 +1,14 @@
+export type FeatureFlags = Record<string, boolean>;
+export type FeatureFlagCookieCodec = {
+    encodeBase64(value: string): string;
+    decodeBase64(value: string): string;
+};
+export type FeatureFlagCookieOptions = {
+    maxCookieLength?: number;
+};
+export declare const DEFAULT_FEATURE_FLAG_COOKIE_MAX_LENGTH = 4096;
+export declare function extractBooleanFeatureFlags(fields: Record<string, unknown>): FeatureFlags;
+export declare function parseFeatureFlagCookie(cookieValue: string, codec: FeatureFlagCookieCodec, options?: FeatureFlagCookieOptions): FeatureFlags;
+export declare function encodeFeatureFlagCookie(overrides: FeatureFlags, codec: FeatureFlagCookieCodec): string;
+export declare function parseFeatureFlagCookieMaxLength(value: string | undefined, fallback?: number): number;
+export declare function safeFeatureFlagCookiePart(cookieName: string, cookieValue: string | undefined, options?: FeatureFlagCookieOptions): string | null;

package/dist/feature-flags.mjs

@@ -0,0 +1,48 @@
+export const DEFAULT_FEATURE_FLAG_COOKIE_MAX_LENGTH = 4096;
+const BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+const COOKIE_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+export function extractBooleanFeatureFlags(fields) {
+    const flags = {};
+    for (const [key, value] of Object.entries(fields)) {
+        if (typeof value === 'boolean') {
+            Object.defineProperty(flags, key, {
+                configurable: true,
+                enumerable: true,
+                value,
+                writable: true,
+            });
+        }
+    }
+    return flags;
+}
+export function parseFeatureFlagCookie(cookieValue, codec, options = {}) {
+    try {
+        if (!isSafeCookieValue(cookieValue, options))
+            return {};
+        const parsed = JSON.parse(codec.decodeBase64(cookieValue));
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            return {};
+        return extractBooleanFeatureFlags(parsed);
+    }
+    catch {
+        return {};
+    }
+}
+export function encodeFeatureFlagCookie(overrides, codec) {
+    return codec.encodeBase64(JSON.stringify(overrides));
+}
+export function parseFeatureFlagCookieMaxLength(value, fallback = DEFAULT_FEATURE_FLAG_COOKIE_MAX_LENGTH) {
+    const parsed = Number.parseInt(value ?? '', 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function safeFeatureFlagCookiePart(cookieName, cookieValue, options = {}) {
+    return COOKIE_NAME.test(cookieName) && isSafeCookieValue(cookieValue, options)
+        ? `${cookieName}=${cookieValue}`
+        : null;
+}
+function isSafeCookieValue(value, { maxCookieLength = DEFAULT_FEATURE_FLAG_COOKIE_MAX_LENGTH }) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= maxCookieLength &&
+        BASE64.test(value));
+}

package/dist/language-tags.d.mts

@@ -0,0 +1,11 @@
+export type ParsedLanguageRange = Readonly<{
+    range: string;
+    quality: number;
+    index: number;
+}>;
+/** Normalizes a locale against the caller's exact supported-tag catalog. */
+export declare function normalizeLanguageTag<Supported extends string>(value: string | null | undefined, supported: readonly Supported[]): Supported | null;
+/** Parses valid, non-zero Accept-Language ranges, highest quality first and stably for ties. */
+export declare function parseAcceptLanguage(value: string | null | undefined): ParsedLanguageRange[];
+/** Returns the caller-configured supported tag selected by strict Accept-Language lookup. */
+export declare function bestAcceptLanguageMatch<Supported extends string>(value: string | null | undefined, supported: readonly Supported[]): Supported | null;

package/dist/language-tags.mjs

@@ -0,0 +1,91 @@
+const HTTP_LANGUAGE_RANGE = /^(?:\*|[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*)$/;
+const QUALITY = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/;
+/** Normalizes a locale against the caller's exact supported-tag catalog. */
+export function normalizeLanguageTag(value, supported) {
+    if (!value)
+        return null;
+    const canonical = canonicalize(value.trim().replaceAll('_', '-'));
+    return canonical === null ? null : lookup(canonical, validSupported(supported));
+}
+/** Parses valid, non-zero Accept-Language ranges, highest quality first and stably for ties. */
+export function parseAcceptLanguage(value) {
+    return parseLanguageRanges(value).filter((parsed) => parsed.quality > 0);
+}
+/** Returns the caller-configured supported tag selected by strict Accept-Language lookup. */
+export function bestAcceptLanguageMatch(value, supported) {
+    const available = validSupported(supported);
+    const parsed = parseLanguageRanges(value);
+    for (const range of parsed) {
+        if (range.quality === 0)
+            continue;
+        if (range.range === '*')
+            return available.find((tag) => !isExcluded(tag.canonical, parsed))?.original ?? null;
+        const match = lookup(range.range, available, parsed);
+        if (match !== null)
+            return match;
+    }
+    return null;
+}
+function parseLanguageRanges(value) {
+    if (!value)
+        return [];
+    return value
+        .split(',')
+        .flatMap((part, index) => {
+        const [range, ...parameters] = part
+            .trim()
+            .split(';')
+            .map((item) => item.trim());
+        if (!range || !HTTP_LANGUAGE_RANGE.test(range))
+            return [];
+        const quality = parameters.length === 0 ? 1 : parseQuality(parameters);
+        const canonical = range === '*' ? '*' : canonicalize(range);
+        return canonical === null || quality === null ? [] : [{ range: canonical, quality, index }];
+    })
+        .toSorted((left, right) => right.quality - left.quality || left.index - right.index);
+}
+function parseQuality(parameters) {
+    if (parameters.length !== 1)
+        return null;
+    const matched = /^q=(.+)$/i.exec(parameters[0]);
+    if (!matched || !QUALITY.test(matched[1]))
+        return null;
+    return Number(matched[1]);
+}
+function canonicalize(value) {
+    try {
+        return Intl.getCanonicalLocales(value)[0];
+    }
+    catch {
+        return null;
+    }
+}
+function lookup(range, supported, parsed = []) {
+    let candidate = range;
+    while (candidate) {
+        for (const tag of supported) {
+            if (tag.canonical === candidate && !isExcluded(candidate, parsed))
+                return tag.original;
+        }
+        const separator = candidate.lastIndexOf('-');
+        candidate = separator > 1 ? candidate.slice(0, separator) : '';
+    }
+    return null;
+}
+function validSupported(supported) {
+    return supported.flatMap((original) => {
+        const canonical = canonicalize(original);
+        return canonical === null ? [] : [{ original, canonical }];
+    });
+}
+function isExcluded(canonical, parsed) {
+    const matching = parsed.filter((range) => matchesRange(range.range, canonical));
+    const specificity = Math.max(...matching.map((range) => rangeSpecificity(range.range)));
+    return matching.some((range) => range.quality === 0 && rangeSpecificity(range.range) === specificity);
+}
+function rangeSpecificity(range) {
+    return range === '*' ? 0 : range.split('-').length;
+}
+function matchesRange(range, candidate) {
+    return range === '*' || candidate === range || candidate.startsWith(`${range}-`);
+}

package/dist/message-catalog-validation.d.mts

@@ -0,0 +1,4 @@
+import type { MessageCatalog, MessageDescriptor } from './message-catalog.mjs';
+export declare function isMessageDescriptor(value: unknown): value is MessageDescriptor;
+export declare function assertCatalog(value: unknown, path?: string): asserts value is MessageCatalog;
+export declare function isCatalogRecord(value: unknown): value is Record<string, unknown>;

package/dist/message-catalog-validation.mjs

@@ -0,0 +1,103 @@
+const pluralCategories = ['zero', 'one', 'two', 'few', 'many', 'other'];
+class CatalogValidationError extends TypeError {
+}
+export function isMessageDescriptor(value) {
+    try {
+        if (!isCatalogRecord(value) ||
+            !hasOwnString(value, 'kind') ||
+            !hasOwnString(value, 'valueParameter') ||
+            !isStringArray(value.numberParameters))
+            return false;
+        if (value.kind === 'plural')
+            return (hasOnlyKeys(value, ['kind', 'valueParameter', 'numberParameters', 'forms']) &&
+                Object.hasOwn(value, 'forms') &&
+                isPluralForms(value.forms));
+        return (value.kind === 'select-plural' &&
+            hasOnlyKeys(value, [
+                'kind',
+                'valueParameter',
+                'selectParameter',
+                'numberParameters',
+                'cases',
+            ]) &&
+            hasOwnString(value, 'selectParameter') &&
+            Object.hasOwn(value, 'cases') &&
+            isCases(value.cases));
+    }
+    catch {
+        return false;
+    }
+}
+export function assertCatalog(value, path = 'catalog') {
+    assertCatalogValue(value, path, new WeakSet());
+}
+export function isCatalogRecord(value) {
+    try {
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return false;
+        const prototype = Object.getPrototypeOf(value);
+        if ((prototype !== Object.prototype && prototype !== null) || Object.hasOwn(value, 'toJSON'))
+            return false;
+        return Object.values(Object.getOwnPropertyDescriptors(value)).every((descriptor) => descriptor.enumerable && 'value' in descriptor && typeof descriptor.value !== 'function');
+    }
+    catch {
+        return false;
+    }
+}
+function assertCatalogValue(value, path, ancestors) {
+    if (!isCatalogRecord(value))
+        fail(`${path} must be a serializable catalog object`);
+    if (ancestors.has(value))
+        fail(`${path} contains a catalog cycle`);
+    ancestors.add(value);
+    try {
+        for (const [key, child] of Object.entries(value)) {
+            if (key.includes('.'))
+                fail(`segment "${key}" must not contain a dot`);
+            if (typeof child === 'string' || isMessageDescriptor(child))
+                continue;
+            if (isCatalogRecord(child) && child.kind === 'plural' && hasDescriptorFields(child))
+                fail(`Invalid plural message descriptor at "${key}"`);
+            if (isCatalogRecord(child) && child.kind === 'select-plural' && hasDescriptorFields(child))
+                fail(`Invalid select-plural message descriptor at "${key}"`);
+            assertCatalogValue(child, `${path}.${key}`, ancestors);
+        }
+    }
+    catch (error) {
+        if (error instanceof CatalogValidationError)
+            throw error;
+        fail(`${path} must be a serializable catalog object`);
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function isCases(value) {
+    return (isCatalogRecord(value) &&
+        Object.keys(value).length > 0 &&
+        Object.values(value).every(isPluralForms));
+}
+function isPluralForms(value) {
+    return (isCatalogRecord(value) &&
+        Object.hasOwn(value, 'other') &&
+        Object.keys(value).every((key) => pluralCategories.includes(key) &&
+            typeof value[key] === 'string'));
+}
+function hasOwnString(value, key) {
+    return Object.hasOwn(value, key) && typeof value[key] === 'string';
+}
+function hasOnlyKeys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}
+function hasDescriptorFields(value) {
+    return ['valueParameter', 'numberParameters', 'forms', 'selectParameter', 'cases'].some((key) => Object.hasOwn(value, key));
+}
+function isStringArray(value) {
+    return (value === undefined ||
+        (Array.isArray(value) &&
+            !Object.hasOwn(value, 'toJSON') &&
+            Array.from(value).every((item) => typeof item === 'string')));
+}
+function fail(message) {
+    throw new CatalogValidationError(message);
+}

package/dist/message-catalog.d.mts

@@ -0,0 +1,36 @@
+export { isCatalogRecord, isMessageDescriptor } from './message-catalog-validation.mjs';
+type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+export type PluralForms = Readonly<{
+    other: string;
+} & Partial<Record<PluralCategory, string>>>;
+export type PluralMessageDescriptor = Readonly<{
+    kind: 'plural';
+    valueParameter: string;
+    numberParameters?: readonly string[];
+    forms: PluralForms;
+}>;
+export type SelectPluralMessageDescriptor = Readonly<{
+    kind: 'select-plural';
+    valueParameter: string;
+    selectParameter: string;
+    numberParameters?: readonly string[];
+    cases: Readonly<Record<string, PluralForms>>;
+}>;
+export type MessageDescriptor = PluralMessageDescriptor | SelectPluralMessageDescriptor;
+type CatalogLeaf = string | MessageDescriptor;
+export type MessageCatalog = {
+    readonly [key: string]: CatalogLeaf | MessageCatalog;
+};
+type DottedCatalog<Catalog extends MessageCatalog> = {
+    [Key in keyof Catalog & string]: Key extends `${string}.${string}` ? true : Catalog[Key] extends MessageCatalog ? DottedCatalog<Catalog[Key]> : false;
+}[keyof Catalog & string];
+type ValidCatalog<Catalog extends MessageCatalog> = string extends keyof Catalog ? unknown : true extends DottedCatalog<Catalog> ? never : unknown;
+export type MessageKey<Catalog extends MessageCatalog> = string extends keyof Catalog ? string : {
+    [Key in keyof Catalog & string]: Catalog[Key] extends CatalogLeaf ? Key : Catalog[Key] extends MessageCatalog ? `${Key}.${MessageKey<Catalog[Key]>}` : never;
+}[keyof Catalog & string];
+export type MessageTranslator<Catalog extends MessageCatalog> = <Key extends MessageKey<Catalog>>(key: Key, parameters?: Readonly<Record<string, unknown>>) => string;
+export declare function plural(valueParameter: string, forms: PluralForms, numberParameters?: readonly string[]): PluralMessageDescriptor;
+export declare function selectPlural(valueParameter: string, selectParameter: string, cases: Readonly<Record<string, PluralForms>>, numberParameters?: readonly string[]): SelectPluralMessageDescriptor;
+export declare function createMessageTranslator<Catalog extends MessageCatalog>(locale: string, catalog: Catalog & ValidCatalog<Catalog>, options?: {
+    formatNumber?: (value: number, locale: string) => string;
+}): MessageTranslator<Catalog>;

package/dist/message-catalog.mjs

@@ -0,0 +1,88 @@
+import { assertCatalog, isCatalogRecord, isMessageDescriptor, } from './message-catalog-validation.mjs';
+export { isCatalogRecord, isMessageDescriptor } from './message-catalog-validation.mjs';
+const pluralRules = new Map();
+export function plural(valueParameter, forms, numberParameters) {
+    const descriptor = {
+        kind: 'plural',
+        valueParameter,
+        ...(numberParameters && { numberParameters }),
+        forms,
+    };
+    if (!isMessageDescriptor(descriptor))
+        throw new TypeError('Invalid plural message descriptor');
+    return descriptor;
+}
+export function selectPlural(valueParameter, selectParameter, cases, numberParameters) {
+    const descriptor = {
+        kind: 'select-plural',
+        valueParameter,
+        selectParameter,
+        ...(numberParameters && { numberParameters }),
+        cases,
+    };
+    if (!isMessageDescriptor(descriptor))
+        throw new TypeError('Invalid select-plural message descriptor');
+    return descriptor;
+}
+export function createMessageTranslator(locale, catalog, options = {}) {
+    assertCatalog(catalog);
+    return (key, parameters = {}) => {
+        const leaf = resolve(catalog, key);
+        if (typeof leaf === 'string')
+            return interpolate(leaf, parameters);
+        if (!isMessageDescriptor(leaf))
+            throw new Error(`Message key "${key}" resolves to a non-leaf value`);
+        const numeric = readNumericParameters(leaf, parameters);
+        const forms = leaf.kind === 'plural' ? leaf.forms : selectForms(leaf, parameters);
+        const category = getPluralRules(locale).select(numeric.get(leaf.valueParameter));
+        const template = Object.hasOwn(forms, category) ? forms[category] : forms.other;
+        const formatted = { ...parameters };
+        for (const parameter of leaf.numberParameters ?? [])
+            formatted[parameter] =
+                options.formatNumber?.(numeric.get(parameter), locale) ?? String(numeric.get(parameter));
+        return interpolate(template, formatted);
+    };
+}
+function resolve(catalog, key) {
+    let value = catalog;
+    for (const segment of key.split('.')) {
+        if (!isCatalogRecord(value) || !Object.hasOwn(value, segment))
+            throw new Error(`Unresolvable message key "${key}" at "${segment}"`);
+        value = value[segment];
+    }
+    return value;
+}
+function readNumericParameters(descriptor, parameters) {
+    const numeric = new Map();
+    for (const parameter of new Set([
+        descriptor.valueParameter,
+        ...(descriptor.numberParameters ?? []),
+    ])) {
+        const value = parameters[parameter];
+        if (!Object.hasOwn(parameters, parameter) ||
+            typeof value !== 'number' ||
+            !Number.isFinite(value))
+            throw new TypeError(`Message parameter "${parameter}" must be a finite number`);
+        numeric.set(parameter, value);
+    }
+    return numeric;
+}
+function selectForms(descriptor, parameters) {
+    if (!Object.hasOwn(parameters, descriptor.selectParameter))
+        throw new TypeError(`Message parameter "${descriptor.selectParameter}" must be present`);
+    const selected = String(parameters[descriptor.selectParameter]);
+    if (!Object.hasOwn(descriptor.cases, selected))
+        throw new Error(`Unknown select-plural case "${selected}" for "${descriptor.selectParameter}"`);
+    return descriptor.cases[selected];
+}
+function interpolate(template, parameters) {
+    return template.replace(/\{([\w.-]+)\}/g, (match, name) => Object.hasOwn(parameters, name) ? String(parameters[name]) : match);
+}
+function getPluralRules(locale) {
+    const cached = pluralRules.get(locale);
+    if (cached)
+        return cached;
+    const rules = new Intl.PluralRules(locale);
+    pluralRules.set(locale, rules);
+    return rules;
+}

package/dist/urls.d.mts

@@ -7,3 +7,5 @@ export declare function normalizeAsciiHostname(value: string): string | null;
 export declare function extractUrlHostname(value: string): string | null;
 export declare function getFirstPathSegment(pathname: string): string | null;
 export declare function matchesPathnamePattern(pathname: string, pattern: string): boolean;
+/** Matches an ASCII hostname against exact patterns or an inclusive `*.` suffix pattern. */
+export declare function matchesHostnamePattern(hostname: string, patterns: string | readonly string[]): boolean;

package/dist/urls.mjs

@@ -91,3 +91,16 @@ export function matchesPathnamePattern(pathname, pattern) {
         patternIndex++;
     return patternIndex === pattern.length;
 }
+/** Matches an ASCII hostname against exact patterns or an inclusive `*.` suffix pattern. */
+export function matchesHostnamePattern(hostname, patterns) {
+    const candidate = hostname.toLowerCase();
+    for (const configuredPattern of typeof patterns === 'string' ? [patterns] : patterns) {
+        const pattern = configuredPattern.toLowerCase();
+        if (pattern === candidate)
+            return true;
+        if (pattern.startsWith('*.') &&
+            (candidate === pattern.slice(2) || candidate.endsWith(pattern.slice(1))))
+            return true;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vouchington/utils",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Dependency-free runtime utilities for Vouchington-style applications.",
   "homepage": "https://github.com/vouchington/vouchington-platform/tree/main/packages/utils#readme",
   "bugs": {
@@ -60,6 +60,11 @@
       "import": "./dist/collections.mjs",
       "default": "./dist/collections.mjs"
     },
+    "./feature-flags": {
+      "types": "./dist/feature-flags.d.mts",
+      "import": "./dist/feature-flags.mjs",
+      "default": "./dist/feature-flags.mjs"
+    },
     "./dates": {
       "types": "./dist/dates.d.mts",
       "import": "./dist/dates.mjs",
@@ -110,6 +115,16 @@
       "import": "./dist/urls.mjs",
       "default": "./dist/urls.mjs"
     },
+    "./language-tags": {
+      "types": "./dist/language-tags.d.mts",
+      "import": "./dist/language-tags.mjs",
+      "default": "./dist/language-tags.mjs"
+    },
+    "./message-catalog": {
+      "types": "./dist/message-catalog.d.mts",
+      "import": "./dist/message-catalog.mjs",
+      "default": "./dist/message-catalog.mjs"
+    },
     "./validation": {
       "types": "./dist/validation.d.mts",
       "import": "./dist/validation.mjs",