locon 1.5.1 → 1.6.1

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+## 1.6.1
+
+### Added
+
+- `L` and `LProps` from `locon/react`: localized source-language text without
+  extra DOM elements, including use inside SVG `<text>`.
+- `L` supports interpolation, CLDR plurals, per-call locale overrides, fallback,
+  and optional `assetKey` disambiguation. React escapes the translated text.
+- The asset checker recognizes `<L>` alongside `<LText>`, including static
+  string-expression children used with placeholders.
+
+### Documentation
+
+- Source-phrase examples for React web and Node; phrase-indexed JSON examples
+  preserve lazy loading without preloading the source locale.
+- Updated website examples and release instructions for 1.6.1.
+
+## 1.6.0
+
+### Added
+
+- `locon/core`: React-free and React Native-free ESM/CommonJS entry for Node and
+  plain TypeScript, exporting `createTranslator`, `intlLocale`, `createLocon`
+  and `matchLocale` with types.
+- `locon/react`: React 19+ adapter with `LoconProvider` and `useLocon`, without
+  importing React Native.
+- Lazy per-locale resource loaders, JSON-module support, successful-load cache,
+  parallel request deduplication and ordered locale preference matching.
+- Async locale switching with last-selection-wins behavior, loading/error state,
+  preservation of the current locale on failure and retry support.
+
+### Compatibility
+
+- The existing `locon` React Native entry, provider, hook and `LText` API remain
+  available. Native device language detection and RTL behavior are unchanged.
+- React and React Native peers are optional at package installation time; each
+  adapter still requires its runtime. Node core needs neither framework.
+- Lazy lookups use only already loaded resources for fallback. Prefer stable
+  keys when the source-language resource has not been loaded. Source-phrase
+  reverse lookup continues to work when that resource is available.
+- Clean the output directory once before building all entries to avoid parallel
+  builds removing each other's output.
+
+### Verification
+
+- Existing native tests and built-entry smoke tests are retained.
+- Added coverage for lazy loads, caching, concurrent switching, failed load
+  retry, platform-free Node imports and React updates after resource loading.

package/README.md

@@ -6,9 +6,19 @@
 
 [Website](https://locon.dev) · [npm](https://www.npmjs.com/package/locon) · [GitHub](https://github.com/loconapp/locon)
 
-`locon` is a small, typed i18n helper for React Native.  
-It provides a context provider, a hook, and a simple text component to keep
-your translations flat, explicit, and easy to use.
+`locon` is a small, typed localization library for **React Native, React and Node**.
+Keep flat JSON resources, translate with interpolation and CLDR plurals, and
+load browser languages only when they are selected.
+
+| Runtime | Import | Resources |
+| --- | --- | --- |
+| React Native / Expo | `locon` | Existing provider, hook and `<LText>` API |
+| React web (React 19+) | `locon/react` | Async loaders, provider and reactive hook |
+| Node / plain TypeScript | `locon/core` | Standalone translator and lazy resource store |
+
+**New in 1.6.1:** the React web `<L>` component. Version 1.6 introduced platform-specific entries and lazy resources. See
+[React (web), Node and lazy resources](#react-web-node-and-lazy-resources).
+The existing React Native entry remains compatible.
 
 Basic usage: use `<LText>` instead of `<Text>`. Put plain text in your project language (or the default language) inside and it will be localized automatically.
 
@@ -24,7 +34,9 @@ function Example() {
 
 ### Features
 
-- **React Native–first**: tiny API, no global singletons
+- **React Native–first**: existing native API, plus independent React web and Node entries
+- **Lazy locale resources** for web: load the selected language, cache successful loads, deduplicate parallel requests
+- **Safe async switching**: the last selection wins; a failed load preserves the current language
 - **Expo-ready**: detects the device language through `expo-localization`, no native linking
 - **Context provider** with pluggable assets (per-locale JSON)
 - **Device language auto-detection** (optional)
@@ -54,7 +66,13 @@ yarn add locon
 bun add locon
 ```
 
-**Peer dependencies**
+**Peer dependencies by entry**
+
+`locon/core` requires neither React nor React Native. `locon/react` requires
+React 19+; add `react-dom` to your web application as usual. The package marks
+React and React Native peers optional so Node users do not install them.
+
+For the existing React Native entry, your app supplies:
 
 - `react >= 19.0.0`
 - `react-native >= 0.70.0`
@@ -448,7 +466,7 @@ no React tree: generating a PDF or spreadsheet, composing an e-mail, or
 building a notification from a background task.
 
 ```ts
-import { createTranslator } from 'locon'
+import { createTranslator } from 'locon/core'
 import de from './assets/i18n/de.json'
 import tr from './assets/i18n/tr.json'
 
@@ -465,9 +483,13 @@ l('Arbeitszeit') // → 'Çalışma süresi'
 This is what lets an app export a report in a language the interface is not
 currently in — a user browsing in German can still produce a Turkish report.
 
-#### `resolveLocale()` — the provider's locale precedence
+#### `resolveLocale()` — the native provider's locale precedence
 
-`createTranslator()` needs a locale, and outside React nothing has picked one
+`resolveLocale()` is a helper for the native entry. In Node and React web, use
+`matchLocale(preferences, supportedLocales, defaultLocale)` from `locon/core`
+instead, or pass `languages` to `createLocon`.
+
+`createTranslator()` needs a locale, and outside a provider nothing has picked one
 for you. `resolveLocale()` answers that question with the exact precedence
 `<Locon />` uses internally: an explicit choice, else the device language, else
 the default.
@@ -745,8 +767,13 @@ raw text inside `<LText>`.
 
 The published package contains:
 
-- `dist/index.js` — one bundled CommonJS file
-- `dist/index.d.ts` — types
+- `dist/index.js`, `dist/index.d.ts` — the existing bundled CommonJS native entry
+- `dist/react.js`, `dist/react.mjs`, and declarations — React web, CommonJS and ESM
+- `dist/core.js`, `dist/core.mjs`, and declarations — Node/plain TypeScript, CommonJS and ESM
+
+Use package entry names (`locon`, `locon/react`, `locon/core`) instead of importing
+`dist` files directly. The entry-specific exports keep native dependencies out
+of browser and server bundles.
 
 So you can import from `locon` in both JS and TS projects and get type support
 for every export. Public component/configuration types are importable too:
@@ -765,7 +792,7 @@ import type {
 } from 'locon'
 ```
 
-The build is deliberately **CommonJS only, and bundled**. Metro finds optional
+The **React Native entry** is deliberately CommonJS only and bundled. Metro finds optional
 dependencies by statically reading literal `require()` calls, and esbuild
 rewrites those into its own shim when emitting ESM — so an ESM build registered
 nothing and even `react-native` failed to resolve at runtime. Bundling matters
@@ -773,11 +800,87 @@ for the same reason: an unbundled tree emitted extensionless relative imports,
 which Node resolves to `.js` but Metro tries `.mjs` for first, loading the
 library twice. Two instances mean two contexts — the provider fills one, every
 `useLocon()` reads the other, and consumers get untranslated screens with no
-error at all. Metro consumes CJS natively, so a second format buys a React
-Native library nothing.
+error at all. Metro consumes CJS natively. React web and Node have their own
+independent ESM/CommonJS entries.
 
 ---
 
+### React (web), Node and lazy resources
+
+The existing `locon` entry remains the React Native API. Use `locon/react` in
+React web apps and `locon/core` in Node. These entries never import React Native;
+`locon/core` does not import React either. React 19+ is required by the adapter.
+
+```tsx
+import { createLocon, LoconProvider, useLocon } from 'locon/react'
+
+const i18n = createLocon({
+  defaultLocale: 'en',
+  languages: navigator.languages,
+  loaders: {
+    en: () => import('./locales/en.json'),
+    de: () => import('./locales/de.json'),
+  },
+})
+await i18n.setLocale(null) // load just the browser language, before mounting
+// <LoconProvider instance={i18n}><App /></LoconProvider>
+// const { l, currentLocale, loading, error, setLocale } = useLocon()
+// await setLocale('de') // fetch once; successful resources stay cached
+```
+
+`setLocale` resolves `true` when that selection was applied, `false` when a later
+selection won. Failed loads reject, preserve the displayed language and can be
+retried. Parallel loads are deduplicated. Catch rejections in event handlers and
+offer a retry. Local storage and document `lang` remain application decisions.
+Only already loaded resources participate in per-key fallback: the store never
+silently downloads every fallback language. Write source-language text in code.
+For lazy apps, use the source phrases as JSON keys so translating them does not
+require downloading the source locale first:
+
+```json
+// en.json
+{ "Überraschung öffnen": "Open your surprise" }
+```
+
+```json
+// de.json
+{ "Überraschung öffnen": "Überraschung öffnen" }
+```
+
+Set `projectLocale: 'de'` for German source strings. Reverse lookup against
+separate technical keys still needs the source resource loaded.
+
+#### Localized React text (`L`, 1.6.1+)
+
+```tsx
+import { L, useLocon } from 'locon/react'
+
+function Card({ name }: { name: string }) {
+  const { l } = useLocon()
+  return <>
+    <button><L>Überraschung öffnen</L></button>
+    <h2><L params={{ name }}>{'Buh, {name}!'}</L></h2>
+    <input placeholder={l('Name eingeben')} />
+  </>
+}
+```
+
+`L` renders a text fragment without a wrapping span. Use it inside HTML or SVG
+text elements. It updates when the provider's locale changes. Pass one source
+string as children; put dynamic values in `params` instead of JSX concatenation
+or nested markup. `count`, `locale`, and `fallback` have the same meaning as in
+`l()`. An optional `assetKey` can disambiguate identical source phrases; missing
+translations fall back to the children unless `fallback` is explicitly set.
+Keep `l()` for string props, document metadata, and other non-rendered values.
+The existing React Native `LText` API is unchanged.
+
+In Node, create an instance per request, pass the request's language preferences
+explicitly, and await `setLocale` before rendering. For resources already loaded
+in memory, use `createTranslator({ assets, locale })` from `locon/core` directly.
+On SSR, use a separate instance per request and hydrate with the same preloaded
+resources/locale; never share a mutable locale store between requests.
+
+
 ### License
 
 `locon` is released under the **ISC** license.

package/dist/core.d.mts

@@ -0,0 +1,46 @@
+import { T as TranslateOptions } from './resources-BwFIzg3m.mjs';
+export { L as LocaleSnapshot, a as LoconInstance, R as ResourceLoader, b as ResourceOptions, c as createLocon, m as matchLocale } from './resources-BwFIzg3m.mjs';
+
+type Assets = Record<string, Record<string, string>>;
+
+/**
+ * The resolver behind `l()`, usable without React.
+ *
+ * The provider builds one of these per render; export pipelines (PDF, XLSX,
+ * e-mail) build their own with an explicit locale, so a document can be
+ * produced in a language the interface is not currently showing.
+ */
+
+interface TranslatorConfig {
+    assets: Assets;
+    locale: string;
+    defaultLocale?: string;
+    projectLocale?: string;
+}
+type Translator = (assetKey: string, options?: TranslateOptions) => string;
+declare function createTranslator({ assets, locale, defaultLocale, projectLocale }: TranslatorConfig): Translator;
+
+/**
+ * Builds a BCP-47 tag carrying Unicode extensions, for handing to `Intl`.
+ *
+ * `locon` has no opinion on which calendar or numbering system your app
+ * should use — a Persian journal app wants Jalali dates, a Persian payroll
+ * export usually does not. That is a product decision. What the library can
+ * do is get the tag syntax right, which naive concatenation does not:
+ * appending `-u-ca-gregory` to a locale that already reads `de-u-nu-latn`
+ * yields a tag with two `-u-` singletons, and `Intl` throws on it.
+ */
+interface IntlExtensions {
+    /** Calendar system, e.g. `gregory`, `islamic`, `persian`. */
+    calendar?: string;
+    /** Numbering system, e.g. `latn`, `arab`, `deva`. */
+    numbering?: string;
+}
+/**
+ * Returns `locale` with the given Unicode extensions applied, merging into an
+ * existing `-u-` section rather than adding a second one. Keys already present
+ * in the tag are left alone, so an explicit choice by the caller wins.
+ */
+declare function intlLocale(locale: string, extensions?: IntlExtensions): string;
+
+export { type Assets, TranslateOptions, type Translator, type TranslatorConfig, createTranslator, intlLocale };

package/dist/core.d.ts

@@ -0,0 +1,46 @@
+import { T as TranslateOptions } from './resources-BwFIzg3m.js';
+export { L as LocaleSnapshot, a as LoconInstance, R as ResourceLoader, b as ResourceOptions, c as createLocon, m as matchLocale } from './resources-BwFIzg3m.js';
+
+type Assets = Record<string, Record<string, string>>;
+
+/**
+ * The resolver behind `l()`, usable without React.
+ *
+ * The provider builds one of these per render; export pipelines (PDF, XLSX,
+ * e-mail) build their own with an explicit locale, so a document can be
+ * produced in a language the interface is not currently showing.
+ */
+
+interface TranslatorConfig {
+    assets: Assets;
+    locale: string;
+    defaultLocale?: string;
+    projectLocale?: string;
+}
+type Translator = (assetKey: string, options?: TranslateOptions) => string;
+declare function createTranslator({ assets, locale, defaultLocale, projectLocale }: TranslatorConfig): Translator;
+
+/**
+ * Builds a BCP-47 tag carrying Unicode extensions, for handing to `Intl`.
+ *
+ * `locon` has no opinion on which calendar or numbering system your app
+ * should use — a Persian journal app wants Jalali dates, a Persian payroll
+ * export usually does not. That is a product decision. What the library can
+ * do is get the tag syntax right, which naive concatenation does not:
+ * appending `-u-ca-gregory` to a locale that already reads `de-u-nu-latn`
+ * yields a tag with two `-u-` singletons, and `Intl` throws on it.
+ */
+interface IntlExtensions {
+    /** Calendar system, e.g. `gregory`, `islamic`, `persian`. */
+    calendar?: string;
+    /** Numbering system, e.g. `latn`, `arab`, `deva`. */
+    numbering?: string;
+}
+/**
+ * Returns `locale` with the given Unicode extensions applied, merging into an
+ * existing `-u-` section rather than adding a second one. Keys already present
+ * in the tag are left alone, so an explicit choice by the caller wins.
+ */
+declare function intlLocale(locale: string, extensions?: IntlExtensions): string;
+
+export { type Assets, TranslateOptions, type Translator, type TranslatorConfig, createTranslator, intlLocale };

package/dist/core.js

@@ -0,0 +1,352 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  createLocon: () => createLocon,
+  createTranslator: () => createTranslator_default,
+  intlLocale: () => intlLocale_default,
+  matchLocale: () => matchLocale
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/locon/utils/pluralCategory.ts
+var between = (x, from, to) => x >= from && x <= to;
+var oneIfIntegerOne = ({ i, v }) => i === 1 && v === 0 ? "one" : "other";
+var oneIfOne = ({ n }) => n === 1 ? "one" : "other";
+var oneIfZeroOrOne = ({ i }) => i === 0 || i === 1 ? "one" : "other";
+var onlyOther = () => "other";
+var eastSlavic = ({ i, v }) => {
+  if (v !== 0) return "other";
+  if (i % 10 === 1 && i % 100 !== 11) return "one";
+  if (between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+  return "many";
+};
+var southSlavic = ({ i, v }) => {
+  if (v === 0 && i % 10 === 1 && i % 100 !== 11) return "one";
+  if (v === 0 && between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+  return "other";
+};
+var westSlavic = ({ i, v }) => {
+  if (i === 1 && v === 0) return "one";
+  if (between(i, 2, 4) && v === 0) return "few";
+  return v !== 0 ? "many" : "other";
+};
+var RULES = {
+  ru: eastSlavic,
+  uk: eastSlavic,
+  be: eastSlavic,
+  pl: ({ i, v }) => {
+    if (v !== 0) return "other";
+    if (i === 1) return "one";
+    if (between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+    return "many";
+  },
+  cs: westSlavic,
+  sk: westSlavic,
+  hr: southSlavic,
+  sr: southSlavic,
+  bs: southSlavic,
+  sl: ({ i, v }) => {
+    if (v !== 0) return "few";
+    if (i % 100 === 1) return "one";
+    if (i % 100 === 2) return "two";
+    if (between(i % 100, 3, 4)) return "few";
+    return "other";
+  },
+  lt: ({ n, v }) => {
+    if (v !== 0) return "many";
+    if (n % 10 === 1 && !between(n % 100, 11, 19)) return "one";
+    if (between(n % 10, 2, 9) && !between(n % 100, 11, 19)) return "few";
+    return "other";
+  },
+  lv: ({ n, v }) => {
+    if (v === 0 && (n % 10 === 0 || between(n % 100, 11, 19))) return "zero";
+    if (v === 0 && n % 10 === 1 && n % 100 !== 11) return "one";
+    return "other";
+  },
+  ro: ({ n, i, v }) => {
+    if (i === 1 && v === 0) return "one";
+    if (v !== 0 || n === 0 || n !== 1 && between(n % 100, 1, 19)) return "few";
+    return "other";
+  },
+  ar: ({ n, v }) => {
+    if (v !== 0) return "other";
+    if (n === 0) return "zero";
+    if (n === 1) return "one";
+    if (n === 2) return "two";
+    if (between(n % 100, 3, 10)) return "few";
+    if (between(n % 100, 11, 99)) return "many";
+    return "other";
+  },
+  he: ({ i, v }) => {
+    if (i === 1 && v === 0 || i === 0 && v !== 0) return "one";
+    if (i === 2 && v === 0) return "two";
+    return "other";
+  },
+  ga: ({ n, v }) => {
+    if (v !== 0) return "other";
+    if (n === 1) return "one";
+    if (n === 2) return "two";
+    if (between(n, 3, 6)) return "few";
+    if (between(n, 7, 10)) return "many";
+    return "other";
+  },
+  fr: oneIfZeroOrOne,
+  pt: oneIfZeroOrOne,
+  hi: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  bn: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  fa: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  es: oneIfOne,
+  tr: oneIfOne,
+  el: oneIfOne,
+  hu: oneIfOne,
+  ka: oneIfOne,
+  kk: oneIfOne,
+  az: oneIfOne,
+  uz: oneIfOne,
+  bg: oneIfOne,
+  sq: oneIfOne,
+  ja: onlyOther,
+  zh: onlyOther,
+  ko: onlyOther,
+  vi: onlyOther,
+  th: onlyOther,
+  id: onlyOther,
+  ms: onlyOther,
+  my: onlyOther,
+  km: onlyOther,
+  lo: onlyOther
+};
+function operands(count) {
+  const n = Math.abs(count);
+  const fraction = String(n).split(".")[1] ?? "";
+  return { n, i: Math.floor(n), v: fraction.length };
+}
+function fallbackCategory(count, tag) {
+  const language = tag.split("-")[0]?.toLowerCase() ?? "";
+  const rule = RULES[language] ?? oneIfIntegerOne;
+  return rule(operands(count));
+}
+function pluralCategory(count, locale) {
+  const tag = locale.replace(/_/g, "-");
+  if (typeof Intl !== "undefined" && typeof Intl.PluralRules === "function") {
+    try {
+      return new Intl.PluralRules(tag).select(count);
+    } catch {
+    }
+  }
+  return fallbackCategory(count, tag);
+}
+
+// src/locon/utils/createTranslator.ts
+var reverseIndexCache = /* @__PURE__ */ new WeakMap();
+function getReverseIndex(assets, locale) {
+  let perLocale = reverseIndexCache.get(assets);
+  if (!perLocale) {
+    perLocale = /* @__PURE__ */ new Map();
+    reverseIndexCache.set(assets, perLocale);
+  }
+  const cached = perLocale.get(locale);
+  if (cached) {
+    return cached;
+  }
+  const index = /* @__PURE__ */ new Map();
+  const localeAssets = assets[locale];
+  if (localeAssets) {
+    for (const key of Object.keys(localeAssets)) {
+      const value = localeAssets[key];
+      if (value !== void 0 && !index.has(value)) {
+        index.set(value, key);
+      }
+    }
+  }
+  perLocale.set(locale, index);
+  return index;
+}
+function interpolate(value, params) {
+  if (!params) {
+    return value;
+  }
+  return value.replace(
+    /\{(\w+)\}/g,
+    (match, token) => params[token] === void 0 ? match : String(params[token])
+  );
+}
+var PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
+function createTranslator({ assets, locale, defaultLocale = "en", projectLocale }) {
+  const resolvedProjectLocale = projectLocale || defaultLocale;
+  const read = (fromLocale, key) => {
+    const value = assets[fromLocale]?.[key];
+    return value === void 0 || value === "" ? void 0 : value;
+  };
+  const keyFor = (input, targetLocale) => {
+    if (assets[targetLocale]?.[input] !== void 0 || assets[defaultLocale]?.[input] !== void 0 || assets[resolvedProjectLocale]?.[input] !== void 0) {
+      return input;
+    }
+    return getReverseIndex(assets, resolvedProjectLocale).get(input) ?? getReverseIndex(assets, defaultLocale).get(input) ?? input;
+  };
+  return function l(assetKey, options) {
+    if (!assetKey) {
+      return "";
+    }
+    const targetLocale = options?.locale || locale;
+    const resolvedKey = keyFor(assetKey, targetLocale);
+    const key = options?.count === void 0 ? resolvedKey : resolvedKey.replace(PLURAL_SUFFIX, "");
+    const params = options?.count === void 0 ? options?.params : { ...options.params, count: options.count };
+    for (const candidateLocale of [targetLocale, defaultLocale, resolvedProjectLocale]) {
+      const candidateKeys = options?.count === void 0 ? [key] : [`${key}_${pluralCategory(options.count, candidateLocale)}`, `${key}_other`, key];
+      for (const candidateKey of candidateKeys) {
+        const value = read(candidateLocale, candidateKey);
+        if (value !== void 0) {
+          return interpolate(value, params);
+        }
+      }
+    }
+    return interpolate(options?.fallback ?? assetKey, params);
+  };
+}
+var createTranslator_default = createTranslator;
+
+// src/locon/utils/intlLocale.ts
+function intlLocale(locale, extensions = {}) {
+  const normalizedLocale = locale.replace(/_/g, "-");
+  const requested = [];
+  if (extensions.calendar) {
+    requested.push(["ca", extensions.calendar]);
+  }
+  if (extensions.numbering) {
+    requested.push(["nu", extensions.numbering]);
+  }
+  if (!requested.length) {
+    return normalizedLocale;
+  }
+  const subtags = normalizedLocale.split("-");
+  const isSingleton = (subtag) => subtag.length === 1;
+  const privateUseIndex = subtags.findIndex((subtag, index) => index > 0 && subtag.toLowerCase() === "x");
+  const unicodeIndex = subtags.findIndex(
+    (subtag, index) => index > 0 && (privateUseIndex < 0 || index < privateUseIndex) && subtag.toLowerCase() === "u"
+  );
+  if (unicodeIndex >= 0) {
+    const nextSingleton = subtags.findIndex((subtag, index) => index > unicodeIndex && isSingleton(subtag));
+    const unicodeEnd = nextSingleton < 0 ? subtags.length : nextSingleton;
+    const existingKeys = new Set(
+      subtags.slice(unicodeIndex + 1, unicodeEnd).filter((subtag) => subtag.length === 2).map((subtag) => subtag.toLowerCase())
+    );
+    const additions = requested.flatMap(([key, value]) => existingKeys.has(key) ? [] : [key, value]);
+    if (!additions.length) {
+      return normalizedLocale;
+    }
+    subtags.splice(unicodeEnd, 0, ...additions);
+    return subtags.join("-");
+  }
+  const insertionIndex = privateUseIndex < 0 ? subtags.length : privateUseIndex;
+  subtags.splice(insertionIndex, 0, "u", ...requested.flat());
+  return subtags.join("-");
+}
+var intlLocale_default = intlLocale;
+
+// src/core/resources.ts
+var normalized = (value) => value.replace(/_/g, "-").toLowerCase();
+function matchLocale(languages, supported, fallback) {
+  for (const language of languages) {
+    let candidate = normalized(language);
+    while (candidate) {
+      const exact = supported.find((locale) => normalized(locale) === candidate);
+      if (exact) return exact;
+      const next = candidate.lastIndexOf("-");
+      if (next < 0) break;
+      candidate = candidate.slice(0, next);
+    }
+    const base = normalized(language).split("-")[0];
+    const variant = supported.find((locale) => normalized(locale).split("-")[0] === base);
+    if (variant) return variant;
+  }
+  return fallback;
+}
+function createLocon(options) {
+  const locales = Object.keys(options.loaders);
+  if (!locales.includes(options.defaultLocale)) throw new Error("[locon] defaultLocale needs a loader");
+  const initial = matchLocale(options.locale ? [options.locale] : options.languages ?? [], locales, options.defaultLocale);
+  let snapshot = { currentLocale: initial, loading: false, ready: false, error: null };
+  let assets = {};
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let selection = 0;
+  const notify = (next) => {
+    snapshot = next;
+    listeners.forEach((listener) => listener());
+  };
+  async function loadLocale(locale) {
+    if (!locales.includes(locale)) throw new Error(`[locon] Unsupported locale: ${locale}`);
+    if (assets[locale]) return assets[locale];
+    let request = pending.get(locale);
+    if (!request) {
+      request = Promise.resolve().then(options.loaders[locale]).then((module2) => {
+        const resource = typeof module2.default === "object" ? module2.default : module2;
+        if (!resource || typeof resource !== "object" || Array.isArray(resource) || Object.values(resource).some((value) => typeof value !== "string")) {
+          throw new Error(`[locon] Invalid resources: ${locale}`);
+        }
+        assets = { ...assets, [locale]: { ...resource } };
+        return assets[locale];
+      }).finally(() => pending.delete(locale));
+      pending.set(locale, request);
+    }
+    return request;
+  }
+  async function setLocale(locale) {
+    const target = locale === null ? matchLocale(options.languages ?? [], locales, options.defaultLocale) : locale;
+    if (!locales.includes(target)) throw new Error(`[locon] Unsupported locale: ${target}`);
+    const version = ++selection;
+    notify({ ...snapshot, loading: true, error: null });
+    try {
+      await loadLocale(target);
+      if (version !== selection) return false;
+      notify({ currentLocale: target, loading: false, ready: true, error: null });
+      return true;
+    } catch (cause) {
+      if (version === selection) notify({ ...snapshot, loading: false, error: cause instanceof Error ? cause : new Error("[locon] Loading failed") });
+      throw cause;
+    }
+  }
+  function l(key, translateOptions) {
+    return createTranslator_default({ assets, locale: snapshot.currentLocale, defaultLocale: options.defaultLocale, projectLocale: options.projectLocale })(key, translateOptions);
+  }
+  return {
+    locales,
+    l,
+    loadLocale,
+    setLocale,
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLocon,
+  createTranslator,
+  intlLocale,
+  matchLocale
+});