@genrwork/laravel-i18next 0.1.0 → 0.1.1

package/dist/shared/{create-i18n-BSEwKsCX.mjs → create-i18n-DaZzs1DJ.mjs}

@@ -1,4 +1,24 @@
 import i18next from 'i18next';
+import { g as getDeclaredNamespaces, t as trackInstance } from './demand-6YnTqSM4.mjs';
+
+/**
+ * The modules lazy loaders (`import.meta.glob()` functions) have already
+ * resolved, keyed by the loader itself. Loading a language file is the one
+ * asynchronous step of translating; once a loader has been awaited, its
+ * module never changes, so every later read of it can be synchronous. That is
+ * what lets `preloadI18n()` load translations during page resolution --
+ * before anything renders -- and lets `createI18n()` and the backend read
+ * them without waiting, so a render never has to suspend.
+ *
+ * Module scoped on purpose, so it is shared by every i18next instance of the
+ * process: a server keeps one copy of each catalog across requests.
+ */ const modules = new WeakMap();
+function getCachedModule(loader) {
+    return modules.get(loader);
+}
+function setCachedModule(loader, module) {
+    modules.set(loader, module);
+}
 
 /**
  * Normalize a `LocaleFileSources` (a single `LocaleFiles` map, or an ordered
@@ -136,6 +156,9 @@ import i18next from 'i18next';
  * module; eager files (`import.meta.glob(..., { eager: true })`) resolve to a
  * module directly; a plain object (hand-built maps, tests) is wrapped as a
  * module's `default`.
+ *
+ * A loader that was awaited before resolves to its module directly, from the
+ * cache (see `src/utils/cache.ts`): reading it is synchronous from then on.
  */ function toModule(entry) {
     const type = Object.prototype.toString.call(entry);
     if (type === '[object Promise]' || type === '[object Module]') {
@@ -146,8 +169,14 @@ import i18next from 'i18next';
             default: entry
         };
     }
-    if (type === '[object Function]') {
-        return entry();
+    if (typeof entry === 'function') {
+        const loader = entry;
+        const cached = getCachedModule(loader);
+        if (cached) return cached;
+        return Promise.resolve(loader()).then((module)=>{
+            setCachedModule(loader, module);
+            return module;
+        });
     }
     return undefined;
 }
@@ -242,335 +271,36 @@ function isPromiseLike(value) {
 }
 LaravelBackend.type = 'backend';
 
-/* eslint-disable */ /**
- * Get the index to use for pluralization.
- * The plural rules are derived from code of the Zend Framework.
- *
- * @category    Zend
- * @package     Zend_Locale
- * @public      https://github.com/zendframework/zf1/blob/master/library/Zend/Translate/Plural.php
- * @copyright   2005-2015 Zend Technologies USA Inc. http://www.zend.com
- * @license     http://framework.zend.com/license     New BSD License
- *
- * @param  {String}  locale
- * @param  {Number}  number
- * @return {Number}
- */ function getPluralIndex(locale, number) {
-    locale = locale.replace('-', '_');
-    if (locale === 'pt_BR') {
-        // temporary set a locale for brazilian
-        locale = 'xbr';
-    }
-    if (locale.length > 3) {
-        locale = locale.substring(0, locale.lastIndexOf('_'));
-    }
-    switch(locale){
-        case 'az':
-        case 'bo':
-        case 'dz':
-        case 'id':
-        case 'ja':
-        case 'jv':
-        case 'ka':
-        case 'km':
-        case 'kn':
-        case 'ko':
-        case 'ms':
-        case 'th':
-        case 'tr':
-        case 'vi':
-        case 'zh':
-            return 0;
-        case 'af':
-        case 'bn':
-        case 'bg':
-        case 'ca':
-        case 'da':
-        case 'de':
-        case 'el':
-        case 'en':
-        case 'eo':
-        case 'es':
-        case 'et':
-        case 'eu':
-        case 'fa':
-        case 'fi':
-        case 'fo':
-        case 'fur':
-        case 'fy':
-        case 'gl':
-        case 'gu':
-        case 'ha':
-        case 'he':
-        case 'hu':
-        case 'is':
-        case 'it':
-        case 'ku':
-        case 'lb':
-        case 'ml':
-        case 'mn':
-        case 'mr':
-        case 'nah':
-        case 'nb':
-        case 'ne':
-        case 'nl':
-        case 'nn':
-        case 'no':
-        case 'om':
-        case 'or':
-        case 'pa':
-        case 'pap':
-        case 'ps':
-        case 'pt':
-        case 'so':
-        case 'sq':
-        case 'sv':
-        case 'sw':
-        case 'ta':
-        case 'te':
-        case 'tk':
-        case 'ur':
-        case 'zu':
-            return number === 1 ? 0 : 1;
-        case 'am':
-        case 'bh':
-        case 'fil':
-        case 'fr':
-        case 'gun':
-        case 'hi':
-        case 'ln':
-        case 'mg':
-        case 'nso':
-        case 'xbr':
-        case 'ti':
-        case 'wa':
-            return number === 0 || number === 1 ? 0 : 1;
-        case 'be':
-        case 'bs':
-        case 'hr':
-        case 'ru':
-        case 'sr':
-        case 'uk':
-            return number % 10 === 1 && number % 100 !== 11 ? 0 : number % 10 >= 2 && number % 10 <= 4 && (number % 100 < 10 || number % 100 >= 20) ? 1 : 2;
-        case 'cs':
-        case 'sk':
-            return number === 1 ? 0 : number >= 2 && number <= 4 ? 1 : 2;
-        case 'ga':
-            return number === 1 ? 0 : number === 2 ? 1 : 2;
-        case 'lt':
-            return number % 10 === 1 && number % 100 !== 11 ? 0 : number % 10 >= 2 && (number % 100 < 10 || number % 100 >= 20) ? 1 : 2;
-        case 'sl':
-            return number % 100 === 1 ? 0 : number % 100 === 2 ? 1 : number % 100 === 3 || number % 100 === 4 ? 2 : 3;
-        case 'mk':
-            return number % 10 === 1 ? 0 : 1;
-        case 'mt':
-            return number === 1 ? 0 : number === 0 || number % 100 > 1 && number % 100 < 11 ? 1 : number % 100 > 10 && number % 100 < 20 ? 2 : 3;
-        case 'lv':
-            return number === 0 ? 0 : number % 10 === 1 && number % 100 !== 11 ? 1 : 2;
-        case 'pl':
-            return number === 1 ? 0 : number % 10 >= 2 && number % 10 <= 4 && (number % 100 < 12 || number % 100 > 14) ? 1 : 2;
-        case 'cy':
-            return number === 1 ? 0 : number === 2 ? 1 : number === 8 || number === 11 ? 2 : 3;
-        case 'ro':
-            return number === 1 ? 0 : number === 0 || number % 100 > 0 && number % 100 < 20 ? 1 : 2;
-        case 'ar':
-            return number === 0 ? 0 : number === 1 ? 1 : number === 2 ? 2 : number >= 3 && number <= 10 ? 3 : number >= 11 && number <= 99 ? 4 : 5;
-        default:
-            return 0;
-    }
-}
-
 /**
- * Select a proper translation string based on the given number,
- * using the same rules as Laravel's `trans_choice()`.
+ * The i18next options Laravel translations need. `createI18n()` applies them;
+ * pass them to `init()` yourself when you set i18next up by hand.
  *
- * @param message
- * @param number
- * @param locale
- */ function pluralization(message, number, locale) {
-    let segments = message.split('|');
-    const extracted = extract(segments, number);
-    if (extracted !== null) {
-        return extracted.trim();
+ * - no key or namespace separator: Laravel keys are flat and contain dots
+ *   and colons (`auth.failed`, `Email:`);
+ * - an empty message counts as missing and falls back to the next language;
+ * - no escaping of interpolated values: React, Vue and Svelte already escape
+ *   what they render, and Laravel's `:name` replacements were never escaped.
+ */ const laravelOptions = {
+    keySeparator: false,
+    nsSeparator: false,
+    returnEmptyString: false,
+    interpolation: {
+        escapeValue: false
     }
-    segments = stripConditions(segments);
-    const pluralIndex = getPluralIndex(locale, number);
-    return segments.length === 1 || !segments[pluralIndex] ? segments[0] : segments[pluralIndex];
-}
+};
 /**
- * Extract a translation string using inline conditions.
- *
- * @param segments
- * @param number
- */ function extract(segments, number) {
-    for (const segment of segments){
-        const result = extractFromString(segment, number);
-        if (result !== null) return result;
-    }
-    return null;
-}
-/**
- * Get the translation string if the condition matches.
- *
- * @param part
- * @param number
- */ function extractFromString(part, number) {
-    const matches = part.match(/^[{[]([^,{}[\]]*),?([^{}[\]]*)[}\]]([\s\S]*)/);
-    if (!matches) return null;
-    const [, from, to, value] = matches;
-    if ((from === '*' || number >= parseFloat(from)) && (to === '*' || number <= parseFloat(to))) {
-        return value;
-    }
-    return from && parseFloat(from) === number ? value : null;
-}
-/**
- * Strip the inline conditions from each segment, just leaving the text.
- *
- * @param segments
- */ function stripConditions(segments) {
-    return segments.map((part)=>part.replace(/^[{[]([^[\]{}]*)[}\]]/, ''));
-}
-
-/**
- * Make the place-holder replacements on a line, the Laravel way:
- * `:name` as is, `:NAME` upper-cased and `:Name` capitalized.
- *
- * @param message
- * @param replacements
- */ function replacer(message, replacements) {
-    if (!replacements) return message;
-    const patterns = Object.entries(replacements).flatMap(([key, value])=>[
-            {
-                pattern: new RegExp(`:${key}`, 'g'),
-                replacement: value.toString()
-            },
-            {
-                pattern: new RegExp(`:${key.toUpperCase()}`, 'g'),
-                replacement: value.toString().toUpperCase()
-            },
-            {
-                pattern: new RegExp(`:${capitalize(key)}`, 'g'),
-                replacement: capitalize(value.toString())
-            }
-        ]);
-    return patterns.reduce((result, { pattern, replacement })=>result.replace(pattern, replacement), message);
-}
-/**
- * Capitalizing string.
- *
- * @param str
- */ function capitalize(str) {
-    return str ? str[0].toUpperCase() + str.slice(1) : '';
-}
-
-/**
- * i18next `t()` options that are not Laravel replacements. Use the `replace`
- * option to pass replacements having one of these names.
- */ const I18NEXT_OPTIONS = new Set([
-    'appendNamespaceToMissingKey',
-    'applyPostProcessor',
-    'context',
-    'fallbackLng',
-    'i18nResolved',
-    'interpolation',
-    'joinArrays',
-    'keyPrefix',
-    'keySeparator',
-    'lng',
-    'lngs',
-    'missingKeyNoValueFallbackToKey',
-    'ns',
-    'nsSeparator',
-    'nest',
-    'ordinal',
-    'postProcess',
-    'replace',
-    'returnDetails',
-    'returnObjects',
-    'scopeNs',
-    'skipInterpolation'
-]);
-function getReplacements(options) {
-    const fromReplace = options.replace !== null && typeof options.replace === 'object';
-    const source = fromReplace ? options.replace : options;
-    const replacements = {};
-    Object.entries(source).forEach(([key, value])=>{
-        if (typeof value !== 'string' && typeof value !== 'number') return;
-        // A numeric count selects the plural form, it is replaced after pluralization.
-        if (key === 'count' && typeof value === 'number') return;
-        if (!fromReplace && (I18NEXT_OPTIONS.has(key) || key.startsWith('defaultValue'))) return;
-        replacements[key] = value;
+ * Register the `uppercase`, `lowercase` and `capitalize` interpolation formats.
+ * The Vite plugin writes Laravel's `:NAME` as `{{name, uppercase}}` and `:Name`
+ * as `{{name, capitalize}}`; call this once the instance is initialized.
+ */ function registerCaseFormats(instance) {
+    const formatter = instance.services.formatter;
+    formatter === null || formatter === void 0 ? void 0 : formatter.add('uppercase', (value)=>String(value).toUpperCase());
+    formatter === null || formatter === void 0 ? void 0 : formatter.add('lowercase', (value)=>String(value).toLowerCase());
+    formatter === null || formatter === void 0 ? void 0 : formatter.add('capitalize', (value)=>{
+        const text = String(value);
+        return text ? text[0].toUpperCase() + text.slice(1) : text;
     });
-    return replacements;
 }
-/**
- * i18next format plugin translating the way Laravel does:
- *
- * - flat keys (`auth.failed`, `Welcome, :name!`), no key or namespace separators;
- * - `:name`, `:NAME` and `:Name` replacements instead of `{{name}}` interpolation and `$t()` nesting;
- * - a numeric `count` selects the message with Laravel's `trans_choice()` rules
- *   (`one|many`, `{0} none|[1,19] some|[20,*] many`) instead of `_one`/`_other` suffixed keys;
- * - empty messages fall back to the next language.
- */ class LaravelFormat {
-    init(i18next) {
-        this.i18next = i18next;
-        // Laravel keys contain dots and colons: disable the separators, unless given to `init()`.
-        const options = i18next.options;
-        if (options.userDefinedKeySeparator === undefined) options.keySeparator = false;
-        if (options.userDefinedNsSeparator === undefined) options.nsSeparator = false;
-    }
-    getResource(language, namespace, key) {
-        var _a;
-        const value = (_a = this.i18next) === null || _a === void 0 ? void 0 : _a.getResource(language, namespace, key, {
-            keySeparator: false,
-            ignoreJSONStructure: false
-        });
-        return value || undefined;
-    }
-    addLookupKeys(finalKeys) {
-        return finalKeys;
-    }
-    parse(message, options, language, namespace, _key, info) {
-        if (typeof message !== 'string') return message;
-        const replacements = getReplacements(options);
-        const translated = replacer(message, replacements);
-        const count = options.count;
-        if (typeof count !== 'number') return translated;
-        return replacer(pluralization(translated, count, this.getPluralLocale(language, namespace, info)), {
-            ...replacements,
-            count: count.toString()
-        });
-    }
-    /**
-     * The language the message actually resolved in, so pluralization always
-     * matches the text being pluralized -- never merely a language that has
-     * translations for the namespace, which is not the same thing once several
-     * sources can contribute to one namespace (see LaravelBackend): a single
-     * unrelated key from a higher-priority source is enough to make
-     * `hasResourceBundle(language, namespace)` true for a namespace whose
-     * actual message still came from the fallback language.
-     *
-     * i18next passes the language the lookup succeeded at as `resolved.usedLng`
-     * in `parse()`'s 6th argument (`extendTranslation()` in i18next's own
-     * `translator.js`); prefer it. Older i18next in the `>=24` peer range that
-     * does not pass it falls back to a heuristic: the current language when it
-     * has translations for the namespace, else the fallback language.
-     */ getPluralLocale(language, namespace, info) {
-        var _a;
-        const usedLng = (_a = info === null || info === void 0 ? void 0 : info.resolved) === null || _a === void 0 ? void 0 : _a.usedLng;
-        if (usedLng) return usedLng;
-        if (!this.i18next || !language || this.i18next.hasResourceBundle(language, namespace)) return language;
-        const [fallbackLanguage] = this.i18next.services.languageUtils.getFallbackCodes(this.i18next.options.fallbackLng, language);
-        return fallbackLanguage !== null && fallbackLanguage !== void 0 ? fallbackLanguage : language;
-    }
-    constructor(){
-        this.type = 'i18nFormat';
-        /**
-         * Non-string translations (e.g. an empty PHP array) are returned as is.
-         */ this.handleAsObject = false;
-    }
-}
-LaravelFormat.type = 'i18nFormat';
 
 /**
  * Locale of the `<html lang="">` attribute (set by Laravel's `app.blade.php`), or `en`.
@@ -608,26 +338,39 @@ LaravelFormat.type = 'i18nFormat';
     return ()=>instance.off('languageChanged', setDocumentLang);
 }
 /**
- * Create an i18next instance translating Laravel language files: the default
+ * Create an i18next instance reading Laravel language files as i18next JSON: the default
  * namespace from `lang/{locale}.json`, and one namespace per `lang/{locale}/{namespace}.json`
- * file (generated by the Vite plugin, or hand-written).
+ * file (converted from PHP by the Vite plugin, or hand-written the i18next way).
  *
  * With eager files, every known namespace of the locale and fallback locale is
  * preloaded synchronously, so a first render never has to wait for translations.
- * With lazy files, namespaces are loaded on demand as components request them.
+ *
+ * With lazy files, only the namespaces the evaluated modules declared are loaded
+ * up front (see `declareNamespaces()`), plus the default one; any other is loaded
+ * when a component first asks for it, which suspends until it arrives. Loaded
+ * beforehand with `preloadI18n()` -- or `withI18nPreload()` around the page
+ * resolver -- the up front ones are already in memory, so the instance is ready
+ * synchronously and neither the first render nor a later page ever waits.
  */ function createI18n({ files, locale, fallbackLocale }) {
     const instance = i18next.createInstance();
     const sources = toSources(files);
-    const namespaces = recognizer(sources).getAllNamespaces();
+    const known = recognizer(sources).getAllNamespaces();
     const resolvedLocale = locale || documentLocale();
     const resolvedFallbackLocale = fallbackLocale || documentLocale();
     const eager = isEagerSources(sources);
-    instance.use(LaravelBackend).use(LaravelFormat).init({
+    const namespaces = eager ? known : Array.from(new Set([
+        DEFAULT_NAMESPACE,
+        ...getDeclaredNamespaces()
+    ])).filter((namespace)=>known.includes(namespace));
+    instance.use(LaravelBackend).init({
+        ...laravelOptions,
         lng: resolvedLocale,
         fallbackLng: resolvedFallbackLocale,
         initAsync: false,
-        ns: namespaces.length > 0 ? namespaces : undefined,
-        preload: eager ? Array.from(new Set([
+        ...namespaces.length > 0 ? {
+            ns: namespaces
+        } : {},
+        preload: namespaces.length > 0 ? Array.from(new Set([
             resolvedLocale,
             resolvedFallbackLocale
         ])) : undefined,
@@ -635,7 +378,9 @@ LaravelFormat.type = 'i18nFormat';
             files: sources
         }
     });
+    registerCaseFormats(instance);
+    trackInstance(instance);
     return instance;
 }
 
-export { LaravelBackend as L, LaravelFormat as a, createI18n as c, documentLocale as d, syncDocumentLang as s };
+export { DEFAULT_NAMESPACE as D, LaravelBackend as L, resolver as a, registerCaseFormats as b, createI18n as c, documentLocale as d, laravelOptions as l, recognizer as r, syncDocumentLang as s, toSources as t };

package/dist/shared/demand-6YnTqSM4.mjs

@@ -0,0 +1,92 @@
+/**
+ * Namespaces the application's modules asked for, by evaluating.
+ *
+ * The Vite plugin adds one `declareNamespaces([...])` call to every module
+ * calling `useTranslation('ns')` (or `withTranslation`, `<Trans ns>`), so
+ * evaluating a module -- a page, a layout, any component it statically
+ * imports -- records which namespaces it will translate with. A bundler loads
+ * a page together with everything it imports, so by the time a page is
+ * resolved this set holds exactly the namespaces that page needs, however
+ * deeply they are nested, with nothing to declare by hand. `preloadI18n()`
+ * reads it.
+ *
+ * Only ever grows, and is shared by every i18next instance of the process.
+ *
+ * It lives on `globalThis`, under a registered symbol, and the code the Vite
+ * plugin injects writes to it directly instead of importing this module: a
+ * module can be evaluated before this one (a bundler is free to order a
+ * package's chunks around import cycles), can sit in a package that does not
+ * depend on this one, and a page bundle and a server bundle can each carry
+ * their own copy of this module -- none of that may lose a declaration.
+ */ const DECLARED_NAMESPACES_KEY = 'laravel-i18next.declared';
+function declaredNamespaces() {
+    var _a;
+    const store = globalThis;
+    const key = Symbol.for(DECLARED_NAMESPACES_KEY);
+    return (_a = store[key]) !== null && _a !== void 0 ? _a : store[key] = new Set();
+}
+/**
+ * Record namespaces a module translates with. Called by the code the Vite
+ * plugin injects; call it yourself for a namespace requested dynamically
+ * (`useTranslation(name)`), which the plugin cannot see.
+ */ function declareNamespaces(namespaces) {
+    (typeof namespaces === 'string' ? [
+        namespaces
+    ] : namespaces).forEach((namespace)=>declaredNamespaces().add(namespace));
+}
+function getDeclaredNamespaces() {
+    return Array.from(declaredNamespaces());
+}
+/**
+ * The instances living in this process, weakly held. Only browser instances
+ * are tracked (one per app, living as long as the page): a server creates one
+ * instance per request, which nothing may keep alive, and needs no tracking
+ * anyway since each request's instance is created after its translations are
+ * preloaded.
+ */ const instances = new Set();
+function trackInstance(instance) {
+    if (typeof window === 'undefined' || typeof WeakRef === 'undefined') return;
+    instances.add(new WeakRef(instance));
+}
+function reportOf(instance) {
+    return instance.reportNamespaces;
+}
+/**
+ * The namespaces the components of the live browser instances have rendered
+ * with since `forgetRenderedNamespaces()`, or none when nothing recorded them
+ * (another framework, or nothing has rendered yet).
+ */ function getRenderedNamespaces() {
+    return Array.from(new Set(getLiveInstances().flatMap((instance)=>{
+        var _a, _b;
+        return Object.keys((_b = (_a = reportOf(instance)) === null || _a === void 0 ? void 0 : _a.usedNamespaces) !== null && _b !== void 0 ? _b : {});
+    })));
+}
+function forgetRenderedNamespaces() {
+    getLiveInstances().forEach((instance)=>{
+        const report = reportOf(instance);
+        if (report) report.usedNamespaces = {};
+    });
+}
+/**
+ * Make the live instances load only these namespaces the next time their
+ * language changes. i18next remembers every namespace it ever loaded and
+ * loads them all again for a new language; this forgets the others, which a
+ * later `loadNamespaces()` (see `preloadI18n()`) brings back when a page
+ * asks for them.
+ */ function keepOnlyNamespaces(namespaces) {
+    getLiveInstances().forEach((instance)=>{
+        const loaded = instance.options.ns;
+        if (Array.isArray(loaded)) instance.options.ns = loaded.filter((namespace)=>namespaces.includes(namespace));
+    });
+}
+function getLiveInstances() {
+    const live = [];
+    instances.forEach((reference)=>{
+        const instance = reference.deref();
+        if (instance) live.push(instance);
+        else instances.delete(reference);
+    });
+    return live;
+}
+
+export { DECLARED_NAMESPACES_KEY as D, getLiveInstances as a, getRenderedNamespaces as b, declareNamespaces as d, forgetRenderedNamespaces as f, getDeclaredNamespaces as g, keepOnlyNamespaces as k, trackInstance as t };

package/dist/shared/demand-sbjTXVnl.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * Namespaces the application's modules asked for, by evaluating.
+ *
+ * The Vite plugin adds one `declareNamespaces([...])` call to every module
+ * calling `useTranslation('ns')` (or `withTranslation`, `<Trans ns>`), so
+ * evaluating a module -- a page, a layout, any component it statically
+ * imports -- records which namespaces it will translate with. A bundler loads
+ * a page together with everything it imports, so by the time a page is
+ * resolved this set holds exactly the namespaces that page needs, however
+ * deeply they are nested, with nothing to declare by hand. `preloadI18n()`
+ * reads it.
+ *
+ * Only ever grows, and is shared by every i18next instance of the process.
+ *
+ * It lives on `globalThis`, under a registered symbol, and the code the Vite
+ * plugin injects writes to it directly instead of importing this module: a
+ * module can be evaluated before this one (a bundler is free to order a
+ * package's chunks around import cycles), can sit in a package that does not
+ * depend on this one, and a page bundle and a server bundle can each carry
+ * their own copy of this module -- none of that may lose a declaration.
+ */ const DECLARED_NAMESPACES_KEY = 'laravel-i18next.declared';
+function declaredNamespaces() {
+    var _a;
+    const store = globalThis;
+    const key = Symbol.for(DECLARED_NAMESPACES_KEY);
+    return (_a = store[key]) !== null && _a !== void 0 ? _a : store[key] = new Set();
+}
+/**
+ * Record namespaces a module translates with. Called by the code the Vite
+ * plugin injects; call it yourself for a namespace requested dynamically
+ * (`useTranslation(name)`), which the plugin cannot see.
+ */ function declareNamespaces(namespaces) {
+    (typeof namespaces === 'string' ? [
+        namespaces
+    ] : namespaces).forEach((namespace)=>declaredNamespaces().add(namespace));
+}
+function getDeclaredNamespaces() {
+    return Array.from(declaredNamespaces());
+}
+/**
+ * The instances living in this process, weakly held. Only browser instances
+ * are tracked (one per app, living as long as the page): a server creates one
+ * instance per request, which nothing may keep alive, and needs no tracking
+ * anyway since each request's instance is created after its translations are
+ * preloaded.
+ */ const instances = new Set();
+function trackInstance(instance) {
+    if (typeof window === 'undefined' || typeof WeakRef === 'undefined') return;
+    instances.add(new WeakRef(instance));
+}
+function reportOf(instance) {
+    return instance.reportNamespaces;
+}
+/**
+ * The namespaces the components of the live browser instances have rendered
+ * with since `forgetRenderedNamespaces()`, or none when nothing recorded them
+ * (another framework, or nothing has rendered yet).
+ */ function getRenderedNamespaces() {
+    return Array.from(new Set(getLiveInstances().flatMap((instance)=>{
+        var _a, _b;
+        return Object.keys((_b = (_a = reportOf(instance)) === null || _a === void 0 ? void 0 : _a.usedNamespaces) !== null && _b !== void 0 ? _b : {});
+    })));
+}
+function forgetRenderedNamespaces() {
+    getLiveInstances().forEach((instance)=>{
+        const report = reportOf(instance);
+        if (report) report.usedNamespaces = {};
+    });
+}
+/**
+ * Make the live instances load only these namespaces the next time their
+ * language changes. i18next remembers every namespace it ever loaded and
+ * loads them all again for a new language; this forgets the others, which a
+ * later `loadNamespaces()` (see `preloadI18n()`) brings back when a page
+ * asks for them.
+ */ function keepOnlyNamespaces(namespaces) {
+    getLiveInstances().forEach((instance)=>{
+        const loaded = instance.options.ns;
+        if (Array.isArray(loaded)) instance.options.ns = loaded.filter((namespace)=>namespaces.includes(namespace));
+    });
+}
+function getLiveInstances() {
+    const live = [];
+    instances.forEach((reference)=>{
+        const instance = reference.deref();
+        if (instance) live.push(instance);
+        else instances.delete(reference);
+    });
+    return live;
+}
+
+exports.DECLARED_NAMESPACES_KEY = DECLARED_NAMESPACES_KEY;
+exports.declareNamespaces = declareNamespaces;
+exports.forgetRenderedNamespaces = forgetRenderedNamespaces;
+exports.getDeclaredNamespaces = getDeclaredNamespaces;
+exports.getLiveInstances = getLiveInstances;
+exports.getRenderedNamespaces = getRenderedNamespaces;
+exports.keepOnlyNamespaces = keepOnlyNamespaces;
+exports.trackInstance = trackInstance;

package/dist/svelte.cjs

@@ -2,8 +2,9 @@
 
 var svelte = require('svelte');
 var store = require('svelte/store');
-var createI18n = require('./shared/create-i18n-WsDK4Z8L.cjs');
+var createI18n = require('./shared/create-i18n-DI7Eog6O.cjs');
 require('i18next');
+require('./shared/demand-sbjTXVnl.cjs');
 
 const CONTEXT_KEY = 'laravel-i18next';
 /**
@@ -54,6 +55,11 @@ function getI18nextFromContext() {
     const instance = i18nextInstance !== null && i18nextInstance !== void 0 ? i18nextInstance : getI18nextFromContext();
     const revision = store.writable(0);
     const bump = ()=>revision.update((n)=>n + 1);
+    // Not preloaded (see `preloadI18n()`): load it now, `ready` turns true once it arrives.
+    const current = instance.language || instance.options.lng;
+    if (namespace && (!current || !instance.hasResourceBundle(current, namespace))) {
+        void instance.loadNamespaces(namespace);
+    }
     instance.on('languageChanged', bump);
     instance.on('loaded', bump);
     instance.on('added', bump);