@intlayer/babel 9.0.0-canary.9 → 9.0.1

package/dist/types/babel-plugin-intlayer-minify.d.ts

@@ -1,6 +1,5 @@
 import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
 //#region src/babel-plugin-intlayer-minify.d.ts
 /**
  * Pre-resolved options accepted by {@link intlayerMinifyBabelPlugin}.

package/dist/types/babel-plugin-intlayer-minify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-minify.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-minify.ts"],"mappings":";;;;;;AAgBA;;;;;KAAY,mBAAA;EAkBV;;;;EAbA,OAAA;EA8ID;;;;;EAvIC,MAAA;EA+DE;;;;EAzDF,QAAA;;;;EAKA,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDW,yBAAA,GAA6B,KAAA;EACxC,KAAA,SAAc,UAAA;AAAA,MACZ,YAAA"}
+{"version":3,"file":"babel-plugin-intlayer-minify.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-minify.ts"],"mappings":";;;;;;;;;;KAgBY;;;;;EAKV;;;;;;EAOA;;;;;EAMA;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDW,4BAAyB;EACpC,cAAc;MACZ"}

package/dist/types/babel-plugin-intlayer-optimize.d.ts

@@ -1,8 +1,8 @@
 import { PluginObject, PluginPass } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
+import { CallerDescriptor } from "@intlayer/config/callers";
 //#region src/babel-plugin-intlayer-optimize.d.ts
-declare const CALLER_LIST: readonly ["useIntlayer", "getIntlayer"];
+declare const CALLER_LIST: readonly ['useIntlayer', 'getIntlayer'];
 /**
  * Options for the optimization Babel plugin
  */
@@ -63,15 +63,38 @@ type OptimizePluginOptions = {
    * Whether the current transform is for an SSR bundle.
    */
   isServer?: boolean;
+  /**
+   * Compat-adapter caller descriptors injected by the compat packages'
+   * bundler plugins (e.g. `@intlayer/react-i18next/plugin`).
+   *
+   * Callers carrying `staticReplacement` / `dynamicReplacement` are rewritten
+   * the same way as native `useIntlayer` calls: the namespace string argument
+   * is replaced by a pre-imported dictionary object and the import specifier
+   * is re-pointed to the dictionary-accepting variant, e.g.
+   * `useTranslation('about')` → `useDictionary(_dictHash)`.
+   *
+   * No compat-specific name is hard-coded in this plugin — the whole rewrite
+   * is driven by these descriptors.
+   */
+  compatCallers?: CallerDescriptor[];
 };
 type State = PluginPass & {
-  opts: OptimizePluginOptions; /** map key → generated ident (per-file) for static imports */
-  _newStaticImports?: Map<string, BabelTypes.Identifier>; /** map key → generated ident (per-file) for dynamic imports */
-  _newDynamicImports?: Map<string, BabelTypes.Identifier>; /** whether the current file imported *any* intlayer package */
-  _hasValidImport?: boolean; /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */
-  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>; /** map from local identifier name to the intlayer package it was imported from */
-  _callerPackageMap?: Map<string, string>; /** whether the current file *is* the dictionaries entry file */
-  _isDictEntry?: boolean; /** whether the current file is included in the filesList */
+  opts: OptimizePluginOptions;
+  /** map key → generated ident (per-file) for static imports */
+  _newStaticImports?: Map<string, BabelTypes.Identifier>;
+  /** map key → generated ident (per-file) for dynamic imports */
+  _newDynamicImports?: Map<string, BabelTypes.Identifier>;
+  /** whether the current file imported *any* intlayer package */
+  _hasValidImport?: boolean;
+  /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */
+  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>;
+  /** map from local identifier name to the intlayer package it was imported from */
+  _callerPackageMap?: Map<string, string>;
+  /** map from local identifier name to the compat caller descriptor it was imported as */
+  _compatCallerMap?: Map<string, CallerDescriptor>;
+  /** whether the current file *is* the dictionaries entry file */
+  _isDictEntry?: boolean;
+  /** whether the current file is included in the filesList */
   _isIncluded?: boolean;
 };
 /**

package/dist/types/babel-plugin-intlayer-optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cAwBM,WAAA;;AAtB0C;;KAqEpC,qBAAA;EA/C+C;;AA+C3D;EAIE,QAAA;;;;EAIA,eAAA;EAIA;;;EAAA,qBAAA;EAgBA;;;EAZA,6BAAA;EA4BA;;;EAxBA,uBAAA;EAuCA;;;EAnCA,sBAAA;EAsCQ;;;EAlCR,4BAAA;EAqCgC;;;EAjChC,oBAAA;EAuCiC;;;EAnCjC,0BAAA;EAqCuB;;;EAjCvB,sBAAA;EAyBA;;;EArBA,UAAA;EAuBA;;;EAnBA,iBAAA,GAAoB,MAAA;EAqBpB;;;EAdA,SAAA;EAkBA;;;EAdA,QAAA;AAAA;AAAA,KAGG,KAAA,GAAQ,UAAA;EACX,IAAA,EAAM,qBAAA,EA6mBP;EA3mBC,iBAAA,GAAoB,GAAA,SAAY,UAAA,CAAW,UAAA,GAgN7B;EA9Md,kBAAA,GAAqB,GAAA,SAAY,UAAA,CAAW,UAAA,GA+M1C;EA7MF,eAAA,YA6Mc;EA3Md,UAAA,GAAa,GAAA,iBAAoB,WAAA,YA0MnB;EAxMd,iBAAA,GAAoB,GAAA,kBAyMlB;EAvMF,YAAA,YAuMoB;EArMpB,WAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmMW,2BAAA,GAA+B,KAAA;EAC1C,KAAA,SAAc,UAAA;AAAA,MACZ,YAAA,CAAa,KAAA"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cA6BM;;;;KAqDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8RW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}

package/dist/types/babel-plugin-intlayer-purge.d.ts

@@ -1,7 +1,6 @@
 import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
 //#region src/babel-plugin-intlayer-purge.d.ts
 /**
  * Pre-resolved options accepted by {@link intlayerPurgeBabelPlugin}.

package/dist/types/babel-plugin-intlayer-purge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;AA6BA;;;;;KAAY,kBAAA;EAmBV;;;;;EAbA,OAAA;EAoDA;;;;EA9CA,KAAA;EA8DkC;AAyBpC;;;;EAhFE,MAAA;EA0sBW;;;;;EAnsBX,QAAA;EAmsBuC;;;;EA7rBvC,aAAA;;;;;EAMA,eAAA;;;;;EAMA,sBAAA;;;;;;EAOA,kBAAA;;;;;;EAOA,4BAAA,EAA8B,MAAA;;;;;;;;;;;;EAgB9B,aAAA,GAAgB,kBAAA;AAAA;;;;;;;;;cAyBL,qBAAA,GAAyB,OAAA,aAAkB,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0nB3C,wBAAA,GAA4B,MAAA;EACvC,KAAA,SAAc,UAAA;AAAA,MACZ,YAAA"}
+{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;;;;;KAgCY;;;;;;EAMV;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;;EAOA;;;;;;EAOA,8BAA8B;;;;;;;;;;;;EAgB9B,gBAAgB;;;;;;;;;;cAqBL,wBAAqB,oBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwjB3C,2BAAwB;EACnC,cAAc;MACZ"}

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts

@@ -1,6 +1,6 @@
-import { PluginObj } from "@babel/core";
+import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
+import { CallerDescriptor, CallerDescriptor as CallerDescriptor$1, CallerResultShape, CallerValueSource } from "@intlayer/config/callers";
 //#region src/babel-plugin-intlayer-usage-analyzer.d.ts
 /**
  * Dictionary field usage result for a single dictionary key.
@@ -23,6 +23,22 @@ type NestedRenameEntry = {
 };
 /** A level of the field-rename tree, mapping original field names to entries. */
 type NestedRenameMap = Map<string, NestedRenameEntry>;
+/**
+ * One opaque consumption of a dictionary content value: the value at
+ * `fieldPath` escapes static analysis (passed as-is to a child component or a
+ * function argument), so its children must keep their original key names in
+ * the compiled JSON.
+ */
+type OpaqueFieldOccurrence = {
+  /**
+   * Original (pre-rename) user-defined field names from the content root to
+   * the escaping value, e.g. `['sections', 'hero']` for
+   * `<Card data={content.sections.hero} />`.
+   */
+  fieldPath: string[];
+  /** Source locations (`filePath:line`) where the value escapes. */
+  locations: string[];
+};
 /**
  * Shared mutable state created once by the vite plugin and passed by reference
  * to the usage-analyzer (writer) and the prune/minify plugins (readers).
@@ -61,14 +77,17 @@ type PruneContext = {
    */
   dictionaryKeyToFieldRenameMap: Map<string, NestedRenameMap>;
   /**
-   * Maps each dictionary key to a per-field list of source locations where
-   * the field value is consumed "opaquely" (passed as-is to a child component
-   * or function argument). When a field is opaque AND has nested user-defined
-   * structure, its children must not be renamed.
+   * Maps each dictionary key to the content field paths whose values are
+   * consumed "opaquely" (passed as-is to a child component or function
+   * argument). When an opaque value has nested user-defined structure, its
+   * children must not be renamed.
    *
-   * Structure: dictionaryKey → fieldName → ["filePath:line", …]
+   * The inner map is keyed by the dot-joined field path for de-duplication
+   * only; the authoritative path is {@link OpaqueFieldOccurrence.fieldPath}.
+   *
+   * Structure: dictionaryKey → joinedFieldPath → { fieldPath, locations }
    */
-  dictionaryKeysWithOpaqueTopLevelFields: Map<string, Map<string, string[]>>;
+  dictionaryKeysWithOpaqueFields: Map<string, Map<string, OpaqueFieldOccurrence>>;
   /**
    * Dictionary keys for which field-key renaming must be skipped even if a
    * finite field-usage set was determined.
@@ -99,124 +118,15 @@ type PruneContext = {
 };
 declare const createPruneContext: () => PruneContext;
 /** Canonical intlayer caller names that trigger usage analysis. */
-declare const INTLAYER_CALLER_NAMES: readonly ["useIntlayer", "getIntlayer"];
+declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer'];
 type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
-/**
- * Describes how a compat-adapter "namespace caller" exposes the dictionary key
- * (namespace) and the translation function `t`.
- *
- * Compat adapters (`@intlayer/react-i18next`, `@intlayer/next-intl`, …) expose
- * the original i18n library API while delegating to intlayer under the hood.
- * Their call sites look like:
- *
- *   const { t } = useTranslation('about');   t('counter.label')
- *   const t     = useTranslations('about');  t('counter.label')
- *   const t     = await getTranslations('about');
- *   const t     = i18n.getFixedT(null, 'about', 'counter');
- *   const { t } = useI18n({ namespace: 'about' });
- *
- * The dictionary key is the *namespace* argument and the consumed top-level
- * field is the **first segment** of every dot-path passed to `t()` (or the
- * first segment of `keyPrefix` when one is supplied).
- */
-type CompatNamespaceSource = /** Namespace is a positional argument (string literal or `{ namespace }`). */{
-  from: 'argument';
-  index: number;
-} /** Namespace is a property of an options object argument. */ | {
-  from: 'option';
-  argumentIndex: number;
-  property: string;
-}
-/**
- * Namespace is a compile-time constant — the same dictionary key is used for
- * every call site. Used by single-catalog libraries such as lingui, where all
- * translations live in a `messages` dictionary regardless of call location.
- */
-| {
-  from: 'fixed';
-  value: string;
-}
-/**
- * Namespace is the first dot-segment of the `id` in the first call argument.
- *
- * Used for libraries like react-intl where the full dotted id encodes both the
- * dictionary key and the field path in a single string:
- *   `formatMessage({ id: 'home.title' })` → dictionaryKey = `'home'`, field = `'title'`
- *
- * Works with both string form (`func('home.title')`) and descriptor form
- * (`func({ id: 'home.title', ... })`). The paired `translationFunction` should
- * be `'self'` so the field (second segment) is also extracted from the same call.
- */
-| {
-  from: 'path-first-segment';
-};
 /**
  * Configuration entry for a single compat namespace caller.
+ *
+ * @deprecated Alias kept for backward compatibility — use the shared
+ * {@link CallerDescriptor} from `@intlayer/config/callers` instead.
  */
-type CompatCallerConfig = {
-  /** The imported (or method) function name, e.g. `'useTranslation'`. */callerName: string;
-  /**
-   * Module specifiers from which `callerName` must be imported to be treated as
-   * a compat caller. Includes both the original library names and their
-   * `@intlayer/*` adapter equivalents, because the bundler aliases the former
-   * to the latter but user source code may import either.
-   *
-   * Ignored when `matchAsMethod` is `true`.
-   */
-  importSources: string[];
-  /**
-   * When `true`, the caller is matched by method name on any object
-   * (`x.getFixedT(...)`) without an import check. Used for `i18next` instance
-   * methods that are never imported as named specifiers.
-   */
-  matchAsMethod?: boolean; /** How the dictionary key (namespace) is read from the call arguments. */
-  namespace: CompatNamespaceSource;
-  /**
-   * Optional location of a `keyPrefix` that prefixes every `t()` path. When a
-   * static prefix is present, the only consumed top-level field is the first
-   * segment of the prefix.
-   */
-  keyPrefix?: CompatNamespaceSource;
-  /**
-   * How the translation function is obtained from the call result.
-   *
-   * - `'return-value'`   — `const t = useTranslations('ns'); t('key')`
-   * - `'destructured-t'` — `const { t } = useTranslation('ns'); t('key')`
-   * - `'self'`           — the caller IS the translation call;
-   *                        the first argument is the message key.
-   *                        Used for lingui's `i18n._('key')` / `i18n.t('key')`.
-   * - `'all'`            — mark the entire dictionary as used without tracking
-   *                        individual fields. Use when static key analysis is
-   *                        impossible (e.g. lingui hashed IDs, Angular templates).
-   */
-  translationFunction: 'return-value' | 'destructured-t' | 'self' | 'all';
-  /**
-   * When `true`, the message key is a *flat* dictionary field that itself
-   * contains dots (e.g. lingui's `i18n._('results-table.bundleSize')`, where the
-   * catalog stores the entry under the literal `'results-table.bundleSize'` key
-   * rather than nesting it as `{ 'results-table': { bundleSize } }`).
-   *
-   * The whole key is then recorded as the consumed top-level field. When unset
-   * (the default), only the first dot-segment is recorded, matching libraries
-   * whose dotted keys map onto nested dictionary objects (next-intl, vue-i18n).
-   *
-   * Only meaningful with `translationFunction: 'self'` and a
-   * `'fixed'` / `'argument'` / `'option'` namespace.
-   */
-  flatKey?: boolean;
-  /**
-   * When set, the caller is *also* matched as a JSX element whose local name is
-   * `callerName` (gated by `importSources`). The named attribute is read as the
-   * message id and analysed with the same `namespace` + `translationFunction`
-   * (`'self'` / `'all'`) semantics as the call-expression form.
-   *
-   * Required for libraries with a JSX message component, e.g. react-intl's
-   * `<FormattedMessage id="home.title" />`. Without it, JSX usages are invisible
-   * to the analyser and field-level pruning of the same dictionary becomes
-   * unsafe (it could prune a field only referenced from JSX).
-   */
-  jsxIdAttribute?: string;
-};
+type CompatCallerConfig = CallerDescriptor$1;
 /**
  * Default registry of compat namespace callers.
  *
@@ -244,11 +154,9 @@ declare const DEFAULT_COMPAT_CALLERS: CompatCallerConfig[];
  */
 declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext, options?: {
   compatCallers?: CompatCallerConfig[];
-}) => ({
-  types: babelTypes
-}: {
+}) => ({ types: babelTypes }: {
   types: typeof BabelTypes;
-}) => PluginObj;
+}) => PluginObject;
 //#endregion
-export { CompatCallerConfig, CompatNamespaceSource, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin };
+export { type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin };
 //# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.d.ts.map

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;AAYA;;;;;KAAY,oBAAA,GAAuB,GAAA;;;;;;;;KASvB,iBAAA;EACV,SAAA;EACA,QAAA,EAAU,eAAA;AAAA;;KAIA,eAAA,GAAkB,GAAA,SAAY,iBAAA;AAS1C;;;;;;;AAAA,KAAY,YAAA;EAiCqB;;;;;EA3B/B,4BAAA,EAA8B,GAAA,SAAY,oBAAA;EA+Db;;;;EAzD7B,yBAAA,EAA2B,GAAA;EAAA;;;;;EAO3B,wBAAA;EAc2C;;;;;EAP3C,mCAAA,EAAqC,GAAA;EA2CrC;;;;;EApCA,6BAAA,EAA+B,GAAA,SAAY,eAAA;EA0ChC;;;;;AAiBb;;;EAjDE,sCAAA,EAAwC,GAAA,SAAY,GAAA;EAiDsB;AAC5E;;;;;AAsBA;;;;;;EA1DE,+BAAA,EAAiC,GAAA;EA8Db;;;;;;;AAuBtB;;;EAzEE,wBAAA,EAA0B,GAAA;IAEtB,YAAA;IAAsB,aAAA;EAAA;AAAA;AAAA,cAIf,kBAAA,QAAyB,YAAA;;cAiBzB,qBAAA;AAAA,KACD,kBAAA,WAA6B,qBAAA;;;;;AA8HzC;;;;;AA22BA;;;;;;;;;KAn9BY,qBAAA;EAEN,IAAA;EAAkB,KAAA;AAAA;EAElB,IAAA;EAAgB,aAAA;EAAuB,QAAA;AAAA;;;;;;;EAMvC,IAAA;EAAe,KAAA;AAAA;;;;;;;;;;;;;EAYf,IAAA;AAAA;;;;KAKM,kBAAA;yEAEV,UAAA;;;;;;;;;EASA,aAAA;;;;;;EAMA,aAAA;EAEA,SAAA,EAAW,qBAAA;;;;;;EAMX,SAAA,GAAY,qBAAA;;;;;;;;;;;;;EAaZ,mBAAA;;;;;;;;;;;;;;EAcA,OAAA;;;;;;;;;;;;EAYA,cAAA;AAAA;;;;;;;;;;;cAaW,sBAAA,EAAwB,kBAAA;;;;;;;;;;;;;;;cA22BxB,4BAAA,GAET,YAAA,EAAc,YAAA,EACd,OAAA;EAAY,aAAA,GAAgB,kBAAA;AAAA;EAE7B,KAAA,EAAA;AAAA;EAAyB,KAAA,SAAc,UAAA;AAAA,MAAe,SAAA"}
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;KAgBY,uBAAuB;;;;;;;;KASvB;EACV;EACA,UAAU;;;KAIA,kBAAkB,YAAY;;;;;;;KAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;KAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;cAIf,0BAAyB;;cAiBzB;KACD,6BAA6B;;;;;;;KAmB7B,qBAAqB;;;;;;;;;;;cAYpB,wBAAwB;;;;;;;;;;;;;;;cAmiCxB,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}

package/dist/types/babelParser.d.ts

@@ -0,0 +1,12 @@
+//#region src/babelParser.d.ts
+/** A parser object accepted by `recast.parse`'s `parser` option. */
+type RecastParser = {
+  parse: (source: string) => unknown;
+};
+/** Drop-in replacement for `recast/parsers/typescript` (TS without JSX). */
+declare const typescriptParser: RecastParser;
+/** Drop-in replacement for `recast/parsers/babel-ts` (TS *and* JSX). */
+declare const babelTsParser: RecastParser;
+//#endregion
+export { RecastParser, babelTsParser, typescriptParser };
+//# sourceMappingURL=babelParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babelParser.d.ts","names":[],"sources":["../../src/babelParser.ts"],"mappings":";;KAuDY;EACV,QAAQ;;;cAIG,kBAAkB;;cAMlB,eAAe"}

package/dist/types/extractContent/babelProcessor.d.ts

@@ -1,7 +1,8 @@
+import { ExistingIntlayerInfo } from "./utils/getExistingIntlayerInfo.js";
+import "./utils/index.js";
 import * as t from "@babel/types";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { NodePath } from "@babel/traverse";
-
 //#region src/extractContent/babelProcessor.d.ts
 type BabelReplacement = {
   path: NodePath;
@@ -26,7 +27,9 @@ declare const extractBabelContentForComponents: (ast: t.File, fileCode: string,
   componentsNeedingHooks: Set<NodePath>;
   componentKeyMap: Map<t.Node, string>;
   componentPaths: NodePath[];
-  hookMap: Map<t.Node, "useIntlayer" | "getIntlayer">;
+  hookMap: Map<t.Node, 'useIntlayer' | 'getIntlayer'>;
+  /** Cached `getExistingIntlayerInfo` result per component node, so callers do not re-traverse. */
+  existingInfoByNode: Map<t.Node, ExistingIntlayerInfo | undefined>;
   isSolid: boolean;
 };
 /**

package/dist/types/extractContent/babelProcessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babelProcessor.d.ts","names":[],"sources":["../../../src/extractContent/babelProcessor.ts"],"mappings":";;;;;KAYY,gBAAA;EACV,IAAA,EAAM,QAAA;EACN,GAAA;EACA,IAAA;EAOA,YAAA;EACA,iBAAA,GAAoB,CAAA,CAAE,IAAA;EACtB,SAAA;AAAA;;;;;cAiFW,uBAAA,GACX,IAAA,EAAM,QAAA,CAAS,CAAA,CAAE,UAAA,GAAa,CAAA,CAAE,WAAA,GAChC,QAAA,UACA,YAAA,EAAc,GAAA,UACd,sBAAA,GAAyB,IAAA,EAAM,QAAA,aAC/B,gBAAA,EAAkB,MAAA,SAAe,MAAA,mBACjC,YAAA,EAAc,gBAAA,IACd,YAAA,EAAc,GAAA,CAAI,CAAA,CAAE,IAAA;;;;;cAwIT,gCAAA,GACX,GAAA,EAAK,CAAA,CAAE,IAAA,EACP,QAAA,UACA,YAAA,EAAc,GAAA,UACd,UAAA,UACA,aAAA,EAAe,cAAA,EACf,QAAA,UACA,oBAAA,GAAsB,MAAA;EAEtB,gBAAA,EAAkB,MAAA,SAAe,MAAA;EACjC,YAAA,EAAc,gBAAA;EACd,sBAAA,EAAwB,GAAA,CAAI,QAAA;EAC5B,eAAA,EAAiB,GAAA,CAAI,CAAA,CAAE,IAAA;EACvB,cAAA,EAAgB,QAAA;EAChB,OAAA,EAAS,GAAA,CAAI,CAAA,CAAE,IAAA;EACf,OAAA;AAAA;;;;cAicW,gBAAA,GACX,GAAA,EAAK,CAAA,CAAE,IAAA,EACP,QAAA,UACA,YAAA,EAAc,GAAA,UACd,aAAA,EAAe,cAAA,EACf,QAAA,UACA,oBAAA,GAAsB,MAAA;EAEtB,gBAAA,EAAkB,MAAA;EAClB,YAAA,EAAc,gBAAA;AAAA"}
+{"version":3,"file":"babelProcessor.d.ts","names":[],"sources":["../../../src/extractContent/babelProcessor.ts"],"mappings":";;;;;;KAaY;EACV,MAAM;EACN;EACA;EAOA;EACA,oBAAoB,EAAE;EACtB;;;;;;cA4IW,0BAAuB,MAC5B,SAAS,EAAE,aAAa,EAAE,cAAY,kBAC5B,cACF,aAAW,yBACA,MAAM,qBAAmB,kBAChC,eAAe,yBAAuB,cAC1C,oBAAkB,cAClB,IAAI,EAAE;;;;;cAwIT,mCAAgC,KACtC,EAAE,MAAI,kBACK,cACF,aAAW,oBACP,eACH,gBAAc,kBACb,uBACM;EAEtB,kBAAkB,eAAe;EACjC,cAAc;EACd,wBAAwB,IAAI;EAC5B,iBAAiB,IAAI,EAAE;EACvB,gBAAgB;EAChB,SAAS,IAAI,EAAE;;EAEf,oBAAoB,IAAI,EAAE,MAAM;EAChC;;;;;cA6ZW,mBAAgB,KACtB,EAAE,MAAI,kBACK,cACF,aAAW,eACV,gBAAc,kBACb,uBACM;EAEtB,kBAAkB;EAClB,cAAc"}

package/dist/types/extractContent/contentWriter.d.ts

@@ -1,6 +1,5 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary, DictionaryKey } from "@intlayer/types/dictionary";
-
 //#region src/extractContent/contentWriter.d.ts
 /**
  * Translation node structure used in dictionaries

package/dist/types/extractContent/contentWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contentWriter.d.ts","names":[],"sources":["../../../src/extractContent/contentWriter.ts"],"mappings":";;;;;;AAY4E;KA2BvE,eAAA;EACH,QAAA;EACA,WAAA,EAAa,MAAA;AAAA;;;;KAMV,oBAAA,GAAuB,MAAA,SAAe,eAAA;AANtB;;;;;AAmBrB;AAnBqB,cAmBR,uCAAA,GACX,gBAAA,EAAkB,MAAA,kBAClB,kBAAA,EAAoB,UAAA,SACpB,aAAA,aACC,oBAAA;;;;;;;cAkDU,oCAAA,GACX,gBAAA,EAAkB,MAAA,kBAClB,kBAAA,EAAoB,UAAA,YACnB,MAAA;;;;cA8CU,kBAAA,GACX,gBAAA,EAAkB,MAAA,kBAClB,aAAA,EAAe,aAAA,EACf,QAAA,UACA,aAAA,EAAe,cAAA,KACd,OAAA"}
+{"version":3,"file":"contentWriter.d.ts","names":[],"sources":["../../../src/extractContent/contentWriter.ts"],"mappings":";;;;;;KAmCK;EACH;EACA,aAAa;;;;;KAMV,uBAAuB,eAAe;;;;;;;cAa9B,0CAAuC,kBAChC,wBAAsB,oBACpB,mBAAiB,0BAEpC;;;;;;;cAkDU,uCAAoC,kBAC7B,wBAAsB,oBACpB,sBACnB;;;;cA8CU,qBAAkB,kBACX,wBAAsB,eACzB,eAAa,kBACZ,eACD,mBACd"}

package/dist/types/extractContent/extractContent.d.ts

@@ -1,7 +1,7 @@
 import { PackageName } from "./utils/constants.js";
+import "./utils/index.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { GetConfigurationOptions } from "@intlayer/config/node";
-
 //#region src/extractContent/extractContent.d.ts
 type ExtractIntlayerOptions = {
   configOptions?: GetConfigurationOptions;

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

@@ -1 +1 @@
-{"version":3,"file":"extractContent.d.ts","names":[],"sources":["../../../src/extractContent/extractContent.ts"],"mappings":";;;;;KA0BY,sBAAA;EACV,aAAA,GAAgB,uBAAA;EAChB,QAAA;EACA,eAAA;EACA,oBAAA,GAAuB,MAAA;EACvB,aAAA,GAAgB,cAAA;EAChB,IAAA;EACA,SAAA,IAAa,MAAA;IACX,GAAA;IACA,OAAA,EAAS,MAAA;IACT,QAAA;EAAA,aACW,OAAA;AAAA;AAAA,KAsRV,aAAA;EACH,eAAA;EACA,mBAAA,EAAqB,MAAA,SAAe,MAAA;AAAA;AAAA,cAmCzB,cAAA,GACX,QAAA,UACA,WAAA,EAAa,WAAA,EACb,OAAA,GAAU,sBAAA,KACT,OAAA,CAAQ,aAAA;;;;;;;;;;;cA8EE,kBAAA,GACX,QAAA,UACA,WAAA,EAAa,WAAA,EACb,OAAA,GAAU,sBAAA,KACT,aAAA"}
+{"version":3,"file":"extractContent.d.ts","names":[],"sources":["../../../src/extractContent/extractContent.ts"],"mappings":";;;;;KA0BY;EACV,gBAAgB;EAChB;EACA;EACA,uBAAuB;EACvB,gBAAgB;EAChB;EACA,aAAa;IACX;IACA,SAAS;IACT;eACW;;KAsRV;EACH;EACA,qBAAqB,eAAe;;cAmCzB,iBAAc,kBACT,aACH,aAAW,UACd,2BACT,QAAQ;;;;;;;;;;;cA8EE,qBAAkB,kBACb,aACH,aAAW,UACd,2BACT"}

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

@@ -1,9 +1,9 @@
 import { ATTRIBUTES_TO_EXTRACT, PackageName, SERVER_CAPABLE_PACKAGES, packageList } from "./utils/constants.js";
-import { mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, writeContentHelper } from "./contentWriter.js";
 import { detectPackageName } from "./utils/detectPackageName.js";
 import { ExtractDictionaryInfoOptions, ResolveContentFilePaths, extractDictionaryInfo, getOutput, resolveContentFilePaths } from "./utils/extractDictionaryInfo.js";
 import { extractDictionaryKey, extractDictionaryKeyFromPath } from "./utils/extractDictionaryKey.js";
 import { generateKey } from "./utils/generateKey.js";
 import { getComponentName } from "./utils/getComponentName.js";
+import { mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, writeContentHelper } from "./contentWriter.js";
 import { ExtractIntlayerOptions, extractContent, extractContentSync } from "./extractContent.js";
 export { ATTRIBUTES_TO_EXTRACT, ExtractDictionaryInfoOptions, ExtractIntlayerOptions, PackageName, ResolveContentFilePaths, SERVER_CAPABLE_PACKAGES, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, generateKey, getComponentName, getOutput, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, packageList, resolveContentFilePaths, writeContentHelper };

package/dist/types/extractContent/processTsxFile.d.ts

@@ -1,6 +1,6 @@
 import { PackageName } from "./utils/constants.js";
+import "./utils/index.js";
 import { IntlayerConfig } from "@intlayer/types/config";
-
 //#region src/extractContent/processTsxFile.d.ts
 type TextEdit = {
   start: number;

package/dist/types/extractContent/processTsxFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processTsxFile.d.ts","names":[],"sources":["../../../src/extractContent/processTsxFile.ts"],"mappings":";;;;KAeY,QAAA;EACV,KAAA;EACA,GAAA;EACA,WAAA;AAAA;;;;cA4BW,cAAA,GACX,QAAA,UACA,YAAA,UACA,WAAA,EAAa,WAAA,EACb,aAAA,EAAe,cAAA,EACf,IAAA,YACA,oBAAA,GAAsB,MAAA,mBACtB,gBAAA;EAEA,gBAAA,EAAkB,MAAA,SAAe,MAAA;EACjC,YAAA;AAAA"}
+{"version":3,"file":"processTsxFile.d.ts","names":[],"sources":["../../../src/extractContent/processTsxFile.ts"],"mappings":";;;;KAcY;EACV;EACA;EACA;;;;;cA4BW,iBAAc,kBACT,sBACI,aACP,aAAW,eACT,gBAAc,gBAChB,uBACS,yBAAuB;EAG7C,kBAAkB,eAAe;EACjC"}

package/dist/types/extractContent/utils/constants.d.ts

@@ -2,16 +2,16 @@
 /**
  * Attributes that should be extracted as translatable strings from JSX/HTML elements.
  * This is the single source of truth shared across all Intlayer compiler packages
- * (@intlayer/babel, @intlayer/vue-compiler, @intlayer/svelte-compiler, @intlayer/chokidar).
+ * (@intlayer/babel, @intlayer/vue-compiler, @intlayer/svelte-compiler, @intlayer/engine).
  */
-declare const ATTRIBUTES_TO_EXTRACT: readonly ["title", "placeholder", "alt", "aria-label", "label"];
+declare const ATTRIBUTES_TO_EXTRACT: readonly ['title', 'placeholder', 'alt', 'aria-label', 'label'];
 /**
  * The list of supported Intlayer integration packages.
  * This is the single source of truth for package name validation.
  *
  * Order matter for resolution
  */
-declare const packageList: readonly ["next-intlayer", "react-intlayer", "vue-intlayer", "svelte-intlayer", "preact-intlayer", "solid-intlayer", "angular-intlayer", "lit-intlayer", "express-intlayer", "hono-intlayer", "fastify-intlayer", "adonis-intlayer", "intlayer"];
+declare const packageList: readonly ['next-intlayer', 'react-intlayer', 'vue-intlayer', 'svelte-intlayer', 'preact-intlayer', 'solid-intlayer', 'angular-intlayer', 'lit-intlayer', 'express-intlayer', 'hono-intlayer', 'fastify-intlayer', 'adonis-intlayer', 'intlayer'];
 /** Packages that support a `/server` sub-path for React Server Components. */
 declare const SERVER_CAPABLE_PACKAGES: ReadonlySet<string>;
 type PackageName = (typeof packageList)[number];

package/dist/types/extractContent/utils/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../../src/extractContent/utils/constants.ts"],"mappings":";;AAKA;;;;cAAa,qBAAA;AAcb;;;;;AAiBA;AAjBA,cAAa,WAAA;;cAiBA,uBAAA,EAAyB,WAAA;AAAA,KAI1B,WAAA,WAAsB,WAAA"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../../src/extractContent/utils/constants.ts"],"mappings":";;;;;;cAKa;;;;;;;cAcA;;cAiBA,yBAAyB;KAI1B,sBAAsB"}

package/dist/types/extractContent/utils/detectPackageName.d.ts

@@ -1,5 +1,4 @@
 import { PackageName } from "./constants.js";
-
 //#region src/extractContent/utils/detectPackageName.d.ts
 /**
  * Detects which intlayer package is used in the project by reading package.json.

package/dist/types/extractContent/utils/detectPackageName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detectPackageName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/detectPackageName.ts"],"mappings":";;;;;AAOA;cAAa,iBAAA,GAAqB,SAAA,aAAoB,WAAA"}
+{"version":3,"file":"detectPackageName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/detectPackageName.ts"],"mappings":";;;;;cAOa,oBAAiB,sBAAwB"}

package/dist/types/extractContent/utils/extractDictionaryInfo.d.ts

@@ -1,7 +1,6 @@
 import { Locale } from "@intlayer/types/allLocales";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { FilePathPatternFunction } from "@intlayer/types/filePathPattern";
-
 //#region src/extractContent/utils/extractDictionaryInfo.d.ts
 declare const getOutput: (configuration: IntlayerConfig, locale?: Locale) => FilePathPatternFunction | false;
 type ResolveContentFilePaths = {

package/dist/types/extractContent/utils/extractDictionaryInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractDictionaryInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryInfo.ts"],"mappings":";;;;;cAmBa,SAAA,GACX,aAAA,EAAe,cAAA,EACf,MAAA,GAAS,MAAA,KACR,uBAAA;AAAA,KA0CS,uBAAA;EACV,YAAA;EACA,YAAA;EACA,WAAA;AAAA;;;;;cAOW,uBAAA,GACX,QAAA,UACA,YAAA,UACA,aAAA,EAAe,cAAA,EACf,MAAA,GAAS,MAAA,KACR,OAAA,CAAQ,uBAAA;AAAA,KA+GC,4BAAA;EACV,aAAA,GAAgB,cAAA;AAAA;;;;cAML,qBAAA,GACX,QAAA,UACA,QAAA,UACA,aAAA,EAAe,cAAA,KACd,OAAA;EAEC,aAAA;AAAA,IACE,uBAAA"}
+{"version":3,"file":"extractDictionaryInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryInfo.ts"],"mappings":";;;;cAmBa,YAAS,eACL,gBAAc,SACpB,WACR;KA0CS;EACV;EACA;EACA;;;;;;cAOW,0BAAuB,kBAClB,sBACI,eACL,gBAAc,SACpB,WACR,QAAQ;KA+GC;EACV,gBAAgB;;;;;cAML,wBAAqB,kBAChB,kBACA,eACD,mBACd;EAEC;IACE"}

package/dist/types/extractContent/utils/extractDictionaryKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryKey.ts"],"mappings":";;AASA;;;;cAAa,4BAAA,GACX,QAAA,UACA,MAAA;AAAA,cAiBW,oBAAA,GACX,QAAA,UACA,QAAA,UACA,MAAA"}
+{"version":3,"file":"extractDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryKey.ts"],"mappings":";;;;;;cASa,+BAA4B,kBACvB;cAkBL,uBAAoB,kBACf,kBACA"}

package/dist/types/extractContent/utils/generateKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/generateKey.ts"],"mappings":";cAAa,WAAA,GACX,IAAA,UACA,YAAA,EAAc,GAAA"}
+{"version":3,"file":"generateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/generateKey.ts"],"mappings":";cAAa,cAAW,cACV,cACE"}

package/dist/types/extractContent/utils/getComponentName.d.ts

@@ -1,5 +1,4 @@
 import { NodePath } from "@babel/traverse";
-
 //#region src/extractContent/utils/getComponentName.d.ts
 /**
  * Resolves the name of the component from various function declaration types.

package/dist/types/extractContent/utils/getComponentName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getComponentName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getComponentName.ts"],"mappings":";;;;;AAMA;cAAa,gBAAA,GAAoB,IAAA,EAAM,QAAA"}
+{"version":3,"file":"getComponentName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getComponentName.ts"],"mappings":";;;;;cAMa,mBAAgB,MAAU"}

package/dist/types/extractContent/utils/getExistingIntlayerInfo.d.ts

@@ -1,13 +1,16 @@
 import * as t from "@babel/types";
 import { NodePath } from "@babel/traverse";
-
 //#region src/extractContent/utils/getExistingIntlayerInfo.d.ts
 type ExistingIntlayerInfo = {
   key: string;
-  hook: 'useIntlayer' | 'getIntlayer'; /** The variable name used to store the call result (e.g. `t` in `const t = useIntlayer(...)`) */
-  variableName: string; /** True when the call result is destructured: `const { a, b } = getIntlayer(...)` */
-  isDestructured: boolean; /** Keys already present in the destructuring pattern (empty when not destructured) */
-  existingDestructuredKeys: string[]; /** The ObjectPattern AST node, present only when `isDestructured` is true */
+  hook: 'useIntlayer' | 'getIntlayer';
+  /** The variable name used to store the call result (e.g. `t` in `const t = useIntlayer(...)`) */
+  variableName: string;
+  /** True when the call result is destructured: `const { a, b } = getIntlayer(...)` */
+  isDestructured: boolean;
+  /** Keys already present in the destructuring pattern (empty when not destructured) */
+  existingDestructuredKeys: string[];
+  /** The ObjectPattern AST node, present only when `isDestructured` is true */
   objectPatternNode?: t.ObjectPattern;
 };
 /**

package/dist/types/extractContent/utils/getExistingIntlayerInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getExistingIntlayerInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getExistingIntlayerInfo.ts"],"mappings":";;;;KAGY,oBAAA;EACV,GAAA;EACA,IAAA,iCAF8B;EAI9B,YAAA,UAMmC;EAJnC,cAAA,WAJA;EAMA,wBAAA,YAFA;EAIA,iBAAA,GAAoB,CAAA,CAAE,aAAA;AAAA;;;;cAMX,uBAAA,GACX,IAAA,EAAM,QAAA,KACL,oBAAA"}
+{"version":3,"file":"getExistingIntlayerInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getExistingIntlayerInfo.ts"],"mappings":";;;KAGY;EACV;EACA;;EAEA;;EAEA;;EAEA;;EAEA,oBAAoB,EAAE;;;;;cAMX,0BAAuB,MAC5B,aACL"}

package/dist/types/extractContent/utils/getOrGenerateKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOrGenerateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getOrGenerateKey.ts"],"mappings":";;AAKA;;cAAa,gBAAA,GACX,IAAA,UACA,YAAA,UACA,YAAA,EAAc,GAAA,UACd,gBAAA,EAAkB,MAAA,SAAe,MAAA"}
+{"version":3,"file":"getOrGenerateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getOrGenerateKey.ts"],"mappings":";;;;cAKa,mBAAgB,cACf,sBACQ,cACN,aAAW,kBACP,eAAe"}

package/dist/types/extractContent/utils/resolveDictionaryKey.d.ts

@@ -1,5 +1,4 @@
 import { IntlayerConfig } from "@intlayer/types/config";
-
 //#region src/extractContent/utils/resolveDictionaryKey.d.ts
 /**
  * Resolves a unique dictionary key, checking for existing dictionaries and files.

package/dist/types/extractContent/utils/resolveDictionaryKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/resolveDictionaryKey.ts"],"mappings":";;;;;AAYA;;;cAAa,oBAAA,GACX,UAAA,UACA,QAAA,UACA,aAAA,EAAe,cAAA,EACf,oBAAA,GAAuB,MAAA,mBACvB,QAAA,GAAU,GAAA"}
+{"version":3,"file":"resolveDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/resolveDictionaryKey.ts"],"mappings":";;;;;;;cAYa,uBAAoB,oBACb,kBACF,eACD,gBAAc,uBACN,yBAAuB,WACpC"}

package/dist/types/extractContent/utils/shouldExtract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shouldExtract.d.ts","names":[],"sources":["../../../../src/extractContent/utils/shouldExtract.ts"],"mappings":";;AAUA;;;;;;;;;cAAa,aAAA,GAAiB,IAAA"}
+{"version":3,"file":"shouldExtract.d.ts","names":[],"sources":["../../../../src/extractContent/utils/shouldExtract.ts"],"mappings":";;;;;;;;;;;cAUa,gBAAa"}

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

@@ -1 +1 @@
-{"version":3,"file":"extractScriptBlocks.d.ts","names":[],"sources":["../../src/extractScriptBlocks.ts"],"mappings":";;AAWA;;;;;;;;KAAY,WAAA;EACV,OAAA;EACA,kBAAA;EACA,gBAAA;AAAA;;;;;;AAgIF;;;;;;;;;cAlCa,mBAAA,GACX,QAAA,UACA,IAAA,aACC,WAAA;;;;;;;;;;;cA+BU,kBAAA,GACX,YAAA,UACA,aAAA,EAAe,aAAA;EACb,KAAA,EAAO,WAAA;EACP,eAAA;AAAA"}
+{"version":3,"file":"extractScriptBlocks.d.ts","names":[],"sources":["../../src/extractScriptBlocks.ts"],"mappings":";;;;;;;;;;KAWY;EACV;EACA;EACA;;;;;;;;;;;;;;;;cA8FW,sBAAmB,kBACd,iBAEf;;;;;;;;;;;cA+BU,qBAAkB,sBACT,eACL;EACb,OAAO;EACP"}

package/dist/types/getExtractPluginOptions.d.ts

@@ -1,6 +1,5 @@
 import { ExtractPluginOptions } from "./babel-plugin-intlayer-extract.js";
 import { IntlayerConfig } from "@intlayer/types/config";
-
 //#region src/getExtractPluginOptions.d.ts
 /**
  * Mode of the compiler

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

@@ -1 +1 @@
-{"version":3,"file":"getExtractPluginOptions.d.ts","names":[],"sources":["../../src/getExtractPluginOptions.ts"],"mappings":";;;;;;AAcA;;;KAAY,YAAA;;AAOZ;;;;cAAa,uBAAA,GACX,aAAA,GAAe,cAAA,EACf,KAAA,GAAO,YAAA,0BACN,oBAAA"}
+{"version":3,"file":"getExtractPluginOptions.d.ts","names":[],"sources":["../../src/getExtractPluginOptions.ts"],"mappings":";;;;;;;;KAcY;;;;;;cAOC,0BAAuB,gBACnB,gBAAc,QACtB,sCACN"}

package/dist/types/getOptimizePluginOptions.d.ts

@@ -1,7 +1,6 @@
 import { OptimizePluginOptions } from "./babel-plugin-intlayer-optimize.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 import { GetConfigurationOptions } from "@intlayer/config/node";
-
 //#region src/getOptimizePluginOptions.d.ts
 type GetOptimizePluginOptionsParams = {
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"getOptimizePluginOptions.d.ts","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"mappings":";;;;;KAUK,8BAAA;;AAFyE;;EAM5E,aAAA,GAAgB,uBAAA;EAAA;;;EAIhB,YAAA,GAAe,UAAA;EAUI;;;;;EAJnB,QAAA;EAAA;;;EAIA,SAAA,GAAY,OAAA,CAAQ,qBAAA;AAAA;;AAyBtB;;;;cAAa,wBAAA,GACX,MAAA,GAAS,8BAAA,KACR,qBAAA"}
+{"version":3,"file":"getOptimizePluginOptions.d.ts","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"mappings":";;;;KAUK;;;;EAIH,gBAAgB;;;;EAIhB,eAAe;;;;;;EAMf;;;;EAIA,YAAY,QAAQ;;;;;;;cAyBT,2BAAwB,SAC1B,mCACR"}

package/dist/types/getPurgePluginOptions.d.ts

@@ -2,7 +2,6 @@ import { MinifyPluginOptions } from "./babel-plugin-intlayer-minify.js";
 import { PurgePluginOptions } from "./babel-plugin-intlayer-purge.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 import { GetConfigurationOptions } from "@intlayer/config/node";
-
 //#region src/getPurgePluginOptions.d.ts
 type GetPurgePluginOptionsParams = {
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"getPurgePluginOptions.d.ts","names":[],"sources":["../../src/getPurgePluginOptions.ts"],"mappings":";;;;;;KAkCK,2BAAA;;AAzBmE;;;;EA+BtE,aAAA,GAAgB,uBAAA;EAYI;;;;;EALpB,YAAA,GAAe,UAAA;EAAf;;;EAKA,SAAA,GAAY,OAAA,CAAQ,kBAAA;AAAA;;;AA0BtB;;;;;;;;;AA0CE;;;;;;;;;;;;cA1CW,qBAAA,GACX,MAAA,GAAS,2BAAA,KACR,kBAAA;AAAA,KA4CE,4BAAA;EASoC;AAwBzC;;EA7BE,aAAA,GAAgB,uBAAA;EA+CjB;;;EA1CC,SAAA,GAAY,OAAA,CAAQ,mBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;cAwBT,sBAAA,GACX,MAAA,GAAS,4BAAA,KACR,mBAAA"}
+{"version":3,"file":"getPurgePluginOptions.d.ts","names":[],"sources":["../../src/getPurgePluginOptions.ts"],"mappings":";;;;;KAkCK;;;;;;EAMH,gBAAgB;;;;;;EAOhB,eAAe;;;;EAKf,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,wBAAqB,SACvB,gCACR;KA4CE;;;;EAIH,gBAAgB;;;;EAKhB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;cAwBT,yBAAsB,SACxB,iCACR"}