@intlayer/config 9.0.0-canary.2 → 9.0.0-canary.20

package/dist/types/callers/transform.d.ts

@@ -0,0 +1,60 @@
+import { CallerDescriptor } from "./types.js";
+//#region src/callers/transform.d.ts
+/**
+ * Wire format of an extra caller forwarded to the `@intlayer/swc` plugin.
+ *
+ * Field names mirror the serde attributes of `ExtraCallerConfig` in
+ * `packages/@intlayer/swc/src/lib.rs` — both sides must stay in sync.
+ */
+type SwcExtraCallerConfig = {
+  /** The function name the user calls, e.g. `"useTranslation"`. */
+  callerName: string;
+  /** Module specifiers exporting the function (original + `@intlayer/*`). */
+  importSources: string[];
+  /**
+   * Zero-based index of the positional argument holding the namespace string.
+   * Omitted for fixed/option namespace callers.
+   */
+  namespaceArgIndex?: number;
+  /**
+   * Compile-time constant namespace — the dictionary ident is inserted as a
+   * new first argument (lingui's `useLingui()`).
+   */
+  fixedNamespace?: string;
+  /**
+   * Namespace read from a property of an options-object argument — the
+   * dictionary ident is inserted as a new first argument and the property is
+   * rewritten to the key-prefix remainder (vue-i18n's `useI18n({ namespace })`).
+   */
+  namespaceOption?: {
+    argumentIndex: number;
+    property: string;
+  };
+  /** Replacement function name for static import mode, e.g. `"useDictionary"`. */
+  staticReplacement: string;
+  /** Replacement function name for dynamic/fetch mode, e.g. `"useDictionaryDynamic"`. */
+  dynamicReplacement: string;
+};
+/**
+ * Returns the callers of a registry slice that the optimize pass can rewrite
+ * at build time: plain imported functions carrying both replacement names.
+ *
+ * Method-matched callers (`i18n.getFixedT`) and JSX components are excluded —
+ * their call sites cannot be re-pointed through an import specifier rename.
+ */
+declare const getRewritableCallers: (descriptors: CallerDescriptor[]) => CallerDescriptor[];
+/**
+ * Serialises the rewritable callers of a registry slice into the
+ * `@intlayer/swc` plugin wire format (`extraCallers` option).
+ *
+ * Callers whose namespace can only be derived per-message id
+ * (`path-first-segment`) are skipped: the transform cannot bind a single
+ * dictionary to the call site.
+ *
+ * @param descriptors - Registry slice, e.g. `REACT_I18NEXT_CALLERS`.
+ * @returns Configs ready to pass as `swcExtraCallers` / `extraCallers`.
+ */
+declare const toSwcExtraCallers: (descriptors: CallerDescriptor[]) => SwcExtraCallerConfig[];
+//#endregion
+export { SwcExtraCallerConfig, getRewritableCallers, toSwcExtraCallers };
+//# sourceMappingURL=transform.d.ts.map

package/dist/types/callers/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","names":[],"sources":["../../../src/callers/transform.ts"],"mappings":";;;;;;;;KAQY;;EAEV;;EAEA;;;;;EAKA;;;;;EAKA;;;;;;EAMA;IAAoB;IAAuB;;;EAE3C;;EAEA;;;;;;;;;cAUW,uBAAoB,aAClB,uBACZ;;;;;;;;;;;;cA6BU,oBAAiB,aACf,uBACZ"}

package/dist/types/callers/types.d.ts

@@ -0,0 +1,160 @@
+//#region src/callers/types.d.ts
+/**
+ * Shared caller-descriptor model.
+ *
+ * A "caller" is any function or JSX component through which application code
+ * reads intlayer content: the base getters (`useIntlayer`, `getIntlayer`) and
+ * every compat-adapter entry point (`useTranslation`, `useTranslations`,
+ * `formatMessage`, lingui's `t`/`_`, …).
+ *
+ * This registry is the single source of truth consumed by:
+ * - `@intlayer/babel` — field-usage analysis (purge/minify) and the optimize
+ *   pass that rewrites caller invocations to `useDictionary(...)` /
+ *   `useDictionaryDynamic(...)` with pre-imported dictionaries.
+ * - `@intlayer/swc` — the same optimize pass for Next.js builds; descriptors
+ *   are serialised to the plugin's wire format via `toSwcExtraCallers`.
+ * - `@intlayer/lsp` and the VS Code extension — AST/regex matchers powering
+ *   go-to-definition, references and completion.
+ * - Each compat package's bundler plugin — injects its library's descriptors
+ *   into the pipelines above, so no compat-specific name is hard-coded in the
+ *   core packages.
+ */
+/**
+ * Where a value (namespace/dictionary key, or key prefix) is read from a call
+ * expression.
+ */
+type CallerValueSource =
+/** Positional argument holding a string literal, e.g. `useTranslations('ns')`. */
+{
+  from: 'argument';
+  index: number;
+} |
+/** Property of an options-object argument, e.g. `useI18n({ namespace: 'ns' })`. */
+{
+  from: 'option';
+  argumentIndex: number;
+  property: string;
+} |
+/**
+ * Compile-time constant — every call site reads the same dictionary.
+ * Used by single-catalog libraries such as lingui (`messages`).
+ */
+{
+  from: 'fixed';
+  value: string;
+} |
+/**
+ * The first dot-segment of the message id passed to the call itself.
+ * Used by react-intl where `formatMessage({ id: 'home.title' })` encodes
+ * both the dictionary key (`home`) and the field path (`title`).
+ */
+{
+  from: 'path-first-segment';
+};
+/**
+ * How translated content is obtained from the caller's result.
+ *
+ * - `'content'`        — returns the dictionary content object; fields are
+ *                        read through member access or destructuring
+ *                        (`useIntlayer`, `getIntlayer`).
+ * - `'return-value'`   — returns the translation function directly:
+ *                        `const t = useTranslations('ns'); t('key')`.
+ * - `'destructured-t'` — returns an object holding `t`:
+ *                        `const { t } = useTranslation('ns'); t('key')`.
+ * - `'self'`           — the caller IS the translation call; the message id is
+ *                        one of its own arguments (`formatMessage`, `i18n._`).
+ * - `'all'`            — field-level analysis is impossible; the whole
+ *                        dictionary is marked as used (Angular templates,
+ *                        lingui hashed ids).
+ */
+type CallerResultShape = 'content' | 'return-value' | 'destructured-t' | 'self' | 'all';
+/**
+ * Full description of a single caller.
+ */
+type CallerDescriptor = {
+  /** Function or JSX component name, e.g. `'useTranslation'`, `'FormattedMessage'`. */
+  callerName: string;
+  /** Library identifier grouping related callers, e.g. `'react-i18next'`. */
+  library: string;
+  /**
+   * Module specifiers the caller may be imported from. Includes both the
+   * original library names and the `@intlayer/*` adapter equivalents, because
+   * bundler aliasing keeps user imports on the original names.
+   */
+  importSources: string[];
+  /**
+   * When `true`, the caller only participates in matching when the analysed
+   * file imports from one of `importSources`. Used for generic names such as
+   * lingui's `t` / `_` that would otherwise produce false positives.
+   */
+  requiresImport?: boolean;
+  /**
+   * When `true`, the caller is also matched as a method on any object
+   * (`i18n.getFixedT(...)`, `intl.formatMessage(...)`) in addition to the
+   * bare-identifier form.
+   */
+  matchAsMethod?: boolean;
+  /** When `true`, also match the tagged-template form, e.g. lingui's ``t`…` ``. */
+  matchAsTaggedTemplate?: boolean;
+  /**
+   * When set, the caller is also matched as a JSX element whose attribute of
+   * this name holds the message id, e.g. `<FormattedMessage id="home.title" />`
+   * or `<Trans i18nKey="richText" />`.
+   */
+  jsxIdAttribute?: string;
+  /**
+   * Optional JSX attribute carrying the namespace (dictionary key), e.g.
+   * react-i18next's `<Trans ns="home" i18nKey="title" />`.
+   */
+  jsxNamespaceAttribute?: string;
+  /**
+   * Where the dictionary key is read from, tried in declaration order.
+   * The first source that yields a static string wins.
+   */
+  namespaceSources: CallerValueSource[];
+  /**
+   * Optional key prefix prepended to every message path resolved through the
+   * returned translation function, e.g. `getFixedT(lng, ns, keyPrefix)` or
+   * `useTranslation(ns, { keyPrefix })`.
+   */
+  keyPrefixSources?: CallerValueSource[];
+  /**
+   * When `true`, a dotted namespace is split at the first `.`: the first
+   * segment is the dictionary key and the rest becomes a key prefix.
+   * next-intl semantics: `useTranslations('about.counter')` reads the
+   * `about` dictionary with every `t()` path prefixed by `counter`.
+   */
+  nestedNamespace?: boolean;
+  /**
+   * When `true`, the caller may be invoked without any namespace
+   * (`useTranslations()` root scope) — the dictionary key is then the first
+   * dot-segment of each message id passed to the returned `t()`.
+   */
+  allowRootScope?: boolean;
+  /** How translated content is obtained from the caller's result. */
+  translationFunction: CallerResultShape;
+  /**
+   * When `true`, the message id is a *flat* dictionary field that itself may
+   * contain dots (lingui catalogs). When unset, dotted ids map onto nested
+   * dictionary objects and are split into a field path.
+   */
+  flatKey?: boolean;
+  /**
+   * Name of the dictionary-accepting replacement used by the optimize pass in
+   * static import mode, e.g. `'useDictionary'`. The replacement must be
+   * exported from every module in `importSources` (the compat package exports
+   * it; original-library specifiers are bundler-aliased to the compat package).
+   *
+   * Only callers with both replacements set — and matched as plain imported
+   * functions (not `matchAsMethod` / JSX) — are rewritten at build time.
+   */
+  staticReplacement?: string;
+  /**
+   * Name of the dictionary-accepting replacement used by the optimize pass in
+   * dynamic/fetch import mode, e.g. `'useDictionaryDynamic'`.
+   */
+  dynamicReplacement?: string;
+};
+//#endregion
+export { CallerDescriptor, CallerResultShape, CallerValueSource };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/callers/types.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;KAyBY;;;EAEN;EAAkB;;;;EAElB;EAAgB;EAAuB;;;;;;;EAKvC;EAAe;;;;;;;;EAMf;;;;;;;;;;;;;;;;;;KAkBM;;;;KAUA;;EAEV;;EAEA;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA;;EAEA;;;;;;EAMA;;;;;EAKA;;;;;EAKA,kBAAkB;;;;;;EAMlB,mBAAmB;;;;;;;EAOnB;;;;;;EAMA;;EAEA,qBAAqB;;;;;;EAMrB;;;;;;;;;;EAUA;;;;;EAKA"}

package/dist/types/client.d.ts

@@ -1,4 +1,4 @@
-import { BrowserIntlayerConfig, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./configFile/buildBrowserConfiguration.js";
+import { BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./configFile/buildBrowserConfiguration.js";
 import { extractErrorMessage } from "./utils/extractErrorMessage.js";
 import { logStack } from "./utils/logStack.js";
 import { normalizePath } from "./utils/normalizePath.js";
@@ -7,4 +7,4 @@ import { camelCaseToKebabCase } from "./utils/stringFormatter/camelCaseToKebabCa
 import { camelCaseToSentence } from "./utils/stringFormatter/camelCaseToSentence.js";
 import { kebabCaseToCamelCase } from "./utils/stringFormatter/kebabCaseToCamelCase.js";
 import { toLowerCamelCase } from "./utils/stringFormatter/toLowerCamelCase.js";
-export { BrowserIntlayerConfig, WindowsWithIntlayer, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, camelCaseToKebabCase, camelCaseToSentence, extractBrowserConfiguration, extractErrorMessage, kebabCaseToCamelCase, logStack, normalizePath, setIntlayerIdentifier, toLowerCamelCase };
+export { BrowserIntlayerConfig, WindowsWithIntlayer, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, camelCaseToKebabCase, camelCaseToSentence, extractBrowserConfiguration, extractErrorMessage, kebabCaseToCamelCase, logStack, normalizePath, setIntlayerIdentifier, toLowerCamelCase };

package/dist/types/colors.d.ts

@@ -1,20 +1,20 @@
 declare namespace colors_d_exports {
   export { BEIGE, BLUE, BOLD, CYAN, GREEN, GREY, GREY_DARK, GREY_LIGHT, MAGENTA, ORANGE, RED, RESET, WHITE, YELLOW };
 }
-declare const RESET: "\u001B[0m";
-declare const GREY: "\u001B[90m";
-declare const GREY_DARK: "\u001B[38;5;239m";
-declare const GREY_LIGHT: "\u001B[38;5;252m";
-declare const BLUE: "\u001B[34m";
-declare const RED: "\u001B[31m";
-declare const GREEN: "\u001B[32m";
-declare const YELLOW: "\u001B[38;5;226m";
-declare const MAGENTA: "\u001B[35m";
-declare const BEIGE: "\u001B[38;5;3m";
-declare const ORANGE: "\u001B[38;5;208m";
-declare const CYAN: "\u001B[36m";
-declare const WHITE: "\u001B[37m";
-declare const BOLD: "\u001B[1m";
+declare const RESET: '';
+declare const GREY: '';
+declare const GREY_DARK: '';
+declare const GREY_LIGHT: '';
+declare const BLUE: '';
+declare const RED: '';
+declare const GREEN: '';
+declare const YELLOW: '';
+declare const MAGENTA: '';
+declare const BEIGE: '';
+declare const ORANGE: '';
+declare const CYAN: '';
+declare const WHITE: '';
+declare const BOLD: '';
 //#endregion
 export { BEIGE, BLUE, BOLD, CYAN, GREEN, GREY, GREY_DARK, GREY_LIGHT, MAGENTA, ORANGE, RED, RESET, WHITE, YELLOW, colors_d_exports };
 //# sourceMappingURL=colors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"colors.d.ts","names":[],"sources":["../../src/colors.ts"],"mappings":";;;cAAa,KAAA;AAAA,cACA,IAAA;AAAA,cACA,SAAA;AAAA,cACA,UAAA;AAAA,cACA,IAAA;AAAA,cACA,GAAA;AAAA,cACA,KAAA;AAAA,cACA,MAAA;AAAA,cACA,OAAA;AAAA,cACA,KAAA;AAAA,cACA,MAAA;AAAA,cACA,IAAA;AAAA,cACA,KAAA;AAAA,cACA,IAAA"}
+{"version":3,"file":"colors.d.ts","names":[],"sources":["../../src/colors.ts"],"mappings":";;;cAAa;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA"}

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

@@ -1,5 +1,4 @@
-import { CustomIntlayerConfig, CustomRoutingConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, RoutingConfig } from "@intlayer/types/config";
-
+import { AnalyticsConfig, CustomIntlayerConfig, CustomRoutingConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, RoutingConfig } from "@intlayer/types/config";
 //#region src/configFile/buildBrowserConfiguration.d.ts
 /**
  * Browser-safe subset of {@link IntlayerConfig}.
@@ -12,6 +11,7 @@ type BrowserIntlayerConfig = {
   internationalization: Pick<InternationalizationConfig, 'locales' | 'defaultLocale'>;
   routing: RoutingConfig;
   editor: Omit<EditorConfig, 'clientId' | 'clientSecret'>;
+  analytics: AnalyticsConfig;
   log: Pick<LogConfig, 'mode' | 'prefix'>;
 };
 declare global {
@@ -41,10 +41,30 @@ declare const buildRoutingFields: (customConfiguration?: Partial<CustomRoutingCo
  * (`clientId`, `clientSecret`). The browser-safe {@link BrowserIntlayerConfig}
  * omits those fields when exposing config to the client.
  *
+ * When the user does not explicitly set `clientId` / `clientSecret` in the
+ * configuration file, they fall back to the `INTLAYER_CLIENT_ID` /
+ * `INTLAYER_CLIENT_SECRET` environment variables read from `env`. This lets
+ * users authenticate purely through their `.env` file (including files passed
+ * via the CLI `--env-file` flag) without having to wire `process.env` into the
+ * configuration manually.
+ *
  * @param customConfiguration - Partial user-supplied editor config.
+ * @param env - Environment variables used to resolve credential fallbacks.
+ *   Defaults to `process.env`.
  * @returns A fully-defaulted {@link EditorConfig}.
  */
-declare const buildEditorFields: (customConfiguration?: Partial<EditorConfig>) => EditorConfig;
+declare const buildEditorFields: (customConfiguration?: Partial<EditorConfig>, env?: NodeJS.ProcessEnv) => EditorConfig;
+/**
+ * Build the analytics section of the Intlayer configuration.
+ *
+ * Analytics is strictly opt-in: `enabled` defaults to `false` and, even when
+ * enabled, the runtime additionally requires a project key (`editor.clientId`)
+ * for attribution before collecting anything.
+ *
+ * @param customConfiguration - Partial user-supplied analytics config.
+ * @returns A fully-defaulted {@link AnalyticsConfig}.
+ */
+declare const buildAnalyticsFields: (customConfiguration?: Partial<AnalyticsConfig>) => AnalyticsConfig;
 /**
  * Build the log section of the Intlayer configuration.
  *
@@ -89,5 +109,5 @@ declare const buildBrowserConfiguration: (customConfig?: CustomIntlayerConfig) =
  */
 declare const extractBrowserConfiguration: (config: IntlayerConfig) => BrowserIntlayerConfig;
 //#endregion
-export { BrowserIntlayerConfig, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
+export { BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
 //# sourceMappingURL=buildBrowserConfiguration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildBrowserConfiguration.d.ts","names":[],"sources":["../../../src/configFile/buildBrowserConfiguration.ts"],"mappings":";;;;;AA0CA;;;;;KAAY,qBAAA;EACV,oBAAA,EAAsB,IAAA,CACpB,0BAAA;EAGF,OAAA,EAAS,aAAA;EACT,MAAA,EAAQ,IAAA,CAAK,YAAA;EACb,GAAA,EAAK,IAAA,CAAK,SAAA;AAAA;AAAA,QAGJ,MAAA;EAAA,UACI,MAAA;IAVY;IAYpB,eAAA,GAAkB,qBAAA;EAAA;AAAA;;;;;;;cAiBT,+BAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,0BAAA,MAC7B,0BAAA;;AAxBD;;;;;cAuEW,kBAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,mBAAA,MAC7B,aAAA;;;;;;AAnDH;;;;;cAuJa,iBAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,YAAA,MAC7B,YAAA;;;;;;;;cAmIU,cAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,SAAA,GAC9B,YAAA,GAAe,YAAA,KACd,SAAA;AA9OH;;;;;;;;;;;;;;AAsGA;;;;;;;;AAtGA,cAsSa,yBAAA,GACX,YAAA,GAAe,oBAAA,KACd,qBAAA;;;;;;AA7DH;;;;;;cA4Fa,2BAAA,GACX,MAAA,EAAQ,cAAA,KACP,qBAAA"}
+{"version":3,"file":"buildBrowserConfiguration.d.ts","names":[],"sources":["../../../src/configFile/buildBrowserConfiguration.ts"],"mappings":";;;;;;;;;KAqDY;EACV,sBAAsB,KACpB;EAGF,SAAS;EACT,QAAQ,KAAK;EACb,WAAW;EACX,KAAK,KAAK;;QAGJ;YACI;;IAER,kBAAkB;;;;;;;;;cAiBT,kCAA+B,sBACpB,QAAQ,gCAC7B;;;;;;;cA+CU,qBAAkB,sBACP,QAAQ,yBAC7B;;;;;;;;;;;;;;;;;;;;cAwHU,oBAAiB,sBACN,QAAQ,eAAa,MACtC,OAAO,eACX;;;;;;;;;;;cAuIU,uBAAoB,sBACT,QAAQ,qBAC7B;;;;;;;;cA8BU,iBAAc,sBACH,QAAQ,YAAU,eACzB,iBACd;;;;;;;;;;;;;;;;;;;;;;;cAwDU,4BAAyB,eACrB,yBACd;;;;;;;;;;;;cAiCU,8BAA2B,QAC9B,mBACP"}

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

@@ -1,6 +1,5 @@
-import { BrowserIntlayerConfig, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./buildBrowserConfiguration.js";
+import { BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./buildBrowserConfiguration.js";
 import { CustomIntlayerConfig, IntlayerConfig, LogFunctions } from "@intlayer/types/config";
-
 //#region src/configFile/buildConfigurationFields.d.ts
 /**
  * Build the complete Intlayer configuration by merging user-supplied values
@@ -18,9 +17,14 @@ import { CustomIntlayerConfig, IntlayerConfig, LogFunctions } from "@intlayer/ty
  * @param customConfiguration - Optional user-supplied configuration object.
  * @param baseDir - Project root directory. Defaults to `process.cwd()`.
  * @param logFunctions - Optional custom logging functions.
+ * @param env - Environment variables used to resolve credential fallbacks
+ *   (e.g. `INTLAYER_CLIENT_ID` / `INTLAYER_CLIENT_SECRET`). Defaults to
+ *   `process.env`. Callers loading a custom env file (such as the CLI
+ *   `--env-file` flag) should pass the merged env so credentials defined there
+ *   are picked up without polluting `process.env`.
  * @returns A fully-built {@link IntlayerConfig}.
  */
-declare const buildConfigurationFields: (customConfiguration?: CustomIntlayerConfig, baseDir?: string, logFunctions?: LogFunctions) => IntlayerConfig;
+declare const buildConfigurationFields: (customConfiguration?: CustomIntlayerConfig, baseDir?: string, logFunctions?: LogFunctions, env?: NodeJS.ProcessEnv) => IntlayerConfig;
 //#endregion
-export { type BrowserIntlayerConfig, buildBrowserConfiguration, buildConfigurationFields, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
+export { type BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildConfigurationFields, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
 //# sourceMappingURL=buildConfigurationFields.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildConfigurationFields.d.ts","names":[],"sources":["../../../src/configFile/buildConfigurationFields.ts"],"mappings":";;;;;;AA0uBA;;;;;;;;;;;;;;;;cAAa,wBAAA,GACX,mBAAA,GAAsB,oBAAA,EACtB,OAAA,WACA,YAAA,GAAe,YAAA,KACd,cAAA"}
+{"version":3,"file":"buildConfigurationFields.d.ts","names":[],"sources":["../../../src/configFile/buildConfigurationFields.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cAivBa,2BAAwB,sBACb,sBAAoB,kBAC1B,eACD,cAAY,MACtB,OAAO,eACX"}