@sveltekit-i18n/base 3.0.1 → 3.1.0-next.0

package/dist/utils.js

@@ -124,6 +124,248 @@ export const sanitizeTranslationLocales = (input, sanitize) => (Object.keys(inpu
     const [sanitized = locale] = sanitize(locale);
     return { ...acc, [sanitized]: { ...read(acc, sanitized), ...read(input, locale) } };
 }, {}));
+// An `Accept-Language` field is visitor-controlled and unbounded, while a
+// browser sends a handful of ranges — the tail of a flood carries no
+// preference worth reading.
+const MAX_RANGES = 100;
+// RFC 4647 §4.4 lets a protocol cap a range but never below 35 characters:
+// language(8) + script(5) + region(4) + two variants(18). The cap is also what
+// bounds the truncation chain below.
+const MAX_RANGE_LENGTH = 64;
+const WILDCARD = '*';
+const ALPHA = 'abcdefghijklmnopqrstuvwxyz';
+const ALPHANUM = `${ALPHA}0123456789`;
+const QVALUE = '0123456789.';
+const isSubtag = (subtag, allowed) => (!!subtag.length && subtag.length <= 8 && [...subtag].every((char) => allowed.includes(char)));
+// RFC 4647 §2.1: `(1*8ALPHA *("-" 1*8alphanum))`. Anything else is not a range,
+// which is what keeps `constructor` and a half-parsed header from becoming one.
+const isLanguageRange = (range) => {
+    const [primary = '', ...rest] = range.split('-');
+    return isSubtag(primary, ALPHA) && rest.every((subtag) => isSubtag(subtag, ALPHANUM));
+};
+const specificityOf = (range) => (range === WILDCARD ? 0 : range.split('-').length);
+// RFC 9110 §12.4.2: `q` is case-insensitive and its absence means 1. A weight
+// that is not a number drops its own range — reading it as 1 would promote
+// junk to the strongest preference, and 0 would turn it into a refusal.
+const readWeight = (parameters) => {
+    const value = parameters.reduce((acc, parameter) => {
+        if (acc !== undefined)
+            return acc;
+        const compact = parameter.split(' ').join('').split('\t').join('').toLowerCase();
+        return compact.startsWith('q=') ? compact.slice(2) : acc;
+    }, undefined);
+    if (value === undefined)
+        return 1;
+    // A qvalue is decimal digits and a dot; `Number` alone would also read
+    // `0x10` and `1e3`, and an empty one as zero.
+    if (!value.length || [...value].some((char) => !QVALUE.includes(char)))
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return undefined;
+    return Math.min(1, Math.max(0, parsed));
+};
+const parseRanges = (field) => (
+// Bounded at the split rather than after it: materializing every member of a
+// hostile field would spend exactly what the cap is there to refuse.
+field.split(',', MAX_RANGES).reduce((acc, element, order) => {
+    const [head = '', ...parameters] = element.split(';');
+    const range = head.trim().toLowerCase();
+    if (!range || range.length > MAX_RANGE_LENGTH)
+        return acc;
+    if (range !== WILDCARD && !isLanguageRange(range))
+        return acc;
+    const q = readWeight(parameters);
+    if (q === undefined)
+        return acc;
+    const seen = acc.find((known) => known.range === range);
+    // A range repeated within one field is one preference, at the strongest
+    // weight it was given.
+    if (seen)
+        return acc.map((known) => (known === seen ? { ...known, q: Math.max(known.q, q) } : known));
+    return [...acc, { range, q, order, specificity: specificityOf(range) }];
+}, []));
+// RFC 5646 §4.4.2: a single-character subtag introduces an extension or a
+// private-use sequence, so it never outlives the subtag it introduced.
+const withoutTrailingSingleton = (subtags) => (subtags.at(-1)?.length === 1 ? withoutTrailingSingleton(subtags.slice(0, -1)) : subtags);
+// The range, then its progressively shorter prefixes – `zh-hant-tw`, `zh-hant`,
+// `zh`. Only the REQUESTED range is ever truncated; an available locale is
+// compared as it was spelled.
+const prefixes = (range) => {
+    const walk = (subtags) => (subtags.length ? [subtags.join('-'), ...walk(withoutTrailingSingleton(subtags.slice(0, -1)))] : []);
+    return walk(range.split('-'));
+};
+const covers = (range, folded) => range === WILDCARD || folded === range || folded.startsWith(`${range}-`);
+// Weight first; at equal weight a concrete range is consulted before the
+// wildcard, and the order the field spelled them in breaks what is left.
+const byPreference = (a, b) => (b.q - a.q
+    || Number(a.range === WILDCARD) - Number(b.range === WILDCARD)
+    || a.order - b.order);
+/**
+ * Matches what a visitor asked for against the locales an app actually has.
+ *
+ * `requested` is an `Accept-Language` field value, a single locale, or a
+ * preference list such as `navigator.languages`; `available` is the configured
+ * set, and the winner is returned as IT spells it. A miss is `undefined` rather
+ * than a guess – what a miss means is the caller's to decide.
+ */
+export const matchLocale = (requested, available) => {
+    // Narrowing `available` in place would widen it to `any[]` and take the
+    // locale union down with it, so the guard hands the value back as it is
+    // declared.
+    const locales = Array.isArray(available) ? available : [];
+    const candidates = locales.reduce((acc, locale) => (locale && typeof locale === 'string' ? [...acc, { locale, folded: locale.toLowerCase() }] : acc), []);
+    if (!candidates.length)
+        return undefined;
+    // Anything that is not a field value carries no preference – an absent
+    // header, a parsed body, a mistyped local. Reading one is a miss, not a throw.
+    const field = typeof requested === 'string'
+        ? requested
+        : Array.isArray(requested)
+            ? requested.slice(0, MAX_RANGES).filter((value) => typeof value === 'string').join(',')
+            : '';
+    const parsed = parseRanges(field);
+    const refusals = parsed.filter(({ q }) => !q);
+    // RFC 2616's longest-matching-range rule, reduced to the only comparison it
+    // ever needs: a refusal loses to a strictly more specific positive match. A
+    // refused candidate is skipped rather than blacklisted, so a later, more
+    // specific range can still select it.
+    const accepted = (folded, specificity) => refusals.every(({ range, specificity: refused }) => (!covers(range, folded) || refused < specificity));
+    const select = (range) => {
+        if (range === WILDCARD)
+            return candidates.find(({ folded }) => accepted(folded, 0))?.locale;
+        const found = prefixes(range).reduce((match, prefix) => match ?? candidates.find(({ folded }) => folded === prefix && accepted(folded, specificityOf(prefix)))?.locale, undefined);
+        if (found)
+            return found;
+        // Truncation answers nothing when the available set is FINER than the
+        // range, which is the other half of the gap. The range AS WRITTEN is then
+        // read as a prefix – never a truncated one, so `en` reaches `en-GB` while
+        // `en-GB` never reaches the sibling `en-US`.
+        return candidates.find(({ folded }) => folded.startsWith(`${range}-`) && accepted(folded, specificityOf(range)))?.locale;
+    };
+    return parsed
+        .filter(({ q }) => q > 0)
+        .sort(byPreference)
+        .reduce((match, { range }) => match ?? select(range), undefined);
+};
+// The scripts Unicode writes right to left, the historic ones and the ISO 15924
+// variants of the living ones (`Aran`, `Syre`) included.
+const RTL_SCRIPTS = new Set([
+    'Adlm', 'Arab', 'Aran', 'Armi', 'Avst', 'Chrs', 'Cprt', 'Elym', 'Gara', 'Hatr', 'Hebr', 'Hung', 'Khar', 'Lydi',
+    'Mand', 'Mani', 'Mend', 'Merc', 'Mero', 'Narb', 'Nbat', 'Nkoo', 'Orkh', 'Ougr', 'Palm', 'Phli', 'Phlp',
+    'Phnx', 'Prti', 'Rohg', 'Samr', 'Sarb', 'Sidt', 'Sogd', 'Sogo', 'Syrc', 'Syre', 'Syrj', 'Syrn', 'Thaa', 'Yezi',
+]);
+/**
+ * The direction `locale` is written in, for `dir` and `<html dir>`.
+ *
+ * Decided by the script alone: the one the tag spells (`az-Arab`, `pa-Guru`),
+ * or else the one `Intl.Locale#maximize()` adds (`dv` is `Thaa`, `pa-PK` is
+ * `Arab`). That likely script is the engine's CLDR data and can differ between
+ * engines (`prs` has none in JavaScriptCore), so a locale whose direction
+ * matters spells its script. The engines' own text info is not read –
+ * JavaScriptCore reports `dv` and `az-Arab` as left to right. A tag
+ * `Intl.Locale` rejects, and a missing locale, is `'ltr'`.
+ */
+export const textDirection = (locale) => {
+    if (typeof locale !== 'string')
+        return 'ltr';
+    try {
+        const tag = new Intl.Locale(locale);
+        const script = tag.script ?? tag.maximize().script;
+        return script && RTL_SCRIPTS.has(script) ? 'rtl' : 'ltr';
+    }
+    catch {
+        return 'ltr';
+    }
+};
+/**
+ * `route` without `basePath` in front of it, cut on a segment boundary only:
+ * under `/repo`, `/repo/about` is `/about`, `/repo` is `/` and `/repo?tab=1`
+ * is `/?tab=1`, while `/repository` and a route without the prefix pass
+ * through unchanged.
+ */
+export const withoutBasePath = (route, basePath) => {
+    if (typeof route !== 'string' || typeof basePath !== 'string')
+        return route;
+    let end = basePath.length;
+    while (end > 0 && basePath[end - 1] === '/')
+        end -= 1;
+    const base = basePath.slice(0, end);
+    if (!base || !route.startsWith(base))
+        return route;
+    const rest = route.slice(base.length);
+    if (!rest)
+        return '/';
+    if (rest[0] === '?' || rest[0] === '#')
+        return `/${rest}`;
+    return rest.startsWith('/') ? rest : route;
+};
+// A pathname is visitor input and the matcher backtracks over it, so a longer
+// one is not examined at all.
+const MAX_ROUTE_SEGMENTS = 64;
+const decodeSegment = (segment) => {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return segment;
+    }
+};
+/** Whether one pathname segment fits one route id segment, where `[x]` stands for one or more characters. */
+const fitsSegment = (segment, pattern) => {
+    const parts = pattern.split(/(\[[^\]]+\])/);
+    if (parts.length === 1)
+        return segment === pattern;
+    const first = parts[0];
+    const last = parts[parts.length - 1];
+    if (!segment.startsWith(first) || !segment.endsWith(last))
+        return false;
+    // The leftmost placement of each literal leaves the most room to the rest.
+    const position = parts.slice(2, -1).filter((_, index) => index % 2 === 0).reduce((at, literal) => {
+        if (at < 0)
+            return at;
+        const found = segment.indexOf(literal, at + 1);
+        return found < 0 ? -1 : found + literal.length;
+    }, first.length);
+    return position >= 0 && segment.length - last.length - position >= 1;
+};
+/**
+ * What stands in front of the part of `pathname` that SvelteKit's `routeId`
+ * matched: `''` when nothing does, `undefined` when the id fits no suffix of
+ * it, when it is `null` (a 404), or when the pathname is too long to examine.
+ * Param matchers cannot run here, so an optional param on the first segment
+ * absorbs a prefix. No regex runs on the pathname.
+ */
+export const routePrefix = (pathname, routeId) => {
+    if (typeof pathname !== 'string' || typeof routeId !== 'string')
+        return undefined;
+    const raw = pathname.split('/').filter(Boolean);
+    if (raw.length > MAX_ROUTE_SEGMENTS)
+        return undefined;
+    const segments = raw.map(decodeSegment);
+    const patterns = routeId.split('/').filter((pattern) => pattern && !(pattern.startsWith('(') && pattern.endsWith(')')));
+    const fitted = new Map();
+    // Whether the segments from `at` on fit the patterns from `index` on. Each
+    // pair is decided once, which keeps rest and optional params polynomial.
+    const fits = (at, index) => {
+        const key = at * (patterns.length + 1) + index;
+        const known = fitted.get(key);
+        if (known !== undefined)
+            return known;
+        const pattern = patterns[index];
+        const result = pattern === undefined
+            ? at === segments.length
+            : pattern.startsWith('[[') && pattern.endsWith(']]')
+                ? fits(at, index + 1) || (at < segments.length && fits(at + 1, index + 1))
+                : pattern.startsWith('[...') && pattern.endsWith(']')
+                    ? segments.slice(at).some((_, skip) => fits(at + skip, index + 1)) || fits(segments.length, index + 1)
+                    : at < segments.length && fitsSegment(segments[at], pattern) && fits(at + 1, index + 1);
+        fitted.set(key, result);
+        return result;
+    };
+    const at = [...segments.keys(), segments.length].find((skip) => fits(skip, 0));
+    return at === undefined ? undefined : raw.slice(0, at).map((segment) => `/${segment}`).join('');
+};
 export const toDotNotation = (input, preserveArrays, parentKey) => {
     if (preserveArrays && Array.isArray(input)) {
         return input.map((v) => toDotNotation(v, preserveArrays));
@@ -155,19 +397,84 @@ export const toDotNotation = (input, preserveArrays, parentKey) => {
     }
     return input;
 };
+const asList = (value) => (Array.isArray(value) ? value : [value]);
+export const unique = (values) => Array.from(new Set(values));
+// Tagged by form, so a string route and a pattern with the same text differ. A
+// matcher's behavior cannot be read — only that it is one.
+const describeRoute = (route) => {
+    if (typeof route === 'string')
+        return `s:${route}`;
+    if (route instanceof RegExp)
+        return `r:${String(route)}`;
+    return 'm';
+};
+// The content itself rather than a hash of it: equality stays exact, and the
+// string repeats what a serialized payload already carries, so it compresses
+// with it.
+const loaderId = ({ locale, namespace, routes }) => JSON.stringify(routes ? [locale, namespace, routes.map(describeRoute)] : [locale, namespace]);
+// A name shared by two loaders would hand one's records to the other, so
+// neither keeps it.
+const withIds = (loaders) => {
+    const ids = loaders.map((loader) => {
+        try {
+            return loaderId(loader);
+        }
+        catch (error) {
+            logError('Cannot derive an id for a loader.', error);
+            return null;
+        }
+    });
+    const counts = ids.reduce((acc, id) => acc.set(id, (acc.get(id) ?? 0) + 1), new Map());
+    return loaders.map((loader, index) => {
+        const id = ids[index] ?? null;
+        return { ...loader, id: counts.get(id) === 1 ? id : null };
+    });
+};
 // Loader properties are consumer code — an accessor may throw. Materialized
 // once at the config boundary, so a single unreadable loader costs only itself
-// instead of taking down every locale-keyed read downstream.
-export const resolveLoaders = (input = []) => (input.reduce((acc, descriptor) => {
-    try {
-        const { key, locale, loader, routes } = descriptor;
-        return [...acc, { key, locale, loader, routes }];
-    }
-    catch (error) {
-        logError('Skipping a loader that cannot be read.', error);
-        return acc;
-    }
-}, []));
+// instead of taking down every locale-keyed read downstream. Everything a
+// descriptor may spell more than one way is settled here, so nothing
+// downstream knows there were several: the two names of the namespace, and a
+// list of locales or namespaces, which expands into one loader per pair with
+// its locale sanitized. Each loader is named by its content here too.
+// A module-level config is read by an instance per request, so the deprecated
+// name is reported once per descriptor rather than once per instance.
+const reportedDeprecations = new WeakSet();
+export const resolveLoaders = (input = [], sanitizeLocales = true) => {
+    const sanitize = sanitizerFactory(sanitizeLocales);
+    return withIds(input.reduce((acc, descriptor) => {
+        try {
+            const { namespace, key, locale, loader, routes, cache } = descriptor;
+            if (key !== undefined && !reportedDeprecations.has(descriptor)) {
+                reportedDeprecations.add(descriptor);
+                logger.warn(`Loader '${String(key)}' uses 'key', which is deprecated. Rename it to 'namespace'.`);
+            }
+            if (cache !== undefined && cache !== false) {
+                logger.error(`Ignoring the 'cache' of loader '${String(namespace ?? key)}': only 'false' is accepted.`);
+            }
+            const namespaces = unique(asList(namespace ?? key).filter((name) => name != null));
+            const locales = unique(sanitize(...asList(locale).filter((name) => name != null)));
+            if (!namespaces.length || !locales.length) {
+                logger.warn('Skipping a loader that names no locale or no namespace.');
+                return acc;
+            }
+            return [
+                ...acc,
+                ...locales.flatMap((pairLocale) => namespaces.map((pairNamespace) => ({
+                    namespace: pairNamespace,
+                    locale: pairLocale,
+                    loader,
+                    routes,
+                    ...(cache === false ? { cache } : {}),
+                }))),
+            ];
+        }
+        catch (error) {
+            logError('Skipping a loader that cannot be read.', error);
+            return acc;
+        }
+    }, []));
+};
 const isMergeable = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
 // Data reaching a namespace that already holds some — route-scoped chunks of
 // one namespace, a later load, a second `addTranslations` — contributes to it
@@ -210,7 +517,7 @@ const reportLoaderConflict = (path) => {
     logger.warn(`Conflicting translations for '${path}'. Keeping the value of the last loader.`);
 };
 export const serialize = (input) => {
-    return input.reduce((acc, { key, data, locale }) => {
+    return input.reduce((acc, { namespace, data, locale }) => {
         if (!data)
             return acc;
         // The locale is already sanitized — loaders are normalized before the fetch.
@@ -219,38 +526,131 @@ export const serialize = (input) => {
             ...acc,
             [locale]: {
                 ...namespaces,
-                [key]: hasOwn(namespaces, key) ? mergeTranslations(read(namespaces, key), data, `${key}`, reportLoaderConflict) : data,
+                [namespace]: hasOwn(namespaces, namespace) ? mergeTranslations(read(namespaces, namespace), data, String(namespace), reportLoaderConflict) : data,
             },
         });
     }, {});
 };
-export const fetchTranslations = async (loaders, route) => {
-    const response = await Promise.all(loaders.map(async ({ loader, ...rest }) => {
-        let data;
-        try {
-            data = await loader({ locale: rest.locale, route });
-        }
-        catch (error) {
-            logError(`Failed to load translation. Verify your '${rest.locale}' > '${rest.key}' Loader.`, error);
-        }
-        return { loader, ...rest, data };
-    }));
-    return serialize(response);
+/** The locales the loaders serve, then the ones the tables hold. */
+export const servedLocales = (loaders, tables) => unique([
+    ...loaders.map(({ locale }) => locale),
+    ...Object.keys(tables),
+]);
+/**
+ * The locales a config serves, sanitized as an instance built from it
+ * sanitizes them. Resolving the loaders logs what is wrong with them, so a
+ * caller runs this once per config.
+ */
+export const configLocales = ({ loaders, translations, sanitizeLocales: strategy }) => servedLocales(resolveLoaders(loaders, strategy), translations ? sanitizeTranslationLocales(translations, sanitizerFactory(strategy)) : {});
+/** A loader as a message names it. `String`, since interpolating a Symbol namespace throws. */
+export const loaderName = ({ locale, namespace }) => `'${locale}' > '${String(namespace)}'`;
+/**
+ * SvelteKit's control flow, told by the shape of its classes so nothing is
+ * imported from `@sveltejs/kit`: a `Redirect` (an integer `status` from 300 to
+ * 308 and a string `location`) and an `HttpError` below 500 (an integer
+ * `status` from 400 to 499 and an object `body`), each an own property of a
+ * value that is neither an `Error` of this realm nor tagged `'Error'`. An
+ * `HttpError` of 500 or more is a failure — a remote `query` throws one on the
+ * client whenever the server failed with an `Error` (during SSR, the query
+ * throws the server's own error) — and so is such an `Error`, whatever it
+ * carries, and a value that cannot be inspected.
+ */
+const isControlFlow = (value) => {
+    try {
+        // The tag covers another realm's `Error`; `instanceof` covers one whose
+        // tag its own class replaced, a `DOMException` included.
+        if (value instanceof Error || Object.prototype.toString.call(value) === '[object Error]')
+            return false;
+        const status = read(value, 'status');
+        if (typeof status !== 'number' || !Number.isInteger(status))
+            return false;
+        if (status >= 300 && status <= 308)
+            return typeof read(value, 'location') === 'string';
+        if (!(status >= 400 && status <= 499))
+            return false;
+        const body = read(value, 'body');
+        return typeof body === 'object' && body !== null;
+    }
+    catch {
+        return false;
+    }
 };
-// `test` advances `lastIndex` on a `g`/`y` pattern, so a route object reused
+// One loader's fetch. One that throws is logged and costs only its own data;
+// SvelteKit's control flow is returned for the load to report and reject with
+// once every loader of it has settled. Only a throw is retried: an empty
+// answer is an answer, and it still replaces what the loader delivered for
+// other params.
+export const fetchTranslation = async ({ loader: resolved, params, signature }, route) => {
+    const { loader, locale, namespace } = resolved;
+    try {
+        const data = await loader({ locale, namespace, route, params });
+        return { deliveries: [{ loader: resolved, signature, data: data || {} }], controlFlow: [] };
+    }
+    catch (error) {
+        if (isControlFlow(error))
+            return { deliveries: [], controlFlow: [{ loader: resolved, signature, value: error }] };
+        logError(`Failed to load translation. Verify your ${loaderName(resolved)} Loader.`, error);
+        return { deliveries: [], controlFlow: [] };
+    }
+};
+/** The fetches of a load as one. */
+export const mergeFetched = (fetched) => ({
+    deliveries: fetched.flatMap(({ deliveries }) => deliveries),
+    controlFlow: fetched.flatMap(({ controlFlow }) => controlFlow),
+});
+// `exec` advances `lastIndex` on a `g`/`y` pattern, so a route object reused
 // across navigations would match only every other time — and writing to the
 // consumer's own pattern is not ours to do, least of all when it is frozen.
-const withoutMatchState = (input) => (input instanceof RegExp && (input.global || input.sticky)
+const withoutMatchState = (input) => (input.global || input.sticky
     ? new RegExp(input.source, input.flags)
     : input);
-export const testRoute = (route) => (input) => {
+// A match yields the named groups of a pattern, copied onto a plain object
+// (a match's `groups` has a null prototype) without the groups that did not
+// take part. A string route and a matcher yield none. `undefined` is no match.
+export const matchRoute = (route) => (input) => {
     try {
         if (typeof input === 'string')
-            return input === route;
-        return withoutMatchState(input).test(route);
+            return input === route ? {} : undefined;
+        if (input instanceof RegExp) {
+            const match = withoutMatchState(input).exec(route);
+            if (!match)
+                return undefined;
+            return Object.entries(match.groups ?? {}).reduce((acc, [name, value]) => (value === undefined ? acc : { ...acc, [name]: value }), {});
+        }
+        return input.test(route) ? {} : undefined;
     }
     catch (error) {
         logError('Invalid route config!', error);
     }
-    return false;
+    return undefined;
+};
+export const testRoute = (route) => (input) => matchRoute(route)(input) !== undefined;
+/** The params a loader loads with on `route` – its first matching route's – or `undefined` when none matches. */
+export const routeParams = (routes, route) => {
+    if (!routes)
+        return {};
+    const match = matchRoute(route);
+    return routes.reduce((found, input) => found ?? match(input), undefined);
+};
+// Whether a route can yield params: a pattern with a named group. Read off an
+// empty match of the pattern made optional, whose `groups` names every group.
+const namesGroups = (input) => {
+    if (!(input instanceof RegExp))
+        return false;
+    try {
+        const groups = new RegExp(`(?:${input.source})|`, input.flags.replace(/[gy]/g, '')).exec('')?.groups;
+        return !!groups && Object.keys(groups).length > 0;
+    }
+    catch {
+        return false;
+    }
+};
+/** Whether any of `routes` can yield params. */
+export const capturesParams = (routes) => !!routes?.some(namesGroups);
+// Keyed on the params alone, not the route: two routes yielding the same params
+// describe the same data. Stable in key order, and '' for none, so a loader
+// without params keys the way a namespace record does.
+export const paramsSignature = (params) => {
+    const names = Object.keys(params).sort();
+    return names.length ? JSON.stringify(names.map((name) => [name, read(params, name)])) : '';
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltekit-i18n/base",
-  "version": "3.0.1",
+  "version": "3.1.0-next.0",
   "description": "Base functionality of sveltekit-i18n library with a support for external message parsers.",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -15,8 +15,23 @@
       "svelte": "./dist/exports/utils.js",
       "default": "./dist/exports/utils.js"
     },
+    "./kit": {
+      "types": "./dist/exports/kit.d.ts",
+      "svelte": "./dist/exports/kit.js",
+      "default": "./dist/exports/kit.js"
+    },
     "./package.json": "./package.json"
   },
+  "imports": {
+    "#kit-env": {
+      "browser": "./dist/kit/env.browser.js",
+      "default": "./dist/kit/env.js"
+    },
+    "#kit-server": {
+      "browser": "./dist/kit/server.browser.js",
+      "default": "./dist/kit/server.js"
+    }
+  },
   "scripts": {
     "dev": "svelte-package -i src -o dist -w",
     "typecheck": "tsc --noEmit -p tsconfig.json",
@@ -50,9 +65,12 @@
   "bugs": {
     "url": "https://github.com/sveltekit-i18n/lib/issues"
   },
-  "homepage": "https://github.com/sveltekit-i18n/base#readme",
+  "homepage": "https://sveltekit-i18n.github.io",
+  "funding": "https://github.com/sponsors/sveltekit-i18n",
   "engines": {
-    "node": ">=22"
+    "node": ">=22",
+    "bun": ">=1.2",
+    "deno": ">=2"
   },
   "peerDependencies": {
     "svelte": ">=5"
@@ -63,10 +81,12 @@
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@types/node": "^26.2.0",
+    "devalue": "^5.9.4",
     "esbuild": "^0.28.2",
     "eslint": "^10.8.1",
     "eslint-plugin-import-x": "^4.17.1",
     "globals": "^17.11.0",
+    "happy-dom": "^20.14.5",
     "simple-git-hooks": "^2.13.1",
     "svelte": "^5.56.9",
     "typescript": "^5.1.6",