@intlayer/engine 9.4.3 → 9.4.4

package/dist/types/reduceDictionaryContent/reduceDictionaryContent.d.ts

@@ -1,6 +1,5 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/reduceDictionaryContent/reduceDictionaryContent.d.ts
-declare const reduceDictionaryContent: (fullDictionary: Dictionary, partialDictionary: Dictionary) => Dictionary;
+export declare const reduceDictionaryContent: (fullDictionary: Dictionary, partialDictionary: Dictionary) => Dictionary;
 //#endregion
-export { reduceDictionaryContent };
 //# sourceMappingURL=reduceDictionaryContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"reduceDictionaryContent.d.ts","names":[],"sources":["../../../src/reduceDictionaryContent/reduceDictionaryContent.ts"],"mappings":";;cAIa,0BAAuB,gBAClB,YAAU,mBACP,eAAU"}
+{"version":3,"file":"reduceDictionaryContent.d.ts","names":[],"sources":["../../../src/reduceDictionaryContent/reduceDictionaryContent.ts"],"mappings":";;qBAIa,0BAAuB,gBAClB,YAAU,mBACP,eAAU"}

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

@@ -9,7 +9,6 @@ import { BundleChunkInput, BundleContentAnalysis } from "./types.js";
  * @param totalPageSize - The total transferred bytes measured for the page.
  * @returns The aggregated {@link BundleContentAnalysis}.
  */
-declare const analyzeBundleContent: (chunks: BundleChunkInput[], htmlContent: string, currentLocale: string, totalPageSize: number) => BundleContentAnalysis;
+export declare const analyzeBundleContent: (chunks: BundleChunkInput[], htmlContent: string, currentLocale: string, totalPageSize: number) => BundleContentAnalysis;
 //#endregion
-export { analyzeBundleContent };
 //# sourceMappingURL=analyzeBundleContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;;;;;;;cA6Ka,uBAAoB,QACvB,oBAAkB,qBACP,uBACE,0BAEpB"}
+{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;;;;;;;qBA6Ka,uBAAoB,QACvB,oBAAkB,qBACP,uBACE,0BAEpB"}

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

@@ -8,7 +8,7 @@
  * of any server-only dependency (no Fastify, no Cheerio, no logger coupling).
  */
 /** Accumulated score across all checks that ran. */
-type Score = {
+export type Score = {
   /** Sum of points obtained (success = full, warning = half, error = none). */
   score: number;
   /** Maximum achievable points for the checks that ran. */
@@ -21,12 +21,12 @@ type Score = {
  * URL using a backslash separator (e.g. `url_htmlLang\https://example.com`), so
  * only the part before the first backslash is used to look up the weight.
  */
-type ScorableEvent = {
+export type ScorableEvent = {
   type?: string;
   status?: string;
 };
 /** Weight (in points) of every scorable check. */
-declare const scoreRecord: {
+export declare const scoreRecord: {
   readonly robots_robotsPresent: 10;
   readonly robots_noLocalizedUrlsForgotten: 8;
   readonly sitemap_sitemapPresent: 10;
@@ -44,7 +44,7 @@ declare const scoreRecord: {
   readonly url_unusedBundleContent: 8;
 };
 /** Identifier of a scorable check (without the URL suffix). */
-type ScoreCheckType = keyof typeof scoreRecord;
+export type ScoreCheckType = keyof typeof scoreRecord;
 /**
  * Apply a single event to the running score, returning a new {@link Score}.
  * Unknown check types are ignored so the function is safe to call on every
@@ -54,14 +54,13 @@ type ScoreCheckType = keyof typeof scoreRecord;
  * @param event - The event to fold into the score.
  * @returns A new score with the event applied.
  */
-declare const mutateScore: (score: Score, event: ScorableEvent) => Score;
+export declare const mutateScore: (score: Score, event: ScorableEvent) => Score;
 /**
  * Convert a raw {@link Score} into a 0–100 percentage.
  *
  * @param score - The accumulated score.
  * @returns The rounded percentage, or 0 when no check ran.
  */
-declare const toScorePercent: (score: Score) => number;
+export declare const toScorePercent: (score: Score) => number;
 //#endregion
-export { ScorableEvent, Score, ScoreCheckType, mutateScore, scoreRecord, toScorePercent };
 //# sourceMappingURL=calculateScore.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;;;;;;;;;KAUY;;EAEV;;EAEA;;;;;;;;;KAUU;EACV;EACA;;;cAgBW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;KAIU,8BAA8B;;;;;;;;;;cAW7B,cAAW,OAAW,OAAK,OAAS,kBAAgB;;;;;;;cAyBpD,iBAAc,OAAW"}
+{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;;;;;;;;;YAUY;;EAEV;;EAEA;;;;;;;;;YAUU;EACV;EACA;;;qBAgBW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;YAIU,8BAA8B;;;;;;;;;;qBAW7B,cAAW,OAAW,OAAK,OAAS,kBAAgB;;;;;;;qBAyBpD,iBAAc,OAAW"}

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

@@ -2,36 +2,35 @@ import { BundleChunkInput, BundleContentAnalysis, ScanEvent } from "./types.js";
 import { Anchor } from "./parseHtml.js";
 //#region src/scan/checks.d.ts
 /** Format a byte count as a human-readable size. */
-declare const formatSize: (bytes: number) => string;
+export declare const formatSize: (bytes: number) => string;
 /**
  * Check the `<html>` element attributes (`lang`, `dir`) and the resulting
  * current-locale signal. Returns the detected language tag.
  */
-declare const checkHtmlAttributes: (html: string, targetUrl: string, events: ScanEvent[]) => {
+export declare const checkHtmlAttributes: (html: string, targetUrl: string, events: ScanEvent[]) => {
   langTag: string | undefined;
 };
 /** Check the presence of a canonical link. */
-declare const checkCanonical: (html: string, targetUrl: string, events: ScanEvent[]) => void;
+export declare const checkCanonical: (html: string, targetUrl: string, events: ScanEvent[]) => void;
 /**
  * Check the page's hreflang structure and collect discovered locales into
  * `localesSet`.
  */
-declare const checkLinguisticStructure: (html: string, targetUrl: string, localesSet: Set<string>, events: ScanEvent[]) => void;
+export declare const checkLinguisticStructure: (html: string, targetUrl: string, localesSet: Set<string>, events: ScanEvent[]) => void;
 /**
  * Check whether internal links carry a locale segment, mirroring the hosted
  * audit's URL-structure analysis but operating on parsed anchors instead of a
  * live DOM.
  */
-declare const checkUrlStructure: (anchors: Anchor[], origin: string, targetUrl: string, events: ScanEvent[]) => void;
+export declare const checkUrlStructure: (anchors: Anchor[], origin: string, targetUrl: string, events: ScanEvent[]) => void;
 /**
  * Analyze the JavaScript bundles for unused locale content and emit the
  * corresponding event. Returns the analysis so callers can report on it.
  */
-declare const checkBundleContent: (chunks: BundleChunkInput[], html: string, currentLocale: string | undefined, targetUrl: string, totalPageSize: number, events: ScanEvent[]) => BundleContentAnalysis | undefined;
+export declare const checkBundleContent: (chunks: BundleChunkInput[], html: string, currentLocale: string | undefined, targetUrl: string, totalPageSize: number, events: ScanEvent[]) => BundleContentAnalysis | undefined;
 /** Fetch and check `robots.txt`, emitting robots-related events. */
-declare const checkRobots: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+export declare const checkRobots: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
 /** Fetch and check `sitemap.xml`, emitting sitemap-related events. */
-declare const checkSitemap: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+export declare const checkSitemap: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
 //#endregion
-export { checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure, formatSize };
 //# sourceMappingURL=checks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;cAgBa,aAAU;;;;;cAUV,sBAAmB,cAClB,mBACK,QACT;EACL;;;cAmCQ,iBAAc,cACb,mBACK,QACT;;;;;cAcG,2BAAwB,cACvB,mBACK,YACL,aAAW,QACf;;;;;;cAwCG,oBAAiB,SACnB,UAAQ,gBACH,mBACG,QACT;;;;;cAwEG,qBAAkB,QACrB,oBAAkB,cACd,mCACqB,mBAChB,uBACI,QACb,gBACP;;cA0CU,cAAW,gBACR,mBACK,aAAW,mBACb,QACT,gBACP;;cA0DU,eAAY,gBACT,mBACK,aAAW,mBACb,QACT,gBACP"}
+{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;qBAgBa,aAAU;;;;;qBAUV,sBAAmB,cAClB,mBACK,QACT;EACL;;;qBAmCQ,iBAAc,cACb,mBACK,QACT;;;;;qBAcG,2BAAwB,cACvB,mBACK,YACL,aAAW,QACf;;;;;;qBAwCG,oBAAiB,SACnB,UAAQ,gBACH,mBACG,QACT;;;;;qBAwEG,qBAAkB,QACrB,oBAAkB,cACd,mCACqB,mBAChB,uBACI,QACb,gBACP;;qBA0CU,cAAW,gBACR,mBACK,aAAW,mBACb,QACT,gBACP;;qBA0DU,eAAY,gBACT,mBACK,aAAW,mBACb,QACT,gBACP"}

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