@intlayer/engine 9.4.3 → 9.4.4

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

@@ -5,27 +5,26 @@
  * when the app is effectively empty) — they never overwrite user code.
  */
 /** Next.js >= 16 locale-detection proxy (`src/proxy.ts`). */
-declare const PROXY_TEMPLATE = "export { intlayerProxy as proxy } from \"next-intlayer/proxy\";\n\nexport const config = {\n  matcher:\n    \"/((?!api|static|assets|robots|sitemap|sw|service-worker|manifest|.*\\\\..*|_next).*)\",\n};\n";
+export declare const PROXY_TEMPLATE = "export { intlayerProxy as proxy } from \"next-intlayer/proxy\";\n\nexport const config = {\n  matcher:\n    \"/((?!api|static|assets|robots|sitemap|sw|service-worker|manifest|.*\\\\..*|_next).*)\",\n};\n";
 /** Next.js < 16 locale-detection middleware (`src/middleware.ts`). */
-declare const MIDDLEWARE_TEMPLATE = "export { intlayerMiddleware as middleware } from \"next-intlayer/middleware\";\n\nexport const config = {\n  matcher:\n    \"/((?!api|static|assets|robots|sitemap|sw|service-worker|manifest|.*\\\\..*|_next).*)\",\n};\n";
+export declare const MIDDLEWARE_TEMPLATE = "export { intlayerMiddleware as middleware } from \"next-intlayer/middleware\";\n\nexport const config = {\n  matcher:\n    \"/((?!api|static|assets|robots|sitemap|sw|service-worker|manifest|.*\\\\..*|_next).*)\",\n};\n";
 /** Minimal pass-through root layout (`app/layout.tsx`), lets `[locale]/layout` own `<html>`. */
-declare const ROOT_LAYOUT_TEMPLATE_TS = "import type { PropsWithChildren, FC } from \"react\";\n\nconst RootLayout: FC<PropsWithChildren> = ({ children }) => <>{children}</>;\n\nexport default RootLayout;\n";
-declare const ROOT_LAYOUT_TEMPLATE_JS = "const RootLayout = ({ children }) => <>{children}</>;\n\nexport default RootLayout;\n";
+export declare const ROOT_LAYOUT_TEMPLATE_TS = "import type { PropsWithChildren, FC } from \"react\";\n\nconst RootLayout: FC<PropsWithChildren> = ({ children }) => <>{children}</>;\n\nexport default RootLayout;\n";
+export declare const ROOT_LAYOUT_TEMPLATE_JS = "const RootLayout = ({ children }) => <>{children}</>;\n\nexport default RootLayout;\n";
 /**
  * Locale layout (`app/[locale]/layout.tsx`) providing `<html>` + the unified
  * provider. `IntlayerProvider` seeds both the server context (read by server
  * hooks and by any page below, without per-page wrapping) and the client
  * provider in one mount.
  */
-declare const LOCALE_LAYOUT_TEMPLATE_TS = "import { type NextLayoutIntlayer } from \"next-intlayer\";\nimport { IntlayerProvider } from \"next-intlayer/server\";\nimport { getHTMLTextDir } from \"intlayer\";\n\nexport { generateStaticParams } from \"next-intlayer\";\n\nconst LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {\n  const { locale } = await params;\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 LocaleLayout;\n";
-declare const LOCALE_LAYOUT_TEMPLATE_JS = "import { IntlayerProvider } from \"next-intlayer/server\";\nimport { getHTMLTextDir } from \"intlayer\";\n\nexport { generateStaticParams } from \"next-intlayer\";\n\nconst LocaleLayout = async ({ children, params }) => {\n  const { locale } = await params;\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 LocaleLayout;\n";
+export declare const LOCALE_LAYOUT_TEMPLATE_TS = "import { type NextLayoutIntlayer } from \"next-intlayer\";\nimport { IntlayerProvider } from \"next-intlayer/server\";\nimport { getHTMLTextDir } from \"intlayer\";\n\nexport { generateStaticParams } from \"next-intlayer\";\n\nconst LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {\n  const { locale } = await params;\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 LocaleLayout;\n";
+export declare const LOCALE_LAYOUT_TEMPLATE_JS = "import { IntlayerProvider } from \"next-intlayer/server\";\nimport { getHTMLTextDir } from \"intlayer\";\n\nexport { generateStaticParams } from \"next-intlayer\";\n\nconst LocaleLayout = async ({ children, params }) => {\n  const { locale } = await params;\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 LocaleLayout;\n";
 /**
  * Locale home page (`app/[locale]/page.tsx`). Self-contained starter that does
  * not depend on an example content declaration — add Intlayer content (a
  * `*.content.ts` file consumed via `useIntlayer`) as the next step.
  */
-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";
-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";
+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";
 //#endregion
-export { LOCALE_LAYOUT_TEMPLATE_JS, LOCALE_LAYOUT_TEMPLATE_TS, LOCALE_PAGE_TEMPLATE_JS, LOCALE_PAGE_TEMPLATE_TS, MIDDLEWARE_TEMPLATE, PROXY_TEMPLATE, ROOT_LAYOUT_TEMPLATE_JS, ROOT_LAYOUT_TEMPLATE_TS };
 //# 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":";;;;;;;cAOa;;cASA;;cASA;cAOA;;;;;;;cAWA;cAqBA;;;;;;cAyBA;cAgBA"}
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/templates.ts"],"mappings":";;;;;;;qBAOa;;qBASA;;qBASA;qBAOA;;;;;;;qBAWA;qBAqBA;;;;;;qBAyBA;qBAgBA"}

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

@@ -1,6 +1,6 @@
 //#region src/init/frameworkSetup/nextAppRouter/transforms.d.ts
 /** Result of a source transform. `code` is unchanged for any non-`wrapped` status. */
-type TransformResult = {
+export type TransformResult = {
   code: string;
   status: 'wrapped' | 'already' | 'skipped-client' | 'skipped';
 };
@@ -15,7 +15,6 @@ type TransformResult = {
  * pages below the locale layout read locale/variant from it without wrapping
  * themselves individually (see the removed `wrapPageWithProvider`).
  */
-declare const wrapLayoutWithProvider: (code: string) => TransformResult;
+export declare const wrapLayoutWithProvider: (code: string) => TransformResult;
 //#endregion
-export { TransformResult, wrapLayoutWithProvider };
 //# 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":";;KAWY;EACV;EACA;;;;;;;;;;;;;cAsLW,yBAAsB,iBAAmB"}
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/transforms.ts"],"mappings":";;YAWY;EACV;EACA;;;;;;;;;;;;;qBAsLW,yBAAsB,iBAAmB"}

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

@@ -1,6 +1,6 @@
 //#region src/init/frameworkSetup/tanstackStart/detect.d.ts
 /** Location of the TanStack Router file-based routes directory. */
-type TanStackRoutesInfo = {
+export type TanStackRoutesInfo = {
   /** Routes directory relative to the root, e.g. `src/routes` or `routes`. */
   routesDir: string;
   /** `src` when the project uses a `src/` directory, otherwise `''`. */
@@ -10,12 +10,11 @@ type TanStackRoutesInfo = {
  * Detects the TanStack Router routes directory, preferring `src/routes` over
  * `routes`. Returns `null` when neither exists.
  */
-declare const detectTanStackRoutesDir: (rootDir: string) => Promise<TanStackRoutesInfo | null>;
+export declare const detectTanStackRoutesDir: (rootDir: string) => Promise<TanStackRoutesInfo | null>;
 /**
  * Returns true when the project depends on TanStack Start (`@tanstack/react-start`)
  * or, failing that, on `@tanstack/react-router` (file-based routing).
  */
-declare const hasTanStackStartDeps: (allDeps: Record<string, string>) => boolean;
+export declare const hasTanStackStartDeps: (allDeps: Record<string, string>) => boolean;
 //#endregion
-export { TanStackRoutesInfo, detectTanStackRoutesDir, hasTanStackStartDeps };
 //# sourceMappingURL=detect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"detect.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/detect.ts"],"mappings":";;KAIY;;EAEV;;EAEA;;;;;;cAOW,0BAAuB,oBAEjC,QAAQ;;;;;cAcE,uBAAoB,SACtB"}
+{"version":3,"file":"detect.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/detect.ts"],"mappings":";;YAIY;;EAEV;;EAEA;;;;;;qBAOW,0BAAuB,oBAEjC,QAAQ;;;;;qBAcE,uBAAoB,SACtB"}

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

@@ -6,7 +6,6 @@ import { FrameworkAdapter } from "../types.js";
  * the Intlayer provider — all idempotently and without overwriting user code it
  * cannot confidently transform.
  */
-declare const tanStackStartAdapter: FrameworkAdapter;
+export declare const tanStackStartAdapter: FrameworkAdapter;
 //#endregion
-export { tanStackStartAdapter };
 //# sourceMappingURL=index.d.ts.map

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":";;;;;;;;cA4Ea,sBAAsB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/index.ts"],"mappings":";;;;;;;;qBA4Ea,sBAAsB"}

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

@@ -5,20 +5,20 @@ import { RoutingMode } from "../../utils/configManipulation.js";
  * used by every routing mode except `prefix-all` so the default locale stays
  * prefix-free.
  */
-declare const LOCALE_SEGMENT = "{-$locale}";
+export declare const LOCALE_SEGMENT = "{-$locale}";
 /**
  * The required TanStack Router locale segment directory (`$locale` param), used
  * by `prefix-all` routing where every URL — including the default locale — is
  * prefixed.
  */
-declare const PREFIX_ALL_LOCALE_SEGMENT = "$locale";
+export declare const PREFIX_ALL_LOCALE_SEGMENT = "$locale";
 /**
  * Picks the locale segment directory for the project's routing mode. `prefix-all`
  * requires the mandatory `$locale` param so the default locale is also prefixed;
  * all other modes use the optional `{-$locale}` param so the default locale stays
  * prefix-free.
  */
-declare const getLocaleSegment: (routingMode: RoutingMode) => string;
+export declare const getLocaleSegment: (routingMode: RoutingMode) => string;
 /**
  * Detects whether a top-level route entry is already a locale segment, in any of
  * the TanStack Router param forms:
@@ -29,7 +29,7 @@ declare const getLocaleSegment: (routingMode: RoutingMode) => string;
  * existing prefix-all `$locale` directory is never nested under a freshly created
  * `{-$locale}` (which would produce `{-$locale}/$locale`).
  */
-declare const isLocaleSegment: (entryName: string) => boolean;
+export declare const isLocaleSegment: (entryName: string) => boolean;
 /**
  * Routes-directory entries that must stay at the root and never be moved under
  * `{-$locale}`:
@@ -42,9 +42,9 @@ declare const isLocaleSegment: (entryName: string) => boolean;
  * Everything else (route files and nested route folders) is moved so it becomes
  * locale-aware.
  */
-declare const shouldKeepRouteAtRoot: (entryName: string) => boolean;
+export declare const shouldKeepRouteAtRoot: (entryName: string) => boolean;
 /** Outcome of an attempted `{-$locale}` restructure. */
-type RestructureResult = {
+export type RestructureResult = {
   status: 'already-structured';
   localeSegment: string;
 } | {
@@ -61,7 +61,6 @@ type RestructureResult = {
  * {@link isLocaleSegment}), which is reported via `localeSegment`. Root-only
  * files (see {@link shouldKeepRouteAtRoot}) are left in place.
  */
-declare const restructureRoutesIntoLocale: (rootDir: string, routesDir: string, localeSegment?: string) => Promise<RestructureResult>;
+export declare const restructureRoutesIntoLocale: (rootDir: string, routesDir: string, localeSegment?: string) => Promise<RestructureResult>;
 //#endregion
-export { LOCALE_SEGMENT, PREFIX_ALL_LOCALE_SEGMENT, RestructureResult, getLocaleSegment, isLocaleSegment, restructureRoutesIntoLocale, shouldKeepRouteAtRoot };
 //# sourceMappingURL=restructure.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"restructure.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/restructure.ts"],"mappings":";;;;;;;cAca;;;;;;cAOA;;;;;;;cAQA,mBAAgB,aAAiB;;;;;;;;;;;cAajC,kBAAe;;;;;;;;;;;;;cAmBf,wBAAqB;;KAUtB;EACN;EAA8B;;EAC9B;;EACA;EAAiB;;;;;;;;;;cAUV,8BAA2B,iBACvB,mBACE,2BAEhB,QAAQ"}
+{"version":3,"file":"restructure.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/restructure.ts"],"mappings":";;;;;;;qBAca;;;;;;qBAOA;;;;;;;qBAQA,mBAAgB,aAAiB;;;;;;;;;;;qBAajC,kBAAe;;;;;;;;;;;;;qBAmBf,wBAAqB;;YAUtB;EACN;EAA8B;;EAC9B;;EACA;EAAiB;;;;;;;;;;qBAUV,8BAA2B,iBACvB,mBACE,2BAEhB,QAAQ"}

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

@@ -10,7 +10,7 @@
  * locale; in both cases `validatePrefix` redirects unknown prefixes to a valid
  * one. Identical for TypeScript and JavaScript projects.
  */
-declare const buildLocaleRouteTemplate: (localeSegment: string) => string;
+export declare const buildLocaleRouteTemplate: (localeSegment: string) => string;
 /**
  * Root route document (`routes/__root.tsx`) providing `<html>` + the Intlayer
  * provider, with the locale read from the locale segment route params.
@@ -19,9 +19,8 @@ declare const buildLocaleRouteTemplate: (localeSegment: string) => string;
  * importing `<segment>/route`, so the root never imports a child route module —
  * the recommended way to consume another route's typed hooks.
  */
-declare const buildRootTemplateTs: (localeSegment: string) => string;
+export declare const buildRootTemplateTs: (localeSegment: string) => string;
 /** JavaScript counterpart of {@link buildRootTemplateTs}. */
-declare const buildRootTemplateJs: (localeSegment: string) => string;
+export declare const buildRootTemplateJs: (localeSegment: string) => string;
 //#endregion
-export { buildLocaleRouteTemplate, buildRootTemplateJs, buildRootTemplateTs };
 //# 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":";;;;;;;;;;;;cAYa,2BAAwB;;;;;;;;;cAgCxB,sBAAmB;;cAkCnB,sBAAmB"}
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/templates.ts"],"mappings":";;;;;;;;;;;;qBAYa,2BAAwB;;;;;;;;;qBAgCxB,sBAAmB;;qBAkCnB,sBAAmB"}

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

@@ -1,6 +1,6 @@
 //#region src/init/frameworkSetup/tanstackStart/transforms.d.ts
 /** Result of a source transform. `code` is unchanged for any non-`wrapped` status. */
-type TransformResult = {
+export type TransformResult = {
   code: string;
   status: 'wrapped' | 'already' | 'skipped';
 };
@@ -15,7 +15,6 @@ type TransformResult = {
  * @param localeSegment Locale segment directory in use — `{-$locale}` for every
  * routing mode but `prefix-all`, which uses the required `$locale`.
  */
-declare const wrapRootWithProvider: (code: string, localeSegment: string) => TransformResult;
+export declare const wrapRootWithProvider: (code: string, localeSegment: string) => TransformResult;
 //#endregion
-export { TransformResult, wrapRootWithProvider };
 //# sourceMappingURL=transforms.d.ts.map

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":";;KAkBY;EACV;EACA;;;;;;;;;;;;;cAoMW,uBAAoB,cACnB,0BAEX"}
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/transforms.ts"],"mappings":";;YAkBY;EACV;EACA;;;;;;;;;;;;;qBAoMW,uBAAoB,cACnB,0BAEX"}

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

@@ -5,7 +5,7 @@ import { RoutingMode } from "../utils/configManipulation.js";
  * Shared context passed to every framework adapter. Mirrors the data already
  * computed by `initIntlayer` so adapters don't re-detect it.
  */
-type FrameworkSetupContext = {
+export type FrameworkSetupContext = {
   /** Absolute project root directory. */
   rootDir: string;
   /** Merged prod + dev dependencies of the project's package.json. */
@@ -27,7 +27,7 @@ type FrameworkSetupContext = {
  * project shape and scaffold the matching Intlayer integration (middleware,
  * providers, example content) in a way that is safe to re-run.
  */
-type FrameworkAdapter = {
+export type FrameworkAdapter = {
   /** Human-readable adapter name, used in logs. */
   name: string;
   /**
@@ -43,5 +43,4 @@ type FrameworkAdapter = {
   setup: (context: FrameworkSetupContext) => Promise<void>;
 };
 //#endregion
-export { FrameworkAdapter, FrameworkSetupContext };
 //# sourceMappingURL=types.d.ts.map

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":";;;;;;;KAOY;;EAEV;;EAEA,SAAS;;EAET,gBAAgB;;EAEhB;;;;;;;EAOA,aAAa;;;;;;;KAQH;;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;;;;;;;YAQH;;EAEV;;;;;EAKA,SAAS,SAAS,oCAAoC;;;;;;EAMtD,QAAQ,SAAS,0BAA0B"}

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

@@ -7,7 +7,7 @@ import "./utils/index.js";
  * embed Vite (Astro, SvelteKit, …) are checked before the bare Vite fallback so
  * their own dev port wins.
  */
-declare const getDefaultApplicationURL: (dependencies: Record<string, string>) => string;
+export declare const getDefaultApplicationURL: (dependencies: Record<string, string>) => string;
 /**
  * How the interactive init organizes autogenerated content (compiler output /
  * autofill):
@@ -17,11 +17,11 @@ declare const getDefaultApplicationURL: (dependencies: Record<string, string>) =
  * - `json-namespaces` — plain per-locale JSON namespace files kept in sync
  *   through `@intlayer/sync-json-plugin`.
  */
-type ContentStrategy = 'per-component' | 'centralized' | 'json-namespaces';
+export type ContentStrategy = 'per-component' | 'centralized' | 'json-namespaces';
 /**
  * OPTIONS
  */
-type InitOptions = {
+export type InitOptions = {
   noGitignore?: boolean;
   /** Skip scaffolding the `fill` and `test` GitHub Actions workflows. */
   noGithubActions?: boolean;
@@ -63,7 +63,6 @@ type InitOptions = {
 /**
  * MAIN LOGIC
  */
-declare const initIntlayer: (rootDir: string, options?: InitOptions) => Promise<void>;
+export declare const initIntlayer: (rootDir: string, options?: InitOptions) => Promise<void>;
 //#endregion
-export { ContentStrategy, InitOptions, getDefaultApplicationURL, initIntlayer };
 //# 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":";;;;;;;;;cAwNa,2BAAwB,cACrB;;;;;;;;;;KAsBJ;;;;KAQA;EACV;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;;;;EAKA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd,kBAAkB;;;;;cAMP,eAAY,iBAAyB,UAAY,gBAAW"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;;;;;qBAwNa,2BAAwB,cACrB;;;;;;;;;;YAsBJ;;;;YAQA;EACV;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;;;;EAKA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd,kBAAkB;;;;;qBAMP,eAAY,iBAAyB,UAAY,gBAAW"}

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

@@ -3,7 +3,7 @@
  * Index just past the leading directives (e.g. `'use client'`) and import
  * declarations — the safe insertion point for a new import.
  */
-declare const firstInsertIndex: (ast: any) => number;
+export declare const firstInsertIndex: (ast: any) => number;
 /**
  * Whether `name` is already bound at module scope — by any import (under that
  * local name, regardless of source) or by a top-level
@@ -13,7 +13,7 @@ declare const firstInsertIndex: (ast: any) => number;
  * `defaultLocale` re-exported from a local `i18n` module), which would otherwise
  * produce an `Identifier '…' has already been declared` parse error.
  */
-declare const isModuleScopeBinding: (ast: any, name: string) => boolean;
+export declare const isModuleScopeBinding: (ast: any, name: string) => boolean;
 /**
  * Ensures `import { importName } from source`, merging into an existing import
  * from the same source. No-ops when `importName` is already bound at module
@@ -23,7 +23,6 @@ declare const isModuleScopeBinding: (ast: any, name: string) => boolean;
  * Shared across every framework adapter so injected identifiers never collide
  * with bindings the user's file already provides.
  */
-declare const ensureNamedImport: (ast: any, importName: string, source: string) => void;
+export declare const ensureNamedImport: (ast: any, importName: string, source: string) => void;
 //#endregion
-export { ensureNamedImport, firstInsertIndex, isModuleScopeBinding };
 //# sourceMappingURL=astImports.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"astImports.d.ts","names":[],"sources":["../../../../src/init/utils/astImports.ts"],"mappings":";;;;;cAQa,mBAAgB;;;;;;;;;;cAuBhB,uBAAoB,UAAY;;;;;;;;;;cAoChC,oBAAiB,UACpB,oBACU"}
+{"version":3,"file":"astImports.d.ts","names":[],"sources":["../../../../src/init/utils/astImports.ts"],"mappings":";;;;;qBAQa,mBAAgB;;;;;;;;;;qBAuBhB,uBAAoB,UAAY;;;;;;;;;;qBAoChC,oBAAiB,UACpB,oBACU"}

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

@@ -2,7 +2,7 @@ import { CompatSyncConfig, CompatVitePluginConfig } from "./packageManager.js";
 import { RoutingConfig } from "@intlayer/types/config";
 //#region src/init/utils/configManipulation.d.ts
 /** The locale routing strategies supported by the Intlayer configuration. */
-type RoutingMode = RoutingConfig['mode'];
+export type RoutingMode = RoutingConfig['mode'];
 /**
  * Sets `routing.mode` in an Intlayer configuration file to the requested
  * strategy. Idempotent: re-running with the same mode produces identical
@@ -10,7 +10,7 @@ type RoutingMode = RoutingConfig['mode'];
  * handled with a scoped string replacement since they cannot be parsed by the
  * TypeScript recast parser.
  */
-declare const setIntlayerConfigRoutingMode: (content: string, extension: string, mode: RoutingMode) => string;
+export declare const setIntlayerConfigRoutingMode: (content: string, extension: string, mode: RoutingMode) => string;
 /**
  * Sets `compiler.output` in an Intlayer configuration file to the given path
  * template (the `{{variable}}` string form, e.g.
@@ -19,7 +19,7 @@ declare const setIntlayerConfigRoutingMode: (content: string, extension: string,
  * `.cjs` configs; JSON configs are supported too since the template is a plain
  * string.
  */
-declare const setIntlayerConfigCompilerOutput: (content: string, extension: string, outputTemplate: string) => string;
+export declare const setIntlayerConfigCompilerOutput: (content: string, extension: string, outputTemplate: string) => string;
 /**
  * Enables the Intlayer visual editor in a configuration file: sets
  * `editor.enabled` to `true` and wires `clientId` / `clientSecret` to the
@@ -28,7 +28,7 @@ declare const setIntlayerConfigCompilerOutput: (content: string, extension: stri
  * are preserved. Only `.ts`, `.mjs`, `.js` and `.cjs` configs are supported
  * (JSON cannot reference `process.env`).
  */
-declare const enableIntlayerEditorConfig: (content: string) => string;
+export declare const enableIntlayerEditorConfig: (content: string) => string;
 /**
  * Detects whether a Vite config already wires in an Intlayer plugin — either the
  * base `vite-intlayer` plugin or one of the compat adapters (e.g.
@@ -36,10 +36,10 @@ declare const enableIntlayerEditorConfig: (content: string) => string;
  * plugins internally wrap `intlayer()`, so a standalone `intlayer()` must not be
  * appended when one is already present, otherwise the plugin runs twice.
  */
-declare const hasIntlayerVitePlugin: (content: string) => boolean;
-declare const updateViteConfig: (content: string, extension: string) => string;
-declare const updateAstroConfig: (content: string, extension: string) => string;
-declare const updateNextConfig: (content: string, extension: string) => string;
+export declare const hasIntlayerVitePlugin: (content: string) => boolean;
+export declare const updateViteConfig: (content: string, extension: string) => string;
+export declare const updateAstroConfig: (content: string, extension: string) => string;
+export declare const updateNextConfig: (content: string, extension: string) => string;
 /**
  * Wraps a React Native Metro config's exported value with
  * `configMetroIntlayerSync` from `react-native-intlayer/metro`, injecting the
@@ -52,26 +52,26 @@ declare const updateNextConfig: (content: string, extension: string) => string;
  * is a custom async IIFE that cannot be wrapped synchronously. Callers should
  * compare the result with the input to detect the skipped case.
  */
-declare const updateMetroConfig: (content: string, extension: string) => string;
+export declare const updateMetroConfig: (content: string, extension: string) => string;
 /**
  * Builds the contents of a fresh `metro.config.js` wired with the Intlayer
  * Metro plugin. Uses the async `configMetroIntlayer` helper (which can build
  * dictionaries on server start) and picks the default-config source based on
  * whether the project is an Expo app.
  */
-declare const getMetroConfigTemplate: (isExpo: boolean) => string;
-declare const updateNuxtConfig: (content: string) => string;
+export declare const getMetroConfigTemplate: (isExpo: boolean) => string;
+export declare const updateNuxtConfig: (content: string) => string;
 /**
  * Updates a Vite config for vue-i18n compat: injects `vueI18nVitePlugin` from
  * `@intlayer/vue-i18n/plugin` into the plugins array.
  */
-declare const updateViteConfigForVueI18n: (content: string, extension: string) => string;
+export declare const updateViteConfigForVueI18n: (content: string, extension: string) => string;
 /**
  * Generic vite config updater for any compat plugin that uses alias injection.
  * Injects the named import from `pluginPackageSource` and appends the plugin
  * call to the `plugins` array.
  */
-declare const updateViteConfigForCompatPlugin: (content: string, extension: string, pluginConfig: CompatVitePluginConfig) => string;
+export declare const updateViteConfigForCompatPlugin: (content: string, extension: string, pluginConfig: CompatVitePluginConfig) => string;
 /**
  * Rewrites the module source of an existing named import in a vite config,
  * keeping the imported binding and its call site untouched. Used when a compat
@@ -81,35 +81,34 @@ declare const updateViteConfigForCompatPlugin: (content: string, extension: stri
  * `plugins` array as-is. Returns the content unchanged when no matching import
  * is found.
  */
-declare const replaceViteConfigPluginImportSource: (content: string, importName: string, fromPackageSource: string, toPackageSource: string) => string;
+export declare const replaceViteConfigPluginImportSource: (content: string, importName: string, fromPackageSource: string, toPackageSource: string) => string;
 /**
  * Updates a Next.js config for next-translate compat: wraps the default export
  * with `withNextTranslate` from `@intlayer/next-translate/plugin`.
  */
-declare const updateNextConfigForNextTranslate: (content: string, extension: string) => string;
+export declare const updateNextConfigForNextTranslate: (content: string, extension: string) => string;
 /**
  * Updates a Nuxt config for nuxtjs-i18n compat: adds `@intlayer/nuxtjs-i18n`
  * to the `modules` array.
  */
-declare const updateNuxtConfigForNuxtjsI18n: (content: string) => string;
+export declare const updateNuxtConfigForNuxtjsI18n: (content: string) => string;
 /**
  * Updates a Next.js config for next-i18next compat: wraps the default export
  * with `withI18next` from `@intlayer/next-i18next/plugin`.
  */
-declare const updateNextConfigForNextI18next: (content: string, extension: string) => string;
+export declare const updateNextConfigForNextI18next: (content: string, extension: string) => string;
 /**
  * Updates a Next.js config for next-intl compat: replaces any existing
  * `next-intl/plugin` import source with `@intlayer/next-intl/plugin`, or
  * injects `createNextIntlPlugin` with a factory-call wrapper when no such
  * import is present.
  */
-declare const updateNextConfigForNextIntl: (content: string, extension: string) => string;
+export declare const updateNextConfigForNextIntl: (content: string, extension: string) => string;
 /**
  * Injects the sync plugin import (`syncJSON` / `syncPO`) and a configured
  * `syncJSON(...)` / `syncPO(...)` call into the plugins array of an intlayer
  * config file. Idempotent: skips when the plugin call is already present.
  */
-declare const updateIntlayerConfigWithSyncPlugin: (content: string, extension: string, syncConfig: CompatSyncConfig) => string;
+export declare const updateIntlayerConfigWithSyncPlugin: (content: string, extension: string, syncConfig: CompatSyncConfig) => string;
 //#endregion
-export { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, hasIntlayerVitePlugin, replaceViteConfigPluginImportSource, setIntlayerConfigCompilerOutput, setIntlayerConfigRoutingMode, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n };
 //# sourceMappingURL=configManipulation.d.ts.map

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":";;;;KAYY,cAAc;;;;;;;;cA0Fb,+BAA4B,iBACxB,mBACE,MACX;;;;;;;;;cA0CK,kCAA+B,iBAC3B,mBACE;;;;;;;;;cA0CN,6BAA0B;;;;;;;;cA+Q1B,wBAAqB;cAIrB,mBAAgB,iBACZ;cAoBJ,oBAAiB,iBACb;cAoBJ,mBAAgB,iBACZ;;;;;;;;;;;;;cA2EJ,oBAAiB,iBACb;;;;;;;cA2EJ,yBAAsB;cAgBtB,mBAAgB;;;;;cA6DhB,6BAA0B,iBACtB;;;;;;cA8BJ,kCAA+B,iBAC3B,mBACE,cACH;;;;;;;;;;cAiCH,sCAAmC,iBAC/B,oBACG,2BACO;;;;;cAqGd,mCAAgC,iBAC5B;;;;;cAcJ,gCAA6B;;;;;cA+D7B,iCAA8B,iBAC1B;;;;;;;cAgBJ,8BAA2B,iBACvB;;;;;;cAgQJ,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;;;;;;;;;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"}

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

@@ -2,31 +2,31 @@
 /**
  * Helper to check if a file exists
  */
-declare const exists: (rootDir: string, filePath: string) => Promise<boolean>;
+export declare const exists: (rootDir: string, filePath: string) => Promise<boolean>;
 /**
  * Helper to read a file
  */
-declare const readFileFromRoot: (rootDir: string, filePath: string) => Promise<string>;
+export declare const readFileFromRoot: (rootDir: string, filePath: string) => Promise<string>;
 /**
  * Helper to write a file
  */
-declare const writeFileToRoot: (rootDir: string, filePath: string, content: string) => Promise<void>;
+export declare const writeFileToRoot: (rootDir: string, filePath: string, content: string) => Promise<void>;
 /**
  * Helper to ensure a directory exists
  */
-declare const ensureDirectory: (rootDir: string, dirPath: string) => Promise<void>;
+export declare const ensureDirectory: (rootDir: string, dirPath: string) => Promise<void>;
 /**
  * Pattern type for locale JSON file organisation.
  * - 'nested': files are at `{base}/{locale}/{key}.json`
  * - 'flat':   files are at `{base}/{locale}.json`
  */
-type JsonLocalePatternType = 'nested' | 'flat';
+export type JsonLocalePatternType = 'nested' | 'flat';
 /**
  * Detected locale JSON file pattern and the corresponding source template.
  * `template` uses `${locale}` and `${key}` as literal placeholders (not JS
  * expressions) so it can be embedded directly in a template-literal string.
  */
-type JsonLocalePattern = {
+export type JsonLocalePattern = {
   type: JsonLocalePatternType;
   /**
    * Source path template for syncJSON `source` option.
@@ -48,12 +48,12 @@ type JsonLocalePattern = {
  * The returned `template` contains `${locale}` and `${key}` as **literal**
  * placeholder strings so it can be embedded inside a JS template literal.
  */
-declare const detectJsonLocalePattern: (rootDir: string) => Promise<JsonLocalePattern | null>;
+export declare const detectJsonLocalePattern: (rootDir: string) => Promise<JsonLocalePattern | null>;
 /**
  * Detected lingui catalog pattern. lingui stores one catalog file per locale
  * (default name `messages`), as `.po` (its default) or `.json`.
  */
-type LinguiCatalogPattern = {
+export type LinguiCatalogPattern = {
   /** Which sync plugin should ingest the catalogs. */
   format: 'po' | 'json';
   /**
@@ -78,12 +78,12 @@ type LinguiCatalogPattern = {
  *
  * @param rootDir - Project root directory.
  */
-declare const detectLinguiCatalogPattern: (rootDir: string) => Promise<LinguiCatalogPattern | null>;
+export declare const detectLinguiCatalogPattern: (rootDir: string) => Promise<LinguiCatalogPattern | null>;
 /**
  * The messages source template derived from a `next-intl` `i18n/request.ts`
  * file, ready to be used as a `syncJSON` `source` builder.
  */
-type NextIntlMessagesPattern = {
+export type NextIntlMessagesPattern = {
   /** `'flat'` (one file per locale) or `'nested'` (per-namespace files). */
   type: JsonLocalePatternType;
   /**
@@ -108,7 +108,6 @@ type NextIntlMessagesPattern = {
  *
  * @param rootDir - Project root directory.
  */
-declare const detectNextIntlMessagesPattern: (rootDir: string) => Promise<NextIntlMessagesPattern | null>;
+export declare const detectNextIntlMessagesPattern: (rootDir: string) => Promise<NextIntlMessagesPattern | null>;
 //#endregion
-export { JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NextIntlMessagesPattern, detectJsonLocalePattern, detectLinguiCatalogPattern, detectNextIntlMessagesPattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot };
 //# sourceMappingURL=fileSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fileSystem.d.ts","names":[],"sources":["../../../../src/init/utils/fileSystem.ts"],"mappings":";;;;cASa,SAAM,iBAAyB,qBAAkB;;;;cAYjD,mBAAgB,iBAAyB,qBAAkB;;;;cAM3D,kBAAe,iBACX,kBACC,oBACD;;;;cAMJ,kBAAe,iBAAyB,oBAAiB;;;;;;KAa1D;;;;;;KAOA;EACV,MAAM;;;;;;EAMN;;;;EAIA;;;;;;;;;;;cA4CW,0BAAuB,oBAEjC,QAAQ;;;;;KA8EC;;EAEV;;;;;;;;EAQA;;EAEA;;;;;;;;;;;;;cAcW,6BAA0B,oBAEpC,QAAQ;;;;;KA4DC;;EAEV,MAAM;;;;;EAKN;;;;;;;;;;;;;;;;;;cAiCW,gCAA6B,oBAEvC,QAAQ"}
+{"version":3,"file":"fileSystem.d.ts","names":[],"sources":["../../../../src/init/utils/fileSystem.ts"],"mappings":";;;;qBASa,SAAM,iBAAyB,qBAAkB;;;;qBAYjD,mBAAgB,iBAAyB,qBAAkB;;;;qBAM3D,kBAAe,iBACX,kBACC,oBACD;;;;qBAMJ,kBAAe,iBAAyB,oBAAiB;;;;;;YAa1D;;;;;;YAOA;EACV,MAAM;;;;;;EAMN;;;;EAIA;;;;;;;;;;;qBA4CW,0BAAuB,oBAEjC,QAAQ;;;;;YA8EC;;EAEV;;;;;;;;EAQA;;EAEA;;;;;;;;;;;;;qBAcW,6BAA0B,oBAEpC,QAAQ;;;;;YA4DC;;EAEV,MAAM;;;;;EAKN;;;;;;;;;;;;;;;;;;qBAiCW,gCAA6B,oBAEvC,QAAQ"}

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

@@ -1,14 +1,14 @@
 import { PackageManager } from "./packageManager.js";
 //#region src/init/utils/githubActions.d.ts
 /** A GitHub Actions workflow file to be written to the project. */
-type GithubWorkflowFile = {
+export type GithubWorkflowFile = {
   /** Path relative to the project root, e.g. `.github/workflows/intlayer-fill.yml`. */
   filePath: string;
   /** Full YAML content of the workflow file. */
   content: string;
 };
 /** Options controlling how the CI workflows are generated. */
-type GithubWorkflowsOptions = {
+export type GithubWorkflowsOptions = {
   /**
    * Route the intlayer commands through `intlayer ci` instead of calling them
    * directly. The `ci` command discovers every Intlayer project of the
@@ -30,7 +30,7 @@ type GithubWorkflowsOptions = {
  * Resolved placement and generation parameters for the CI workflows.
  * See {@link resolveGithubWorkflowsContext}.
  */
-type GithubWorkflowsContext = {
+export type GithubWorkflowsContext = {
   /**
    * Directory the workflow files must be written to. GitHub only triggers
    * workflows stored in `.github/workflows` at the repository root, so this is
@@ -60,17 +60,16 @@ type GithubWorkflowsContext = {
  *   are written at the git root but run inside the project directory
  *   (`working-directory`), keeping the project's own package manager.
  */
-declare const resolveGithubWorkflowsContext: (rootDir: string, projectPackageManager: PackageManager) => Promise<GithubWorkflowsContext>;
+export declare const resolveGithubWorkflowsContext: (rootDir: string, projectPackageManager: PackageManager) => Promise<GithubWorkflowsContext>;
 /** Workflow file path constants, relative to the project root. */
-declare const GITHUB_FILL_WORKFLOW_PATH = ".github/workflows/intlayer-fill.yml";
-declare const GITHUB_TEST_WORKFLOW_PATH = ".github/workflows/intlayer-test.yml";
+export declare const GITHUB_FILL_WORKFLOW_PATH = ".github/workflows/intlayer-fill.yml";
+export declare const GITHUB_TEST_WORKFLOW_PATH = ".github/workflows/intlayer-test.yml";
 /**
  * Returns the two Intlayer GitHub Actions workflows (`fill` and `test`),
  * generated with commands matching the detected package manager and the
  * repository layout (see {@link GithubWorkflowsOptions} for the monorepo and
  * nested-project variants).
  */
-declare const getGithubWorkflows: (packageManager: PackageManager, options?: GithubWorkflowsOptions) => GithubWorkflowFile[];
+export declare const getGithubWorkflows: (packageManager: PackageManager, options?: GithubWorkflowsOptions) => GithubWorkflowFile[];
 //#endregion
-export { GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, getGithubWorkflows, resolveGithubWorkflowsContext };
 //# sourceMappingURL=githubActions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"githubActions.d.ts","names":[],"sources":["../../../../src/init/utils/githubActions.ts"],"mappings":";;;KAMY;;EAEV;;EAEA;;;KAIU;;;;;;;;;EASV;;;;;;;EAOA;;;;;;KAOU;;;;;;EAMV;;EAEA,gBAAgB;;EAEhB,SAAS;;;;;;;;;;;;;;;;;;;;cAyCE,gCAA6B,iBACzB,uBACQ,mBACtB,QAAQ;;cA4SE;cACA;;;;;;;cAQA,qBAAkB,gBACb,gBAAc,UACrB,2BACR"}
+{"version":3,"file":"githubActions.d.ts","names":[],"sources":["../../../../src/init/utils/githubActions.ts"],"mappings":";;;YAMY;;EAEV;;EAEA;;;YAIU;;;;;;;;;EASV;;;;;;;EAOA;;;;;;YAOU;;;;;;EAMV;;EAEA,gBAAgB;;EAEhB,SAAS;;;;;;;;;;;;;;;;;;;;qBAyCE,gCAA6B,iBACzB,uBACQ,mBACtB,QAAQ;;qBA4SE;qBACA;;;;;;;qBAQA,qBAAkB,gBACb,gBAAc,UACrB,2BACR"}

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

@@ -2,7 +2,6 @@
 /**
  * Helper to parse JSON that may contain comments (tsconfig allows comments)
  */
-declare const parseJSONWithComments: (jsonString: string) => any;
+export declare const parseJSONWithComments: (jsonString: string) => any;
 //#endregion
-export { parseJSONWithComments };
 //# sourceMappingURL=jsonParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"jsonParser.d.ts","names":[],"sources":["../../../../src/init/utils/jsonParser.ts"],"mappings":";;;;cAGa,wBAAqB"}
+{"version":3,"file":"jsonParser.d.ts","names":[],"sources":["../../../../src/init/utils/jsonParser.ts"],"mappings":";;;;qBAGa,wBAAqB"}