intor 1.0.26 → 1.0.28

package/dist/next/index.cjs

@@ -1,10 +1,6 @@
 'use strict';
 
-var React7 = require('react');
-var logry = require('logry');
-var intorTranslator = require('intor-translator');
-var server = require('next/server');
-var headers = require('next/headers');
+var React = require('react');
 var NextLink = require('next/link');
 var navigation = require('next/navigation');
 
@@ -28,12 +24,10 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React7__namespace = /*#__PURE__*/_interopNamespace(React7);
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var NextLink__default = /*#__PURE__*/_interopDefault(NextLink);
 
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -49,7 +43,6 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -62,98 +55,16 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-var IntorConfigContext = React7__namespace.createContext(void 0);
-var IntorConfigProvider = ({
-  value: { config, pathname },
-  children
-}) => {
-  const value = React7__namespace.useMemo(
-    () => ({
-      config,
-      pathname
-    }),
-    [config, pathname]
-  );
-  return /* @__PURE__ */ React7__namespace.createElement(IntorConfigContext.Provider, { value }, children);
-};
+var IntorLocaleContext = React__namespace.createContext(void 0);
+var IntorConfigContext = React__namespace.createContext(void 0);
 var useIntorConfig = () => {
-  const context = React7__namespace.useContext(IntorConfigContext);
+  const context = React__namespace.useContext(IntorConfigContext);
   if (!context) {
     throw new Error("useIntorConfig must be used within IntorConfigProvider");
   }
   return context;
 };
-var IntorLocaleContext = React7__namespace.createContext(void 0);
-
-// src/adapters/next-client/utils/build-cookie-string.ts
-var buildCookieString = (cookie, locale) => {
-  var _a;
-  const parts = [];
-  parts.push(`${cookie.name}=${encodeURIComponent(locale)}`);
-  if (cookie.maxAge) {
-    const expires = new Date(Date.now() + cookie.maxAge * 1e3).toUTCString();
-    parts.push(`expires=${expires}`);
-    parts.push(`max-age=${cookie.maxAge}`);
-  }
-  parts.push(`path=${(_a = cookie.path) != null ? _a : "/"}`);
-  if (cookie.domain) {
-    parts.push(`domain=${cookie.domain}`);
-  }
-  if (cookie.sameSite) {
-    parts.push(
-      `SameSite=${cookie.sameSite[0].toUpperCase()}${cookie.sameSite.slice(1).toLowerCase()}`
-    );
-  }
-  if (cookie.secure !== false) {
-    parts.push(`Secure`);
-  }
-  return parts.join("; ");
-};
-
-// src/adapters/next-client/utils/set-locale-cookie-client.ts
-var setLocaleCookieClient = ({
-  cookie,
-  locale
-}) => {
-  if (typeof window === "undefined") {
-    return;
-  }
-  if (cookie.disabled || !cookie.autoSetCookie) {
-    return;
-  }
-  const cookieString = buildCookieString(cookie, locale);
-  document.cookie = cookieString;
-};
-
-// src/adapters/next-client/contexts/intor-locale/utils/change-locale.ts
-var changeLocale = ({
-  currentLocale,
-  newLocale,
-  loaderOptions,
-  cookie,
-  setLocale,
-  refetchMessages
-}) => {
-  if (typeof document === "undefined") {
-    return;
-  }
-  const loaderType = loaderOptions == null ? void 0 : loaderOptions.type;
-  if (newLocale === currentLocale) {
-    return;
-  }
-  if (loaderType === "import") {
-    console.warn(
-      `[Intor] You are using dynamic import to switch languages. Please make sure to use the wrapped <Link> component to trigger a page reload, ensuring that the translation data is dynamically updated.`
-    );
-  }
-  setLocale(newLocale);
-  setLocaleCookieClient({ cookie, locale: newLocale });
-  document.documentElement.lang = newLocale;
-  if (loaderType === "api" && refetchMessages) {
-    void refetchMessages(newLocale);
-  }
-};
-var IntorMessagesContext = React7__namespace.createContext(void 0);
+var IntorMessagesContext = React__namespace.createContext(void 0);
 
 // src/shared/utils/pathname/normalize-pathname.ts
 var normalizePathname = (rawPathname, options = {}) => {
@@ -189,127 +100,6 @@ var normalizePathname = (rawPathname, options = {}) => {
   return result || "/";
 };
 
-// src/modules/intor-messages-loader/fetch-api-messages/build-search-params.ts
-var buildSearchParams = (params) => {
-  const searchParams = new URLSearchParams();
-  const appendParam = (key, value) => {
-    if (value === void 0 || value === null) {
-      return;
-    }
-    if (Array.isArray(value) && value.length > 0) {
-      value.forEach((v) => v && searchParams.append(key, v));
-    } else {
-      searchParams.append(key, value);
-    }
-  };
-  Object.entries(params).forEach(([key, value]) => {
-    appendParam(key, value);
-  });
-  return searchParams;
-};
-var fetcher = async ({
-  apiUrl,
-  locale,
-  searchParams,
-  loggerId
-}) => {
-  const logger = logry.logry({ id: loggerId, scope: "fetcher" });
-  try {
-    const params = new URLSearchParams(searchParams);
-    params.append("locale", locale);
-    const url = `${apiUrl}?${params.toString()}`;
-    const response = await fetch(url, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" },
-      cache: "no-store"
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Fetch failed for locale "${locale}" at URL: ${url} - ${response.status} ${response.statusText}`
-      );
-    }
-    const data = await response.json();
-    if (data == null || typeof data === "object" && Object.keys(data).length === 0) {
-      throw new Error(
-        `Missing or invalid messages for locale "${locale}" at URL: ${url}`
-      );
-    }
-    return data;
-  } catch (e) {
-    logger.warn(`Failed to fetch messages for locale "${locale}".`, {
-      locale,
-      apiUrl,
-      searchParams: decodeURIComponent(searchParams.toString())
-    });
-    return void 0;
-  }
-};
-
-// src/modules/intor-messages-loader/fetch-api-messages/fetch-fallback-messages.ts
-var fetchFallbackMessages = async (apiUrl, searchParams, fallbackLocales, loggerId) => {
-  for (const fallbackLocale of fallbackLocales) {
-    const result = await fetcher({
-      apiUrl,
-      searchParams,
-      locale: fallbackLocale,
-      loggerId
-    });
-    if (result) {
-      return { locale: fallbackLocale, messages: result };
-    }
-  }
-  return void 0;
-};
-
-// src/modules/intor-messages-loader/fetch-api-messages/fetch-api-messages.ts
-var fetchApiMessages = async ({
-  apiUrl,
-  basePath,
-  locale,
-  fallbackLocales = [],
-  namespaces = [],
-  loggerId
-}) => {
-  const logger = logry.logry({ id: loggerId, scope: "fetchApiMessages" });
-  if (!apiUrl) {
-    logger.warn("No apiUrl provided for fetchApiMessages. Skipping fetch.");
-    return void 0;
-  }
-  const searchParams = buildSearchParams({
-    basePath,
-    loggerId,
-    namespaces
-  });
-  const messages = await fetcher({
-    apiUrl,
-    searchParams,
-    locale,
-    loggerId
-  });
-  if (messages) {
-    return messages;
-  }
-  const fallbackResult = await fetchFallbackMessages(
-    apiUrl,
-    searchParams,
-    fallbackLocales,
-    loggerId
-  );
-  if (fallbackResult) {
-    logger.info("Fallback locale succeeded.", {
-      usedLocale: fallbackResult.locale,
-      apiUrl,
-      searchParams: decodeURIComponent(searchParams.toString())
-    });
-    return fallbackResult.messages;
-  }
-  logger.warn("Failed to fetch messages for all locales.", {
-    locale,
-    fallbackLocales
-  });
-  return void 0;
-};
-
 // src/shared/utils/pathname/extract-pathname.ts
 var extractPathname = ({
   config,
@@ -362,162 +152,8 @@ var standardizePathname = ({
   const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
   return normalizePathname(standardizedPathname);
 };
-
-// src/shared/utils/resolve-namespaces.ts
-var resolveNamespaces = ({
-  config,
-  pathname
-}) => {
-  var _a, _b, _c, _d;
-  const { loaderOptions, prefixPlaceHolder } = config;
-  const {
-    routeNamespaces = {},
-    namespaces: fallbackNamespaces
-  } = loaderOptions;
-  const { unprefixedPathname } = extractPathname({ config, pathname });
-  const standardizedPathname = standardizePathname({
-    config,
-    pathname: unprefixedPathname
-  });
-  const placeholderRemovedPathname = standardizedPathname.replace(
-    `/${prefixPlaceHolder}`,
-    ""
-  );
-  const defaultNamespaces = (_a = routeNamespaces.default) != null ? _a : [];
-  const exactMatchNamespaces = (_b = routeNamespaces[standardizedPathname]) != null ? _b : routeNamespaces[placeholderRemovedPathname];
-  if (exactMatchNamespaces) {
-    return [...defaultNamespaces, ...exactMatchNamespaces];
-  }
-  let bestMatch = "";
-  let bestNamespaces;
-  const prefixPatterns = Object.keys(routeNamespaces).filter(
-    (pattern) => pattern.endsWith("/*")
-  );
-  for (const pattern of prefixPatterns) {
-    const basePath = pattern.replace(/\/\*$/, "");
-    if (standardizedPathname.startsWith(basePath)) {
-      if (basePath.length > bestMatch.length) {
-        bestMatch = basePath;
-        bestNamespaces = routeNamespaces[pattern];
-      }
-    }
-  }
-  const matchedNamespaces = (_d = (_c = bestNamespaces != null ? bestNamespaces : routeNamespaces["/*"]) != null ? _c : fallbackNamespaces) != null ? _d : [];
-  if (matchedNamespaces.length > 0) {
-    return [...defaultNamespaces, ...matchedNamespaces];
-  } else {
-    return [...defaultNamespaces];
-  }
-};
-
-// src/adapters/next-client/hooks/api/use-fetch-messages.ts
-var useFetchMessages = ({
-  onError
-}) => {
-  const fetcher2 = async (params) => {
-    try {
-      const data = await fetchApiMessages(params);
-      return data;
-    } catch (error) {
-      onError == null ? void 0 : onError(error, params.apiUrl);
-      return null;
-    }
-  };
-  return { fetcher: fetcher2 };
-};
-
-// src/shared/utils/merge-static-and-dynamic-messages.ts
-var mergeStaticAndDynamicMessages = (staticMessages = {}, dynamicMessages = {}) => {
-  const result = Object.keys(staticMessages).length ? __spreadValues({}, staticMessages) : {};
-  for (const locale in dynamicMessages) {
-    const dynamic = dynamicMessages[locale];
-    if (!result[locale]) {
-      result[locale] = dynamic;
-      continue;
-    }
-    result[locale] = __spreadValues(__spreadValues({}, result[locale]), dynamic);
-  }
-  return result;
-};
-
-// src/adapters/next-client/hooks/api/use-refetch-messages.ts
-var useRefetchMessages = ({
-  config,
-  pathname,
-  setLoadedMessages,
-  setIsLoadingMessages,
-  onError
-  // Error handler
-}) => {
-  const { messages: staticMessages } = config;
-  const namespaces = React7__namespace.useMemo(() => {
-    if (!config.loaderOptions) {
-      return [];
-    }
-    return resolveNamespaces({ config, pathname });
-  }, [config, pathname]);
-  const { fetcher: fetcher2 } = useFetchMessages({ onError });
-  const refetchMessages = React7__namespace.useCallback(
-    async (newLocale) => {
-      var _a;
-      if (((_a = config.loaderOptions) == null ? void 0 : _a.type) === "api") {
-        setIsLoadingMessages(true);
-        const dynamicMessages = await fetcher2(__spreadProps(__spreadValues({}, config.loaderOptions), {
-          locale: newLocale,
-          fallbackLocales: config.fallbackLocales[newLocale] || [],
-          namespaces,
-          loggerId: config.id
-        }));
-        const messages = mergeStaticAndDynamicMessages(
-          staticMessages,
-          dynamicMessages
-        );
-        setLoadedMessages(messages);
-        setIsLoadingMessages(false);
-      }
-    },
-    [
-      config.loaderOptions,
-      config.fallbackLocales,
-      config.id,
-      setIsLoadingMessages,
-      fetcher2,
-      namespaces,
-      staticMessages,
-      setLoadedMessages
-    ]
-  );
-  return { refetchMessages };
-};
-
-// src/adapters/next-client/contexts/intor-messages/intor-messages-provider.tsx
-var IntorMessagesProvider = ({
-  value: { messages },
-  children
-}) => {
-  const { config, pathname } = useIntorConfig();
-  const [loadedMessages, setLoadedMessages] = React7__namespace.useState(null);
-  const [isLoadingMessages, setIsLoadingMessages] = React7__namespace.useState(false);
-  const { refetchMessages } = useRefetchMessages({
-    config,
-    pathname,
-    setLoadedMessages,
-    setIsLoadingMessages
-  });
-  const value = React7__namespace.useMemo(
-    () => ({
-      messages: loadedMessages || messages,
-      isLoading: isLoadingMessages,
-      setLoadedMessages,
-      setIsLoadingMessages,
-      refetchMessages
-    }),
-    [loadedMessages, messages, isLoadingMessages, refetchMessages]
-  );
-  return /* @__PURE__ */ React7__namespace.createElement(IntorMessagesContext.Provider, { value }, children);
-};
 var useIntorMessages = () => {
-  const context = React7__namespace.useContext(IntorMessagesContext);
+  const context = React__namespace.useContext(IntorMessagesContext);
   if (!context) {
     throw new Error(
       "useIntorMessages must be used within a IntorMessagesProvider"
@@ -525,145 +161,21 @@ var useIntorMessages = () => {
   }
   return context;
 };
-var useInitLazyLoad = ({
-  loaderOptions,
-  currentLocale
-}) => {
-  const { refetchMessages } = useIntorMessages();
-  const lazyLoad = !!(loaderOptions == null ? void 0 : loaderOptions.lazyLoad);
-  const isFirstLoadedRef = React7__namespace.useRef(false);
-  React7__namespace.useEffect(() => {
-    if (lazyLoad && !isFirstLoadedRef.current) {
-      void refetchMessages(currentLocale);
-      isFirstLoadedRef.current = true;
-    }
-  }, [lazyLoad, currentLocale, refetchMessages, isFirstLoadedRef]);
-};
-var useInitLocaleCookie = ({
-  config,
-  locale
-}) => {
-  React7__namespace.useEffect(() => {
-    if (typeof document === "undefined") {
-      return;
-    }
-    const { cookie, routing } = config;
-    const { firstVisit } = routing;
-    const cookies = document.cookie.split(";").map((c) => c.trim());
-    const isCookieExists = cookies.some((c) => c.startsWith(`${cookie.name}=`));
-    if (isCookieExists) {
-      return;
-    }
-    if (!firstVisit.redirect) {
-      return;
-    }
-    if (cookie.disabled || !cookie.autoSetCookie) {
-      return;
-    }
-    setLocaleCookieClient({ cookie, locale });
-  }, []);
-};
-
-// src/adapters/next-client/contexts/intor-locale/intor-locale-provider.tsx
-var IntorLocaleProvider = ({
-  value: { initialLocale },
-  children
-}) => {
-  const { config } = useIntorConfig();
-  const { refetchMessages } = useIntorMessages();
-  const { loaderOptions, cookie } = config;
-  const [currentLocale, setCurrentLocale] = React7__namespace.useState(initialLocale);
-  useInitLazyLoad({ loaderOptions, currentLocale });
-  useInitLocaleCookie({ config, locale: initialLocale });
-  const setLocale = React7__namespace.useCallback(
-    (newLocale) => {
-      changeLocale({
-        currentLocale,
-        newLocale,
-        loaderOptions,
-        cookie,
-        setLocale: setCurrentLocale,
-        refetchMessages
-      });
-    },
-    [currentLocale, loaderOptions, cookie, refetchMessages]
-  );
-  const value = React7__namespace.useMemo(
-    () => ({
-      locale: currentLocale,
-      setLocale
-    }),
-    [currentLocale, setLocale]
-  );
-  return /* @__PURE__ */ React7__namespace.createElement(IntorLocaleContext.Provider, { value }, children);
-};
 var useIntorLocale = () => {
-  const context = React7__namespace.useContext(IntorLocaleContext);
+  const context = React__namespace.useContext(IntorLocaleContext);
   if (!context) {
     throw new Error("useIntorLocale must be used within a IntorLocaleProvider");
   }
   return context;
 };
-var IntorTranslatorContext = React7__namespace.createContext(void 0);
-var TranslateHandlersContext = React7__namespace.createContext(void 0);
-var TranslateHandlersProvider = ({
-  children,
-  handlers
-}) => {
-  const value = handlers;
-  return /* @__PURE__ */ React7__namespace.createElement(TranslateHandlersContext.Provider, { value }, children);
-};
+var IntorTranslatorContext = React__namespace.createContext(void 0);
+var TranslateHandlersContext = React__namespace.createContext(void 0);
 var useTranslateHandlers = () => {
-  const context = React7__namespace.useContext(TranslateHandlersContext);
+  const context = React__namespace.useContext(TranslateHandlersContext);
   return context;
 };
-var useInitLoadingState = (config) => {
-  var _a;
-  const lazyLoad = !!((_a = config.loaderOptions) == null ? void 0 : _a.lazyLoad);
-  const [isCsr, setIsCsr] = React7__namespace.useState(false);
-  React7__namespace.useEffect(() => {
-    setIsCsr(true);
-  }, []);
-  const isBeforeCSRLoading = lazyLoad && !isCsr;
-  return isBeforeCSRLoading;
-};
-
-// src/adapters/next-client/contexts/intor-translator/intor-translator-provider.tsx
-var EMPTY_OBJECT = Object.freeze({});
-var IntorTranslatorProvider = ({
-  children
-}) => {
-  const { config } = useIntorConfig();
-  const { messages, isLoading } = useIntorMessages();
-  const { locale } = useIntorLocale();
-  const translatorHandlers = useTranslateHandlers();
-  const { fallbackLocales, translator: translatorOptions } = config;
-  const isBeforeCSRLoading = useInitLoadingState(config);
-  const value = React7__namespace.useMemo(() => {
-    const translator = new intorTranslator.Translator({
-      messages: messages || EMPTY_OBJECT,
-      locale,
-      fallbackLocales,
-      loadingMessage: translatorOptions == null ? void 0 : translatorOptions.loadingMessage,
-      placeholder: translatorOptions == null ? void 0 : translatorOptions.placeholder,
-      handlers: translatorHandlers
-    });
-    translator.setLoading(isBeforeCSRLoading || isLoading);
-    return { translator };
-  }, [
-    fallbackLocales,
-    isBeforeCSRLoading,
-    isLoading,
-    locale,
-    messages,
-    translatorHandlers,
-    translatorOptions == null ? void 0 : translatorOptions.loadingMessage,
-    translatorOptions == null ? void 0 : translatorOptions.placeholder
-  ]);
-  return /* @__PURE__ */ React7__namespace.createElement(IntorTranslatorContext.Provider, { value }, children);
-};
 function useIntorTranslator() {
-  const context = React7__namespace.useContext(IntorTranslatorContext);
+  const context = React__namespace.useContext(IntorTranslatorContext);
   if (!context) {
     throw new Error(
       "useIntorTranslator must be used within IntorTranslatorProvider"
@@ -672,19 +184,6 @@ function useIntorTranslator() {
   return context;
 }
 
-// src/adapters/next-client/contexts/intor-client-provider.tsx
-var IntorClientProvider = ({
-  value: { config, pathname, initialLocale, messages },
-  children
-}) => {
-  return /* @__PURE__ */ React7__namespace.createElement(IntorConfigProvider, { value: { config, pathname } }, /* @__PURE__ */ React7__namespace.createElement(IntorMessagesProvider, { value: { messages } }, /* @__PURE__ */ React7__namespace.createElement(IntorLocaleProvider, { value: { initialLocale } }, /* @__PURE__ */ React7__namespace.createElement(IntorTranslatorProvider, null, children))));
-};
-
-// src/adapters/next-client/contexts/intor-provider.tsx
-var IntorProvider = (props) => {
-  return /* @__PURE__ */ React7__namespace.createElement(IntorClientProvider, __spreadValues({}, props));
-};
-
 // src/adapters/next-client/hooks/use-intor/use-intor.ts
 function useIntorWithPreKey(preKey) {
   const { translator } = useIntorTranslator();
@@ -717,46 +216,6 @@ function useIntor(preKey) {
   return useIntorWithoutPreKey();
 }
 
-// src/adapters/next-client/routing/utils/set-locale-cookie-edge.ts
-function setLocaleCookieEdge({
-  request,
-  response,
-  cookie,
-  locale,
-  override = false
-  // Default to not override existed cookie
-}) {
-  if (cookie.disabled || !cookie.autoSetCookie) {
-    return;
-  }
-  const isCookieExists = request.cookies.has(cookie.name);
-  if (isCookieExists && !override) {
-    return;
-  }
-  response.cookies.set(cookie.name, locale, __spreadProps(__spreadValues({
-    maxAge: cookie.maxAge,
-    path: cookie.path
-  }, cookie.domain ? { domain: cookie.domain } : {}), {
-    secure: cookie.secure,
-    httpOnly: cookie.httpOnly,
-    sameSite: cookie.sameSite
-  }));
-}
-
-// src/adapters/next-client/constants/header-key-constants.ts
-var DEFAULT_PATHNAME_HEADER_NAME = "x-intor-pathname";
-
-// src/adapters/next-client/routing/utils/set-pathname-header.ts
-var setPathnameHeader = ({
-  request,
-  response,
-  key = DEFAULT_PATHNAME_HEADER_NAME
-}) => {
-  const pathname = request.nextUrl.pathname;
-  response.headers.set(key, pathname);
-  return response;
-};
-
 // src/adapters/next-client/utils/locale-prefix-pathname.ts
 var localePrefixPathname = ({
   config,
@@ -807,240 +266,6 @@ var localizePathname = ({
   };
 };
 
-// src/adapters/next-client/routing/utils/create-response.ts
-var createResponse = ({
-  request,
-  config,
-  locale,
-  responseType = "next",
-  setCookieOptions = { override: false }
-}) => {
-  const { cookie } = config;
-  const { override } = setCookieOptions;
-  const url = request.nextUrl.clone();
-  const { localePrefixedPathname } = localizePathname({
-    config,
-    pathname: url.pathname,
-    locale
-  });
-  url.pathname = localePrefixedPathname;
-  let response;
-  switch (responseType) {
-    case "next": {
-      response = server.NextResponse.next();
-      break;
-    }
-    case "redirect": {
-      response = server.NextResponse.redirect(url);
-      break;
-    }
-    default: {
-      throw new Error(`Unsupported responseType: ${responseType}`);
-    }
-  }
-  if (locale) {
-    setLocaleCookieEdge({
-      request,
-      response,
-      locale,
-      cookie,
-      override
-    });
-  }
-  const finalResponse = setPathnameHeader({ request, response });
-  return finalResponse;
-};
-
-// src/shared/utils/locale/normalize-locale.ts
-var normalizeLocale = (locale = "", supportedLocales = []) => {
-  if (!locale || supportedLocales.length === 0) return void 0;
-  const toCanonical = (input) => {
-    var _a;
-    try {
-      return (_a = Intl.getCanonicalLocales(input)[0]) == null ? void 0 : _a.toLowerCase();
-    } catch (e) {
-      return void 0;
-    }
-  };
-  const canonicalLocale = toCanonical(locale);
-  if (!canonicalLocale) return void 0;
-  const supportedCanonicalMap = /* @__PURE__ */ new Map();
-  for (const l of supportedLocales) {
-    const normalized = toCanonical(l);
-    if (normalized) {
-      supportedCanonicalMap.set(normalized, l);
-    }
-  }
-  if (supportedCanonicalMap.has(canonicalLocale)) {
-    return supportedCanonicalMap.get(canonicalLocale);
-  }
-  const baseLang = canonicalLocale.split("-")[0];
-  for (const [key, original] of supportedCanonicalMap) {
-    const supportedBase = key.split("-")[0];
-    if (supportedBase === baseLang) {
-      return original;
-    }
-  }
-  return void 0;
-};
-
-// src/shared/utils/locale/resolve-preferred-locale.ts
-var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
-  var _a;
-  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
-    return;
-  }
-  const supportedLocalesSet = new Set(supportedLocales);
-  const preferred = (_a = acceptLanguageHeader.split(",").map((part) => {
-    const [lang, qValue] = part.split(";");
-    const q = qValue ? parseFloat(qValue.split("=")[1]) : 1;
-    if (isNaN(q)) {
-      return { lang: lang.trim(), q: 0 };
-    }
-    return { lang: lang.trim(), q };
-  }).sort((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))) == null ? void 0 : _a.lang;
-  return preferred;
-};
-
-// src/adapters/next-client/routing/utils/determine-initial-locale.ts
-var determineInitialLocale = async (config) => {
-  const { defaultLocale, supportedLocales, routing } = config;
-  let initialLocale = defaultLocale;
-  if (routing.firstVisit.localeSource === "browser") {
-    const acceptLanguageHeader = (await headers.headers()).get("accept-language") || void 0;
-    const preferredLocale = resolvePreferredLocale(
-      acceptLanguageHeader,
-      supportedLocales
-    );
-    initialLocale = normalizeLocale(preferredLocale, supportedLocales) || defaultLocale;
-  }
-  return initialLocale;
-};
-
-// src/adapters/next-client/routing/handle-prefix/handle-prefix-all.ts
-var handlePrefixAll = async ({
-  request,
-  config
-}) => {
-  var _a;
-  const { cookie, routing } = config;
-  const { maybeLocale, isLocalePrefixed } = extractPathname({
-    config,
-    pathname: request.nextUrl.pathname
-  });
-  const localeFromCookie = (_a = request.cookies.get(cookie.name)) == null ? void 0 : _a.value;
-  if (isLocalePrefixed) {
-    return createResponse({
-      request,
-      config,
-      locale: maybeLocale,
-      setCookieOptions: { override: true }
-    });
-  }
-  if (!localeFromCookie) {
-    if (!routing.firstVisit.redirect) {
-      return createResponse({ request, config });
-    }
-    const initialLocale = await determineInitialLocale(config);
-    return createResponse({
-      request,
-      config,
-      locale: initialLocale,
-      // Use locale from 'browser' | 'default'
-      responseType: "redirect"
-    });
-  }
-  return createResponse({
-    request,
-    config,
-    locale: localeFromCookie,
-    // Use locale from cookie
-    responseType: "redirect"
-  });
-};
-
-// src/adapters/next-client/routing/handle-prefix/handle-prefix-except-default.ts
-var handlePrefixExceptDefault = async ({
-  request,
-  config
-}) => {
-  var _a;
-  const { defaultLocale, cookie, routing } = config;
-  const { maybeLocale, isLocalePrefixed } = extractPathname({
-    config,
-    pathname: request.nextUrl.pathname
-  });
-  const localeFromCookie = (_a = request.cookies.get(cookie.name)) == null ? void 0 : _a.value;
-  if (isLocalePrefixed && maybeLocale !== defaultLocale) {
-    return createResponse({
-      request,
-      config,
-      locale: maybeLocale,
-      setCookieOptions: { override: true }
-    });
-  }
-  if (!localeFromCookie) {
-    if (!routing.firstVisit.redirect) {
-      return createResponse({ request, config });
-    }
-    const initialLocale = await determineInitialLocale(config);
-    const isDefaultLocale2 = initialLocale === defaultLocale;
-    if (isDefaultLocale2) {
-      return createResponse({
-        request,
-        config,
-        locale: defaultLocale
-      });
-    }
-    return createResponse({
-      request,
-      config,
-      locale: initialLocale,
-      // Use locale from 'browser' | 'default'
-      responseType: "redirect"
-    });
-  }
-  const isDefaultLocale = localeFromCookie === defaultLocale;
-  if (isDefaultLocale) {
-    return createResponse({ request, config, locale: localeFromCookie });
-  }
-  return createResponse({
-    request,
-    config,
-    locale: localeFromCookie,
-    // Use locale from cookie
-    responseType: "redirect"
-  });
-};
-
-// src/adapters/next-client/routing/handle-prefix/handle-prefix-none.ts
-var handlePrefixNone = async ({
-  request,
-  config
-}) => {
-  var _a;
-  let locale = (_a = request.cookies.get(config.cookie.name)) == null ? void 0 : _a.value;
-  if (!locale) {
-    locale = await determineInitialLocale(config);
-  }
-  return createResponse({ request, config, locale });
-};
-
-// src/adapters/next-client/routing/intor-middleware.ts
-async function intorMiddleware({
-  request,
-  config
-}) {
-  const { prefix } = config.routing;
-  if (prefix === "none") {
-    return handlePrefixNone({ request, config });
-  }
-  if (prefix === "except-default") {
-    return await handlePrefixExceptDefault({ request, config });
-  }
-  return await handlePrefixAll({ request, config });
-}
-
 // src/adapters/next-client/utils/should-use-full-reload.ts
 var shouldUseFullReload = (loaderOptions) => {
   return (loaderOptions == null ? void 0 : loaderOptions.type) === "import" || (loaderOptions == null ? void 0 : loaderOptions.type) === "api" && loaderOptions.fullReload === true;
@@ -1080,7 +305,7 @@ var Link = (_a) => {
       setLocale(targetLocale);
     }
   };
-  return /* @__PURE__ */ React7__namespace.createElement(NextLink__default.default, __spreadValues({ href, onClick: handleClick }, props), children);
+  return /* @__PURE__ */ React__namespace.createElement(NextLink__default.default, __spreadValues({ href, onClick: handleClick }, props), children);
 };
 var usePathname = () => {
   const { config } = useIntorConfig();
@@ -1139,10 +364,7 @@ var useRouter = () => {
   }, rest);
 };
 
-exports.IntorProvider = IntorProvider;
 exports.Link = Link;
-exports.TranslateHandlersProvider = TranslateHandlersProvider;
-exports.intorMiddleware = intorMiddleware;
 exports.useIntor = useIntor;
 exports.useIntorConfig = useIntorConfig;
 exports.useIntorLocale = useIntorLocale;