@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.119 → 3.2.0-ultramodern.120

package/README.md

@@ -2,20 +2,236 @@
   <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
 </p>
 
-<h1 align="center">Modern.js</h1>
+<h1 align="center">@modern-js/plugin-i18n</h1>
 
 <p align="center">
-  A Progressive React Framework for modern web development.
+  Internationalization plugin for Modern.js, providing multi-language support with locale-aware routing and navigation.
 </p>
 
+## Features
+
+- **Locale detection**: Supports detection from URL path, Cookie, LocalStorage, request headers, browser settings, and other sources.
+- **Resource loading**: Supports HTTP static files, file system loading for SSR, custom SDK functions, and chained backend progressive loading.
+- **Routing integration**: Automatically adds locale path prefixes and provides the `Link` component for language-agnostic navigation.
+- **SSR support**: Detects the language on the server and injects it into the page to avoid language flicker.
+- **TypeScript support**: Provides complete type definitions and type-safe route navigation.
+
 ## Getting Started
 
-Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+For full documentation, see the [Modern.js Internationalization Guide](https://modernjs.dev/en/guides/advanced-features/international/).
+
+## Link Component
+
+The `Link` component is the standard way to create navigation links in i18n-enabled applications. It automatically localizes language-agnostic canonical paths and provides type-safe navigation with params validation.
+
+### Basic Usage
+
+```tsx
+import { Link } from '@modern-js/plugin-i18n/runtime';
+
+function Navigation() {
+  return (
+    <nav>
+      <Link to="/">Home</Link>
+      <Link to="/about">About</Link>
+      <Link to="/talks/$slug" params={{ slug: 'my-talk' }} />
+      <Link to="/#work-with-me" />
+    </nav>
+  );
+}
+```
+
+### Key Features
+
+**Canonical path localization**: `to` accepts language-agnostic canonical paths. The Link automatically adds the locale prefix and applies `localisedUrls` slug mappings:
+
+```tsx
+// When current language is 'cs' and localisedUrls maps '/platform' to '/platforma':
+<Link to="/platform" />
+// renders as: <a href="/cs/platforma">...</a>
+```
+
+**Hash and query preservation**: Hash fragments and query strings in `to` are preserved during localization:
+
+```tsx
+<Link to="/#work-with-me" />  // Cross-page anchor → /cs#work-with-me
+<Link to="/talks?sort=date" /> // Search params preserved
+```
+
+**Typed routes and params**: When used with TanStack Router codegen, `to` accepts typed canonical route paths with validated params:
+
+```tsx
+// Route /talks/$slug exists → TypeScript validates this:
+<Link to="/talks/$slug" params={{ slug: 'my-talk' }} />
+
+// TypeScript error: route does not exist
+<Link to="/talkz" />
+
+// TypeScript error: missing required param
+<Link to="/talks/$slug" />
+```
+
+**Language-invariant active state**: The link is marked active when the location matches any localized variant of the canonical route:
+
+```tsx
+// Matches /en/talks/my-talk, /cs/prednaska/muj-pohovor, etc.
+<Link to="/talks/$slug" params={{ slug: 'my-talk' }} activeProps={{ className: 'active' }} />
+```
+
+**Active state props and classes**:
+
+```tsx
+<Link
+  to="/about"
+  activeProps={{ className: 'active-link' }}
+  activeOptions={{ exact: false }} // Nested routes also match
+/>
+// When active, renders: <a href="..." className="active-link" data-status="active" aria-current="page">
+```
+
+**External URLs and bare anchors render as plain `<a>` tags**:
+
+```tsx
+<Link to="https://example.com" /> // → <a href="https://example.com">
+<Link to="#contact" />           // → <a href="#contact">
+```
+
+### Props
+
+- `to` (string): Canonical (language-agnostic) target path, optionally with `#hash` and `?query` suffixes.
+- `params` (object, optional): Route param values for dynamic segments (e.g., `$slug`).
+- `hash` (string, optional): Hash fragment (overrides any `#hash` in `to`).
+- `search` (string | object, optional): Query string or object (overrides any `?query` in `to`).
+- `hashScrollIntoView` (boolean | ScrollIntoViewOptions, optional): TanStack Router scroll behavior.
+- `activeProps` (object, optional): Props applied when the link is active.
+- `activeOptions` (object, optional): `{ exact?: boolean }` for active state matching.
+- All standard `<a>` HTML attributes (className, style, onClick, etc.).
+
+## Localization Utilities
+
+### `localizePath(pathname, language, config)`
+
+Localize a canonical pathname for a given language, applying language prefix and `localisedUrls` mapping:
+
+```tsx
+import { localizePath } from '@modern-js/plugin-i18n/runtime';
+
+localizePath('/about', 'cs', {
+  languages: ['en', 'cs'],
+  localisedUrls: { '/about': { en: '/about', cs: '/o-nas' } }
+})
+// → '/cs/o-nas'
+```
+
+### `canonicalPath(target, config)`
+
+Reverse of `localizePath`: strip language prefix and reverse `localisedUrls` mapping:
+
+```tsx
+import { canonicalPath } from '@modern-js/plugin-i18n/runtime';
+
+canonicalPath('/cs/o-nas', {
+  languages: ['en', 'cs'],
+  localisedUrls: { '/about': { en: '/about', cs: '/o-nas' } }
+})
+// → '/about'
+```
+
+### `useLocalizedPaths()`
+
+Hook for context-bound `localizePath` and `canonicalPath` (reads plugin config automatically):
+
+```tsx
+import { useLocalizedPaths } from '@modern-js/plugin-i18n/runtime';
+
+function MyComponent() {
+  const { localizePath, canonicalPath } = useLocalizedPaths();
+  
+  const localized = localizePath('/about', 'cs');
+  const canonical = canonicalPath('/cs/o-nas');
+}
+```
+
+### `useLocalizedLocation()`
+
+Hook for hreflang tags and language switchers. Returns the current location's canonical path and per-language hrefs:
+
+```tsx
+import { useLocalizedLocation } from '@modern-js/plugin-i18n/runtime';
+
+function HrefLang() {
+  const { language, canonical, alternates } = useLocalizedLocation();
+  
+  return (
+    <>
+      <link rel="canonical" href={alternates['en']} />
+      {Object.entries(alternates).map(([lang, href]) => (
+        <link key={lang} rel="alternate" hrefLang={lang} href={href} />
+      ))}
+    </>
+  );
+}
+
+function LanguageSwitcher() {
+  const { alternates } = useLocalizedLocation();
+  
+  return (
+    <select onChange={(e) => window.location.href = alternates[e.target.value]}>
+      {Object.entries(alternates).map(([lang, href]) => (
+        <option key={lang} value={lang}>{lang}</option>
+      ))}
+    </select>
+  );
+}
+```
+
+## Migration from Deprecated I18nLink
+
+The deprecated `I18nLink` component is now an alias for `Link`. Update your code:
+
+| Old Pattern | New Pattern | Notes |
+|-------------|-------------|-------|
+| `import { I18nLink }` | `import { Link }` | Drop the `I18n` prefix. |
+| `<I18nLink to="/">` | `<Link to="/">` | Identical props and behavior. |
+| Hand-rolled `localizePath` helper | `useLocalizedPaths()` hook | Reads config from context automatically. |
+| Hand-rolled `matchPattern` for active state | `Link` with `activeProps`/`activeOptions` | Language-invariant matching. |
+| Manual hreflang blocks | `useLocalizedLocation()` hook | Generates per-language hrefs automatically. |
+
+**I18nLink deprecation notice:** `I18nLink` is deprecated and will be removed in a future version. A one-time development console warning is logged when used.
+
+```tsx
+// ❌ Old
+import { I18nLink } from '@modern-js/plugin-i18n/runtime';
+<I18nLink to="/about">About</I18nLink>
+
+// ✅ New
+import { Link } from '@modern-js/plugin-i18n/runtime';
+<Link to="/about">About</Link>
+```
+
+## Exported Types
+
+For TypeScript projects, the following types are exported from `@modern-js/plugin-i18n/runtime`:
+
+- `LinkProps<TTo>`: Props type for the `Link` component with typed `to` and `params`.
+- `LinkBaseProps`: Base props shared across router frameworks.
+- `LinkParams`: Record of route param values.
+- `LinkActiveOptions`: Active state matching options.
+- `UltramodernCanonicalRoutes`: Canonical route map (emitted by TanStack Router codegen).
+- `CanonicalRoutePath`: Typed canonical route path.
+- `AllowedLinkTarget`: Union of all valid canonical routes (when codegen is active).
+
+## Exported Utilities
+
+- `buildLocalizedUrl(pathname, language, languages, localisedUrls)`: Localize a pathname (used internally by `Link`).
+- `splitUrlTarget(urlString)`: Parse a URL into pathname, search, and hash.
 
 ## Documentation
 
-- [English Documentation](https://modernjs.dev/en/)
-- [中文文档](https://modernjs.dev)
+For complete documentation, including locale detection, resource loading, SSR, and custom route configuration, see:
+
+- [English Documentation](https://modernjs.dev/en/guides/advanced-features/international/)
+- [中文文档](https://modernjs.dev/guides/advanced-features/international/)
 
 ## Contributing
 
@@ -24,9 +240,3 @@ Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/
 ## License
 
 Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).
-
-## Credist
-
-Thanks to:
-
-- [@loadable/webpack-plugin](https://github.com/gregberge/loadable-components) to create a webpack plugin prepare for loadable usage in ssr.

package/dist/cjs/runtime/I18nLink.js

@@ -32,25 +32,15 @@ __webpack_require__.d(__webpack_exports__, {
     default: ()=>runtime_I18nLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const external_context_js_namespaceObject = require("./context.js");
-const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
-const external_utils_js_namespaceObject = require("./utils.js");
+const external_Link_js_namespaceObject = require("./Link.js");
+let warnedDeprecation = false;
 const I18nLink = ({ to, children, ...props })=>{
-    const { Link, params, hasRouter } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
-    const { language, supportedLanguages, localisedUrls } = (0, external_context_js_namespaceObject.useModernI18n)();
-    const currentLang = language;
-    const localizedTo = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(to, currentLang, supportedLanguages, localisedUrls);
-    if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
-    if (!hasRouter || !Link) {
-        const { prefetch: _prefetch, preload: _preload, ...anchorProps } = props;
-        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
-            href: localizedTo,
-            ...anchorProps,
-            children: children
-        });
+    if ('development' === process.env.NODE_ENV && !warnedDeprecation) {
+        warnedDeprecation = true;
+        console.warn("[plugin-i18n] I18nLink is deprecated. Import { Link } from '@modern-js/plugin-i18n/runtime' instead — it accepts the same language-agnostic `to` values.");
     }
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Link, {
-        to: localizedTo,
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_Link_js_namespaceObject.Link, {
+        to: to,
         ...props,
         children: children
     });

package/dist/cjs/runtime/Link.js

@@ -0,0 +1,252 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Link: ()=>Link,
+    default: ()=>runtime_Link,
+    interpolateRouteParams: ()=>interpolateRouteParams
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_context_js_namespaceObject = require("./context.js");
+const external_localizedPaths_js_namespaceObject = require("./localizedPaths.js");
+const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+const warnedTargets = new Set();
+const warnOnce = (key, message)=>{
+    if ('development' !== process.env.NODE_ENV || warnedTargets.has(key)) return;
+    warnedTargets.add(key);
+    console.warn(message);
+};
+const interpolateRouteParams = (pathname, params)=>{
+    if (!/[$:*{]/.test(pathname)) return pathname;
+    const resolveParam = (name)=>{
+        const value = params?.[name];
+        return void 0 === value ? void 0 : String(value);
+    };
+    const segments = pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if (segment.startsWith('{-$') && segment.endsWith('}')) {
+            const value = resolveParam(segment.slice(3, -1));
+            return void 0 === value ? null : encodeURIComponent(value);
+        }
+        if ('$' === segment || '*' === segment) {
+            const value = resolveParam('_splat') ?? resolveParam('*');
+            return void 0 === value ? null : value.split('/').map(encodeURIComponent).join('/');
+        }
+        if (segment.startsWith('$')) {
+            const value = resolveParam(segment.slice(1));
+            if (void 0 === value) {
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        if (segment.startsWith(':')) {
+            const optional = segment.endsWith('?');
+            const name = segment.slice(1, optional ? -1 : void 0);
+            const value = resolveParam(name);
+            if (void 0 === value) {
+                if (optional) return null;
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        return segment;
+    }).filter((segment)=>null !== segment);
+    return segments.join('/') || '/';
+};
+const normalizeSearch = (search, searchFromTo)=>{
+    if (search && 'object' == typeof search) {
+        const entries = Object.entries(search).filter(([, value])=>null != value);
+        const searchObject = Object.fromEntries(entries.map(([key, value])=>[
+                key,
+                String(value)
+            ]));
+        const params = new URLSearchParams(searchObject);
+        const serialized = params.toString();
+        return {
+            searchString: serialized ? `?${serialized}` : '',
+            searchObject
+        };
+    }
+    const raw = 'string' == typeof search && search ? search : searchFromTo;
+    if (!raw) return {
+        searchString: '',
+        searchObject: void 0
+    };
+    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
+    const searchObject = {};
+    new URLSearchParams(searchString).forEach((value, key)=>{
+        searchObject[key] = value;
+    });
+    return {
+        searchString,
+        searchObject
+    };
+};
+const splitActiveProps = (active, activeProps)=>{
+    if (!active || !activeProps) return {};
+    return activeProps;
+};
+const mergeClassNames = (...values)=>{
+    const classNames = values.filter((value)=>'string' == typeof value && value.length > 0);
+    return classNames.length > 0 ? classNames.join(' ') : void 0;
+};
+const Link = (props)=>{
+    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, ...rest } = props;
+    const adapter = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
+    const { language, supportedLanguages, localisedUrls } = (0, external_context_js_namespaceObject.useModernI18n)();
+    const config = {
+        languages: supportedLanguages,
+        localisedUrls
+    };
+    const isExternal = EXTERNAL_TARGET_RE.test(to);
+    const isBareHash = to.startsWith('#');
+    const target = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (isExternal || isBareHash) return null;
+        const { pathname, search: searchFromTo, hash: hashFromTo } = (0, external_utils_js_namespaceObject.splitUrlTarget)(to);
+        const interpolated = interpolateRouteParams(pathname || '/', params);
+        const firstSegment = interpolated.split('/').filter(Boolean)[0];
+        if (firstSegment && supportedLanguages.includes(firstSegment)) warnOnce(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
+        const localizedPathname = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(interpolated, language, supportedLanguages, localisedUrls);
+        const hash = hashProp ?? (hashFromTo ? hashFromTo.slice(1) : '');
+        const { searchString, searchObject } = normalizeSearch(searchProp, searchFromTo);
+        return {
+            canonicalPathname: interpolated,
+            localizedPathname,
+            hash,
+            searchString,
+            searchObject,
+            href: `${localizedPathname}${searchString}${hash ? `#${hash}` : ''}`
+        };
+    }, [
+        to,
+        params,
+        hashProp,
+        searchProp,
+        isExternal,
+        isBareHash,
+        language,
+        supportedLanguages,
+        localisedUrls
+    ]);
+    const isActive = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!target || !adapter.location) return false;
+        const current = (0, external_localizedPaths_js_namespaceObject.canonicalPath)(adapter.location.pathname, config);
+        const targetCanonical = (0, external_localizedPaths_js_namespaceObject.canonicalPath)(target.canonicalPathname, config);
+        const exact = activeOptions?.exact ?? '/' === targetCanonical;
+        if (current === targetCanonical) return true;
+        if (exact) return false;
+        return current.startsWith('/' === targetCanonical ? '/' : `${targetCanonical}/`);
+    }, [
+        target,
+        adapter.location,
+        activeOptions?.exact,
+        supportedLanguages,
+        localisedUrls
+    ]);
+    const resolvedActiveProps = splitActiveProps(isActive, activeProps);
+    const activeAttributes = isActive ? {
+        'data-status': 'active',
+        'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
+    } : {};
+    if (!target) {
+        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
+            href: to,
+            ...anchorProps,
+            children: children
+        });
+    }
+    const { Link: RouterLink, hasRouter, framework } = adapter;
+    if (!hasRouter || !RouterLink) {
+        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
+            href: target.href,
+            ...anchorProps,
+            ...activeRest,
+            ...activeAttributes,
+            className: mergeClassNames(rest.className, activeClassName),
+            style: {
+                ...rest.style,
+                ...activeStyle
+            },
+            children: children
+        });
+    }
+    const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
+    const mergedClassName = mergeClassNames(rest.className, activeClassName);
+    const mergedStyle = {
+        ...rest.style,
+        ...activeStyle
+    };
+    if ('tanstack' === framework) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterLink, {
+        to: target.localizedPathname,
+        ...target.searchObject ? {
+            search: target.searchObject
+        } : {},
+        ...target.hash ? {
+            hash: target.hash
+        } : {},
+        ...void 0 === hashScrollIntoView ? {} : {
+            hashScrollIntoView
+        },
+        ...rest,
+        ...activeRest,
+        ...activeAttributes,
+        className: mergedClassName,
+        style: mergedStyle,
+        children: children
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterLink, {
+        to: target.href,
+        ...rest,
+        ...activeRest,
+        ...activeAttributes,
+        className: mergedClassName,
+        style: mergedStyle,
+        children: children
+    });
+};
+const runtime_Link = Link;
+exports.Link = __webpack_exports__.Link;
+exports["default"] = __webpack_exports__["default"];
+exports.interpolateRouteParams = __webpack_exports__.interpolateRouteParams;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Link",
+    "default",
+    "interpolateRouteParams"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/canonicalRoutes.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/index.js

@@ -29,8 +29,15 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     I18nLink: ()=>external_I18nLink_js_namespaceObject.I18nLink,
+    Link: ()=>external_Link_js_namespaceObject.Link,
+    buildLocalizedUrl: ()=>external_utils_js_namespaceObject.buildLocalizedUrl,
+    canonicalPath: ()=>external_localizedPaths_js_namespaceObject.canonicalPath,
     default: ()=>runtime,
     i18nPlugin: ()=>i18nPlugin,
+    localizePath: ()=>external_localizedPaths_js_namespaceObject.localizePath,
+    splitUrlTarget: ()=>external_utils_js_namespaceObject.splitUrlTarget,
+    useLocalizedLocation: ()=>external_localizedPaths_js_namespaceObject.useLocalizedLocation,
+    useLocalizedPaths: ()=>external_localizedPaths_js_namespaceObject.useLocalizedPaths,
     useModernI18n: ()=>external_context_js_namespaceObject.useModernI18n
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
@@ -50,6 +57,8 @@ const utils_js_namespaceObject = require("./i18n/utils.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 require("./types.js");
 const external_I18nLink_js_namespaceObject = require("./I18nLink.js");
+const external_Link_js_namespaceObject = require("./Link.js");
+const external_localizedPaths_js_namespaceObject = require("./localizedPaths.js");
 const i18nPlugin = (options)=>({
         name: '@modern-js/plugin-i18n',
         setup: (api)=>{
@@ -172,13 +181,27 @@ const i18nPlugin = (options)=>({
     });
 const runtime = i18nPlugin;
 exports.I18nLink = __webpack_exports__.I18nLink;
+exports.Link = __webpack_exports__.Link;
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.canonicalPath = __webpack_exports__.canonicalPath;
 exports["default"] = __webpack_exports__["default"];
 exports.i18nPlugin = __webpack_exports__.i18nPlugin;
+exports.localizePath = __webpack_exports__.localizePath;
+exports.splitUrlTarget = __webpack_exports__.splitUrlTarget;
+exports.useLocalizedLocation = __webpack_exports__.useLocalizedLocation;
+exports.useLocalizedPaths = __webpack_exports__.useLocalizedPaths;
 exports.useModernI18n = __webpack_exports__.useModernI18n;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "I18nLink",
+    "Link",
+    "buildLocalizedUrl",
+    "canonicalPath",
     "default",
     "i18nPlugin",
+    "localizePath",
+    "splitUrlTarget",
+    "useLocalizedLocation",
+    "useLocalizedPaths",
     "useModernI18n"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {