@genrwork/laravel-i18next 0.1.0

package/dist/shared/create-i18n-BSEwKsCX.mjs

@@ -0,0 +1,641 @@
+import i18next from 'i18next';
+
+/**
+ * Normalize a `LocaleFileSources` (a single `LocaleFiles` map, or an ordered
+ * array of them, highest priority first) into an array, always -- a bare
+ * map behaves like a single-entry array. Non-object entries (e.g. `null`,
+ * defensively) are dropped rather than throwing, so a hand-built array with a
+ * gap does not crash the whole app.
+ *
+ * `Array.isArray` is the discriminator: `LocaleFiles` is itself a plain
+ * `Record<string, unknown>`, which is why every consumer of `files` must call
+ * this before treating it as a map of maps -- `Object.keys()` on a raw array
+ * would otherwise yield `'0'`, `'1'`, ... instead of file paths.
+ */ function toSources(files) {
+    const list = Array.isArray(files) ? files : [
+        files
+    ];
+    return list.filter((source)=>typeof source === 'object' && source !== null);
+}
+
+/**
+ * The i18next namespace of a flat `lang/{locale}.json` file (i18next's own default).
+ */ const DEFAULT_NAMESPACE = 'translation';
+/**
+ * A directory segment is treated as a locale when it looks like a locale code
+ * (`en`, `id`, `pt_BR`, `zh-CN`...), so namespace detection works regardless of
+ * how deep the configured lang directory itself is nested.
+ */ const LOCALE_PATTERN = /^[a-z]{2,3}([_-][a-z]{2,4})?$/i;
+/**
+ * Classify one file path into a `(locale, namespace)` pair, or `null` when it
+ * is not a recognizable translation file.
+ *
+ * `lang/{locale}.json` is the default namespace. `lang/{locale}/{ns}.json`
+ * (hand-written, or generated by the Vite plugin from `{ns}.php`) is a named
+ * namespace one level deep. A namespace may nest to any depth --
+ * `lang/{locale}/{ns1}/{ns2}.json` and deeper -- by walking the directory
+ * segments backward (closest to the file first) until one of them looks like
+ * a locale; every segment walked past becomes part of the namespace, in
+ * top-down order, e.g. `es/reports/teams/x.json` -> locale `es`, namespace
+ * `reports/teams/x`. A one-level path finds its locale on the very first
+ * (only) segment checked, so `lang/{locale}/{ns}.json` needs no walking.
+ *
+ * Known limitation: this is a purely lexical scan with no knowledge of where
+ * a source's own root directory ends (a bare file->module record carries no
+ * such information, including a hand-rolled `import.meta.glob()` per the
+ * README's manual-fallback path). It picks the NEAREST directory segment that
+ * merely looks like a locale code, so a namespace segment that itself looks
+ * like one (e.g. `es/reports/en/x.json`, intended as locale `es` / namespace
+ * `reports/en/x`) is misread as locale `en` / namespace `x`. No namespace in
+ * a typical app looks like a locale code, so this is accepted and documented
+ * rather than solved.
+ */ function classify(file) {
+    const segments = file.split('/').filter(Boolean);
+    const last = segments.at(-1);
+    const match = last === null || last === void 0 ? void 0 : last.match(/^(.+)\.json$/);
+    if (!match) return null;
+    const basename = match[1];
+    const dirSegments = segments.slice(0, -1);
+    const nsParts = [];
+    for(let i = dirSegments.length - 1; i >= 0; i -= 1){
+        const segment = dirSegments[i];
+        if (LOCALE_PATTERN.test(segment)) {
+            return {
+                locale: segment,
+                namespace: [
+                    ...nsParts.reverse(),
+                    basename
+                ].join('/')
+            };
+        }
+        nsParts.push(segment);
+    }
+    if (LOCALE_PATTERN.test(basename)) {
+        return {
+            locale: basename,
+            namespace: DEFAULT_NAMESPACE
+        };
+    }
+    return null;
+}
+/**
+ * Recognize the locales and namespaces available from one or more
+ * `LocaleFileSources`, highest priority first.
+ *
+ * @param files
+ */ function recognizer(files) {
+    const index = new Map();
+    const namespaces = new Set();
+    const seen = new Set();
+    toSources(files).forEach((source, rank)=>{
+        Object.keys(source).forEach((file)=>{
+            var _a;
+            // Two sources overlapping on the exact same path (e.g. two `sources`
+            // patterns matching the same file) keep only the higher-priority one.
+            if (seen.has(file)) return;
+            const classified = classify(file);
+            if (!classified) return;
+            seen.add(file);
+            namespaces.add(classified.namespace);
+            if (!index.has(classified.locale)) index.set(classified.locale, new Map());
+            const byNamespace = index.get(classified.locale);
+            if (!byNamespace) return;
+            const candidates = (_a = byNamespace.get(classified.namespace)) !== null && _a !== void 0 ? _a : [];
+            candidates.push({
+                source: rank,
+                file
+            });
+            byNamespace.set(classified.namespace, candidates);
+        });
+    });
+    // Sources are visited in rank order above, so each namespace's candidate
+    // list is already highest-priority-first -- no sort needed here.
+    const locales = Array.from(index.keys()).sort();
+    return {
+        isLocale: (locale)=>index.has(locale),
+        getLocales: ()=>locales,
+        getNamespaces: (locale)=>{
+            var _a, _b;
+            return Array.from((_b = (_a = index.get(locale)) === null || _a === void 0 ? void 0 : _a.keys()) !== null && _b !== void 0 ? _b : []).sort();
+        },
+        getAllNamespaces: ()=>Array.from(namespaces).sort(),
+        /** The single highest-priority file, or `undefined` when none exists. */ getFile: (locale, namespace)=>{
+            var _a, _b, _c;
+            return (_c = (_b = (_a = index.get(locale)) === null || _a === void 0 ? void 0 : _a.get(namespace)) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.file;
+        },
+        /** Every candidate file for the pair, highest priority first. */ getCandidates: (locale, namespace)=>{
+            var _a, _b;
+            return (_b = (_a = index.get(locale)) === null || _a === void 0 ? void 0 : _a.get(namespace)) !== null && _b !== void 0 ? _b : [];
+        }
+    };
+}
+
+/**
+ * Turn one `files` entry into a module or a promise of one. Lazy files
+ * (`import.meta.glob()`) are loader functions resolving to a promise of a
+ * 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`.
+ */ function toModule(entry) {
+    const type = Object.prototype.toString.call(entry);
+    if (type === '[object Promise]' || type === '[object Module]') {
+        return entry;
+    }
+    if (type === '[object Object]') {
+        return {
+            default: entry
+        };
+    }
+    if (type === '[object Function]') {
+        return entry();
+    }
+    return undefined;
+}
+/**
+ * Resolve every candidate language file of a locale's namespace, highest
+ * priority first (see `recognizer().getCandidates()`). Each candidate keeps
+ * its own shape -- eager candidates stay synchronous, lazy ones stay a
+ * promise -- so a caller merging them can still take an all-synchronous path
+ * when every candidate happens to be eager.
+ *
+ * An empty array means the locale has no file at all for that namespace, in
+ * any source.
+ *
+ * @param files
+ * @param locale
+ * @param namespace
+ */ function resolver(files, locale, namespace) {
+    const sources = toSources(files);
+    const candidates = recognizer(sources).getCandidates(locale, namespace);
+    return candidates.reduce((resolved, candidate)=>{
+        var _a;
+        const entry = (_a = sources[candidate.source]) === null || _a === void 0 ? void 0 : _a[candidate.file];
+        const module = toModule(entry);
+        if (module !== undefined) resolved.push(module);
+        return resolved;
+    }, []);
+}
+
+function isPromiseLike(value) {
+    return typeof (value === null || value === void 0 ? void 0 : value.then) === 'function';
+}
+/**
+ * Merge resolved modules into one resource object, LOWEST priority first, so
+ * a higher-priority source's key wins. Every key is already flat/dotted (the
+ * Vite plugin flattens PHP arrays before writing JSON), so this shallow merge
+ * is exactly the deep merge Laravel itself does over the original nested PHP
+ * arrays -- no recursive merge is needed.
+ *
+ * Starts from a fresh object rather than the first module's `default`, so no
+ * source module is ever mutated. A candidate whose `default` is missing or
+ * not an object (e.g. a disabled module stubbed to `export default {}` by the
+ * consumer's build) contributes nothing rather than throwing.
+ */ function merge(modules) {
+    var _a;
+    const resources = {};
+    for(let i = modules.length - 1; i >= 0; i -= 1){
+        const translations = (_a = modules[i]) === null || _a === void 0 ? void 0 : _a.default;
+        if (translations && typeof translations === 'object') Object.assign(resources, translations);
+    }
+    return resources;
+}
+/**
+ * i18next backend loading Laravel language files as separate namespaces from
+ * one or more sources, highest priority first: the default namespace from
+ * `{source}/{locale}.json`, and one namespace per PHP file from
+ * `{source}/{locale}/{namespace}.json` (generated by the Vite plugin from
+ * `{namespace}.php`, or hand-written) -- a namespace may also nest to any
+ * depth, see `src/utils/recognizer.ts`.
+ *
+ * When several sources have a file for the same `(locale, namespace)`, they
+ * are merged per key: a higher-priority source's key overrides a
+ * lower-priority one, but a key present only in a lower-priority source still
+ * resolves. This is what lets a namespace migrate from PHP to hand-written
+ * JSON one string at a time.
+ *
+ * Eager files are read synchronously, lazy files asynchronously -- and the
+ * whole read stays synchronous as long as every candidate for the pair is
+ * eager, even when several sources contribute, which SSR depends on
+ * (`initAsync: false` + `preload`). A (locale, namespace) pair without a
+ * matching file in any source gets no resources.
+ */ class LaravelBackend {
+    init(_services, backendOptions) {
+        var _a;
+        this.files = (_a = backendOptions === null || backendOptions === void 0 ? void 0 : backendOptions.files) !== null && _a !== void 0 ? _a : {};
+    }
+    read(language, namespace, callback) {
+        const candidates = resolver(this.files, language, namespace);
+        if (candidates.length === 0) {
+            callback(null, null);
+            return;
+        }
+        if (candidates.some(isPromiseLike)) {
+            Promise.all(candidates).then((modules)=>callback(null, merge(modules)), (error)=>callback(error, false));
+            return;
+        }
+        callback(null, merge(candidates));
+    }
+    constructor(){
+        this.type = 'backend';
+        this.files = {};
+    }
+}
+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()`.
+ *
+ * @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();
+    }
+    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;
+    });
+    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`.
+ */ function documentLocale() {
+    var _a, _b;
+    return typeof document !== 'undefined' && ((_b = (_a = document.documentElement) === null || _a === void 0 ? void 0 : _a.lang) === null || _b === void 0 ? void 0 : _b.replace('-', '_')) || 'en';
+}
+/**
+ * One source is eager (`import.meta.glob(..., { eager: true })`) when every
+ * entry is already a resolved module, lazy (`import.meta.glob(...)`) when
+ * they are loader functions.
+ */ function isEagerSource(source) {
+    return Object.values(source).every((value)=>typeof value === 'object' && value !== null);
+}
+/**
+ * All-or-nothing across every non-empty source: the Vite plugin's `sources`
+ * option never mixes eager and lazy sources, so a hand-rolled config that
+ * does is the only way to end up here with a mixed result -- `preload` is
+ * then skipped and the backend's async path still produces correct results,
+ * just not synchronously. An empty source (e.g. a module with no
+ * translations) is ignored rather than short-circuiting eagerness to false.
+ */ function isEagerSources(sources) {
+    return sources.filter((source)=>Object.keys(source).length > 0).every(isEagerSource);
+}
+/**
+ * Set the `<html lang="">` attribute to the instance's current language, and keep it
+ * in sync whenever the language changes afterwards.
+ */ function syncDocumentLang(instance) {
+    const setDocumentLang = (language)=>{
+        // When setting the HTML lang attribute, hyphen must be used instead of underscore.
+        document.documentElement.setAttribute('lang', language.replace('_', '-'));
+    };
+    if (typeof document !== 'undefined' && instance.language) setDocumentLang(instance.language);
+    instance.on('languageChanged', setDocumentLang);
+    return ()=>instance.off('languageChanged', setDocumentLang);
+}
+/**
+ * Create an i18next instance translating Laravel language files: the default
+ * namespace from `lang/{locale}.json`, and one namespace per `lang/{locale}/{namespace}.json`
+ * file (generated by the Vite plugin, or hand-written).
+ *
+ * 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.
+ */ function createI18n({ files, locale, fallbackLocale }) {
+    const instance = i18next.createInstance();
+    const sources = toSources(files);
+    const namespaces = recognizer(sources).getAllNamespaces();
+    const resolvedLocale = locale || documentLocale();
+    const resolvedFallbackLocale = fallbackLocale || documentLocale();
+    const eager = isEagerSources(sources);
+    instance.use(LaravelBackend).use(LaravelFormat).init({
+        lng: resolvedLocale,
+        fallbackLng: resolvedFallbackLocale,
+        initAsync: false,
+        ns: namespaces.length > 0 ? namespaces : undefined,
+        preload: eager ? Array.from(new Set([
+            resolvedLocale,
+            resolvedFallbackLocale
+        ])) : undefined,
+        backend: {
+            files: sources
+        }
+    });
+    return instance;
+}
+
+export { LaravelBackend as L, LaravelFormat as a, createI18n as c, documentLocale as d, syncDocumentLang as s };