intor 2.4.17 → 2.5.0

package/dist/svelte-kit/src/routing/inbound/resolve-inbound.js

@@ -2,7 +2,7 @@ import { getLocaleFromPathname } from '../locale/get-locale-from-pathname.js';
 import { getLocaleFromHost } from '../locale/get-locale-from-host.js';
 import { getLocaleFromQuery } from '../locale/get-locale-from-query.js';
 import { resolveLocale } from './resolve-locale/resolve-locale.js';
-import { resolvePath } from './resolve-path/resolve-path.js';
+import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
 
 /**
  * Resolves inbound routing state.
@@ -13,24 +13,26 @@ import { resolvePath } from './resolve-path/resolve-path.js';
  *
  * No side effects. No navigation.
  */
-async function resolveInbound(config, rawPathname, localeInputs, options) {
+function resolveInbound(config, rawPathname, localeInputs, options) {
     const { queryKey } = config.routing.inbound;
     const { host, query, cookie, detected } = localeInputs;
     // ------------------------------------------------------
     // Resolve locale from inbound inputs
     // ------------------------------------------------------
     const pathLocale = getLocaleFromPathname(rawPathname, config);
+    const hostLocale = getLocaleFromHost(host);
+    const queryLocale = getLocaleFromQuery(query, queryKey);
     const { locale, localeSource } = resolveLocale(config, {
-        path: { locale: pathLocale },
-        host: { locale: getLocaleFromHost(host) },
-        query: { locale: getLocaleFromQuery(query, queryKey) },
-        cookie: { locale: cookie },
-        detected: { locale: detected },
+        ...(pathLocale !== undefined && { path: { locale: pathLocale } }),
+        ...(hostLocale !== undefined && { host: { locale: hostLocale } }),
+        ...(queryLocale !== undefined && { query: { locale: queryLocale } }),
+        ...(cookie !== undefined && { cookie: { locale: cookie } }),
+        ...(detected !== undefined && { detected: { locale: detected } }),
     });
     // ------------------------------------------------------
     // Resolve localized pathname and redirect requirement
     // ------------------------------------------------------
-    const { pathname, shouldRedirect } = resolvePath(config, rawPathname, {
+    const { pathname, shouldRedirect } = resolvePathname(config, rawPathname, {
         locale,
         hasPathLocale: !!pathLocale,
         hasPersisted: !!cookie});

package/dist/svelte-kit/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,18 +1,23 @@
-import '../../../core/error/intor-error.js';
 import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Resolve the active locale from inbound routing configuration.
+ * Resolves the active locale from inbound routing configuration.
  *
- * Iterates through configured locale sources and returns the first normalized, supported locale.
+ * Resolution order:
+ * 1. Configured locale signals (path / query / host / cookie)
+ * 2. Runtime detection signal ("detected")
+ * 3. Invariant fallback ("default")
  *
- * Falls back to the detected locale or the default locale if none match.
+ * Always returns a supported locale.
  */
 function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
+    // ------------------------------------------------------
+    // 1. Configured resolution signals (policy-ordered)
+    // ------------------------------------------------------
     for (const source of localeSources) {
         const locale = context[source]?.locale;
         const normalized = matchLocale(locale, config.supportedLocales);
@@ -23,12 +28,22 @@ function resolveLocale(config, context) {
             localeSource: source,
         };
     }
-    // Fallback: detected is always available
-    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
-        config.defaultLocale;
+    // ------------------------------------------------------
+    // 2. Detection fallback (runtime signal)
+    // ------------------------------------------------------
+    const detected = matchLocale(context.detected?.locale, config.supportedLocales);
+    if (detected) {
+        return {
+            locale: detected,
+            localeSource: "detected",
+        };
+    }
+    // ------------------------------------------------------
+    // 3. Final invariant fallback (guaranteed)
+    // ------------------------------------------------------
     return {
-        locale: fallback,
-        localeSource: "detected",
+        locale: config.defaultLocale,
+        localeSource: "default",
     };
 }
 

package/dist/svelte-kit/src/routing/inbound/resolve-pathname/resolve-pathname.js

@@ -0,0 +1,42 @@
+import { localizePathname } from '../../pathname/localize-pathname.js';
+import { all } from './strategies/all.js';
+import { exceptDefault } from './strategies/except-default.js';
+import { none } from './strategies/none.js';
+
+const assertNever = (x) => {
+    throw new Error(`Unhandled prefix strategy: ${String(x)}`);
+};
+/**
+ * Resolves the canonical pathname based on locale prefix behavior.
+ *
+ * The resolved pathname represents the final, normalized form
+ * used for routing and navigation.
+ */
+const resolvePathname = (config, rawPathname, context) => {
+    const { localePrefix } = config.routing;
+    let directive;
+    switch (localePrefix) {
+        case "all": {
+            directive = all(config, context);
+            break;
+        }
+        case "except-default": {
+            directive = exceptDefault(config, context);
+            break;
+        }
+        case "none": {
+            directive = none();
+            break;
+        }
+        default: {
+            return assertNever(localePrefix);
+        }
+    }
+    const { pathname } = localizePathname(rawPathname, config, context.locale);
+    return {
+        pathname,
+        shouldRedirect: directive.type === "redirect",
+    };
+};
+
+export { resolvePathname };

package/dist/svelte-kit/src/routing/locale/get-locale-from-accept-language.js

@@ -20,16 +20,18 @@ const getLocaleFromAcceptLanguage = (acceptLanguageHeader, supportedLocales) =>
     const supportedLocalesSet = new Set(supportedLocales);
     // 1. Parse Accept-Language header into language + priority pairs
     const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
-        const [rawLang, rawQ] = part.split(";");
+        const segments = part.split(";");
+        const rawLang = segments[0];
+        const rawQ = segments[1];
         const lang = rawLang.trim();
-        const q = rawQ ? Number.parseFloat(rawQ.split("=")[1]) : 1;
+        const q = rawQ !== undefined ? Number.parseFloat(rawQ.split("=")[1] ?? "") : 1;
         return {
             lang,
             q: Number.isNaN(q) ? 0 : q, // Invalid q values have lowest priority
         };
     });
     // 2. Sort by priority (highest first)
-    const sortedByPriority = parsedLanguages.toSorted((a, b) => b.q - a.q);
+    const sortedByPriority = parsedLanguages.sort((a, b) => b.q - a.q);
     // 3. Pick the first language explicitly supported
     const preferred = sortedByPriority.find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
     return preferred;

package/dist/svelte-kit/src/routing/locale/get-locale-from-pathname.js

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';

package/dist/svelte-kit/src/routing/outbound/utils/derive-host-destination.js

@@ -6,7 +6,7 @@ const deriveHostDestination = (rawDestination, config, locale) => {
     const resolvedHost = host.map[locale] ?? host.default;
     if (!resolvedHost)
         return rawDestination;
-    const url = new URL(rawDestination, "http://internal");
+    const url = new URL(rawDestination, "http://localhost");
     return `${url.protocol}//${resolvedHost}${url.pathname}${url.search}`;
 };
 

package/dist/svelte-kit/src/routing/outbound/utils/derive-query-destination.js

@@ -3,7 +3,7 @@
  */
 const deriveQueryDestination = (rawDestination, config, locale) => {
     const { queryKey } = config.routing.outbound;
-    const url = new URL(rawDestination, "http://internal");
+    const url = new URL(rawDestination, "http://localhost");
     url.searchParams.set(queryKey, locale);
     return `${url.pathname}${url.search}`;
 };

package/dist/svelte-kit/src/routing/pathname/canonicalize-pathname.js

@@ -1,47 +1,78 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Returns a canonical, locale-agnostic pathname.
+ * Returns the internal canonical pathname.
+ *
+ * Canonical representation is the locale-neutral and deployment-neutral
+ * internal routing form used for identity and routing computation.
+ *
+ * Guarantees:
+ * - Pathname is normalized
+ * - Deployment prefix (`basePath`) is removed
+ * - Leading locale segment or `{locale}` placeholder is removed
+ * - Only the first path segment is evaluated for locale stripping
+ * - Result always starts with "/"
+ * - Root is represented as "/"
  *
  * Accepts `{locale}` as a locale placeholder segment.
  *
  * @example
  * ```ts
- * // config.supportedLocales: ["en-US"]
+ * // config.supportedLocales: ["en"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * canonicalizePathname("/app/en-US/about", config);
+ * canonicalizePathname("/app/en/about", config);
  * // => "/about"
  *```
  */
 function canonicalizePathname(rawPathname, config) {
     const { routing, supportedLocales } = config;
-    const { basePath } = routing;
     const normalizedPathname = normalizePathname(rawPathname);
-    // Strip basePath
-    let prefixedPathname = normalizedPathname;
-    if (basePath && normalizedPathname === basePath) {
-        prefixedPathname = "/";
+    // ---------------------------------------------------------------------------
+    // Strip basePath (deployment prefix)
+    // ---------------------------------------------------------------------------
+    const basePath = routing.basePath === "/" ? "" : routing.basePath;
+    let path = normalizedPathname;
+    if (basePath) {
+        if (path === basePath) {
+            path = "/";
+        }
+        else if (path.startsWith(basePath + "/")) {
+            path = path.slice(basePath.length);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Detect first segment (allocation-minimized)
+    // ---------------------------------------------------------------------------
+    if (path === "/")
+        return "/";
+    const segmentStart = 1; // skip leading "/"
+    const nextSlash = path.indexOf("/", segmentStart);
+    const firstSegment = nextSlash === -1
+        ? path.slice(segmentStart)
+        : path.slice(segmentStart, nextSlash);
+    // ---------------------------------------------------------------------------
+    // Determine if first segment is locale representation
+    // ---------------------------------------------------------------------------
+    let localeLength;
+    if (firstSegment === LOCALE_PLACEHOLDER) {
+        localeLength = firstSegment.length;
+    }
+    else if (supportedLocales.includes(firstSegment)) {
+        localeLength = firstSegment.length;
     }
-    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-        prefixedPathname = normalizedPathname.slice(basePath.length);
+    // ---------------------------------------------------------------------------
+    // Strip locale segment (if any)
+    // ---------------------------------------------------------------------------
+    if (localeLength !== undefined) {
+        const stripped = path.slice(localeLength + 1);
+        return stripped || "/";
     }
-    // Detect locale segment
-    const firstSegment = prefixedPathname.split("/").find(Boolean);
-    const locale = firstSegment === LOCALE_PLACEHOLDER
-        ? LOCALE_PLACEHOLDER
-        : firstSegment && supportedLocales.includes(firstSegment)
-            ? firstSegment
-            : undefined;
-    // Strip locale segment
-    return locale
-        ? prefixedPathname.slice(locale.length + 1) || "/"
-        : prefixedPathname;
+    return path;
 }
 
 export { canonicalizePathname };

package/dist/svelte-kit/src/routing/pathname/localize-pathname.js

@@ -14,22 +14,24 @@ import { standardizePathname } from './standardize-pathname.js';
  * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
- * //   unprefixedPathname: '/about',
+ * //   canonicalPathname: '/about',
  * //   templatedPathname: '/app/{locale}/about',
  * // }
  * ```
+ *
+ * @public
  */
 const localizePathname = (rawPathname, config, locale) => {
     // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalized = canonicalizePathname(rawPathname, config);
+    const canonicalPathname = canonicalizePathname(rawPathname, config);
     // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardized = standardizePathname(canonicalized, config);
+    const standardizedPathname = standardizePathname(canonicalPathname, config);
     // 3. Materialize: apply routing rules to produce the final pathname
-    const materialized = materializePathname(standardized, config, locale);
+    const materializedPathname = materializePathname(standardizedPathname, config, locale);
     return {
-        pathname: materialized,
-        unprefixedPathname: canonicalized,
-        templatedPathname: standardized,
+        canonicalPathname,
+        templatedPathname: standardizedPathname,
+        pathname: materializedPathname,
     };
 };
 

package/dist/svelte-kit/src/routing/pathname/materialize-pathname.js

@@ -1,42 +1,53 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Materializes a standardized pathname by applying
- * the configured locale prefix behavior.
+ * Materializes a standardized pathname into a concrete, locale-aware URL.
+ *
+ * This function resolves the `{locale}` placeholder according to the
+ * configured `localePrefix` strategy and produces the final pathname.
+ *
+ * Behavior:
+ * - "all": always injects the locale segment
+ * - "except-default": injects the locale unless it equals `defaultLocale`
+ * - "none": removes the locale placeholder entirely
+ *
+ * Invariants:
+ * - `standardizedPathname` must be produced by `standardizePathname`
+ * - The pathname must contain exactly one `{locale}` placeholder
+ * - The placeholder must appear as the first path segment
+ *
+ * This function performs structural transformation only.
+ * It does not normalize or sanitize the resulting pathname.
  *
  * @example
  * ```ts
  * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/en-US/about
+ * materializePathname("/app/{locale}/about", config, "en");
+ * // => /app/en/about
  *
  * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en-US");
+ * materializePathname("/app/{locale}/about", config, "en");
  * // => /app/about
  * ```
  */
 const materializePathname = (standardizedPathname, config, locale) => {
     const { localePrefix } = config.routing;
-    if (localePrefix !== "none" && !locale) {
-        throw new Error('No locale when using localePrefix "all", "except-default"');
-    }
+    const removeLocale = () => {
+        const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
+        return result === "" ? "/" : result;
+    };
+    const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
+    // localePrefix: "none"
+    if (localePrefix === "none")
+        return removeLocale();
     // localePrefix: "all"
-    if (localePrefix === "all") {
-        return normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
+    if (localePrefix === "all")
+        return injectLocale();
     // localePrefix: "except-default"
-    if (localePrefix === "except-default") {
-        return locale === config.defaultLocale
-            ? normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""))
-            : normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // localePrefix: "none"
-    return normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""));
+    return locale === config.defaultLocale ? removeLocale() : injectLocale();
 };
 
 export { materializePathname };

package/dist/svelte-kit/src/routing/pathname/standardize-pathname.js

@@ -1,34 +1,39 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Standardizes a canonical pathname into an internal routing template
- * by applying the base path and injecting a locale placeholder.
+ * Standardizes a canonical pathname into an internal routing template.
+ *
+ * Standardized representation:
+ * - Prepends the deployment prefix (`basePath`) if defined
+ * - Injects the `{locale}` placeholder as the first path segment
+ * - Preserves the canonical pathname structure
+ *
+ * Input must be a canonical pathname.
+ *
+ * Output is an internal routing template and
+ * is not a locale-resolved URL.
  *
  * @example
  * ```ts
  * // config.routing.basePath: "/app",
- * // config.routing.prefix: "all"
  * standardizePathname("/about", config);
  * // => "/app/{locale}/about"
  * ```
  */
-const standardizePathname = (canonicalizedPathname, config) => {
-    const { basePath } = config.routing;
-    // Normalize each segment before join to avoid redundant slashes
-    const parts = [
-        normalizePathname(basePath),
-        LOCALE_PLACEHOLDER,
-        normalizePathname(canonicalizedPathname),
-    ];
-    // Avoid double slashes between segments
-    const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-    // Final normalization to ensure leading slash, no trailing
-    return normalizePathname(standardizedPathname);
+const standardizePathname = (canonicalPathname, config) => {
+    const { routing } = config;
+    const basePath = routing.basePath && routing.basePath !== "/" ? routing.basePath : "";
+    if (canonicalPathname === "/") {
+        return basePath
+            ? `${basePath}/${LOCALE_PLACEHOLDER}`
+            : `/${LOCALE_PLACEHOLDER}`;
+    }
+    return basePath
+        ? `${basePath}/${LOCALE_PLACEHOLDER}${canonicalPathname}`
+        : `/${LOCALE_PLACEHOLDER}${canonicalPathname}`;
 };
 
 export { standardizePathname };

package/dist/types/export/edge/index.d.ts

@@ -1,2 +1,3 @@
-export { getTranslator } from "../../src/edge";
-export { resolveInboundFromRequest } from "../../src/routing";
+export * from "../shared-types";
+export { getTranslator, type GetTranslatorParams, } from "../../src/edge";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/edge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/edge/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAEL,aAAa,EACb,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC"}

package/dist/types/export/express/index.d.ts

@@ -1 +1,4 @@
+export * from "../shared-types";
 export { createIntorHandler, getTranslator } from "../../src/adapters/express";
+export type { GetTranslatorParams } from "../../src/server";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/express/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/express/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/types/export/fastify/index.d.ts

@@ -1 +1,4 @@
-export { intorFastifyPlugin, getTranslator } from "../../src/adapters/fastify";
+export * from "../shared-types";
+export { intorFastifyPlugin, type IntorFastifyPluginOptions, getTranslator, } from "../../src/adapters/fastify";
+export type { GetTranslatorParams } from "../../src/server";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/fastify/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/fastify/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,aAAa,GACd,MAAM,4BAA4B,CAAC;AAEpC,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/types/export/hono/index.d.ts

@@ -1 +1,4 @@
+export * from "../shared-types";
 export { createIntorHandler, getTranslator } from "../../src/adapters/hono";
+export type { GetTranslatorParams } from "../../src/edge";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/hono/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/hono/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE5E,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/types/export/index.d.ts

@@ -1,4 +1,7 @@
-export { LOCALE_PLACEHOLDER, IntorError, IntorErrorCode, matchLocale, clearLoggerPool, mergeMessages, type MessagesReader, type MessagesReaders, type GenLocale as Locale, } from "../src/core";
-export { defineIntorConfig, type IntorRawConfig, type IntorResolvedConfig, } from "../src/config";
-export { localizePathname, type InboundContext } from "../src/routing";
-export { Translator, type TranslatorPlugin, type TranslateContext, type TranslateHook, type TranslateHandlers, type HandlerContext, type FormatHandler, type LoadingHandler, type MissingHandler, type LocaleMessages, type MessageObject, type MessageValue, } from "intor-translator";
+export * from "./shared-types";
+export { type IntorErrorOptions, IntorError, INTOR_ERROR_CODE, type IntorErrorCode, matchLocale, mergeMessages, type MergeMessagesOptions, type MergeMessagesEvent, } from "../src/core";
+export { defineIntorConfig } from "../src/config";
+export { localizePathname, type LocalizedPathname, type InboundResult, type InboundContext, resolveInboundFromRequest, } from "../src/routing";
+export { getClientLocale } from "../src/client";
+export type { Translator, TranslateContext, TranslateHook, TranslateHandlers, HandlerContext, FormatHandler, LoadingHandler, MissingHandler, LocaleMessages, MessageObject, MessageValue, } from "intor-translator";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../export/index.ts"],"names":[],"mappings":"AAEA,cAAc,gBAAgB,CAAC;AAK/B,OAAO,EAEL,KAAK,iBAAiB,EACtB,UAAU,EACV,gBAAgB,EAChB,KAAK,cAAc,EAGnB,WAAW,EAGX,aAAa,EACb,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,GACxB,MAAM,aAAa,CAAC;AAKrB,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAKlD,OAAO,EAEL,gBAAgB,EAChB,KAAK,iBAAiB,EAGtB,KAAK,aAAa,EAClB,KAAK,cAAc,EAGnB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAKhD,YAAY,EACV,UAAU,EAGV,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,cAAc,EACd,cAAc,EAGd,cAAc,EACd,aAAa,EACb,YAAY,GACb,MAAM,kBAAkB,CAAC"}

package/dist/types/export/internal/index.d.ts

@@ -1,7 +1,10 @@
 /**
  *  NOTE: It is not part of the public stable contract and may change without notice.
  */
-export { resolveLoaderOptions, type DeepMergeOverrideEvent, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "../../src/core";
+export { resolveLoaderOptions, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, } from "../../src/core";
 export { loadMessages } from "../../src/server";
-export type { GenConfigKeys, GenConfig, TranslatorInstance, } from "../../src/core";
-export type { TranslatorInstanceReact } from "../../src/client/react/translator/translator-instance";
+export type { GenConfigKeys, GenConfig, BaseTranslator, } from "../../src/core";
+export type { ReactTranslator } from "../../src/client/react/translator/types";
+export type { VueTranslator } from "../../src/client/vue/translator/types";
+export type { SvelteTranslator } from "../../src/client/svelte/translator/types";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/internal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/internal/index.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH,OAAO,EAEL,oBAAoB,EAGpB,YAAY,EACZ,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,YAAY,EAEV,aAAa,EACb,SAAS,EAGT,cAAc,GACf,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,YAAY,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAC3E,YAAY,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC"}

package/dist/types/export/next/index.d.ts

@@ -1 +1,3 @@
-export { Link, useRouter, redirect, createIntorHandler } from "../../src/adapters/next";
+export * from "../shared-types";
+export { Link, useRouter, redirect, createIntorHandler, } from "../../src/adapters/next";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/next/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/next/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EACL,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,kBAAkB,GACnB,MAAM,yBAAyB,CAAC"}

package/dist/types/export/next/server/index.d.ts

@@ -1 +1,4 @@
-export { intor, getLocale, getTranslator } from "../../../src/adapters/next/server";
+export * from "../../shared-types";
+export { intor, getLocale, getTranslator, } from "../../../src/adapters/next/server";
+export type { IntorValue, IntorOptions, GetTranslatorParams, } from "../../../src/server";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/next/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../export/next/server/index.ts"],"names":[],"mappings":"AAEA,cAAc,oBAAoB,CAAC;AAEnC,OAAO,EACL,KAAK,EACL,SAAS,EACT,aAAa,GACd,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EACV,UAAU,EACV,YAAY,EACZ,mBAAmB,GACpB,MAAM,qBAAqB,CAAC"}

package/dist/types/export/react/index.d.ts

@@ -1,2 +1,3 @@
-export { IntorProvider, type IntorProviderProps, useIntorContext, // @internal
-useTranslator, Trans, useIntor, getClientLocale, } from "../../src/client/react";
+export * from "../shared-types";
+export { IntorProvider, type IntorProviderProps, type IntorValue, useTranslator, type ReactTranslator, type ReactTagRenderers, useIntor, } from "../../src/client/react";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/react/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAEL,aAAa,EACb,KAAK,kBAAkB,EACvB,KAAK,UAAU,EAGf,aAAa,EACb,KAAK,eAAe,EAGpB,KAAK,iBAAiB,EAGtB,QAAQ,GACT,MAAM,wBAAwB,CAAC"}

package/dist/types/export/react/internal/index.d.ts

@@ -0,0 +1,2 @@
+export { useIntorContext } from "../../../src/client/react";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/react/internal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../export/react/internal/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/types/export/server/index.d.ts

@@ -1 +1,3 @@
-export { intor, type IntorValue, clearMessagesPool, getTranslator, type MessagesLoader, } from "../../src/server";
+export * from "../shared-types";
+export { intor, type IntorOptions, type IntorValue, getTranslator, type GetTranslatorParams, } from "../../src/server";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/server/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAEL,KAAK,EACL,KAAK,YAAY,EACjB,KAAK,UAAU,EAGf,aAAa,EACb,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC"}

package/dist/types/export/shared-types.d.ts

@@ -0,0 +1,3 @@
+export type { TagRenderer, TagRenderers, HtmlTagRenderers, MessagesReader, MessagesReaders, MessagesLoader, INTOR_GENERATED_KEY, GenConfigKeys, GeneratedConfigKeys, HasGen, GenConfig, SafeExtract, FallbackConfig, GenMessages, GenLocale, GenReplacements, GenRich, BaseTranslator, RoutingLocaleCarrier, RoutingLocaleSignal, RoutingLocaleSource, LocalePathPrefix, RuntimeFetch, } from "../src/core";
+export type { IntorRawConfig, IntorResolvedConfig, IntorConfig, LoaderOptions, ServerLoaderOptions, ClientLoaderOptions, LocalLoader, RemoteLoader, RemoteHeaders, TranslatorOptions, RoutingRawOptions, RoutingResolvedOptions, RoutingStructuredOptions, RoutingFlatOptions, CookieRawOptions, CookieResolvedOptions, LoggerOptions, } from "../src/config";
+//# sourceMappingURL=shared-types.d.ts.map

package/dist/types/export/shared-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-types.d.ts","sourceRoot":"","sources":["../../../export/shared-types.ts"],"names":[],"mappings":"AAKA,YAAY,EAEV,WAAW,EACX,YAAY,EACZ,gBAAgB,EAGhB,cAAc,EACd,eAAe,EACf,cAAc,EAGd,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,MAAM,EACN,SAAS,EACT,WAAW,EACX,cAAc,EACd,WAAW,EACX,SAAS,EACT,eAAe,EACf,OAAO,EAEP,cAAc,EAEd,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAEhB,YAAY,GACb,MAAM,aAAa,CAAC;AAKrB,YAAY,EAEV,cAAc,EACd,mBAAmB,EACnB,WAAW,EAEX,aAAa,EACb,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,aAAa,EAEb,iBAAiB,EAEjB,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EACxB,kBAAkB,EAElB,gBAAgB,EAChB,qBAAqB,EAErB,aAAa,GACd,MAAM,eAAe,CAAC"}

package/dist/types/export/svelte/index.d.ts

@@ -1,6 +1,11 @@
-export { createIntorStore, // @internal
-type IntorProviderProps, useIntorContext, // @internal
-useTranslator, getClientLocale, } from "../../src/client/svelte";
+export * from "../shared-types";
+export { createIntorStore, type IntorProviderProps, type IntorValue, useTranslator, type SvelteTranslator, } from "../../src/client/svelte";
 import type { IntorProviderProps } from "../../src/client/svelte";
 import type { Component } from "svelte";
+/**
+ * Svelte provider component for Intor.
+ *
+ * @public
+ */
 export declare const IntorProvider: Component<IntorProviderProps>;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/svelte/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/svelte/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAEL,gBAAgB,EAChB,KAAK,kBAAkB,EACvB,KAAK,UAAU,EAGf,aAAa,EACb,KAAK,gBAAgB,GACtB,MAAM,yBAAyB,CAAC;AAIjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAGxC;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,kBAAkB,CAChC,CAAC"}

package/dist/types/export/svelte/internal/index.d.ts

@@ -0,0 +1,2 @@
+export { getIntorContext } from "../../../src/client/svelte";
+//# sourceMappingURL=index.d.ts.map