@intlayer/engine 9.4.2 → 9.4.4

package/dist/types/scan/parseHtml.d.ts

@@ -8,26 +8,26 @@
  * tag can't be parsed it is simply skipped rather than throwing.
  */
 /** Compute the UTF-8 byte length of a string in both Node and browser builds. */
-declare const byteLength: (text: string) => number;
+export declare const byteLength: (text: string) => number;
 /** Extract the `lang` attribute of the `<html>` element, if present. */
-declare const extractHtmlLang: (html: string) => string | undefined;
+export declare const extractHtmlLang: (html: string) => string | undefined;
 /** Extract the `dir` attribute of the `<html>` element, if present. */
-declare const extractHtmlDir: (html: string) => string | undefined;
+export declare const extractHtmlDir: (html: string) => string | undefined;
 /** Extract the document `<title>` text. */
-declare const extractTitle: (html: string) => string;
+export declare const extractTitle: (html: string) => string;
 /** Extract the `<meta name="description">` content. */
-declare const extractMetaDescription: (html: string) => string;
+export declare const extractMetaDescription: (html: string) => string;
 /** Extract the `<meta property="og:image">` content. */
-declare const extractOgImage: (html: string) => string | undefined;
+export declare const extractOgImage: (html: string) => string | undefined;
 /** Whether a `<link rel="canonical">` element is present. */
-declare const hasCanonical: (html: string) => boolean;
+export declare const hasCanonical: (html: string) => boolean;
 /** A parsed `<link rel="alternate" hreflang>` element. */
-type HreflangLink = {
+export type HreflangLink = {
   hreflang: string;
   href: string;
 };
 /** Extract every `<link rel="alternate" hreflang="…" href="…">` element. */
-declare const extractHreflangs: (html: string) => HreflangLink[];
+export declare const extractHreflangs: (html: string) => HreflangLink[];
 /**
  * Extract every eagerly-loaded script URL: `<script src>`,
  * `<link rel="modulepreload">` and `<link rel="preload" as="script">`.
@@ -36,19 +36,18 @@ declare const extractHreflangs: (html: string) => HreflangLink[];
  * @param baseUrl - Base URL used to resolve relative script URLs.
  * @returns Absolute, de-duplicated script URLs.
  */
-declare const extractScriptUrls: (html: string, baseUrl: string) => string[];
+export declare const extractScriptUrls: (html: string, baseUrl: string) => string[];
 /** A parsed `<a href>` anchor. */
-type Anchor = {
+export type Anchor = {
   href: string;
   text: string;
 };
 /** Extract every `<a href="…">text</a>` anchor from the document. */
-declare const extractAnchors: (html: string) => Anchor[];
+export declare const extractAnchors: (html: string) => Anchor[];
 /**
  * Extract visible text snippets from an HTML document (scripts, styles and
  * tags stripped). Used to approximate the rendered content size without a DOM.
  */
-declare const extractVisibleTextStrings: (html: string) => string[];
+export declare const extractVisibleTextStrings: (html: string) => string[];
 //#endregion
-export { Anchor, HreflangLink, byteLength, extractAnchors, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractScriptUrls, extractTitle, extractVisibleTextStrings, hasCanonical };
 //# sourceMappingURL=parseHtml.d.ts.map

package/dist/types/scan/parseHtml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseHtml.d.ts","names":[],"sources":["../../../src/scan/parseHtml.ts"],"mappings":";;;;;;;;;;cAUa,aAAU;;cAkBV,kBAAe;;cAMf,iBAAc;;cAMd,eAAY;;cAMZ,yBAAsB;;cAWtB,iBAAc;;cAWd,eAAY;;KAMb;EAAiB;EAAkB;;;cAGlC,mBAAgB,iBAAmB;;;;;;;;;cAoBnC,oBAAiB,cAAgB;;KA4BlC;EAAW;EAAc;;;cAGxB,iBAAc,iBAAmB;;;;;cAsBjC,4BAAyB"}
+{"version":3,"file":"parseHtml.d.ts","names":[],"sources":["../../../src/scan/parseHtml.ts"],"mappings":";;;;;;;;;;qBAUa,aAAU;;qBAkBV,kBAAe;;qBAMf,iBAAc;;qBAMd,eAAY;;qBAMZ,yBAAsB;;qBAWtB,iBAAc;;qBAWd,eAAY;;YAMb;EAAiB;EAAkB;;;qBAGlC,mBAAgB,iBAAmB;;;;;;;;;qBAoBnC,oBAAiB,cAAgB;;YA4BlC;EAAW;EAAc;;;qBAGxB,iBAAc,iBAAmB;;;;;qBAsBjC,4BAAyB"}

package/dist/types/scan/scanWebsite.d.ts

@@ -11,7 +11,6 @@ import { ScanOptions, ScanResult } from "./types.js";
  * @param options - {@link ScanOptions} controlling depth, timeout and UA.
  * @returns The {@link ScanResult} including score, page size and per-check events.
  */
-declare const scanWebsite: (targetUrl: string, options?: ScanOptions) => Promise<ScanResult>;
+export declare const scanWebsite: (targetUrl: string, options?: ScanOptions) => Promise<ScanResult>;
 //#endregion
-export { scanWebsite };
 //# sourceMappingURL=scanWebsite.d.ts.map

package/dist/types/scan/scanWebsite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scanWebsite.d.ts","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"mappings":";;;;;;;;;;;;;cAmNa,cAAW,mBACL,UACR,gBACR,QAAQ"}
+{"version":3,"file":"scanWebsite.d.ts","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"mappings":";;;;;;;;;;;;;qBAmNa,cAAW,mBACL,UACR,gBACR,QAAQ"}

package/dist/types/scan/types.d.ts

@@ -1,9 +1,9 @@
 import { Score } from "./calculateScore.js";
 //#region src/scan/types.d.ts
 /** Status of an individual scan check. */
-type ScanCheckStatus = 'success' | 'warning' | 'error';
+export type ScanCheckStatus = 'success' | 'warning' | 'error';
 /** Per-status human-readable details attached to a {@link ScanEvent}. */
-type ScanEventDetails = {
+export type ScanEventDetails = {
   success?: unknown;
   warning?: unknown;
   error?: unknown;
@@ -12,22 +12,22 @@ type ScanEventDetails = {
  * A single check produced while scanning a page. The `type` matches a key of
  * the score table (optionally suffixed with the URL for URL-scoped checks).
  */
-type ScanEvent = {
+export type ScanEvent = {
   type: string;
   status: ScanCheckStatus;
   details?: ScanEventDetails;
 };
 /** How the scan was performed. */
-type ScanMode = 'basic' | 'deep';
+export type ScanMode = 'basic' | 'deep';
 /** A single JavaScript chunk fetched while scanning. */
-type BundleChunkInput = {
+export type BundleChunkInput = {
   url: string;
   /** Whether the chunk is eagerly loaded on the initial page load. */
   isMainBundle: boolean;
   content: string;
 };
 /** Locale-weight analysis of a single bundle chunk. */
-type ChunkAnalysis = {
+export type ChunkAnalysis = {
   url: string;
   fileSize: number;
   totalLocaleSize: number;
@@ -38,7 +38,7 @@ type ChunkAnalysis = {
   unusedPercent: number;
 };
 /** Aggregated locale-weight analysis across every fetched chunk. */
-type BundleContentAnalysis = {
+export type BundleContentAnalysis = {
   currentLocale: string;
   totalPageSize: number;
   renderedContentSize: number;
@@ -54,7 +54,7 @@ type BundleContentAnalysis = {
   lazyBundleChunks: ChunkAnalysis[];
 };
 /** Options controlling how a website is scanned. */
-type ScanOptions = {
+export type ScanOptions = {
   /**
    * Attempt a deeper, render-based scan using a locally installed `puppeteer`.
    * When `puppeteer` is not installed, the scan transparently falls back to the
@@ -67,7 +67,7 @@ type ScanOptions = {
   userAgent?: string;
 };
 /** Result of scanning a single page. */
-type ScanResult = {
+export type ScanResult = {
   url: string;
   /** Whether the scan ran in `basic` or `deep` mode. */
   mode: ScanMode;
@@ -87,5 +87,4 @@ type ScanResult = {
   bundle?: BundleContentAnalysis;
 };
 //#endregion
-export { BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/scan/types.ts"],"mappings":";;;KAGY;;KAGA;EACV;EACA;EACA;;;;;;KAOU;EACV;EACA,QAAQ;EACR,UAAU;;;KAIA;;KAGA;EACV;;EAEA;EACA;;;KAIU;EACV;EACA;EACA;EACA;EACA;EACA;;EAEA;;;KAIU;EACV;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,kBAAkB;EAClB,kBAAkB;;;KAIR;;;;;;EAMV;;EAEA;;EAEA;;;KAIU;EACV;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA,UAAU;;EAEV,QAAQ;;EAER;;EAEA,SAAS"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/scan/types.ts"],"mappings":";;;YAGY;;YAGA;EACV;EACA;EACA;;;;;;YAOU;EACV;EACA,QAAQ;EACR,UAAU;;;YAIA;;YAGA;EACV;;EAEA;EACA;;;YAIU;EACV;EACA;EACA;EACA;EACA;EACA;;EAEA;;;YAIU;EACV;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,kBAAkB;EAClB,kBAAkB;;;YAIR;;;;;;EAMV;;EAEA;;EAEA;;;YAIU;EACV;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA,UAAU;;EAEV,QAAQ;;EAER;;EAEA,SAAS"}

package/dist/types/syncPluginKit/createFileAdapter.d.ts

@@ -9,8 +9,8 @@ import { FilePathPattern } from "@intlayer/types/filePathPattern";
  * - `inclusive`: keep every glob match without fabricating missing entries
  *   (read-only load plugins, whose patterns may contain free `**` globs).
  */
-type FileAdapterDiscovery = 'strict' | 'inclusive';
-type CreateFileAdapterOptions = {
+export type FileAdapterDiscovery = 'strict' | 'inclusive';
+export type CreateFileAdapterOptions = {
   /**
    * Location of the files, as a static string, a templated string
    * (e.g. `./messages/{{locale}}/{{key}}.json`) or a function building the
@@ -39,12 +39,11 @@ type CreateFileAdapterOptions = {
  * Handles glob discovery of the source pattern, key/locale extraction from
  * paths, base-directory resolution, and change-detected atomic writes.
  */
-declare const createFileAdapter: (options: CreateFileAdapterOptions) => ContentAdapter;
+export declare const createFileAdapter: (options: CreateFileAdapterOptions) => ContentAdapter;
 /**
  * Default `readEntry` implementation: plain utf-8 read followed by the given
  * parser. Returns `undefined` for missing or unreadable files.
  */
-declare const createFileReader: (parse: (raw: string) => SyncContent) => (absoluteFilePath: string) => Promise<SyncContent | undefined>;
+export declare const createFileReader: (parse: (raw: string) => SyncContent) => (absoluteFilePath: string) => Promise<SyncContent | undefined>;
 //#endregion
-export { CreateFileAdapterOptions, FileAdapterDiscovery, createFileAdapter, createFileReader };
 //# sourceMappingURL=createFileAdapter.d.ts.map

package/dist/types/syncPluginKit/createFileAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createFileAdapter.d.ts","names":[],"sources":["../../../src/syncPluginKit/createFileAdapter.ts"],"mappings":";;;;;;;;;;;KAyBY;KAEA;;;;;;EAMV,QAAQ;;;;EAKR,OAAO;;;;;;;EAQP,aACE,0BACA,SAAS,sBACN,QAAQ;;;;EAKb,YAAY;;;;;;;;cAYD,oBAAiB,SACnB,6BACR;;;;;cAwNU,mBAAgB,QAClB,gBAAgB,iBAAW,6BACF,QAAQ"}
+{"version":3,"file":"createFileAdapter.d.ts","names":[],"sources":["../../../src/syncPluginKit/createFileAdapter.ts"],"mappings":";;;;;;;;;;;YAyBY;YAEA;;;;;;EAMV,QAAQ;;;;EAKR,OAAO;;;;;;;EAQP,aACE,0BACA,SAAS,sBACN,QAAQ;;;;EAKb,YAAY;;;;;;;;qBAYD,oBAAiB,SACnB,6BACR;;;;;qBAwNU,mBAAgB,QAClB,gBAAgB,iBAAW,6BACF,QAAQ"}

package/dist/types/syncPluginKit/createSyncPlugin.d.ts

@@ -11,7 +11,6 @@ import { Plugin } from "@intlayer/types/plugin";
  * payload format. Write-back only processes dictionaries whose `location`
  * matches this plugin instance, so adapters never see foreign content.
  */
-declare const createSyncPlugin: (options: CreateSyncPluginOptions) => Plugin;
+export declare const createSyncPlugin: (options: CreateSyncPluginOptions) => Plugin;
 //#endregion
-export { createSyncPlugin };
 //# sourceMappingURL=createSyncPlugin.d.ts.map

package/dist/types/syncPluginKit/createSyncPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createSyncPlugin.d.ts","names":[],"sources":["../../../src/syncPluginKit/createSyncPlugin.ts"],"mappings":";;;;;;;;;;;;;cAuCa,mBAAgB,SAAa,4BAA0B"}
+{"version":3,"file":"createSyncPlugin.d.ts","names":[],"sources":["../../../src/syncPluginKit/createSyncPlugin.ts"],"mappings":";;;;;;;;;;;;;qBAuCa,mBAAgB,SAAa,4BAA0B"}

package/dist/types/syncPluginKit/extractKeyAndLocaleFromPath.d.ts

@@ -10,10 +10,9 @@ import { Locale } from "@intlayer/types/allLocales";
  * Missing placeholders fall back to `'index'` for the key and to
  * `defaultLocale` for the locale.
  */
-declare const extractKeyAndLocaleFromPath: (filePath: string, maskPattern: string, locales: Locale[], defaultLocale: Locale) => {
+export declare const extractKeyAndLocaleFromPath: (filePath: string, maskPattern: string, locales: Locale[], defaultLocale: Locale) => {
   key: string;
   locale: Locale;
 } | null;
 //#endregion
-export { extractKeyAndLocaleFromPath };
 //# sourceMappingURL=extractKeyAndLocaleFromPath.d.ts.map

package/dist/types/syncPluginKit/extractKeyAndLocaleFromPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractKeyAndLocaleFromPath.d.ts","names":[],"sources":["../../../src/syncPluginKit/extractKeyAndLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;cAea,8BAA2B,kBACtB,qBACG,SACV,UAAQ,eACF;EACZ;EAAa,QAAQ"}
+{"version":3,"file":"extractKeyAndLocaleFromPath.d.ts","names":[],"sources":["../../../src/syncPluginKit/extractKeyAndLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;qBAea,8BAA2B,kBACtB,qBACG,SACV,UAAQ,eACF;EACZ;EAAa,QAAQ"}

package/dist/types/syncPluginKit/filePathPatternHelpers.d.ts

@@ -9,7 +9,6 @@ import { FilePathPatternContext } from "@intlayer/types/filePathPattern";
  * patterns never reference them, so this single cast keeps the partial
  * context in one audited place instead of scattering `as any` at call sites.
  */
-declare const buildFilePathPatternContext: (key: string, locale?: string) => FilePathPatternContext;
+export declare const buildFilePathPatternContext: (key: string, locale?: string) => FilePathPatternContext;
 //#endregion
-export { buildFilePathPatternContext };
 //# sourceMappingURL=filePathPatternHelpers.d.ts.map

package/dist/types/syncPluginKit/filePathPatternHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filePathPatternHelpers.d.ts","names":[],"sources":["../../../src/syncPluginKit/filePathPatternHelpers.ts"],"mappings":";;;;;;;;;;;cAWa,8BAA2B,aAC3B,oBAEV"}
+{"version":3,"file":"filePathPatternHelpers.d.ts","names":[],"sources":["../../../src/syncPluginKit/filePathPatternHelpers.ts"],"mappings":";;;;;;;;;;;qBAWa,8BAA2B,aAC3B,oBAEV"}

package/dist/types/syncPluginKit/types.d.ts

@@ -5,17 +5,17 @@ import { Locale } from "@intlayer/types/allLocales";
 /**
  * Structured dictionary content handled by sync plugins.
  */
-type SyncContent = Record<string, unknown>;
+export type SyncContent = Record<string, unknown>;
 /**
  * Context handed to every {@link ContentAdapter} call.
  */
-type SyncPluginContext = {
+export type SyncPluginContext = {
   configuration: IntlayerConfig;
 };
 /**
  * One translatable resource discovered in the external system.
  */
-type ContentEntry = {
+export type ContentEntry = {
   /** Dictionary key the entry maps to. */
   key: string;
   /** Locale of the entry content. */
@@ -35,7 +35,7 @@ type ContentEntry = {
 /**
  * Identifies where content must be written back by a {@link ContentAdapter}.
  */
-type ContentTarget = {
+export type ContentTarget = {
   key: string;
   locale: Locale;
 };
@@ -45,7 +45,7 @@ type ContentTarget = {
  * CMS…). Format concerns belong to {@link FormatCodec}, orchestration to
  * `createSyncPlugin`.
  */
-type ContentAdapter = {
+export type ContentAdapter = {
   /**
    * Enumerate every entry available in the external system.
    */
@@ -90,7 +90,7 @@ type ContentAdapter = {
  * Format layer of a sync plugin: how a raw string payload maps to structured
  * dictionary content and back (JSON, PO, XLIFF…).
  */
-type FormatCodec = {
+export type FormatCodec = {
   /**
    * Parse a raw payload into dictionary content.
    * May throw on malformed payloads — callers treat a throw as empty content.
@@ -108,11 +108,11 @@ type FormatCodec = {
  * - `pull`: only ingest external content as dictionaries (read-only).
  * - `both`: ingest and write the merged build output back to the source.
  */
-type SyncDirection = 'pull' | 'both';
+export type SyncDirection = 'pull' | 'both';
 /**
  * Options of `createSyncPlugin`.
  */
-type CreateSyncPluginOptions = {
+export type CreateSyncPluginOptions = {
   /** Plugin name reported to the Intlayer engine (e.g. `sync-json`). */
   name: string;
   /** Transport used to enumerate, read and write entries. */
@@ -149,5 +149,4 @@ type CreateSyncPluginOptions = {
   localeOverride?: Locale;
 };
 //#endregion
-export { ContentAdapter, ContentEntry, ContentTarget, CreateSyncPluginOptions, FormatCodec, SyncContent, SyncDirection, SyncPluginContext };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/syncPluginKit/types.ts"],"mappings":";;;;;;;KAOY,cAAc;;;;KAKd;EACV,eAAe;;;;;KAML;;EAEV;;EAEA,QAAQ;;;;;EAKR;;;;;;EAMA;;;;;KAMU;EACV;EACA,QAAQ;;;;;;;;KASE;;;;EAIV,OAAO,SAAS,sBAAsB,QAAQ;;;;;;EAO9C,OACE,OAAO,cACP,SAAS,sBACN,QAAQ;;;;;EAMb,QACE,QAAQ,eACR,SAAS,aACT,SAAS,sBACN;;;;;;;EAQL,cACE,QAAQ,eACR,SAAS,sBACN;;;;;;EAOL,kBAAkB,SAAS,sBAAsB;;;;;EAMjD,kBAAkB,SAAS,sBAAsB;;;;;;EAOjD,wBAAwB;;;;;;KAOd;;;;;EAKV,QAAQ,gBAAgB;;;;EAKxB,YAAY,SAAS,aAAa;IAAW,QAAQ;;;;;;;;KAQ3C;;;;KAKA;;EAEV;;EAGA,SAAS;;;;;EAMT,YAAY;;;;;;EAOZ;;;;;EAMA;;EAGA,SAAS;;;;;;;EAQT;;;;;EAMA,iBAAiB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/syncPluginKit/types.ts"],"mappings":";;;;;;;YAOY,cAAc;;;;YAKd;EACV,eAAe;;;;;YAML;;EAEV;;EAEA,QAAQ;;;;;EAKR;;;;;;EAMA;;;;;YAMU;EACV;EACA,QAAQ;;;;;;;;YASE;;;;EAIV,OAAO,SAAS,sBAAsB,QAAQ;;;;;;EAO9C,OACE,OAAO,cACP,SAAS,sBACN,QAAQ;;;;;EAMb,QACE,QAAQ,eACR,SAAS,aACT,SAAS,sBACN;;;;;;;EAQL,cACE,QAAQ,eACR,SAAS,sBACN;;;;;;EAOL,kBAAkB,SAAS,sBAAsB;;;;;EAMjD,kBAAkB,SAAS,sBAAsB;;;;;;EAOjD,wBAAwB;;;;;;YAOd;;;;;EAKV,QAAQ,gBAAgB;;;;EAKxB,YAAY,SAAS,aAAa;IAAW,QAAQ;;;;;;;;YAQ3C;;;;YAKA;;EAEV;;EAGA,SAAS;;;;;EAMT,YAAY;;;;;;EAOZ;;;;;EAMA;;EAGA,SAAS;;;;;;;EAQT;;;;;EAMA,iBAAiB"}

package/dist/types/utils/autoDecorateContent.d.ts

@@ -7,7 +7,6 @@ type AutoTransformationOptions = {
 /**
  * Automatically decorate content strings with md() or insert() if they match
  */
-declare const autoDecorateContent: (content: any, options?: boolean | AutoTransformationOptions) => any;
+export declare const autoDecorateContent: (content: any, options?: boolean | AutoTransformationOptions) => any;
 //#endregion
-export { autoDecorateContent };
 //# sourceMappingURL=autoDecorateContent.d.ts.map

package/dist/types/utils/autoDecorateContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoDecorateContent.d.ts","names":[],"sources":["../../../src/utils/autoDecorateContent.ts"],"mappings":";KAwEK;EACH;EACA;EACA;;;;;cAMW,sBAAmB,cAClB,oBACO"}
+{"version":3,"file":"autoDecorateContent.d.ts","names":[],"sources":["../../../src/utils/autoDecorateContent.ts"],"mappings":";KAwEK;EACH;EACA;EACA;;;;;qBAMW,sBAAmB,cAClB,oBACO"}

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

@@ -1,9 +1,9 @@
 import { RecastParser } from "@intlayer/babel/babelParser";
 //#region src/utils/babelParser.d.ts
 /** Drop-in replacement for `recast/parsers/typescript` (TS without JSX). */
-declare const typescriptParser: RecastParser;
+export declare const typescriptParser: RecastParser;
 /** Drop-in replacement for `recast/parsers/babel-ts` (TS *and* JSX). */
-declare const babelTsParser: RecastParser;
+export declare const babelTsParser: RecastParser;
 //#endregion
-export { type RecastParser, babelTsParser, typescriptParser };
+export type { RecastParser };
 //# sourceMappingURL=babelParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"babelParser.d.ts","names":[],"sources":["../../../src/utils/babelParser.ts"],"mappings":";;;cA6Da,kBAAkB;;cAKlB,eAAe"}
+{"version":3,"file":"babelParser.d.ts","names":[],"sources":["../../../src/utils/babelParser.ts"],"mappings":";;;qBA6Da,kBAAkB;;qBAKlB,eAAe"}

package/dist/types/utils/buildComponentFilesList.d.ts

@@ -21,7 +21,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * // intlayer.config.ts: { content: { codeDir: ['node_modules/my-ds/src'] } }
  * const files = buildComponentFilesList(config);
  */
-declare const buildComponentFilesList: (config: IntlayerConfig, excludePattern?: string[]) => string[];
+export declare const buildComponentFilesList: (config: IntlayerConfig, excludePattern?: string[]) => string[];
 //#endregion
-export { buildComponentFilesList };
 //# sourceMappingURL=buildComponentFilesList.d.ts.map

package/dist/types/utils/buildComponentFilesList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildComponentFilesList.d.ts","names":[],"sources":["../../../src/utils/buildComponentFilesList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cAqEa,0BAAuB,QAC1B,gBAAc"}
+{"version":3,"file":"buildComponentFilesList.d.ts","names":[],"sources":["../../../src/utils/buildComponentFilesList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBAqEa,0BAAuB,QAC1B,gBAAc"}

package/dist/types/utils/buildFilesList.d.ts

@@ -3,7 +3,7 @@ import { IntlayerConfig } from "@intlayer/types/config";
 /**
  * Options for building the files list
  */
-type BuildComponentFilesListOptions = {
+export type BuildComponentFilesListOptions = {
   /**
    * Glob patterns to match files
    */
@@ -46,7 +46,7 @@ type BuildComponentFilesListOptions = {
  *   dot: true,
  * });
  */
-declare const buildComponentFilesList: (config: BuildComponentFilesListOptions) => string[];
+export declare const buildComponentFilesList: (config: BuildComponentFilesListOptions) => string[];
 /**
  * Convenience wrapper that derives all file-list options directly from an
  * `IntlayerConfig` object.
@@ -55,7 +55,6 @@ declare const buildComponentFilesList: (config: BuildComponentFilesListOptions)
  * content declaration file extensions and any `compiler.excludePattern`
  * entries defined in the configuration, and includes dot files.
  */
-declare const buildComponentFilesListFromConfig: (intlayerConfig: IntlayerConfig) => string[];
+export declare const buildComponentFilesListFromConfig: (intlayerConfig: IntlayerConfig) => string[];
 //#endregion
-export { BuildComponentFilesListOptions, buildComponentFilesList, buildComponentFilesListFromConfig };
 //# sourceMappingURL=buildFilesList.d.ts.map

package/dist/types/utils/buildFilesList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildFilesList.d.ts","names":[],"sources":["../../../src/utils/buildFilesList.ts"],"mappings":";;;;;KAOY;;;;EAIV;;;;EAIA;;;;;;EAMA;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;cAmDW,0BAAuB,QAC1B;;;;;;;;;cAqDG,oCAAiC,gBAC5B"}
+{"version":3,"file":"buildFilesList.d.ts","names":[],"sources":["../../../src/utils/buildFilesList.ts"],"mappings":";;;;;YAOY;;;;EAIV;;;;EAIA;;;;;;EAMA;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDW,0BAAuB,QAC1B;;;;;;;;;qBAqDG,oCAAiC,gBAC5B"}

package/dist/types/utils/chunkArray.d.ts

@@ -10,7 +10,6 @@
  * chunkArray(['a', 'b', 'c', 'd', 'e'], 2); // [['a', 'b'], ['c', 'd'], ['e']]
  * ```
  */
-declare const chunkArray: <T>(items: T[], chunkSize: number) => T[][];
+export declare const chunkArray: <T>(items: T[], chunkSize: number) => T[][];
 //#endregion
-export { chunkArray };
 //# sourceMappingURL=chunkArray.d.ts.map

package/dist/types/utils/chunkArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunkArray.d.ts","names":[],"sources":["../../../src/utils/chunkArray.ts"],"mappings":";;;;;;;;;;;;cAWa,aAAc,GAAC,OAAS,KAAG,sBAAsB"}
+{"version":3,"file":"chunkArray.d.ts","names":[],"sources":["../../../src/utils/chunkArray.ts"],"mappings":";;;;;;;;;;;;qBAWa,aAAc,GAAC,OAAS,KAAG,sBAAsB"}

package/dist/types/utils/chunkJSON.d.ts

@@ -8,7 +8,7 @@
  */
 type JSONPrimitive = string | number | boolean | null;
 type JSONValue = JSONPrimitive | JSONObject | JSONArray;
-type JSONObject = {
+export type JSONObject = {
   [k: string]: JSONValue;
 };
 type JSONArray = JSONValue[];
@@ -27,7 +27,7 @@ type StrAppendPatch = {
 };
 type Patch = SetPatch | StrAppendPatch;
 type RootType = 'object' | 'array';
-type JsonChunk = {
+export type JsonChunk = {
   schemaVersion: 1;
   index: number;
   total: number;
@@ -38,7 +38,7 @@ type JsonChunk = {
 /**
  * Split JSON into chunks constrained by character count of serialized chunk.
  */
-declare const chunkJSON: (value: JSONObject | JSONArray, maxChars: number) => JsonChunk[];
+export declare const chunkJSON: (value: JSONObject | JSONArray, maxChars: number) => JsonChunk[];
 /**
  * Reassemble JSON from chunks.
  * - Validates checksums and indices.
@@ -49,8 +49,7 @@ declare const chunkJSON: (value: JSONObject | JSONArray, maxChars: number) => Js
  * Useful for processing individual chunks in a pipeline where you don't have all chunks yet.
  * Note: This will only reconstruct the partial content contained in this chunk.
  */
-declare const reconstructFromSingleChunk: (chunk: JsonChunk) => JSONObject | JSONArray;
-declare const assembleJSON: (chunks: JsonChunk[]) => JSONObject | JSONArray;
+export declare const reconstructFromSingleChunk: (chunk: JsonChunk) => JSONObject | JSONArray;
+export declare const assembleJSON: (chunks: JsonChunk[]) => JSONObject | JSONArray;
 //#endregion
-export { JSONObject, JsonChunk, assembleJSON, chunkJSON, reconstructFromSingleChunk };
 //# sourceMappingURL=chunkJSON.d.ts.map

package/dist/types/utils/chunkJSON.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunkJSON.d.ts","names":[],"sources":["../../../src/utils/chunkJSON.ts"],"mappings":";;;;;;;;KAUK;KACA,YAAY,gBAAgB,aAAa;KAElC;GACT,YAAY;;KAGV,YAAY;KAEZ,OAAO;KAEP;EAAa;EAAW,MAAM;EAAM,OAAO;;KAC3C;EACH;EACA,MAAM;EACN;EACA;EACA;;KAEG,QAAQ,WAAW;KAEnB;KAEO;EACV;EACA;EACA;EACA,UAAU;EACV;EACA,SAAS;;;;;cAiME,YAAS,OACb,aAAa,WAAS,qBAE5B;;;;;;;;;;;cAsHU,6BAA0B,OAC9B,cACN,aAAa;cAiGH,eAAY,QAAY,gBAAc,aAAa"}
+{"version":3,"file":"chunkJSON.d.ts","names":[],"sources":["../../../src/utils/chunkJSON.ts"],"mappings":";;;;;;;;KAUK;KACA,YAAY,gBAAgB,aAAa;YAElC;GACT,YAAY;;KAGV,YAAY;KAEZ,OAAO;KAEP;EAAa;EAAW,MAAM;EAAM,OAAO;;KAC3C;EACH;EACA,MAAM;EACN;EACA;EACA;;KAEG,QAAQ,WAAW;KAEnB;YAEO;EACV;EACA;EACA;EACA,UAAU;EACV;EACA,SAAS;;;;;qBAiME,YAAS,OACb,aAAa,WAAS,qBAE5B;;;;;;;;;;;qBAsHU,6BAA0B,OAC9B,cACN,aAAa;qBAiGH,eAAY,QAAY,gBAAc,aAAa"}

package/dist/types/utils/formatter.d.ts

@@ -1,8 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { ANSIColorsType } from "@intlayer/config/logger";
 //#region src/utils/formatter.d.ts
-declare const formatPath: (path: string | string[], color?: ANSIColorsType | false) => string;
-declare const formatLocale: (locale: LocalesValues | LocalesValues[], color?: ANSIColorsType | false) => string;
+export declare const formatPath: (path: string | string[], color?: ANSIColorsType | false) => string;
+export declare const formatLocale: (locale: LocalesValues | LocalesValues[], color?: ANSIColorsType | false) => string;
 //#endregion
-export { formatLocale, formatPath };
 //# sourceMappingURL=formatter.d.ts.map

package/dist/types/utils/formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","names":[],"sources":["../../../src/utils/formatter.ts"],"mappings":";;;cAYa,aAAU,yBACE,QACf;cAYG,eAAY,QACf,gBAAgB,iBAAe,QAChC"}
+{"version":3,"file":"formatter.d.ts","names":[],"sources":["../../../src/utils/formatter.ts"],"mappings":";;;qBAYa,aAAU,yBACE,QACf;qBAYG,eAAY,QACf,gBAAgB,iBAAe,QAChC"}

package/dist/types/utils/getChunk.d.ts

@@ -5,7 +5,6 @@ type TrunkOptions = {
   charStart?: number;
   charLength?: number;
 };
-declare const getChunk: (text: string, options?: TrunkOptions) => string;
+export declare const getChunk: (text: string, options?: TrunkOptions) => string;
 //#endregion
-export { getChunk };
 //# sourceMappingURL=getChunk.d.ts.map

package/dist/types/utils/getChunk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getChunk.d.ts","names":[],"sources":["../../../src/utils/getChunk.ts"],"mappings":";KAEK;EACH;EACA;EACA;EACA;;cAGW,WAAQ,cAAgB,UAAW"}
+{"version":3,"file":"getChunk.d.ts","names":[],"sources":["../../../src/utils/getChunk.ts"],"mappings":";KAEK;EACH;EACA;EACA;EACA;;qBAGW,WAAQ,cAAgB,UAAW"}

package/dist/types/utils/getContentExtension.d.ts

@@ -8,7 +8,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * format 'ts' -> '.content.ts'
  * format 'esm' -> '.content.js' (if matching .content.js is found in config)
  */
-declare const getContentExtension: (format: 'ts' | 'esm' | 'cjs' | 'json' | 'jsonc' | 'json5' | (string & {}), configuration: IntlayerConfig) => string;
+export declare const getContentExtension: (format: 'ts' | 'esm' | 'cjs' | 'json' | 'jsonc' | 'json5' | (string & {}), configuration: IntlayerConfig) => string;
 //#endregion
-export { getContentExtension };
 //# sourceMappingURL=getContentExtension.d.ts.map

package/dist/types/utils/getContentExtension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getContentExtension.d.ts","names":[],"sources":["../../../src/utils/getContentExtension.ts"],"mappings":";;;;;;;;;;cAUa,sBAAmB,2EAC2C,eAC1D"}
+{"version":3,"file":"getContentExtension.d.ts","names":[],"sources":["../../../src/utils/getContentExtension.ts"],"mappings":";;;;;;;;;;qBAUa,sBAAmB,2EAC2C,eAC1D"}

package/dist/types/utils/getFormatFromExtension.d.ts

@@ -1,8 +1,7 @@
 //#region src/utils/getFormatFromExtension.d.ts
-type Format = 'ts' | 'cjs' | 'esm' | 'json' | 'jsonc' | 'json5' | 'md' | 'yaml';
-type Extension = '.ts' | '.tsx' | '.js' | '.jsx' | '.cjs' | '.cjsx' | '.mjs' | '.mjsx' | '.json' | '.jsonc' | '.json5' | '.md' | '.mdx' | '.yaml' | '.yml';
-declare const getFormatFromExtension: (extension: Extension | (string & {})) => Format;
-declare const getExtensionFromFormat: (format: Format | (string & {})) => Extension;
+export type Format = 'ts' | 'cjs' | 'esm' | 'json' | 'jsonc' | 'json5' | 'md' | 'yaml';
+export type Extension = '.ts' | '.tsx' | '.js' | '.jsx' | '.cjs' | '.cjsx' | '.mjs' | '.mjsx' | '.json' | '.jsonc' | '.json5' | '.md' | '.mdx' | '.yaml' | '.yml';
+export declare const getFormatFromExtension: (extension: Extension | (string & {})) => Format;
+export declare const getExtensionFromFormat: (format: Format | (string & {})) => Extension;
 //#endregion
-export { Extension, Format, getExtensionFromFormat, getFormatFromExtension };
 //# sourceMappingURL=getFormatFromExtension.d.ts.map

package/dist/types/utils/getFormatFromExtension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFormatFromExtension.d.ts","names":[],"sources":["../../../src/utils/getFormatFromExtension.ts"],"mappings":";KAAY;KAUA;cAiBC,yBAAsB,WACtB,8BACV;cA4BU,yBAAsB,QACzB,2BACP"}
+{"version":3,"file":"getFormatFromExtension.d.ts","names":[],"sources":["../../../src/utils/getFormatFromExtension.ts"],"mappings":";YAAY;YAUA;qBAiBC,yBAAsB,WACtB,8BACV;qBA4BU,yBAAsB,QACzB,2BACP"}

package/dist/types/utils/getPathHash.d.ts

@@ -2,7 +2,6 @@
 /**
  * Fast hashing using cyrb53 algorithm for small unique strings with low collisions risk
  */
-declare const getPathHash: (filePath: string) => string;
+export declare const getPathHash: (filePath: string) => string;
 //#endregion
-export { getPathHash };
 //# sourceMappingURL=getPathHash.d.ts.map

package/dist/types/utils/getPathHash.d.ts.map

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

package/dist/types/utils/mergeChunks.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/mergeChunks.d.ts
-declare const mergeChunks: (chunks: any[]) => any;
+export declare const mergeChunks: (chunks: any[]) => any;
 //#endregion
-export { mergeChunks };
 //# sourceMappingURL=mergeChunks.d.ts.map

package/dist/types/utils/mergeChunks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeChunks.d.ts","names":[],"sources":["../../../src/utils/mergeChunks.ts"],"mappings":";cAAa,cAAW"}
+{"version":3,"file":"mergeChunks.d.ts","names":[],"sources":["../../../src/utils/mergeChunks.ts"],"mappings":";qBAAa,cAAW"}

package/dist/types/utils/pLimit.d.ts

@@ -1,5 +1,5 @@
 //#region src/utils/pLimit.d.ts
-declare class Queue<T> {
+export declare class Queue<T> {
   #private;
   constructor();
   enqueue(value: T): void;
@@ -10,7 +10,6 @@ declare class Queue<T> {
   [Symbol.iterator](): Generator<T, void, unknown>;
   drain(): Generator<T | undefined, void, unknown>;
 }
-declare const pLimit: (concurrency: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
+export declare const pLimit: (concurrency: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
 //#endregion
-export { Queue, pLimit };
 //# sourceMappingURL=pLimit.d.ts.map

package/dist/types/utils/pLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pLimit.d.ts","names":[],"sources":["../../../src/utils/pLimit.ts"],"mappings":";cAca,MAAM;;EAKjB;EAIA,QAAQ,OAAO;EAcf,WAAW;EAWX,QAAQ;EAWR;MAMI;GAIF,OAAO,aAAa,UAAU;EAS/B,SAAS,UAAU;;cAOT,SAAM,yBAAuB,QAkE9B,gBAAgB,iBAAY,sBAEnC"}
+{"version":3,"file":"pLimit.d.ts","names":[],"sources":["../../../src/utils/pLimit.ts"],"mappings":";qBAca,MAAM;;EAKjB;EAIA,QAAQ,OAAO;EAcf,WAAW;EAWX,QAAQ;EAWR;MAMI;GAIF,OAAO,aAAa,UAAU;EAS/B,SAAS,UAAU;;qBAOT,SAAM,yBAAuB,QAkE9B,gBAAgB,iBAAY,sBAEnC"}

package/dist/types/utils/parallelize.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/parallelize.d.ts
-declare const parallelize: <T, R>(items: T[], callback?: (item: T) => Promise<R>, parallelLimit?: number) => Promise<R[]>;
+export declare const parallelize: <T, R>(items: T[], callback?: (item: T) => Promise<R>, parallelLimit?: number) => Promise<R[]>;
 //#endregion
-export { parallelize };
 //# sourceMappingURL=parallelize.d.ts.map

package/dist/types/utils/parallelize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelize.d.ts","names":[],"sources":["../../../src/utils/parallelize.ts"],"mappings":";cAEa,cAAqB,GAAG,GAAC,OAC7B,KAAG,YACC,MAAM,MAAM,QAAQ,IAAE,2BAGhC,QAAQ"}
+{"version":3,"file":"parallelize.d.ts","names":[],"sources":["../../../src/utils/parallelize.ts"],"mappings":";qBAEa,cAAqB,GAAG,GAAC,OAC7B,KAAG,YACC,MAAM,MAAM,QAAQ,IAAE,2BAGhC,QAAQ"}

package/dist/types/utils/parallelizeGlobal.d.ts

@@ -1,10 +1,10 @@
 import { pLimit } from "./pLimit.js";
 //#region src/utils/parallelizeGlobal.d.ts
 /** Get (and optionally configure) the single, shared limiter. */
-declare const getGlobalLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
+export declare const getGlobalLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
 /** Limits how many *tasks* run concurrently (independent from AI calls). */
-declare const getTaskLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
-declare const parallelizeGlobal: <T, R>(items: T[], callback?: (item: T, index: number) => Promise<R>, options?: {
+export declare const getTaskLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
+export declare const parallelizeGlobal: <T, R>(items: T[], callback?: (item: T, index: number) => Promise<R>, options?: {
   /** Share a single limiter across the app. If omitted, uses global limiter. */
   limiter?: ReturnType<typeof pLimit>;
   /** If provided and no limiter is passed, configure the global limiter. */
@@ -17,5 +17,4 @@ declare const parallelizeGlobal: <T, R>(items: T[], callback?: (item: T, index:
   wrapInLimiter?: boolean;
 }) => Promise<R[]>;
 //#endregion
-export { getGlobalLimiter, getTaskLimiter, parallelizeGlobal };
 //# sourceMappingURL=parallelizeGlobal.d.ts.map

package/dist/types/utils/parallelizeGlobal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelizeGlobal.d.ts","names":[],"sources":["../../../src/utils/parallelizeGlobal.ts"],"mappings":";;;cAQa,mBAAgB,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;;cAaxC,iBAAc,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;cAUtC,oBAA2B,GAAG,GAAC,OACnC,KAAG,YACC,MAAM,GAAG,kBAAkB,QAAQ,IAAE;;EAI9C,UAAU,kBAAkB;;EAE5B;;;;;;EAMA;MAED,QAAQ"}
+{"version":3,"file":"parallelizeGlobal.d.ts","names":[],"sources":["../../../src/utils/parallelizeGlobal.ts"],"mappings":";;;qBAQa,mBAAgB,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;;qBAaxC,iBAAc,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;qBAUtC,oBAA2B,GAAG,GAAC,OACnC,KAAG,YACC,MAAM,GAAG,kBAAkB,QAAQ,IAAE;;EAI9C,UAAU,kBAAkB;;EAE5B;;;;;;EAMA;MAED,QAAQ"}