@intlayer/engine 9.5.9 → 9.5.10

package/dist/types/init/documentationRouter.d.ts

@@ -0,0 +1,64 @@
+//#region src/init/documentationRouter.d.ts
+/**
+ * Documentation URL Constants
+ */
+export declare const DocumentationRouter: {
+  NextJS: string;
+  NextJS_16: string;
+  NextJS_15: string;
+  NextJS_14: string;
+  NextJS_PageRouter: string;
+  CRA: string;
+  Astro: string;
+  Astro_Lit: string;
+  Astro_Preact: string;
+  Astro_React: string;
+  Astro_Solid: string;
+  Astro_Svelte: string;
+  Astro_Vue: string;
+  ViteAndReact: string;
+  ViteAndReact_ReactRouterV7: string;
+  ViteAndVue: string;
+  ViteAndSolid: string;
+  ViteAndSvelte: string;
+  ViteAndPreact: string;
+  ViteAndLit: string;
+  ViteAndVanilla: string;
+  Vanilla: string;
+  TanStackRouter: string;
+  TanStackRouterAndSolid: string;
+  SolidStart: string;
+  Analog: string;
+  Remix: string;
+  NuxtAndVue: string;
+  Angular: string;
+  Angular_19: string;
+  SvelteKit: string;
+  ReactNativeAndExpo: string;
+  Lynx: string;
+  HTMX: string;
+  Storybook: string;
+  Express: string;
+  NestJS: string;
+  Fastify: string;
+  Hono: string;
+  AdonisJS: string;
+  Elysia: string;
+  Default: string;
+  LSP: string;
+  ESLint: string;
+  NextIntl: string;
+  NextI18Next: string;
+  ReactI18Next: string;
+  ReactIntl: string;
+  VueI18n: string;
+  NuxtI18n: string;
+  I18next: string;
+};
+export type DocumentationRouterType = typeof DocumentationRouter;
+/**
+ * Helper: Detects the environment and returns the doc URL
+ */
+export declare const getDocumentationUrl: (packageJson: any) => string;
+//#endregion
+//# sourceMappingURL=documentationRouter.d.ts.map

package/dist/types/init/documentationRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentationRouter.d.ts","names":[],"sources":["../../../src/init/documentationRouter.ts"],"mappings":";;;;qBAGa;EACX;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EAGA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;;YAGU,iCAAiC;;;;qBAKhC,sBAAmB"}

package/dist/types/init/frameworkSetup/backend/index.d.ts

@@ -0,0 +1,16 @@
+import { FrameworkAdapter } from "../types.js";
+//#region src/init/frameworkSetup/backend/index.d.ts
+/**
+ * NestJS on the Express platform. Checked before Express: a Nest app is
+ * created by `NestFactory`, not `express()`. Nest on Fastify is left to the
+ * guide (its adapter is registered through the Fastify instance).
+ */
+export declare const nestJsAdapter: FrameworkAdapter;
+export declare const expressAdapter: FrameworkAdapter;
+export declare const fastifyAdapter: FrameworkAdapter;
+export declare const honoAdapter: FrameworkAdapter;
+export declare const elysiaAdapter: FrameworkAdapter;
+/** Backend adapters, in detection order. */
+export declare const backendAdapters: FrameworkAdapter[];
+//#endregion
+//# sourceMappingURL=index.d.ts.map

package/dist/types/init/frameworkSetup/backend/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/backend/index.ts"],"mappings":";;;;;;;qBAiJa,eAAa;qBAUb,gBAAc;qBASd,gBAAc;qBASd,aAAW;qBASX,eAAa;;qBAUb,iBAAiB"}

package/dist/types/init/frameworkSetup/backend/transforms.d.ts

@@ -0,0 +1,37 @@
+//#region src/init/frameworkSetup/backend/transforms.d.ts
+/** Result of a backend transform. `code` is unchanged for any non-`registered` status. */
+export type BackendTransformResult = {
+  code: string;
+  status: 'registered' | 'already' | 'skipped';
+};
+/**
+ * Registers `express-intlayer` right after `const app = express()`:
+ * `app.use(intlayer());`.
+ */
+export declare const registerExpressMiddleware: (code: string) => BackendTransformResult;
+/**
+ * Registers `fastify-intlayer` right after `const app = Fastify()`:
+ * `app.register(intlayer);`. Not awaited, so it also works in CommonJS and
+ * non-async scopes — Fastify queues plugins until `ready`/`listen`.
+ */
+export declare const registerFastifyPlugin: (code: string) => BackendTransformResult;
+/**
+ * Registers `hono-intlayer` right after `const app = new Hono()`:
+ * `app.use("*", intlayer());`. A chained declaration
+ * (`new Hono().get(…)`) is skipped: its routes would be registered before the
+ * middleware, which Hono runs in registration order.
+ */
+export declare const registerHonoMiddleware: (code: string) => BackendTransformResult;
+/**
+ * Registers `express-intlayer` on a NestJS (Express platform) app right after
+ * `const app = await NestFactory.create(…)`: `app.use(intlayer());`.
+ */
+export declare const registerNestJsMiddleware: (code: string) => BackendTransformResult;
+/**
+ * Registers `elysia-intlayer` directly on the app constructor:
+ * `new Elysia()` → `new Elysia().use(intlayer())`. Works for chained
+ * declarations too, and keeps the plugin ahead of every route.
+ */
+export declare const registerElysiaPlugin: (code: string) => BackendTransformResult;
+//#endregion
+//# sourceMappingURL=transforms.d.ts.map

package/dist/types/init/frameworkSetup/backend/transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/backend/transforms.ts"],"mappings":";;YAoBY;EACV;EACA;;;;;;qBAoMW,4BAAyB,iBAEnC;;;;;;qBAoBU,wBAAqB,iBAAmB;;;;;;;qBAsBxC,yBAAsB,iBAAmB;;;;;qBAmBzC,2BAAwB,iBAElC;;;;;;qBAqBU,uBAAoB,iBAAmB"}

package/dist/types/init/frameworkSetup/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/index.ts"],"mappings":";;;;;;;;qBAsBa,iBAAc,SAChB,0BACR"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/index.ts"],"mappings":";;;;;;;;qBAyBa,iBAAc,SAChB,0BACR"}

package/dist/types/init/frameworkSetup/localeRouting.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkSetupContext } from "./types.js";
+//#region src/init/frameworkSetup/localeRouting.d.ts
+/**
+ * Whether the locale is carried by a URL path segment (`/fr/about`), which the
+ * framework router must declare (`[locale]`, `{-$locale}`, `$locale`…). Only the
+ * prefix routing modes do, and only while the proxy is enabled: `no-prefix` and
+ * `search-params` resolve the locale from storage/headers/query instead.
+ */
+export declare const usesLocalePathSegment: ({ routingMode, enableProxy }: Pick<FrameworkSetupContext, 'routingMode' | 'enableProxy'>) => boolean;
+//#endregion
+//# sourceMappingURL=localeRouting.d.ts.map

package/dist/types/init/frameworkSetup/localeRouting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeRouting.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/localeRouting.ts"],"mappings":";;;;;;;;qBAQa,0BAAqB,aAAA,eAG/B,KAAK"}

package/dist/types/init/frameworkSetup/nextAppRouter/index.d.ts

@@ -1,11 +1,11 @@
 import { FrameworkAdapter } from "../types.js";
 //#region src/init/frameworkSetup/nextAppRouter/index.d.ts
 /**
- * Next.js App Router adapter. Scaffolds the locale proxy/middleware, restructures
- * the app into a `[locale]` segment, and wraps the layout with the unified
- * Intlayer provider — all idempotently and without overwriting recognizable
- * user code. Pages are never wrapped: `IntlayerProvider` in the locale layout
- * covers them.
+ * Next.js App Router adapter. Scaffolds the locale proxy/middleware (when the
+ * proxy is enabled), restructures the app into a `[locale]` segment (prefix
+ * routing modes only), and wraps the layout with the unified Intlayer provider
+ * — all idempotently and without overwriting recognizable user code. Pages are
+ * never wrapped: `IntlayerProvider` in the layout covers them.
  */
 export declare const nextAppRouterAdapter: FrameworkAdapter;
 //#endregion

package/dist/types/init/frameworkSetup/nextAppRouter/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/index.ts"],"mappings":";;;;;;;;;qBA2Ha,sBAAsB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/index.ts"],"mappings":";;;;;;;;;qBAiLa,sBAAsB"}

package/dist/types/init/frameworkSetup/nextAppRouter/templates.d.ts

@@ -26,5 +26,17 @@ export declare const LOCALE_LAYOUT_TEMPLATE_JS = "import { IntlayerProvider } fr
  */
 export declare const LOCALE_PAGE_TEMPLATE_TS = "import { type NextPageIntlayer } from \"next-intlayer\";\n\nconst Page: NextPageIntlayer = async ({ params }) => {\n  const { locale } = await params;\n\n  return (\n    <main>\n      <h1>{locale}</h1>\n      <p>Get started by editing this page.</p>\n    </main>\n  );\n};\n\nexport default Page;\n";
 export declare const LOCALE_PAGE_TEMPLATE_JS = "const Page = async ({ params }) => {\n  const { locale } = await params;\n\n  return (\n    <main>\n      <h1>{locale}</h1>\n      <p>Get started by editing this page.</p>\n    </main>\n  );\n};\n\nexport default Page;\n";
+/**
+ * Root layout (`app/layout.tsx`) for routing modes without a locale path
+ * segment (`no-prefix`, `search-params`, or no proxy at all). Owns `<html>` and
+ * resolves the locale from the request (cookie / header) via `getLocale()`.
+ */
+export declare const UNPREFIXED_ROOT_LAYOUT_TEMPLATE_TS = "import type { PropsWithChildren } from \"react\";\nimport { getHTMLTextDir } from \"intlayer\";\nimport { getLocale, IntlayerProvider } from \"next-intlayer/server\";\n\nconst RootLayout = async ({ children }: PropsWithChildren) => {\n  const locale = await getLocale();\n\n  return (\n    <html lang={locale} dir={getHTMLTextDir(locale)}>\n      <body>\n        <IntlayerProvider locale={locale}>{children}</IntlayerProvider>\n      </body>\n    </html>\n  );\n};\n\nexport default RootLayout;\n";
+export declare const UNPREFIXED_ROOT_LAYOUT_TEMPLATE_JS = "import { getHTMLTextDir } from \"intlayer\";\nimport { getLocale, IntlayerProvider } from \"next-intlayer/server\";\n\nconst RootLayout = async ({ children }) => {\n  const locale = await getLocale();\n\n  return (\n    <html lang={locale} dir={getHTMLTextDir(locale)}>\n      <body>\n        <IntlayerProvider locale={locale}>{children}</IntlayerProvider>\n      </body>\n    </html>\n  );\n};\n\nexport default RootLayout;\n";
+/**
+ * Home page (`app/page.tsx`) for routing modes without a locale path segment.
+ * Identical for TypeScript and JavaScript projects.
+ */
+export declare const UNPREFIXED_PAGE_TEMPLATE = "const Page = () => (\n  <main>\n    <h1>Hello</h1>\n    <p>Get started by editing this page.</p>\n  </main>\n);\n\nexport default Page;\n";
 //#endregion
 //# sourceMappingURL=templates.d.ts.map

package/dist/types/init/frameworkSetup/nextAppRouter/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/templates.ts"],"mappings":";;;;;;;qBAOa;;qBASA;;qBASA;qBAOA;;;;;;;qBAWA;qBAqBA;;;;;;qBAyBA;qBAgBA"}
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/templates.ts"],"mappings":";;;;;;;qBAOa;;qBASA;;qBASA;qBAOA;;;;;;;qBAWA;qBAqBA;;;;;;qBAyBA;qBAgBA;;;;;;qBAmBA;qBAmBA;;;;;qBAsBA"}

package/dist/types/init/frameworkSetup/nextAppRouter/transforms.d.ts

@@ -4,6 +4,15 @@ export type TransformResult = {
   code: string;
   status: 'wrapped' | 'already' | 'skipped-client' | 'skipped';
 };
+/** Options of {@link wrapLayoutWithProvider}. */
+export type WrapLayoutOptions = {
+  /**
+   * Re-export `generateStaticParams` from `next-intlayer`. Only meaningful for a
+   * layout under a `[locale]` segment; a root layout of an unprefixed app has
+   * no locale param to pre-render. Default: `true`.
+   */
+  exportStaticParams?: boolean;
+};
 /**
  * Wraps the `{children}` of a Next.js App Router **layout** with the unified
  * `IntlayerProvider`, deriving the locale via `getLocale()`. Safe and
@@ -15,6 +24,6 @@ export type TransformResult = {
  * pages below the locale layout read locale/variant from it without wrapping
  * themselves individually (see the removed `wrapPageWithProvider`).
  */
-export declare const wrapLayoutWithProvider: (code: string) => TransformResult;
+export declare const wrapLayoutWithProvider: (code: string, { exportStaticParams }?: WrapLayoutOptions) => TransformResult;
 //#endregion
 //# sourceMappingURL=transforms.d.ts.map

package/dist/types/init/frameworkSetup/nextAppRouter/transforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/transforms.ts"],"mappings":";;YAWY;EACV;EACA;;;;;;;;;;;;;qBAsLW,yBAAsB,iBAAmB"}
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/transforms.ts"],"mappings":";;YAWY;EACV;EACA;;;YA4KU;;;;;;EAMV;;;;;;;;;;;;;qBAcW,yBAAsB,gBACrB,uBACmB,sBAC9B"}

package/dist/types/init/frameworkSetup/tanstackStart/index.d.ts

@@ -1,8 +1,9 @@
 import { FrameworkAdapter } from "../types.js";
 //#region src/init/frameworkSetup/tanstackStart/index.d.ts
 /**
- * TanStack Start adapter. Restructures the file-based routes under a `{-$locale}`
- * segment, scaffolds the locale segment route, and wraps the root document with
+ * TanStack Start adapter. For prefix routing modes, restructures the file-based
+ * routes under a `{-$locale}` / `$locale` segment and scaffolds the locale
+ * segment route; for the others, keeps routes in place. Wraps the root document with
  * the Intlayer provider — all idempotently and without overwriting user code it
  * cannot confidently transform.
  */

package/dist/types/init/frameworkSetup/tanstackStart/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/index.ts"],"mappings":";;;;;;;;qBA4Ea,sBAAsB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/index.ts"],"mappings":";;;;;;;;;qBAgIa,sBAAsB"}

package/dist/types/init/frameworkSetup/tanstackStart/templates.d.ts

@@ -22,5 +22,15 @@ export declare const buildLocaleRouteTemplate: (localeSegment: string) => string
 export declare const buildRootTemplateTs: (localeSegment: string) => string;
 /** JavaScript counterpart of {@link buildRootTemplateTs}. */
 export declare const buildRootTemplateJs: (localeSegment: string) => string;
+/**
+ * Module-scope server function resolving the request locale from the locale
+ * cookie / headers (`Accept-Language` fallback). Shared by the unprefixed root
+ * template and the root transform.
+ */
+export declare const REQUEST_LOCALE_SERVER_FUNCTION = "const getRequestLocale = createServerFn().handler(() =>\n  getLocale({\n    getCookie: (name) => getCookie(name, getRequestHeader(\"cookie\")),\n    getHeader: (name) => getRequestHeader(name),\n  })\n);";
+/** {@link buildUnprefixedRootTemplate} for TypeScript projects. */
+export declare const UNPREFIXED_ROOT_TEMPLATE_TS: string;
+/** {@link buildUnprefixedRootTemplate} for JavaScript projects. */
+export declare const UNPREFIXED_ROOT_TEMPLATE_JS: string;
 //#endregion
 //# sourceMappingURL=templates.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/templates.ts"],"mappings":";;;;;;;;;;;;qBAYa,2BAAwB;;;;;;;;;qBAgCxB,sBAAmB;;qBAkCnB,sBAAmB"}
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/templates.ts"],"mappings":";;;;;;;;;;;;qBAYa,2BAAwB;;;;;;;;;qBAgCxB,sBAAmB;;qBAkCnB,sBAAmB;;;;;;qBAqCnB;;qBAmDA;;qBAKA"}

package/dist/types/init/frameworkSetup/tanstackStart/transforms.d.ts

@@ -4,6 +4,18 @@ export type TransformResult = {
   code: string;
   status: 'wrapped' | 'already' | 'skipped';
 };
+/**
+ * Wraps the `{children}` of a TanStack Start root document with
+ * `IntlayerProvider` for routing modes without a locale path segment. The
+ * locale is resolved per request by a server function exposed through the root
+ * `loader`, and read with `Route.useLoaderData()`. Safe and idempotent: bails
+ * when the provider is already present, when no `<html>` document or
+ * `{children}` is found, or when the root route cannot safely take a loader
+ * (no `Route` binding, no options object, or an existing `loader`).
+ *
+ * @param code Source of the project's `__root` document.
+ */
+export declare const wrapRootWithRequestLocaleProvider: (code: string) => TransformResult;
 /**
  * Wraps the `{children}` of a TanStack Start root document with
  * `IntlayerProvider`, deriving the locale from the locale segment route params.

package/dist/types/init/frameworkSetup/tanstackStart/transforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/transforms.ts"],"mappings":";;YAkBY;EACV;EACA;;;;;;;;;;;;;qBAoMW,uBAAoB,cACnB,0BAEX"}
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/transforms.ts"],"mappings":";;YAmBY;EACV;EACA;;;;;;;;;;;;;qBA6QW,oCAAiC,iBAE3C;;;;;;;;;;;;qBAsFU,uBAAoB,cACnB,0BAEX"}

package/dist/types/init/frameworkSetup/types.d.ts

@@ -21,6 +21,12 @@ export type FrameworkSetupContext = {
    * (`prefix-no-default` → `{-$locale}`).
    */
   routingMode: RoutingMode;
+  /**
+   * Whether locale routing goes through the Intlayer proxy (middleware), i.e.
+   * the effective `routing.enableProxy`. When `false`, adapters scaffold no
+   * proxy file and no locale route segment.
+   */
+  enableProxy: boolean;
 };
 /**
  * A framework integration adapter. Each adapter knows how to recognize a

package/dist/types/init/frameworkSetup/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/types.ts"],"mappings":";;;;;;;YAOY;;EAEV;;EAEA,SAAS;;EAET,gBAAgB;;EAEhB;;;;;;;EAOA,aAAa;;;;;;;YAQH;;EAEV;;;;;EAKA,SAAS,SAAS,oCAAoC;;;;;;EAMtD,QAAQ,SAAS,0BAA0B"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/types.ts"],"mappings":";;;;;;;YAOY;;EAEV;;EAEA,SAAS;;EAET,gBAAgB;;EAEhB;;;;;;;EAOA,aAAa;;;;;;EAMb;;;;;;;YAQU;;EAEV;;;;;EAKA,SAAS,SAAS,oCAAoC;;;;;;EAMtD,QAAQ,SAAS,0BAA0B"}

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

@@ -1,4 +1,5 @@
 import { RoutingMode } from "./utils/configManipulation.js";
+import { DocumentationRouter, DocumentationRouterType, getDocumentationUrl } from "./documentationRouter.js";
 import "./utils/index.js";
 //#region src/init/index.d.ts
 /**
@@ -43,6 +44,8 @@ export type InitOptions = {
    * enabled.
    */
   noFrameworkSetup?: boolean;
+  /** Skip logging the final success message and documentation link. */
+  skipFinalMessage?: boolean;
   /**
    * Version to install the missing Intlayer packages at (typically the running
    * CLI version). Already declared Intlayer packages are upgraded to the latest
@@ -55,6 +58,13 @@ export type InitOptions = {
    * (`prefix-no-default`) is kept.
    */
   routingMode?: RoutingMode;
+  /**
+   * Whether the app routes by locale through the Intlayer proxy (middleware).
+   * Written to `routing.enableProxy` in the configuration file and drives the
+   * framework scaffolding: `false` skips the proxy file and any locale route
+   * segment. When omitted, the configured value is kept (unset means enabled).
+   */
+  enableProxy?: boolean;
   /**
    * Content organization strategy chosen by the interactive init prompt. Drives
    * the `compiler.output` template (`centralized`) or the injection of the
@@ -66,6 +76,10 @@ export type InitOptions = {
 /**
  * MAIN LOGIC
  */
-export declare const initIntlayer: (rootDir: string, options?: InitOptions) => Promise<void>;
+export declare const initIntlayer: (rootDir: string, options?: InitOptions) => Promise<{
+  guideUrl: string;
+}>;
+export declare const logInitSuccessMessage: (guideUrl: string) => void;
 //#endregion
+export { DocumentationRouter, type DocumentationRouterType, getDocumentationUrl };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;;;;;qBA6Oa,2BAAwB,cACrB;;;;;;;;;;YAsBJ;;;;YAQA;EACV;;EAEA;;;;;EAKA;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd,kBAAkB;;;;;qBAMP,eAAY,iBAAyB,UAAY,gBAAW"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;;;;;;qBA6Ea,2BAAwB,cACrB;;;;;;;;;;YAsBJ;;;;YAQA;EACV;;EAEA;;;;;EAKA;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;EAEA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd;;;;;;;EAOA,kBAAkB;;;;;qBAMP,eAAY,iBAAyB,UAAY,gBAAW;;;qBA6kC5D,wBAAqB"}

package/dist/types/init/utils/configManipulation.d.ts

@@ -11,6 +11,20 @@ export type RoutingMode = RoutingConfig['mode'];
  * TypeScript recast parser.
  */
 export declare const setIntlayerConfigRoutingMode: (content: string, extension: string, mode: RoutingMode) => string;
+/**
+ * Sets `routing.enableProxy` in an Intlayer configuration file. Idempotent and
+ * comment-preserving: an existing property only has its value swapped. Supports
+ * `.ts`, `.mjs`, `.js`, `.cjs` and `.json` configs.
+ */
+export declare const setIntlayerConfigEnableProxy: (content: string, extension: string, enableProxy: boolean) => string;
+/**
+ * Reduces `routing` in an Intlayer configuration file to its `storage` entry,
+ * for projects without URL routing (backend-only, React Native…) where the
+ * routing mode and the locale proxy have no effect. An existing `storage`
+ * value is kept; otherwise `['cookie', 'header']` is written. JSON configs are
+ * returned unchanged.
+ */
+export declare const setIntlayerConfigRoutingStorageOnly: (content: string, extension: string) => string;
 /**
  * Sets `compiler.output` in an Intlayer configuration file to the given path
  * template (the `{{variable}}` string form, e.g.

package/dist/types/init/utils/configManipulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configManipulation.d.ts","names":[],"sources":["../../../../src/init/utils/configManipulation.ts"],"mappings":";;;;YAYY,cAAc;;;;;;;;qBA0Fb,+BAA4B,iBACxB,mBACE,MACX;;;;;;;;;qBA0CK,kCAA+B,iBAC3B,mBACE;;;;;;;;;qBA0CN,6BAA0B;;;;;;;;qBA+Q1B,wBAAqB;qBAIrB,mBAAgB,iBACZ;qBAoBJ,oBAAiB,iBACb;qBAoBJ,mBAAgB,iBACZ;;;;;;;;;;;;;qBA2EJ,oBAAiB,iBACb;;;;;;;qBA2EJ,yBAAsB;qBAgBtB,mBAAgB;;;;;qBA6DhB,6BAA0B,iBACtB;;;;;;qBA8BJ,kCAA+B,iBAC3B,mBACE,cACH;;;;;;;;;;qBAiCH,sCAAmC,iBAC/B,oBACG,2BACO;;;;;qBAqGd,mCAAgC,iBAC5B;;;;;qBAcJ,gCAA6B;;;;;qBA+D7B,iCAA8B,iBAC1B;;;;;;;qBAgBJ,8BAA2B,iBACvB;;;;;;qBAgQJ,qCAAkC,iBAC9B,mBACE,YACL"}
+{"version":3,"file":"configManipulation.d.ts","names":[],"sources":["../../../../src/init/utils/configManipulation.ts"],"mappings":";;;;YAYY,cAAc;;;;;;;;qBA0Fb,+BAA4B,iBACxB,mBACE,MACX;;;;;;qBAuCK,+BAA4B,iBACxB,mBACE;;;;;;;;qBA+CN,sCAAmC,iBAC/B;;;;;;;;;qBAgDJ,kCAA+B,iBAC3B,mBACE;;;;;;;;;qBA0CN,6BAA0B;;;;;;;;qBA+Q1B,wBAAqB;qBAIrB,mBAAgB,iBACZ;qBAoBJ,oBAAiB,iBACb;qBAoBJ,mBAAgB,iBACZ;;;;;;;;;;;;;qBA2EJ,oBAAiB,iBACb;;;;;;;qBA2EJ,yBAAsB;qBAgBtB,mBAAgB;;;;;qBA6DhB,6BAA0B,iBACtB;;;;;;qBA8BJ,kCAA+B,iBAC3B,mBACE,cACH;;;;;;;;;;qBAiCH,sCAAmC,iBAC/B,oBACG,2BACO;;;;;qBAqGd,mCAAgC,iBAC5B;;;;;qBAcJ,gCAA6B;;;;;qBA+D7B,iCAA8B,iBAC1B;;;;;;;qBAgBJ,8BAA2B,iBACvB;;;;;;qBAgQJ,qCAAkC,iBAC9B,mBACE,YACL"}

package/dist/types/init/utils/index.d.ts

@@ -1,12 +1,14 @@
-import { COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, IntlayerPackageAnalysis, PackageManager, detectCompatI18nLibraries, detectMissingIntlayerPackages, detectPackageManager, findLockFileDir, hasLintTooling, installPackages, isIntlayerPackageName, moveCompatPackagesToDevDependencies, normalizeVersion, runPackageInstall } from "./packageManager.js";
-import { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, hasIntlayerVitePlugin, replaceViteConfigPluginImportSource, setIntlayerConfigCompilerOutput, setIntlayerConfigRoutingMode, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n } from "./configManipulation.js";
+import { COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, IntlayerPackageAnalysis, MINIMUM_ESLINT_MAJOR, PENDING_COMPAT_ADAPTERS, PackageManager, detectCompatI18nLibraries, detectMissingIntlayerPackages, detectPackageManager, findLockFileDir, hasLegacyEslint, hasLintTooling, installPackages, isIntlayerPackageName, moveCompatPackagesToDevDependencies, normalizeVersion, runPackageInstall } from "./packageManager.js";
+import { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, hasIntlayerVitePlugin, replaceViteConfigPluginImportSource, setIntlayerConfigCompilerOutput, setIntlayerConfigEnableProxy, setIntlayerConfigRoutingMode, setIntlayerConfigRoutingStorageOnly, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n } from "./configManipulation.js";
 import { ensureNamedImport, firstInsertIndex, isModuleScopeBinding } from "./astImports.js";
 import { BACKEND_INTLAYER_PACKAGES, ResolveDevScriptParams, resolveDevScript } from "./devScript.js";
 import { JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NextIntlMessagesPattern, detectJsonLocalePattern, detectLinguiCatalogPattern, detectNextIntlMessagesPattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot } from "./fileSystem.js";
 import { GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, getGithubWorkflows, resolveGithubWorkflowsContext } from "./githubActions.js";
 import { IntlayerDependency, IntlayerDependencyUpgrade, PackageJsonIntlayerDependencies, fetchLatestPackageVersion, findPackageJsonFiles, getIntlayerDependencies, getIntlayerDependencyUpgrades, listIntlayerDependencies, toRange, writeIntlayerDependencyUpgrades } from "./intlayerDependencies.js";
 import { parseJSONWithComments } from "./jsonParser.js";
+import { LINT_PLUGIN_PACKAGE_NAME, OxlintConfig, addIntlayerRulesToOxlintConfig } from "./lintConfig.js";
 import { NEXT_INTLAYER_BABEL_CONFIG_CONTENT, setupNextCompilerBabelConfig } from "./nextCompilerBabel.js";
 import { findTsConfigFiles } from "./tsConfig.js";
+import { hasUrlRoutingFramework } from "./urlRoutingFramework.js";
 import { isVersionAtLeast } from "./version.js";
-export { BACKEND_INTLAYER_PACKAGES, COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, IntlayerDependency, IntlayerDependencyUpgrade, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, NextIntlMessagesPattern, PackageJsonIntlayerDependencies, PackageManager, ResolveDevScriptParams, RoutingMode, detectCompatI18nLibraries, detectJsonLocalePattern, detectLinguiCatalogPattern, detectMissingIntlayerPackages, detectNextIntlMessagesPattern, detectPackageManager, enableIntlayerEditorConfig, ensureDirectory, ensureNamedImport, exists, fetchLatestPackageVersion, findLockFileDir, findPackageJsonFiles, findTsConfigFiles, firstInsertIndex, getGithubWorkflows, getIntlayerDependencies, getIntlayerDependencyUpgrades, getMetroConfigTemplate, hasIntlayerVitePlugin, hasLintTooling, installPackages, isIntlayerPackageName, isModuleScopeBinding, isVersionAtLeast, listIntlayerDependencies, moveCompatPackagesToDevDependencies, normalizeVersion, parseJSONWithComments, readFileFromRoot, replaceViteConfigPluginImportSource, resolveDevScript, resolveGithubWorkflowsContext, runPackageInstall, setIntlayerConfigCompilerOutput, setIntlayerConfigRoutingMode, setupNextCompilerBabelConfig, toRange, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, writeFileToRoot, writeIntlayerDependencyUpgrades };
+export { BACKEND_INTLAYER_PACKAGES, COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, IntlayerDependency, IntlayerDependencyUpgrade, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, LINT_PLUGIN_PACKAGE_NAME, LinguiCatalogPattern, MINIMUM_ESLINT_MAJOR, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, NextIntlMessagesPattern, OxlintConfig, PENDING_COMPAT_ADAPTERS, PackageJsonIntlayerDependencies, PackageManager, ResolveDevScriptParams, RoutingMode, addIntlayerRulesToOxlintConfig, detectCompatI18nLibraries, detectJsonLocalePattern, detectLinguiCatalogPattern, detectMissingIntlayerPackages, detectNextIntlMessagesPattern, detectPackageManager, enableIntlayerEditorConfig, ensureDirectory, ensureNamedImport, exists, fetchLatestPackageVersion, findLockFileDir, findPackageJsonFiles, findTsConfigFiles, firstInsertIndex, getGithubWorkflows, getIntlayerDependencies, getIntlayerDependencyUpgrades, getMetroConfigTemplate, hasIntlayerVitePlugin, hasLegacyEslint, hasLintTooling, hasUrlRoutingFramework, installPackages, isIntlayerPackageName, isModuleScopeBinding, isVersionAtLeast, listIntlayerDependencies, moveCompatPackagesToDevDependencies, normalizeVersion, parseJSONWithComments, readFileFromRoot, replaceViteConfigPluginImportSource, resolveDevScript, resolveGithubWorkflowsContext, runPackageInstall, setIntlayerConfigCompilerOutput, setIntlayerConfigEnableProxy, setIntlayerConfigRoutingMode, setIntlayerConfigRoutingStorageOnly, setupNextCompilerBabelConfig, toRange, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, writeFileToRoot, writeIntlayerDependencyUpgrades };

package/dist/types/init/utils/lintConfig.d.ts

@@ -0,0 +1,28 @@
+//#region src/init/utils/lintConfig.d.ts
+/**
+ * The Intlayer lint setup, as `intlayer init` writes it into `.oxlintrc.json`.
+ *
+ * Declared locally on purpose: `@intlayer/engine` is installed by every Intlayer
+ * user, so it must not depend on a lint plugin to write a handful of strings
+ * into a JSON file. oxlint resolves a plugin's *rules* but not its shipped
+ * *configs*, so the preset cannot be referenced by name there either.
+ *
+ * Mirrors the `recommended` preset of `eslint-plugin-intlayer`; keep in sync
+ * when a rule is enabled by default there.
+ */
+export declare const LINT_PLUGIN_PACKAGE_NAME = "eslint-plugin-intlayer";
+/** The `.oxlintrc.json` fields init reads and writes. */
+export type OxlintConfig = {
+  jsPlugins?: string[];
+  rules?: Record<string, unknown>;
+  ignorePatterns?: string[];
+};
+/**
+ * Adds the Intlayer plugin, the `recommended` rules and the generated-output
+ * ignore to an oxlint config, in place. Rules the user already set are kept.
+ *
+ * @returns Whether anything was added.
+ */
+export declare const addIntlayerRulesToOxlintConfig: (oxlintConfig: OxlintConfig) => boolean;
+//#endregion
+//# sourceMappingURL=lintConfig.d.ts.map

package/dist/types/init/utils/lintConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lintConfig.d.ts","names":[],"sources":["../../../../src/init/utils/lintConfig.ts"],"mappings":";;;;;;;;;;;;qBAWa;;YAaD;EACV;EACA,QAAQ;EACR;;;;;;;;qBASW,iCAA8B,cAC3B"}

package/dist/types/init/utils/packageManager.d.ts

@@ -83,7 +83,20 @@ export type IntlayerPackageAnalysis = {
    * library requires alias injection.
    */
   compatVitePluginConfig: CompatVitePluginConfig | undefined;
+  /**
+   * Compat adapters the project would need but that are not published yet
+   * (see {@link PENDING_COMPAT_ADAPTERS}). The original library is kept as is;
+   * only its catalogs are synced.
+   */
+  pendingCompatAdapters: string[];
 };
+/**
+ * Compat adapters that live in `compat-comming/` and are not published to npm
+ * yet. Installing one fails the whole install command, so init keeps the
+ * original library, skips the adapter and its bundler / framework wiring, and
+ * only syncs the catalogs. Remove an entry once its package is released.
+ */
+export declare const PENDING_COMPAT_ADAPTERS: ReadonlySet<string>;
 /**
  * Detects the package manager in use by checking for lock files in the
  * project root, then the `packageManager` field of its `package.json`. Falls
@@ -166,14 +179,24 @@ export declare const moveCompatPackagesToDevDependencies: (packageJson: Record<s
  * @param dependencies - Merged dependencies of the target project.
  */
 export declare const detectCompatI18nLibraries: (dependencies: Record<string, string>) => string[];
+/** Lowest ESLint major `eslint-plugin-intlayer` supports (flat config). */
+export declare const MINIMUM_ESLINT_MAJOR = 9;
+/**
+ * True when the project pins ESLint below {@link MINIMUM_ESLINT_MAJOR}.
+ * Installing the plugin there fails on its `eslint` peer range (and takes the
+ * whole install command down with it). Ranges without a version number
+ * (`latest`, `*`, `catalog:`) are assumed current.
+ *
+ * @param dependencies - Merged dependencies of the target project.
+ */
+export declare const hasLegacyEslint: (dependencies: Record<string, string>) => boolean;
 /**
- * True when the project already lints, and so has something to plug the
- * Intlayer lint rules into.
+ * True when the project already lints with a linter the Intlayer rules can
+ * plug into: oxlint, or ESLint 9+.
  *
- * `eslint-plugin-intlayer` loads in both ESLint and oxlint, so either linter is
- * enough. Shared with the init flow so that installing the plugin and wiring up
- * its configuration are gated on exactly the same condition — a project that
- * does not lint is left alone entirely.
+ * Shared with the init flow so that installing the plugin and wiring up its
+ * configuration are gated on exactly the same condition — a project that does
+ * not lint, or lints with ESLint 8, is left alone.
  *
  * @param dependencies - Merged dependencies of the target project.
  */

package/dist/types/init/utils/packageManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packageManager.d.ts","names":[],"sources":["../../../../src/init/utils/packageManager.ts"],"mappings":";;YAKY;;;;;YAMA;;;;;;;EAOV;;;;;EAKA;;;;;EAKA;;;;;;;;;;;;;;;EAeA;;;;;;;YAQU;;EAEV;;EAEA;;;;;;;;EAQA;;IAEE;;IAEA;;;;YAKQ;;EAEV;;EAEA;;EAEA;;;;;;EAMA,kBAAkB;;;;;;EAMlB,wBAAwB;;;;;;;qBA8Cb,uBAAoB,oBAAsB;;;;;;qBAY1C,kBAAe;;;;;;;YA2ChB;;;;;;EAMV;;;;;;EAMA,eAAe;;;;EAIf,kBAAkB;;;YAIR;;EAEV;;;;;;EAMA;;;;;EAKA,cAAc;;;;;;;;qBASH,gCAAgC;;;;;qBA+GhC,6BAA6B;;;;;;;;qBAc7B,sCAAmC,aACjC;;;;;;;;;;qBA8BF,4BAAyB,cACtB;;;;;;;;;;;;qBAiBH,iBAAc,cAAkB;qBAGhC,gCAA6B,iBACvB,wBAAsB,UAC9B,iCACR;;;;;qBA4VU,kBAAe,iBACX,oBACG,gBACF,gBAAc;;;;;;;;;;qBAgBnB,wBAAqB;;;;;;;;qBAarB,mBAAgB;;;;;;qBAahB,oBAAiB,iBACb,gBACC"}
+{"version":3,"file":"packageManager.d.ts","names":[],"sources":["../../../../src/init/utils/packageManager.ts"],"mappings":";;YAMY;;;;;YAMA;;;;;;;EAOV;;;;;EAKA;;;;;EAKA;;;;;;;;;;;;;;;EAeA;;;;;;;YAQU;;EAEV;;EAEA;;;;;;;;EAQA;;IAEE;;IAEA;;;;YAKQ;;EAEV;;EAEA;;EAEA;;;;;;EAMA,kBAAkB;;;;;;EAMlB,wBAAwB;;;;;;EAMxB;;;;;;;;qBASW,yBAAyB;;;;;;qBAiDzB,uBAAoB,oBAAsB;;;;;;qBAY1C,kBAAe;;;;;;;YA2ChB;;;;;;EAMV;;;;;;EAMA,eAAe;;;;EAIf,kBAAkB;;;YAIR;;EAEV;;;;;;EAMA;;;;;EAKA,cAAc;;;;;;;;qBASH,gCAAgC;;;;;qBA+GhC,6BAA6B;;;;;;;;qBAc7B,sCAAmC,aACjC;;;;;;;;;;qBA8BF,4BAAyB,cACtB;;qBAOH;;;;;;;;;qBAUA,kBAAe,cACZ;;;;;;;;;;;qBAiBH,iBAAc,cAAkB;qBAIhC,gCAA6B,iBACvB,wBAAsB,UAC9B,iCACR;;;;;qBAyZU,kBAAe,iBACX,oBACG,gBACF,gBAAc;;;;;;;;;;qBAgBnB,wBAAqB;;;;;;;;qBAarB,mBAAgB;;;;;;qBAahB,oBAAiB,iBACb,gBACC"}

package/dist/types/init/utils/urlRoutingFramework.d.ts

@@ -0,0 +1,9 @@
+//#region src/init/utils/urlRoutingFramework.d.ts
+/**
+ * Returns true when the project is a web frontend for which locale routing is
+ * meaningful. React Native / Expo apps are excluded (no URL routing), as are
+ * backend-only and plain Node projects.
+ */
+export declare const hasUrlRoutingFramework: (dependencies: Record<string, string>) => boolean;
+//#endregion
+//# sourceMappingURL=urlRoutingFramework.d.ts.map

package/dist/types/init/utils/urlRoutingFramework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlRoutingFramework.d.ts","names":[],"sources":["../../../../src/init/utils/urlRoutingFramework.ts"],"mappings":";;;;;;qBAgCa,yBAAsB,cACnB"}

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

@@ -13,7 +13,9 @@ export type InitConfigOptions = {
 /**
  * Initialize the Intlayer configuration file. No-ops when a configuration file
  * already exists at `baseDir`.
+ *
+ * @returns `true` when the file was created, `false` when one already existed.
  */
-export declare const initConfig: (format: (typeof configurationFilesCandidates)[number], baseDir: string, options?: InitConfigOptions) => Promise<void>;
+export declare const initConfig: (format: (typeof configurationFilesCandidates)[number], baseDir: string, options?: InitConfigOptions) => Promise<boolean>;
 //#endregion
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/initConfig/index.ts"],"mappings":";;;YA6BY;;EAEV;;;;;EAKA;;;;;;qBAOW,aAAU,gBACL,uCAAqC,iBACtC,UACL,sBAAiB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/initConfig/index.ts"],"mappings":";;;YA6BY;;EAEV;;;;;EAKA;;;;;;;;qBASW,aAAU,gBACL,uCAAqC,iBACtC,UACL,sBACT"}

package/dist/types/loadDictionaries/logTypeScriptErrors.d.ts

@@ -1,5 +1,9 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/loadDictionaries/logTypeScriptErrors.d.ts
+/**
+ * Type-checks content declaration files and logs errors as warnings.
+ * Supports both the classic (`typescript` <= 6) and native (>= 7) compilers.
+ */
 export declare const logTypeScriptErrors: (filePaths: string[], configuration: IntlayerConfig) => Promise<void>;
 //#endregion
 //# sourceMappingURL=logTypeScriptErrors.d.ts.map

package/dist/types/loadDictionaries/logTypeScriptErrors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logTypeScriptErrors.d.ts","names":[],"sources":["../../../src/loadDictionaries/logTypeScriptErrors.ts"],"mappings":";;qBAIa,sBAAmB,qBACX,eACJ,mBAAc"}
+{"version":3,"file":"logTypeScriptErrors.d.ts","names":[],"sources":["../../../src/loadDictionaries/logTypeScriptErrors.ts"],"mappings":";;;;;;qBAoQa,sBAAmB,qBACX,eACJ,mBACd"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/engine",
-  "version": "9.5.9",
+  "version": "9.5.10",
   "private": false,
   "description": "Scans and builds Intlayer declaration files into dictionaries based on Intlayer configuration.",
   "keywords": [
@@ -142,11 +142,11 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.5.9",
-    "@intlayer/config": "9.5.9",
-    "@intlayer/core": "9.5.9",
-    "@intlayer/dictionaries-entry": "9.5.9",
-    "@intlayer/types": "9.5.9",
+    "@intlayer/api": "9.5.10",
+    "@intlayer/config": "9.5.10",
+    "@intlayer/core": "9.5.10",
+    "@intlayer/dictionaries-entry": "9.5.10",
+    "@intlayer/types": "9.5.10",
     "@parcel/watcher": "2.6.0",
     "defu": "6.1.7",
     "fast-glob": "3.3.3",
@@ -162,11 +162,11 @@
     "rimraf": "6.1.3",
     "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "5.0.1",
+    "vitest": "5.0.2",
     "zod": "4.6.5"
   },
   "peerDependencies": {
-    "@intlayer/babel": "9.5.9"
+    "@intlayer/babel": "9.5.10"
   },
   "peerDependenciesMeta": {
     "@intlayer/babel": {