@intlayer/config 9.4.3 → 9.5.0

package/dist/types/configFile/configurationSchema.d.ts

@@ -1,7 +1,7 @@
 import { AiProviders } from "@intlayer/types/config";
 import z from "zod";
 //#region src/configFile/configurationSchema.d.ts
-declare const internationalizationSchema: z.ZodObject<{
+export declare const internationalizationSchema: z.ZodObject<{
   locales: z.ZodArray<z.ZodString>;
   requiredLocales: z.ZodOptional<z.ZodArray<z.ZodString>>;
   strictMode: z.ZodOptional<z.ZodEnum<{
@@ -11,7 +11,7 @@ declare const internationalizationSchema: z.ZodObject<{
   }>>;
   defaultLocale: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const cookiesAttributesSchema: z.ZodObject<{
+export declare const cookiesAttributesSchema: z.ZodObject<{
   type: z.ZodLiteral<"cookie">;
   name: z.ZodOptional<z.ZodString>;
   domain: z.ZodOptional<z.ZodString>;
@@ -26,7 +26,7 @@ declare const cookiesAttributesSchema: z.ZodObject<{
   expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
   maxAge: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-declare const storageAttributesSchema: z.ZodObject<{
+export declare const storageAttributesSchema: z.ZodObject<{
   type: z.ZodEnum<{
     header: "header";
     localStorage: "localStorage";
@@ -34,7 +34,7 @@ declare const storageAttributesSchema: z.ZodObject<{
   }>;
   name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const storageSchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum<{
+export declare const storageSchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum<{
   cookie: "cookie";
   header: "header";
   localStorage: "localStorage";
@@ -87,17 +87,17 @@ declare const storageSchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum
   }>;
   name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>]>>]>;
-declare const rewriteRuleSchema: z.ZodObject<{
+export declare const rewriteRuleSchema: z.ZodObject<{
   canonical: z.ZodString;
   localized: z.ZodRecord<z.ZodString, z.ZodString>;
 }, z.core.$strip>;
-declare const rewriteRulesSchema: z.ZodObject<{
+export declare const rewriteRulesSchema: z.ZodObject<{
   rules: z.ZodArray<z.ZodObject<{
     canonical: z.ZodString;
     localized: z.ZodRecord<z.ZodString, z.ZodString>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-declare const rewriteObjectSchema: z.ZodObject<{
+export declare const rewriteObjectSchema: z.ZodObject<{
   url: z.ZodObject<{
     rules: z.ZodArray<z.ZodObject<{
       canonical: z.ZodString;
@@ -117,7 +117,7 @@ declare const rewriteObjectSchema: z.ZodObject<{
     }, z.core.$strip>>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-declare const routingSchema: z.ZodObject<{
+export declare const routingSchema: z.ZodObject<{
   rewrite: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodObject<{
     url: z.ZodObject<{
       rules: z.ZodArray<z.ZodObject<{
@@ -201,7 +201,7 @@ declare const routingSchema: z.ZodObject<{
   basePath: z.ZodOptional<z.ZodString>;
   domains: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
-declare const systemSchema: z.ZodObject<{
+export declare const systemSchema: z.ZodObject<{
   baseDir: z.ZodOptional<z.ZodString>;
   moduleAugmentationDir: z.ZodOptional<z.ZodString>;
   unmergedDictionariesDir: z.ZodOptional<z.ZodString>;
@@ -215,7 +215,7 @@ declare const systemSchema: z.ZodObject<{
   cacheDir: z.ZodOptional<z.ZodString>;
   tempDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const contentSchema: z.ZodObject<{
+export declare const contentSchema: z.ZodObject<{
   fileExtensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
   contentDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
   codeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -223,7 +223,7 @@ declare const contentSchema: z.ZodObject<{
   watch: z.ZodOptional<z.ZodBoolean>;
   formatCommand: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const editorSchema: z.ZodObject<{
+export declare const editorSchema: z.ZodObject<{
   applicationURL: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"">]>>;
   editorURL: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"">]>>;
   cmsURL: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"">]>>;
@@ -240,12 +240,12 @@ declare const editorSchema: z.ZodObject<{
   liveSyncPort: z.ZodOptional<z.ZodNumber>;
   liveSyncURL: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"">]>>;
 }, z.core.$strip>;
-declare const analyticsSchema: z.ZodObject<{
+export declare const analyticsSchema: z.ZodObject<{
   enabled: z.ZodOptional<z.ZodBoolean>;
   flushInterval: z.ZodOptional<z.ZodNumber>;
   sampleRate: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-declare const logSchema: z.ZodObject<{
+export declare const logSchema: z.ZodObject<{
   mode: z.ZodOptional<z.ZodEnum<{
     default: "default";
     disabled: "disabled";
@@ -257,7 +257,7 @@ declare const logSchema: z.ZodObject<{
   info: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
   warn: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
 }, z.core.$strip>;
-declare const aiSchema: z.ZodObject<{
+export declare const aiSchema: z.ZodObject<{
   provider: z.ZodOptional<z.ZodEnum<typeof AiProviders>>;
   apiKey: z.ZodOptional<z.ZodString>;
   model: z.ZodOptional<z.ZodString>;
@@ -269,7 +269,7 @@ declare const aiSchema: z.ZodObject<{
     toon: "toon";
   }>>;
 }, z.core.$strip>;
-declare const buildSchema: z.ZodObject<{
+export declare const buildSchema: z.ZodObject<{
   mode: z.ZodOptional<z.ZodEnum<{
     auto: "auto";
     manual: "manual";
@@ -289,7 +289,7 @@ declare const buildSchema: z.ZodObject<{
   require: z.ZodOptional<z.ZodUnknown>;
   checkTypes: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-declare const compilerSchema: z.ZodObject<{
+export declare const compilerSchema: z.ZodObject<{
   enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"build-only">]>>;
   dictionaryKeyPrefix: z.ZodOptional<z.ZodString>;
   transformPattern: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
@@ -298,7 +298,7 @@ declare const compilerSchema: z.ZodObject<{
   noMetadata: z.ZodOptional<z.ZodBoolean>;
   saveComponents: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-declare const dictionarySchema: z.ZodObject<{
+export declare const dictionarySchema: z.ZodObject<{
   fill: z.ZodOptional<z.ZodUnknown>;
   contentAutoTransformation: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
     markdown: z.ZodOptional<z.ZodBoolean>;
@@ -309,7 +309,7 @@ declare const dictionarySchema: z.ZodObject<{
   locale: z.ZodOptional<z.ZodString>;
   title: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const intlayerConfigSchema: z.ZodObject<{
+export declare const intlayerConfigSchema: z.ZodObject<{
   internationalization: z.ZodOptional<z.ZodObject<{
     locales: z.ZodArray<z.ZodString>;
     requiredLocales: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -521,5 +521,4 @@ declare const intlayerConfigSchema: z.ZodObject<{
   }, z.core.$strip>>;
 }, z.core.$strip>;
 //#endregion
-export { aiSchema, analyticsSchema, buildSchema, compilerSchema, contentSchema, cookiesAttributesSchema, dictionarySchema, editorSchema, internationalizationSchema, intlayerConfigSchema, logSchema, rewriteObjectSchema, rewriteRuleSchema, rewriteRulesSchema, routingSchema, storageAttributesSchema, storageSchema, systemSchema };
 //# sourceMappingURL=configurationSchema.d.ts.map

package/dist/types/configFile/configurationSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configurationSchema.d.ts","names":[],"sources":["../../../src/configFile/configurationSchema.ts"],"mappings":";;;cAGa,4BAA0B,EAAA;;;;;;;;;GAKrC,EAAA,KAAA;cA0BW,yBAAuB,EAAA;;;;;;;;;;;;;;GAUlC,EAAA,KAAA;cAEW,yBAAuB,EAAA;;;;;;;GAGlC,EAAA,KAAA;cAEW,eAAa,EAAA,mBAAA,EAAA,mBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYxB,EAAA,KAAA;cAEW,mBAAiB,EAAA;;;GAG5B,EAAA,KAAA;cAEW,oBAAkB,EAAA;;;;;GAE7B,EAAA,KAAA;cAEW,qBAAmB,EAAA;;;;;;;;;;;;;;;;;;;GAI9B,EAAA,KAAA;cAEW,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAcxB,EAAA,KAAA;cAEW,cAAY,EAAA;;;;;;;;;;;;;GAavB,EAAA,KAAA;cAEW,eAAa,EAAA;;;;;;;GAOxB,EAAA,KAAA;cAEW,cAAY,EAAA;;;;;;;;;;;;;;;;GAevB,EAAA,KAAA;cAEW,iBAAe,EAAA;;;;GAI1B,EAAA,KAAA;cAEW,WAAS,EAAA;;;;;;;;;;;GAOpB,EAAA,KAAA;cAEW,UAAQ,EAAA;;;;;;;;;;;GAQnB,EAAA,KAAA;cAEW,aAAW,EAAA;;;;;;;;;;;;;;;;;;;GAStB,EAAA,KAAA;cAEW,gBAAc,EAAA;;;;;;;;GAQzB,EAAA,KAAA;cAEW,kBAAgB,EAAA;;;;;;;;;;GAe3B,EAAA,KAAA;cAEW,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqB/B,EAAA,KAAA"}
+{"version":3,"file":"configurationSchema.d.ts","names":[],"sources":["../../../src/configFile/configurationSchema.ts"],"mappings":";;;qBAGa,4BAA0B,EAAA;;;;;;;;;GAKrC,EAAA,KAAA;qBA0BW,yBAAuB,EAAA;;;;;;;;;;;;;;GAUlC,EAAA,KAAA;qBAEW,yBAAuB,EAAA;;;;;;;GAGlC,EAAA,KAAA;qBAEW,eAAa,EAAA,mBAAA,EAAA,mBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYxB,EAAA,KAAA;qBAEW,mBAAiB,EAAA;;;GAG5B,EAAA,KAAA;qBAEW,oBAAkB,EAAA;;;;;GAE7B,EAAA,KAAA;qBAEW,qBAAmB,EAAA;;;;;;;;;;;;;;;;;;;GAI9B,EAAA,KAAA;qBAEW,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAcxB,EAAA,KAAA;qBAEW,cAAY,EAAA;;;;;;;;;;;;;GAavB,EAAA,KAAA;qBAEW,eAAa,EAAA;;;;;;;GAOxB,EAAA,KAAA;qBAEW,cAAY,EAAA;;;;;;;;;;;;;;;;GAevB,EAAA,KAAA;qBAEW,iBAAe,EAAA;;;;GAI1B,EAAA,KAAA;qBAEW,WAAS,EAAA;;;;;;;;;;;GAOpB,EAAA,KAAA;qBAEW,UAAQ,EAAA;;;;;;;;;;;GAQnB,EAAA,KAAA;qBAEW,aAAW,EAAA;;;;;;;;;;;;;;;;;;;GAStB,EAAA,KAAA;qBAEW,gBAAc,EAAA;;;;;;;;GAQzB,EAAA,KAAA;qBAEW,kBAAgB,EAAA;;;;;;;;;;GAe3B,EAAA,KAAA;qBAEW,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqB/B,EAAA,KAAA"}

package/dist/types/configFile/getConfiguration.d.ts

@@ -2,7 +2,7 @@ import { SandBoxContextOptions } from "../loadExternalFile/parseFileContent.js";
 import { LoadExternalFileOptions } from "../loadExternalFile/loadExternalFile.js";
 import { CustomIntlayerConfig, IntlayerConfig, LogFunctions } from "@intlayer/types/config";
 //#region src/configFile/getConfiguration.d.ts
-type GetConfigurationOptions = {
+export type GetConfigurationOptions = {
   baseDir?: string;
   override?: CustomIntlayerConfig;
   env?: string;
@@ -12,7 +12,7 @@ type GetConfigurationOptions = {
   cache?: boolean;
   buildOptions?: LoadExternalFileOptions['buildOptions'];
 } & Omit<SandBoxContextOptions, 'projectRequire'>;
-type GetConfigurationAndFilePathResult = {
+export type GetConfigurationAndFilePathResult = {
   configuration: IntlayerConfig;
   customConfiguration: CustomIntlayerConfig | undefined;
   numCustomConfiguration: number;
@@ -21,11 +21,10 @@ type GetConfigurationAndFilePathResult = {
 /**
  * Get the configuration for the intlayer by reading the configuration file (e.g. intlayer.config.js)
  */
-declare const getConfigurationAndFilePath: (options?: GetConfigurationOptions) => GetConfigurationAndFilePathResult;
+export declare const getConfigurationAndFilePath: (options?: GetConfigurationOptions) => GetConfigurationAndFilePathResult;
 /**
  * Get the configuration for the intlayer by reading the configuration file (e.g. intlayer.config.js)
  */
-declare const getConfiguration: (options?: GetConfigurationOptions) => IntlayerConfig;
+export declare const getConfiguration: (options?: GetConfigurationOptions) => IntlayerConfig;
 //#endregion
-export { GetConfigurationAndFilePathResult, GetConfigurationOptions, getConfiguration, getConfigurationAndFilePath };
 //# sourceMappingURL=getConfiguration.d.ts.map

package/dist/types/configFile/getConfiguration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getConfiguration.d.ts","names":[],"sources":["../../../src/configFile/getConfiguration.ts"],"mappings":";;;;KAcY;EACV;EACA,WAAW;EAEX;EACA;EAEA,eAAe;EAEf,UAAU,OAAO;EAEjB;EAEA,eAAe;IACb,KAAK;KAEG;EACV,eAAe;EACf,qBAAqB;EACrB;EACA;;;;;cAMW,8BAA2B,UAC5B,4BACT;;;;cAqGU,mBAAgB,UACjB,4BACT"}
+{"version":3,"file":"getConfiguration.d.ts","names":[],"sources":["../../../src/configFile/getConfiguration.ts"],"mappings":";;;;YAcY;EACV;EACA,WAAW;EAEX;EACA;EAEA,eAAe;EAEf,UAAU,OAAO;EAEjB;EAEA,eAAe;IACb,KAAK;YAEG;EACV,eAAe;EACf,qBAAqB;EACrB;EACA;;;;;qBAMW,8BAA2B,UAC5B,4BACT;;;;qBAqGU,mBAAgB,UACjB,4BACT"}

package/dist/types/configFile/loadConfigurationFile.d.ts

@@ -7,7 +7,6 @@ import { CustomIntlayerConfig } from "@intlayer/types/config";
  *
  * Accepts JSON, JS, MJS and TS files as configuration
  */
-declare const loadConfigurationFile: (configFilePath: string, options?: Omit<LoadExternalFileOptions, 'configuration'>) => CustomIntlayerConfig | undefined;
+export declare const loadConfigurationFile: (configFilePath: string, options?: Omit<LoadExternalFileOptions, 'configuration'>) => CustomIntlayerConfig | undefined;
 //#endregion
-export { loadConfigurationFile };
 //# sourceMappingURL=loadConfigurationFile.d.ts.map

package/dist/types/configFile/loadConfigurationFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadConfigurationFile.d.ts","names":[],"sources":["../../../src/configFile/loadConfigurationFile.ts"],"mappings":";;;;;;;;;cA4Ba,wBAAqB,wBACV,UACZ,KAAK,8CACd"}
+{"version":3,"file":"loadConfigurationFile.d.ts","names":[],"sources":["../../../src/configFile/loadConfigurationFile.ts"],"mappings":";;;;;;;;;qBA4Ba,wBAAqB,wBACV,UACZ,KAAK,8CACd"}

package/dist/types/configFile/searchConfigurationFile.d.ts

@@ -1,5 +1,5 @@
 //#region src/configFile/searchConfigurationFile.d.ts
-declare const configurationFilesCandidates: readonly ['intlayer.config.ts', 'intlayer.config.js', 'intlayer.config.json', 'intlayer.config.json5', 'intlayer.config.jsonc', 'intlayer.config.cjs', 'intlayer.config.mjs', '.intlayerrc'];
+export declare const configurationFilesCandidates: readonly ['intlayer.config.ts', 'intlayer.config.js', 'intlayer.config.json', 'intlayer.config.json5', 'intlayer.config.jsonc', 'intlayer.config.cjs', 'intlayer.config.mjs', '.intlayerrc'];
 type SearchConfigurationFileResult = {
   configurationFilePath?: string;
   numCustomConfiguration: number;
@@ -15,7 +15,6 @@ type SearchConfigurationFileResult = {
  * - intlayer.config.mjs
  * - .intlayerrc
  */
-declare const searchConfigurationFile: (startDir: string) => SearchConfigurationFileResult;
+export declare const searchConfigurationFile: (startDir: string) => SearchConfigurationFileResult;
 //#endregion
-export { configurationFilesCandidates, searchConfigurationFile };
 //# sourceMappingURL=searchConfigurationFile.d.ts.map

package/dist/types/configFile/searchConfigurationFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchConfigurationFile.d.ts","names":[],"sources":["../../../src/configFile/searchConfigurationFile.ts"],"mappings":";cAKa;KAWR;EACH;EACA;;;;;;;;;;;;;cAiBW,0BAAuB,qBAEjC"}
+{"version":3,"file":"searchConfigurationFile.d.ts","names":[],"sources":["../../../src/configFile/searchConfigurationFile.ts"],"mappings":";qBAKa;KAWR;EACH;EACA;;;;;;;;;;;;;qBAiBW,0BAAuB,qBAEjC"}

package/dist/types/defaultValues/analytics.d.ts

@@ -4,9 +4,8 @@
  * Analytics is opt-out — enabled unless the user disables it, and only
  * effective once the optional `@intlayer/analytics` package is installed.
  */
-declare const ANALYTICS_ENABLED = true;
-declare const ANALYTICS_FLUSH_INTERVAL = 20000;
-declare const ANALYTICS_SAMPLE_RATE = 1;
+export declare const ANALYTICS_ENABLED = true;
+export declare const ANALYTICS_FLUSH_INTERVAL = 20000;
+export declare const ANALYTICS_SAMPLE_RATE = 1;
 //#endregion
-export { ANALYTICS_ENABLED, ANALYTICS_FLUSH_INTERVAL, ANALYTICS_SAMPLE_RATE };
 //# sourceMappingURL=analytics.d.ts.map

package/dist/types/defaultValues/analytics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analytics.d.ts","names":[],"sources":["../../../src/defaultValues/analytics.ts"],"mappings":";;;;;;cAKa;cACA;cACA"}
+{"version":3,"file":"analytics.d.ts","names":[],"sources":["../../../src/defaultValues/analytics.ts"],"mappings":";;;;;;qBAKa;qBACA;qBACA"}

package/dist/types/defaultValues/build.d.ts

@@ -1,14 +1,13 @@
 //#region src/defaultValues/build.d.ts
-declare const BUILD_MODE = "auto";
-declare const OPTIMIZE: any;
-declare const TRAVERSE_PATTERN: string[];
-declare const OUTPUT_FORMAT: ('cjs' | 'esm')[];
-declare const CACHE = true;
-declare const TYPE_CHECKING = false;
-declare const MINIFY = false;
-declare const PURGE = false;
-declare const CHUNK_GROUPING = true;
-declare const DICTIONARIES_PRELOAD = true;
+export declare const BUILD_MODE = "auto";
+export declare const OPTIMIZE: any;
+export declare const TRAVERSE_PATTERN: string[];
+export declare const OUTPUT_FORMAT: ('cjs' | 'esm')[];
+export declare const CACHE = true;
+export declare const TYPE_CHECKING = false;
+export declare const MINIFY = false;
+export declare const PURGE = false;
+export declare const CHUNK_GROUPING = true;
+export declare const DICTIONARIES_PRELOAD = true;
 //#endregion
-export { BUILD_MODE, CACHE, CHUNK_GROUPING, DICTIONARIES_PRELOAD, MINIFY, OPTIMIZE, OUTPUT_FORMAT, PURGE, TRAVERSE_PATTERN, TYPE_CHECKING };
 //# sourceMappingURL=build.d.ts.map

package/dist/types/defaultValues/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","names":[],"sources":["../../../src/defaultValues/build.ts"],"mappings":";cAAa;cAEA;cAEA;cA0BA;cAEA;cAEA;cAEA;cAEA;cAEA;cAEA"}
+{"version":3,"file":"build.d.ts","names":[],"sources":["../../../src/defaultValues/build.ts"],"mappings":";qBAAa;qBAEA;qBAEA;qBA0BA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA"}

package/dist/types/defaultValues/compiler.d.ts

@@ -1,8 +1,7 @@
 //#region src/defaultValues/compiler.d.ts
-declare const COMPILER_ENABLED = false;
-declare const COMPILER_DICTIONARY_KEY_PREFIX = "";
-declare const COMPILER_NO_METADATA = false;
-declare const COMPILER_SAVE_COMPONENTS = false;
+export declare const COMPILER_ENABLED = false;
+export declare const COMPILER_DICTIONARY_KEY_PREFIX = "";
+export declare const COMPILER_NO_METADATA = false;
+export declare const COMPILER_SAVE_COMPONENTS = false;
 //#endregion
-export { COMPILER_DICTIONARY_KEY_PREFIX, COMPILER_ENABLED, COMPILER_NO_METADATA, COMPILER_SAVE_COMPONENTS };
 //# sourceMappingURL=compiler.d.ts.map

package/dist/types/defaultValues/compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/defaultValues/compiler.ts"],"mappings":";cAAa;cAEA;cAEA;cAEA"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/defaultValues/compiler.ts"],"mappings":";qBAAa;qBAEA;qBAEA;qBAEA"}

package/dist/types/defaultValues/content.d.ts

@@ -1,11 +1,10 @@
 //#region src/defaultValues/content.d.ts
-declare const FILE_EXTENSIONS: string[];
-declare const EXCLUDED_PATHS: string[];
-declare const CONTENT_DIR: string[];
-declare const CODE_DIR: string[];
-declare const I18NEXT_DICTIONARIES_DIR = "i18next_resources";
-declare const REACT_INTL_MESSAGES_DIR = "intl_messages";
-declare const WATCH = true;
+export declare const FILE_EXTENSIONS: string[];
+export declare const EXCLUDED_PATHS: string[];
+export declare const CONTENT_DIR: string[];
+export declare const CODE_DIR: string[];
+export declare const I18NEXT_DICTIONARIES_DIR = "i18next_resources";
+export declare const REACT_INTL_MESSAGES_DIR = "intl_messages";
+export declare const WATCH = true;
 //#endregion
-export { CODE_DIR, CONTENT_DIR, EXCLUDED_PATHS, FILE_EXTENSIONS, I18NEXT_DICTIONARIES_DIR, REACT_INTL_MESSAGES_DIR, WATCH };
 //# sourceMappingURL=content.d.ts.map

package/dist/types/defaultValues/content.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"content.d.ts","names":[],"sources":["../../../src/defaultValues/content.ts"],"mappings":";cAAa;cAgBA;cAeA;cAEA;cAEA;cAEA;cAEA"}
+{"version":3,"file":"content.d.ts","names":[],"sources":["../../../src/defaultValues/content.ts"],"mappings":";qBAAa;qBAgBA;qBAeA;qBAEA;qBAEA;qBAEA;qBAEA"}

package/dist/types/defaultValues/dictionary.d.ts

@@ -1,9 +1,9 @@
 import { DictionaryLocation } from "@intlayer/types/dictionary";
 //#region src/defaultValues/dictionary.d.ts
-declare const FILL = true;
-declare const LOCATION: DictionaryLocation;
-declare const CONTENT_AUTO_TRANSFORMATION = false;
-declare const IMPORT_MODE = "static";
+export declare const FILL = true;
+export declare const LOCATION: DictionaryLocation;
+export declare const CONTENT_AUTO_TRANSFORMATION = false;
+export declare const IMPORT_MODE = "static";
 /**
  * Directory the per-locale JSON chunks of `importMode: 'dynamic'` are written
  * under, relative to `system.dynamicDictionariesDir`.
@@ -14,14 +14,14 @@ declare const IMPORT_MODE = "static";
  * module ids against this layout — hence the shared constant rather than a
  * literal repeated on both sides.
  */
-declare const DYNAMIC_DICTIONARIES_JSON_SUBDIR = "json";
+export declare const DYNAMIC_DICTIONARIES_JSON_SUBDIR = "json";
 /**
  * Marker property carrying the ordered qualifier dimensions on a dynamic loader
  * map. Its presence distinguishes a qualified group loader map (a nested tree
  * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed
  * and unlikely to collide with a real locale code.
  */
-declare const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
+export declare const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
 /**
  * Marker property carrying the dictionary a generated dynamic entry point
  * already resolved for the browsing locale, before any component rendered.
@@ -31,7 +31,7 @@ declare const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
  * locale chunk has landed. A read during render then finds the content in place
  * instead of suspending.
  */
-declare const PRELOADED_DYNAMIC_KEY = "__intlayerPreloaded";
+export declare const PRELOADED_DYNAMIC_KEY = "__intlayerPreloaded";
 /**
  * Name of the local binding a generated dynamic entry point holds its loader
  * map in, before exporting it as default.
@@ -40,7 +40,6 @@ declare const PRELOADED_DYNAMIC_KEY = "__intlayerPreloaded";
  * binding, so the code generator and the build plugins have to agree on the
  * name — hence the shared constant rather than a literal repeated in both.
  */
-declare const DYNAMIC_ENTRY_LOADER_MAP_IDENTIFIER = "content";
+export declare const DYNAMIC_ENTRY_LOADER_MAP_IDENTIFIER = "content";
 //#endregion
-export { CONTENT_AUTO_TRANSFORMATION, DYNAMIC_DICTIONARIES_JSON_SUBDIR, DYNAMIC_ENTRY_LOADER_MAP_IDENTIFIER, FILL, IMPORT_MODE, LOCATION, PRELOADED_DYNAMIC_KEY, QUALIFIER_DYNAMIC_TYPES_KEY };
 //# sourceMappingURL=dictionary.d.ts.map

package/dist/types/defaultValues/dictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dictionary.d.ts","names":[],"sources":["../../../src/defaultValues/dictionary.ts"],"mappings":";;cAEa;cACA,UAAU;cACV;cACA;;;;;;;;;;;cAYA;;;;;;;cAQA;;;;;;;;;;cAWA;;;;;;;;;cAUA"}
+{"version":3,"file":"dictionary.d.ts","names":[],"sources":["../../../src/defaultValues/dictionary.ts"],"mappings":";;qBAEa;qBACA,UAAU;qBACV;qBACA;;;;;;;;;;;qBAYA;;;;;;;qBAQA;;;;;;;;;;qBAWA;;;;;;;;;qBAUA"}

package/dist/types/defaultValues/editor.d.ts

@@ -1,13 +1,12 @@
 //#region src/defaultValues/editor.d.ts
-declare const APPLICATION_URL: any;
-declare const EDITOR_URL = "http://localhost:8000";
-declare const CMS_URL = "https://app.intlayer.org";
-declare const BACKEND_URL = "https://back.intlayer.org";
-declare const PORT = 8000;
-declare const IS_ENABLED = false;
-declare const LIVE_SYNC = false;
-declare const DICTIONARY_PRIORITY_STRATEGY = "local_first";
-declare const LIVE_SYNC_PORT = 4000;
+export declare const APPLICATION_URL: any;
+export declare const EDITOR_URL = "http://localhost:8000";
+export declare const CMS_URL = "https://app.intlayer.org";
+export declare const BACKEND_URL = "https://back.intlayer.org";
+export declare const PORT = 8000;
+export declare const IS_ENABLED = false;
+export declare const LIVE_SYNC = false;
+export declare const DICTIONARY_PRIORITY_STRATEGY = "local_first";
+export declare const LIVE_SYNC_PORT = 4000;
 //#endregion
-export { APPLICATION_URL, BACKEND_URL, CMS_URL, DICTIONARY_PRIORITY_STRATEGY, EDITOR_URL, IS_ENABLED, LIVE_SYNC, LIVE_SYNC_PORT, PORT };
 //# sourceMappingURL=editor.d.ts.map

package/dist/types/defaultValues/editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editor.d.ts","names":[],"sources":["../../../src/defaultValues/editor.ts"],"mappings":";cAAa;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA"}
+{"version":3,"file":"editor.d.ts","names":[],"sources":["../../../src/defaultValues/editor.ts"],"mappings":";qBAAa;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA"}

package/dist/types/defaultValues/internationalization.d.ts

@@ -1,10 +1,9 @@
 import { StrictMode } from "@intlayer/types/config";
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/defaultValues/internationalization.d.ts
-declare const LOCALES: Locale[];
-declare const REQUIRED_LOCALES: Locale[];
-declare const DEFAULT_LOCALE: Locale;
-declare const STRICT_MODE: StrictMode;
+export declare const LOCALES: Locale[];
+export declare const REQUIRED_LOCALES: Locale[];
+export declare const DEFAULT_LOCALE: Locale;
+export declare const STRICT_MODE: StrictMode;
 //#endregion
-export { DEFAULT_LOCALE, LOCALES, REQUIRED_LOCALES, STRICT_MODE };
 //# sourceMappingURL=internationalization.d.ts.map

package/dist/types/defaultValues/internationalization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internationalization.d.ts","names":[],"sources":["../../../src/defaultValues/internationalization.ts"],"mappings":";;;cAGa,SAAS;cAET,kBAAkB;cAElB,gBAAgB;cAEhB,aAAa"}
+{"version":3,"file":"internationalization.d.ts","names":[],"sources":["../../../src/defaultValues/internationalization.ts"],"mappings":";;;qBAGa,SAAS;qBAET,kBAAkB;qBAElB,gBAAgB;qBAEhB,aAAa"}

package/dist/types/defaultValues/log.d.ts

@@ -1,6 +1,5 @@
 //#region src/defaultValues/log.d.ts
-declare const MODE = "default";
-declare const PREFIX: string;
+export declare const MODE = "default";
+export declare const PREFIX: string;
 //#endregion
-export { MODE, PREFIX };
 //# sourceMappingURL=log.d.ts.map

package/dist/types/defaultValues/log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","names":[],"sources":["../../../src/defaultValues/log.ts"],"mappings":";cAEa;cAEA"}
+{"version":3,"file":"log.d.ts","names":[],"sources":["../../../src/defaultValues/log.ts"],"mappings":";qBAEa;qBAEA"}

package/dist/types/defaultValues/routing.d.ts

@@ -1,19 +1,18 @@
 import { RoutingStorageInput } from "@intlayer/types/config";
 //#region src/defaultValues/routing.d.ts
-declare const HEADER_NAME = "x-intlayer-locale";
-declare const COOKIE_NAME = "INTLAYER_LOCALE";
-declare const LOCALE_STORAGE_NAME = "INTLAYER_LOCALE";
-declare const BASE_PATH = "";
-declare const SERVER_SET_COOKIE = "always";
-declare const ROUTING_MODE = "prefix-no-default";
+export declare const HEADER_NAME = "x-intlayer-locale";
+export declare const COOKIE_NAME = "INTLAYER_LOCALE";
+export declare const LOCALE_STORAGE_NAME = "INTLAYER_LOCALE";
+export declare const BASE_PATH = "";
+export declare const SERVER_SET_COOKIE = "always";
+export declare const ROUTING_MODE = "prefix-no-default";
 /**
  * Left `undefined` on purpose: it selects the proxy's *auto* mode, which keeps
  * locale routing URL-driven on development and preview servers while behaving
  * like `true` in production. `true` and `false` are the explicit opt-in and
  * opt-out. See `resolveProxyMode` in `@intlayer/core/localization`.
  */
-declare const ENABLE_PROXY: boolean | undefined;
-declare const STORAGE: RoutingStorageInput;
+export declare const ENABLE_PROXY: boolean | undefined;
+export declare const STORAGE: RoutingStorageInput;
 //#endregion
-export { BASE_PATH, COOKIE_NAME, ENABLE_PROXY, HEADER_NAME, LOCALE_STORAGE_NAME, ROUTING_MODE, SERVER_SET_COOKIE, STORAGE };
 //# sourceMappingURL=routing.d.ts.map

package/dist/types/defaultValues/routing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routing.d.ts","names":[],"sources":["../../../src/defaultValues/routing.ts"],"mappings":";;cAEa;cAEA;cACA;cAEA;cAEA;cAEA;;;;;;;cAQA;cAEA,SAAS"}
+{"version":3,"file":"routing.d.ts","names":[],"sources":["../../../src/defaultValues/routing.ts"],"mappings":";;qBAEa;qBAEA;qBACA;qBAEA;qBAEA;qBAEA;;;;;;;qBAQA;qBAEA,SAAS"}

package/dist/types/defaultValues/system.d.ts

@@ -1,16 +1,15 @@
 //#region src/defaultValues/system.d.ts
-declare const MAIN_DIR = ".intlayer/main";
-declare const DICTIONARIES_DIR = ".intlayer/dictionary";
-declare const MASKS_DIR = ".intlayer/mask";
-declare const REMOTE_DICTIONARIES_DIR = ".intlayer/remote_dictionary";
-declare const UNMERGED_DICTIONARIES_DIR = ".intlayer/unmerged_dictionary";
-declare const DYNAMIC_DICTIONARIES_DIR = ".intlayer/dynamic_dictionary";
-declare const FETCH_DICTIONARIES_DIR = ".intlayer/fetch_dictionary";
-declare const TYPES_DIR = ".intlayer/types";
-declare const MODULE_AUGMENTATION_DIR = ".intlayer/types";
-declare const CONFIG_DIR = ".intlayer/config";
-declare const CACHE_DIR = ".intlayer/cache";
-declare const TEMP_DIR = ".intlayer/tmp";
+export declare const MAIN_DIR = ".intlayer/main";
+export declare const DICTIONARIES_DIR = ".intlayer/dictionary";
+export declare const MASKS_DIR = ".intlayer/mask";
+export declare const REMOTE_DICTIONARIES_DIR = ".intlayer/remote_dictionary";
+export declare const UNMERGED_DICTIONARIES_DIR = ".intlayer/unmerged_dictionary";
+export declare const DYNAMIC_DICTIONARIES_DIR = ".intlayer/dynamic_dictionary";
+export declare const FETCH_DICTIONARIES_DIR = ".intlayer/fetch_dictionary";
+export declare const TYPES_DIR = ".intlayer/types";
+export declare const MODULE_AUGMENTATION_DIR = ".intlayer/types";
+export declare const CONFIG_DIR = ".intlayer/config";
+export declare const CACHE_DIR = ".intlayer/cache";
+export declare const TEMP_DIR = ".intlayer/tmp";
 //#endregion
-export { CACHE_DIR, CONFIG_DIR, DICTIONARIES_DIR, DYNAMIC_DICTIONARIES_DIR, FETCH_DICTIONARIES_DIR, MAIN_DIR, MASKS_DIR, MODULE_AUGMENTATION_DIR, REMOTE_DICTIONARIES_DIR, TEMP_DIR, TYPES_DIR, UNMERGED_DICTIONARIES_DIR };
 //# sourceMappingURL=system.d.ts.map

package/dist/types/defaultValues/system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","names":[],"sources":["../../../src/defaultValues/system.ts"],"mappings":";cAAa;cAEA;cAEA;cAEA;cAEA;cAEA;cAEA;cAEA;cAEA;cAEA;cAEA;cAEA"}
+{"version":3,"file":"system.d.ts","names":[],"sources":["../../../src/defaultValues/system.ts"],"mappings":";qBAAa;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA;qBAEA"}

package/dist/types/dictionaryPreload.d.ts

@@ -4,7 +4,7 @@
  * `<dynamicDictionariesDir>/<key>.mjs`. The per-locale JSON chunks it imports
  * live one directory deeper, under `json/`, and are deliberately excluded.
  */
-declare const DYNAMIC_ENTRY_PATTERN: RegExp;
+export declare const DYNAMIC_ENTRY_PATTERN: RegExp;
 /**
  * Builds a filter matching only the generated dynamic entry points, for
  * bundlers whose load hook is selected by a regular expression over the raw
@@ -21,7 +21,7 @@ declare const DYNAMIC_ENTRY_PATTERN: RegExp;
  *
  * @param dynamicDictionariesDir - Absolute dictionaries root, any separator.
  */
-declare const createDynamicEntryFilter: (dynamicDictionariesDir: string) => RegExp;
+export declare const createDynamicEntryFilter: (dynamicDictionariesDir: string) => RegExp;
 /**
  * Specifier of the module the injected preamble reads the locale from, as the
  * bundler plugins are expected to resolve it.
@@ -32,7 +32,7 @@ declare const createDynamicEntryFilter: (dynamicDictionariesDir: string) => RegE
  * resolve from a directory where the package is absent, or, worse, silently
  * hit an unrelated copy hoisted higher up the tree.
  */
-declare const PRELOAD_MODULE_SPECIFIER = "@intlayer/core/localization";
+export declare const PRELOAD_MODULE_SPECIFIER = "@intlayer/core/localization";
 /**
  * Resolves {@link PRELOAD_MODULE_SPECIFIER} to an absolute id the injected
  * preamble can import, from a package that actually depends on it.
@@ -49,10 +49,10 @@ declare const PRELOAD_MODULE_SPECIFIER = "@intlayer/core/localization";
  * @returns Absolute path to the ESM build, falling back to whatever the
  *   standard resolution yields if the package ever stops publishing one.
  */
-declare const resolvePreloadModuleId: (requireFn: NodeRequire) => string;
+export declare const resolvePreloadModuleId: (requireFn: NodeRequire) => string;
 /** Why a generated entry point was left untransformed. */
-type PreloadSkipReason = 'qualified' | 'unrecognized-shape';
-type PreloadTransformResult = {
+export type PreloadSkipReason = 'qualified' | 'unrecognized-shape';
+export type PreloadTransformResult = {
   code: string;
   skipped?: undefined;
 } | {
@@ -73,7 +73,6 @@ type PreloadTransformResult = {
  *   from, already resolved against the plugin package.
  * @returns The transformed source, or the reason it was left alone.
  */
-declare const addDynamicEntryPreload: (code: string, preloadModuleId: string) => PreloadTransformResult;
+export declare const addDynamicEntryPreload: (code: string, preloadModuleId: string) => PreloadTransformResult;
 //#endregion
-export { DYNAMIC_ENTRY_PATTERN, PRELOAD_MODULE_SPECIFIER, PreloadSkipReason, PreloadTransformResult, addDynamicEntryPreload, createDynamicEntryFilter, resolvePreloadModuleId };
 //# sourceMappingURL=dictionaryPreload.d.ts.map

package/dist/types/dictionaryPreload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dictionaryPreload.d.ts","names":[],"sources":["../../src/dictionaryPreload.ts"],"mappings":";;;;;;cAYa,uBAAqB;;;;;;;;;;;;;;;;;cAsBrB,2BAAwB,mCAElC;;;;;;;;;;;cAmBU;;;;;;;;;;;;;;;;;cA2BA,yBAAsB,WAAe;;KAuEtC;KAEA;EACN;EAAc;;EACd;EAAkB,SAAS;;;;;;;;;;;;;;;;cAgBpB,yBAAsB,cACrB,4BAEX"}
+{"version":3,"file":"dictionaryPreload.d.ts","names":[],"sources":["../../src/dictionaryPreload.ts"],"mappings":";;;;;;qBAYa,uBAAqB;;;;;;;;;;;;;;;;;qBAsBrB,2BAAwB,mCAElC;;;;;;;;;;;qBAmBU;;;;;;;;;;;;;;;;;qBA2BA,yBAAsB,WAAe;;YAuEtC;YAEA;EACN;EAAc;;EACd;EAAkB,SAAS;;;;;;;;;;;;;;;;qBAgBpB,yBAAsB,cACrB,4BAEX"}

package/dist/types/envVars/envVars.d.ts

@@ -11,7 +11,7 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * formatNodeTypeToEnvVar(['reactNode'], (k) => `process.env.${k}`, (v) => `"${v}"`)
  * // { 'process.env.INTLAYER_NODE_TYPE_REACT_NODE': '"false"' }
  */
-declare const formatNodeTypeToEnvVar: (nodeTypes: string[], wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
+export declare const formatNodeTypeToEnvVar: (nodeTypes: string[], wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
 /**
  * Returns the env-var definition disabling the dictionary-selector resolution
  * path (collections, variants) when no built dictionary declares
@@ -30,7 +30,7 @@ declare const formatNodeTypeToEnvVar: (nodeTypes: string[], wrapKey?: (key: stri
  * formatDictionarySelectorEnvVar(false, (k) => `process.env.${k}`, (v) => `"${v}"`)
  * // { 'process.env.INTLAYER_DICTIONARY_SELECTOR': '"false"' }
  */
-declare const formatDictionarySelectorEnvVar: (hasDictionarySelector: boolean, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
+export declare const formatDictionarySelectorEnvVar: (hasDictionarySelector: boolean, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
 /**
  * Returns the env-var definition selecting the local `nest()` resolver, which
  * reads the nest targets the optimizer attached to each dictionary instead of
@@ -52,7 +52,7 @@ declare const formatDictionarySelectorEnvVar: (hasDictionarySelector: boolean, w
  * formatOptimizedNestingEnvVar(true, (k) => `process.env.${k}`, (v) => `"${v}"`)
  * // { 'process.env.INTLAYER_OPTIMIZED_NESTING': '"true"' }
  */
-declare const formatOptimizedNestingEnvVar: (isOptimized: boolean, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
+export declare const formatOptimizedNestingEnvVar: (isOptimized: boolean, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
 /**
  * Returns env-var definitions for the full Intlayer config to be injected at
  * build time. Allows bundlers to dead-code-eliminate unused routing modes,
@@ -65,7 +65,6 @@ declare const formatOptimizedNestingEnvVar: (isOptimized: boolean, wrapKey?: (ke
  * getConfigEnvVars(config, true)
  * // { 'process.env.INTLAYER_ROUTING_MODE': '"prefix-no-default"', ... }
  */
-declare const getConfigEnvVars: (config: IntlayerConfig, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
+export declare const getConfigEnvVars: (config: IntlayerConfig, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
 //#endregion
-export { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, formatOptimizedNestingEnvVar, getConfigEnvVars };
 //# sourceMappingURL=envVars.d.ts.map

package/dist/types/envVars/envVars.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"envVars.d.ts","names":[],"sources":["../../../src/envVars/envVars.ts"],"mappings":";;;;;;;;;;;;;cA2Ba,yBAAsB,qBACd,WAAA,wBACG,aAAA,6BAErB;;;;;;;;;;;;;;;;;;;cA4BU,iCAA8B,gCACX,WAAA,wBACR,aAAA,6BAErB;;;;;;;;;;;;;;;;;;;;;;cA0BU,+BAA4B,sBACnB,WAAA,wBACE,aAAA,6BAErB;;;;;;;;;;;;;cAiBU,mBAAgB,QACnB,gBAAc,WAAA,wBACA,aAAA,6BAErB"}
+{"version":3,"file":"envVars.d.ts","names":[],"sources":["../../../src/envVars/envVars.ts"],"mappings":";;;;;;;;;;;;;qBA2Ba,yBAAsB,qBACd,WAAA,wBACG,aAAA,6BAErB;;;;;;;;;;;;;;;;;;;qBA4BU,iCAA8B,gCACX,WAAA,wBACR,aAAA,6BAErB;;;;;;;;;;;;;;;;;;;;;;qBA0BU,+BAA4B,sBACnB,WAAA,wBACE,aAAA,6BAErB;;;;;;;;;;;;;qBAiBU,mBAAgB,QACnB,gBAAc,WAAA,wBACA,aAAA,6BAErB"}