@intlayer/engine 9.0.0-canary.12

package/dist/cjs/build.cjs

@@ -0,0 +1,60 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_createDictionaryEntryPoint_generateDictionaryListContent = require('./createDictionaryEntryPoint/generateDictionaryListContent.cjs');
+const require_createDictionaryEntryPoint_getBuiltDictionariesPath = require('./createDictionaryEntryPoint/getBuiltDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltDynamicDictionariesPath = require('./createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltFetchDictionariesPath = require('./createDictionaryEntryPoint/getBuiltFetchDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltRemoteDictionariesPath = require('./createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_getBuiltUnmergedDictionariesPath = require('./createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.cjs');
+const require_createDictionaryEntryPoint_createDictionaryEntryPoint = require('./createDictionaryEntryPoint/createDictionaryEntryPoint.cjs');
+const require_utils_readDictionariesFromDisk = require('./utils/readDictionariesFromDisk.cjs');
+const require_buildIntlayerDictionary_buildIntlayerDictionary = require('./buildIntlayerDictionary/buildIntlayerDictionary.cjs');
+const require_createType_createModuleAugmentation = require('./createType/createModuleAugmentation.cjs');
+const require_createType_createType = require('./createType/createType.cjs');
+const require_buildIntlayerDictionary_processContentDeclaration = require('./buildIntlayerDictionary/processContentDeclaration.cjs');
+const require_loadDictionaries_loadContentDeclaration = require('./loadDictionaries/loadContentDeclaration.cjs');
+const require_loadDictionaries_loadLocalDictionaries = require('./loadDictionaries/loadLocalDictionaries.cjs');
+const require_formatDictionary = require('./formatDictionary.cjs');
+const require_loadDictionaries_loadRemoteDictionaries = require('./loadDictionaries/loadRemoteDictionaries.cjs');
+const require_loadDictionaries_loadDictionaries = require('./loadDictionaries/loadDictionaries.cjs');
+const require_cleanOutputDir = require('./cleanOutputDir.cjs');
+const require_writeConfiguration_index = require('./writeConfiguration/index.cjs');
+const require_prepareIntlayer = require('./prepareIntlayer.cjs');
+const require_writeContentDeclaration_detectExportedComponentName = require('./writeContentDeclaration/detectExportedComponentName.cjs');
+const require_writeContentDeclaration_transformJSFile = require('./writeContentDeclaration/transformJSFile.cjs');
+const require_writeContentDeclaration_writeJSFile = require('./writeContentDeclaration/writeJSFile.cjs');
+const require_writeContentDeclaration_writeContentDeclaration = require('./writeContentDeclaration/writeContentDeclaration.cjs');
+
+exports.buildDictionary = require_buildIntlayerDictionary_buildIntlayerDictionary.buildDictionary;
+exports.cleanOutputDir = require_cleanOutputDir.cleanOutputDir;
+exports.createDictionaryEntryPoint = require_createDictionaryEntryPoint_createDictionaryEntryPoint.createDictionaryEntryPoint;
+exports.createModuleAugmentation = require_createType_createModuleAugmentation.createModuleAugmentation;
+exports.createTypes = require_createType_createType.createTypes;
+exports.detectExportedComponentName = require_writeContentDeclaration_detectExportedComponentName.detectExportedComponentName;
+exports.ensureIntlayerBundle = require_loadDictionaries_loadContentDeclaration.ensureIntlayerBundle;
+exports.formatDictionaries = require_formatDictionary.formatDictionaries;
+exports.formatDictionariesOutput = require_formatDictionary.formatDictionariesOutput;
+exports.formatDictionary = require_formatDictionary.formatDictionary;
+exports.formatDictionaryOutput = require_formatDictionary.formatDictionaryOutput;
+exports.formatDistantDictionaries = require_loadDictionaries_loadRemoteDictionaries.formatDistantDictionaries;
+exports.formatLocalDictionaries = require_loadDictionaries_loadContentDeclaration.formatLocalDictionaries;
+exports.generateDictionaryListContent = require_createDictionaryEntryPoint_generateDictionaryListContent.generateDictionaryListContent;
+exports.generateTypeScriptType = require_createType_createType.generateTypeScriptType;
+exports.getBuiltDictionariesPath = require_createDictionaryEntryPoint_getBuiltDictionariesPath.getBuiltDictionariesPath;
+exports.getBuiltDynamicDictionariesPath = require_createDictionaryEntryPoint_getBuiltDynamicDictionariesPath.getBuiltDynamicDictionariesPath;
+exports.getBuiltFetchDictionariesPath = require_createDictionaryEntryPoint_getBuiltFetchDictionariesPath.getBuiltFetchDictionariesPath;
+exports.getBuiltRemoteDictionariesPath = require_createDictionaryEntryPoint_getBuiltRemoteDictionariesPath.getBuiltRemoteDictionariesPath;
+exports.getBuiltUnmergedDictionariesPath = require_createDictionaryEntryPoint_getBuiltUnmergedDictionariesPath.getBuiltUnmergedDictionariesPath;
+exports.getTypeName = require_createType_createModuleAugmentation.getTypeName;
+exports.isCachedConfigurationUpToDate = require_writeConfiguration_index.isCachedConfigurationUpToDate;
+exports.loadContentDeclaration = require_loadDictionaries_loadContentDeclaration.loadContentDeclaration;
+exports.loadContentDeclarations = require_loadDictionaries_loadContentDeclaration.loadContentDeclarations;
+exports.loadDictionaries = require_loadDictionaries_loadDictionaries.loadDictionaries;
+exports.loadLocalDictionaries = require_loadDictionaries_loadLocalDictionaries.loadLocalDictionaries;
+exports.loadRemoteDictionaries = require_loadDictionaries_loadRemoteDictionaries.loadRemoteDictionaries;
+exports.prepareIntlayer = require_prepareIntlayer.prepareIntlayer;
+exports.processContentDeclaration = require_buildIntlayerDictionary_processContentDeclaration.processContentDeclaration;
+exports.readDictionariesFromDisk = require_utils_readDictionariesFromDisk.readDictionariesFromDisk;
+exports.transformJSFile = require_writeContentDeclaration_transformJSFile.transformJSFile;
+exports.writeConfiguration = require_writeConfiguration_index.writeConfiguration;
+exports.writeContentDeclaration = require_writeContentDeclaration_writeContentDeclaration.writeContentDeclaration;
+exports.writeJSFile = require_writeContentDeclaration_writeJSFile.writeJSFile;

package/dist/cjs/buildIntlayerDictionary/buildIntlayerDictionary.cjs

@@ -0,0 +1,80 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_readDictionariesFromDisk = require('../utils/readDictionariesFromDisk.cjs');
+const require_buildIntlayerDictionary_writeDynamicDictionary = require('./writeDynamicDictionary.cjs');
+const require_buildIntlayerDictionary_writeFetchDictionary = require('./writeFetchDictionary.cjs');
+const require_buildIntlayerDictionary_writeMergedDictionary = require('./writeMergedDictionary.cjs');
+const require_buildIntlayerDictionary_writeUnmergedDictionary = require('./writeUnmergedDictionary.cjs');
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+
+//#region src/buildIntlayerDictionary/buildIntlayerDictionary.ts
+const defaultOptions = {
+	formats: _intlayer_config_defaultValues.OUTPUT_FORMAT,
+	importOtherDictionaries: true,
+	env: "dev"
+};
+/**
+* This function transpile the bundled code to to make dictionaries as JSON files
+*/
+const buildDictionary = async (localDictionariesEntries, configuration, options) => {
+	const importMode = configuration?.build?.importMode ?? configuration?.dictionary?.importMode ?? _intlayer_config_defaultValues.IMPORT_MODE;
+	const { importOtherDictionaries, env, formats } = {
+		...defaultOptions,
+		...options
+	};
+	const unmergedDictionariesToUpdate = [...localDictionariesEntries];
+	if (importOtherDictionaries) {
+		const prevUnmergedDictionaries = require_utils_readDictionariesFromDisk.readDictionariesFromDisk(configuration.system.unmergedDictionariesDir);
+		for (const dictionaryToWrite of localDictionariesEntries) {
+			const allPrebuiltUnmergedDictionaries = prevUnmergedDictionaries[dictionaryToWrite.key];
+			if (allPrebuiltUnmergedDictionaries?.length > 0) {
+				const otherUnmergedDictionaries = allPrebuiltUnmergedDictionaries?.filter((unmergedDictionary) => unmergedDictionary.localId !== dictionaryToWrite.localId);
+				unmergedDictionariesToUpdate.push(...otherUnmergedDictionaries ?? []);
+			}
+		}
+	}
+	const unmergedDictionaries = await require_buildIntlayerDictionary_writeUnmergedDictionary.writeUnmergedDictionaries(unmergedDictionariesToUpdate, configuration, env);
+	const mergedDictionaries = await require_buildIntlayerDictionary_writeMergedDictionary.writeMergedDictionaries(unmergedDictionaries, configuration);
+	const dictionariesToBuildDynamic = {};
+	const qualifiedDictionariesToBuildDynamic = {};
+	const keysToBuildFetch = /* @__PURE__ */ new Set();
+	for (const [key, mergedResult] of Object.entries(mergedDictionaries)) {
+		const dictionary = mergedResult.dictionary;
+		if ((0, _intlayer_core_dictionaryManipulator.isQualifiedDictionaryGroup)(dictionary)) {
+			const entryMode = dictionary.importMode ?? importMode;
+			if (entryMode === "dynamic") qualifiedDictionariesToBuildDynamic[key] = {
+				dictionaryPath: mergedResult.dictionaryPath,
+				dictionary
+			};
+			else if (entryMode === "fetch") (0, _intlayer_config_logger.getAppLogger)(configuration)(`Dictionary ${(0, _intlayer_config_logger.colorizeKey)(key)} uses 'fetch' import mode with (${dictionary.qualifierTypes.join(", ")}) entries — fetch mode is not qualifier-aware yet, falling back to static import.`, { level: "warn" });
+			continue;
+		}
+		const mode = dictionary.importMode ?? importMode;
+		if (mode === "dynamic" || mode === "fetch") dictionariesToBuildDynamic[key] = {
+			dictionaryPath: mergedResult.dictionaryPath,
+			dictionary
+		};
+		if (mode === "fetch") keysToBuildFetch.add(key);
+	}
+	let dynamicDictionaries = null;
+	if (Object.keys(dictionariesToBuildDynamic).length > 0) dynamicDictionaries = await require_buildIntlayerDictionary_writeDynamicDictionary.writeDynamicDictionary(dictionariesToBuildDynamic, configuration, formats);
+	if (Object.keys(qualifiedDictionariesToBuildDynamic).length > 0) await require_buildIntlayerDictionary_writeDynamicDictionary.writeDynamicQualifiedDictionaries(qualifiedDictionariesToBuildDynamic, configuration, formats);
+	let fetchDictionaries = null;
+	if (dynamicDictionaries && keysToBuildFetch.size > 0) {
+		const dictionariesToBuildFetch = {};
+		for (const key of keysToBuildFetch) if (dynamicDictionaries[key]) dictionariesToBuildFetch[key] = dynamicDictionaries[key];
+		if (Object.keys(dictionariesToBuildFetch).length > 0) fetchDictionaries = await require_buildIntlayerDictionary_writeFetchDictionary.writeFetchDictionary(dictionariesToBuildFetch, configuration, formats);
+	}
+	return {
+		unmergedDictionaries,
+		mergedDictionaries,
+		dynamicDictionaries,
+		fetchDictionaries
+	};
+};
+
+//#endregion
+exports.buildDictionary = buildDictionary;
+//# sourceMappingURL=buildIntlayerDictionary.cjs.map

package/dist/cjs/buildIntlayerDictionary/buildIntlayerDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildIntlayerDictionary.cjs","names":["OUTPUT_FORMAT","IMPORT_MODE","readDictionariesFromDisk","writeUnmergedDictionaries","writeMergedDictionaries","writeDynamicDictionary","writeDynamicQualifiedDictionaries","writeFetchDictionary"],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"sourcesContent":["import { IMPORT_MODE, OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport { isQualifiedDictionaryGroup } from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { readDictionariesFromDisk } from '../utils/readDictionariesFromDisk';\nimport {\n  type LocalizedDictionaryOutput,\n  type QualifiedMergedDictionaryOutput,\n  writeDynamicDictionary,\n  writeDynamicQualifiedDictionaries,\n} from './writeDynamicDictionary';\nimport { writeFetchDictionary } from './writeFetchDictionary';\nimport {\n  type PlainMergedDictionaryOutput,\n  writeMergedDictionaries,\n} from './writeMergedDictionary';\nimport { writeUnmergedDictionaries } from './writeUnmergedDictionary';\n\nexport type BuildDictionariesOptions = Partial<{\n  formats: typeof OUTPUT_FORMAT;\n  importOtherDictionaries: boolean;\n  env: 'prod' | 'dev';\n}>;\n\nconst defaultOptions = {\n  formats: OUTPUT_FORMAT,\n  importOtherDictionaries: true,\n  env: 'dev',\n} as const satisfies BuildDictionariesOptions;\n\n/**\n * This function transpile the bundled code to to make dictionaries as JSON files\n */\nexport const buildDictionary = async (\n  localDictionariesEntries: Dictionary[],\n  configuration: IntlayerConfig,\n  options?: BuildDictionariesOptions\n) => {\n  const importMode =\n    configuration?.build?.importMode ??\n    configuration?.dictionary?.importMode ??\n    IMPORT_MODE;\n\n  const { importOtherDictionaries, env, formats } = {\n    ...defaultOptions,\n    ...options,\n  };\n\n  const unmergedDictionariesToUpdate: Dictionary[] = [\n    ...localDictionariesEntries,\n  ];\n\n  if (importOtherDictionaries) {\n    const prevUnmergedDictionaries: Record<string, Dictionary[]> =\n      readDictionariesFromDisk(configuration.system.unmergedDictionariesDir);\n\n    // Reinsert other dictionaries with the same key to avoid merging errors\n    for (const dictionaryToWrite of localDictionariesEntries) {\n      const allPrebuiltUnmergedDictionaries =\n        prevUnmergedDictionaries[dictionaryToWrite.key]!;\n\n      if (allPrebuiltUnmergedDictionaries?.length > 0) {\n        // Do not add the same dictionary again by filtering out the one with the same localId\n        const otherUnmergedDictionaries =\n          allPrebuiltUnmergedDictionaries?.filter(\n            (unmergedDictionary) =>\n              unmergedDictionary.localId !== dictionaryToWrite.localId\n          );\n\n        unmergedDictionariesToUpdate.push(...(otherUnmergedDictionaries ?? []));\n      }\n    }\n  }\n\n  const unmergedDictionaries = await writeUnmergedDictionaries(\n    unmergedDictionariesToUpdate,\n    configuration,\n    env\n  );\n\n  const mergedDictionaries = await writeMergedDictionaries(\n    unmergedDictionaries,\n    configuration\n  );\n\n  const dictionariesToBuildDynamic: PlainMergedDictionaryOutput = {};\n  const qualifiedDictionariesToBuildDynamic: QualifiedMergedDictionaryOutput =\n    {};\n  const keysToBuildFetch = new Set<string>();\n\n  for (const [key, mergedResult] of Object.entries(mergedDictionaries)) {\n    const dictionary = mergedResult.dictionary;\n\n    if (isQualifiedDictionaryGroup(dictionary)) {\n      // Collections / variants resolve their qualifier at\n      // runtime from a selector. Static mode keeps every entry in one JSON;\n      // dynamic mode splits them into one chunk per (locale, qualifierId).\n      const entryMode = dictionary.importMode ?? importMode;\n\n      if (entryMode === 'dynamic') {\n        qualifiedDictionariesToBuildDynamic[key] = {\n          dictionaryPath: mergedResult.dictionaryPath,\n          dictionary,\n        };\n      } else if (entryMode === 'fetch') {\n        const appLogger = getAppLogger(configuration);\n        appLogger(\n          `Dictionary ${colorizeKey(key)} uses 'fetch' import mode with (${dictionary.qualifierTypes.join(', ')}) entries — fetch mode is not qualifier-aware yet, falling back to static import.`,\n          { level: 'warn' }\n        );\n      }\n\n      continue;\n    }\n\n    const mode = dictionary.importMode ?? importMode;\n\n    if (mode === 'dynamic' || mode === 'fetch') {\n      dictionariesToBuildDynamic[key] = {\n        dictionaryPath: mergedResult.dictionaryPath,\n        dictionary,\n      };\n    }\n\n    if (mode === 'fetch') {\n      keysToBuildFetch.add(key);\n    }\n  }\n\n  let dynamicDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (Object.keys(dictionariesToBuildDynamic).length > 0) {\n    dynamicDictionaries = await writeDynamicDictionary(\n      dictionariesToBuildDynamic,\n      configuration,\n      formats\n    );\n  }\n\n  if (Object.keys(qualifiedDictionariesToBuildDynamic).length > 0) {\n    await writeDynamicQualifiedDictionaries(\n      qualifiedDictionariesToBuildDynamic,\n      configuration,\n      formats\n    );\n  }\n\n  let fetchDictionaries: LocalizedDictionaryOutput | null = null;\n\n  if (dynamicDictionaries && keysToBuildFetch.size > 0) {\n    const dictionariesToBuildFetch: LocalizedDictionaryOutput = {};\n\n    for (const key of keysToBuildFetch) {\n      if (dynamicDictionaries[key]) {\n        dictionariesToBuildFetch[key] = dynamicDictionaries[key];\n      }\n    }\n\n    if (Object.keys(dictionariesToBuildFetch).length > 0) {\n      fetchDictionaries = await writeFetchDictionary(\n        dictionariesToBuildFetch,\n        configuration,\n        formats\n      );\n    }\n  }\n\n  return {\n    unmergedDictionaries,\n    mergedDictionaries,\n    dynamicDictionaries,\n    fetchDictionaries,\n  };\n};\n"],"mappings":";;;;;;;;;;;;AAyBA,MAAM,iBAAiB;CACrB,SAASA;CACT,yBAAyB;CACzB,KAAK;CACN;;;;AAKD,MAAa,kBAAkB,OAC7B,0BACA,eACA,YACG;CACH,MAAM,aACJ,eAAe,OAAO,cACtB,eAAe,YAAY,cAC3BC;CAEF,MAAM,EAAE,yBAAyB,KAAK,YAAY;EAChD,GAAG;EACH,GAAG;EACJ;CAED,MAAM,+BAA6C,CACjD,GAAG,yBACJ;AAED,KAAI,yBAAyB;EAC3B,MAAM,2BACJC,gEAAyB,cAAc,OAAO,wBAAwB;AAGxE,OAAK,MAAM,qBAAqB,0BAA0B;GACxD,MAAM,kCACJ,yBAAyB,kBAAkB;AAE7C,OAAI,iCAAiC,SAAS,GAAG;IAE/C,MAAM,4BACJ,iCAAiC,QAC9B,uBACC,mBAAmB,YAAY,kBAAkB,QACpD;AAEH,iCAA6B,KAAK,GAAI,6BAA6B,EAAE,CAAE;;;;CAK7E,MAAM,uBAAuB,MAAMC,kFACjC,8BACA,eACA,IACD;CAED,MAAM,qBAAqB,MAAMC,8EAC/B,sBACA,cACD;CAED,MAAM,6BAA0D,EAAE;CAClE,MAAM,sCACJ,EAAE;CACJ,MAAM,mCAAmB,IAAI,KAAa;AAE1C,MAAK,MAAM,CAAC,KAAK,iBAAiB,OAAO,QAAQ,mBAAmB,EAAE;EACpE,MAAM,aAAa,aAAa;AAEhC,2EAA+B,WAAW,EAAE;GAI1C,MAAM,YAAY,WAAW,cAAc;AAE3C,OAAI,cAAc,UAChB,qCAAoC,OAAO;IACzC,gBAAgB,aAAa;IAC7B;IACD;YACQ,cAAc,QAEvB,2CAD+B,cACtB,CACP,uDAA0B,IAAI,CAAC,kCAAkC,WAAW,eAAe,KAAK,KAAK,CAAC,oFACtG,EAAE,OAAO,QAAQ,CAClB;AAGH;;EAGF,MAAM,OAAO,WAAW,cAAc;AAEtC,MAAI,SAAS,aAAa,SAAS,QACjC,4BAA2B,OAAO;GAChC,gBAAgB,aAAa;GAC7B;GACD;AAGH,MAAI,SAAS,QACX,kBAAiB,IAAI,IAAI;;CAI7B,IAAI,sBAAwD;AAE5D,KAAI,OAAO,KAAK,2BAA2B,CAAC,SAAS,EACnD,uBAAsB,MAAMC,8EAC1B,4BACA,eACA,QACD;AAGH,KAAI,OAAO,KAAK,oCAAoC,CAAC,SAAS,EAC5D,OAAMC,yFACJ,qCACA,eACA,QACD;CAGH,IAAI,oBAAsD;AAE1D,KAAI,uBAAuB,iBAAiB,OAAO,GAAG;EACpD,MAAM,2BAAsD,EAAE;AAE9D,OAAK,MAAM,OAAO,iBAChB,KAAI,oBAAoB,KACtB,0BAAyB,OAAO,oBAAoB;AAIxD,MAAI,OAAO,KAAK,yBAAyB,CAAC,SAAS,EACjD,qBAAoB,MAAMC,0EACxB,0BACA,eACA,QACD;;AAIL,QAAO;EACL;EACA;EACA;EACA;EACD"}

package/dist/cjs/buildIntlayerDictionary/index.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_buildIntlayerDictionary_buildIntlayerDictionary = require('./buildIntlayerDictionary.cjs');
+const require_buildIntlayerDictionary_processContentDeclaration = require('./processContentDeclaration.cjs');
+
+exports.buildDictionary = require_buildIntlayerDictionary_buildIntlayerDictionary.buildDictionary;
+exports.processContentDeclaration = require_buildIntlayerDictionary_processContentDeclaration.processContentDeclaration;

package/dist/cjs/buildIntlayerDictionary/processContentDeclaration.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_autoDecorateContent = require('../utils/autoDecorateContent.cjs');
+const require_utils_resolveObjectPromises = require('../utils/resolveObjectPromises.cjs');
+let _intlayer_config_logger = require("@intlayer/config/logger");
+
+//#region src/buildIntlayerDictionary/processContentDeclaration.ts
+/**
+* Function to load, process the module and return the Intlayer Dictionary from the module file
+*/
+const processContentDeclaration = async (contentDeclaration, configuration) => {
+	try {
+		const resolvedContent = await require_utils_resolveObjectPromises.resolveObjectPromises(contentDeclaration.content);
+		const isAutoDecorateContentEnabled = contentDeclaration.contentAutoTransformation ?? configuration.dictionary?.contentAutoTransformation ?? false;
+		const decoratedContent = isAutoDecorateContentEnabled ? require_utils_autoDecorateContent.autoDecorateContent(resolvedContent, isAutoDecorateContentEnabled) : resolvedContent;
+		return {
+			...contentDeclaration,
+			content: decoratedContent
+		};
+	} catch (error) {
+		(0, _intlayer_config_logger.logger)(error, { level: "error" });
+	}
+};
+
+//#endregion
+exports.processContentDeclaration = processContentDeclaration;
+//# sourceMappingURL=processContentDeclaration.cjs.map

package/dist/cjs/buildIntlayerDictionary/processContentDeclaration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"processContentDeclaration.cjs","names":["resolveObjectPromises","autoDecorateContent"],"sources":["../../../src/buildIntlayerDictionary/processContentDeclaration.ts"],"sourcesContent":["import { logger } from '@intlayer/config/logger';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { autoDecorateContent } from '../utils/autoDecorateContent';\nimport { resolveObjectPromises } from '../utils/resolveObjectPromises';\n\n/**\n * Function to load, process the module and return the Intlayer Dictionary from the module file\n */\nexport const processContentDeclaration = async (\n  contentDeclaration: Dictionary,\n  configuration: IntlayerConfig\n): Promise<Dictionary | undefined> => {\n  try {\n    const resolvedContent = (await resolveObjectPromises(\n      contentDeclaration.content\n    )) as Dictionary['content'];\n\n    const isAutoDecorateContentEnabled =\n      contentDeclaration.contentAutoTransformation ??\n      configuration.dictionary?.contentAutoTransformation ??\n      false;\n\n    const decoratedContent = isAutoDecorateContentEnabled\n      ? autoDecorateContent(resolvedContent, isAutoDecorateContentEnabled)\n      : resolvedContent;\n\n    return {\n      ...contentDeclaration,\n      content: decoratedContent,\n    } as Dictionary;\n  } catch (error) {\n    logger(error, {\n      level: 'error',\n    });\n  }\n};\n"],"mappings":";;;;;;;;;;AASA,MAAa,4BAA4B,OACvC,oBACA,kBACoC;AACpC,KAAI;EACF,MAAM,kBAAmB,MAAMA,0DAC7B,mBAAmB,QACpB;EAED,MAAM,+BACJ,mBAAmB,6BACnB,cAAc,YAAY,6BAC1B;EAEF,MAAM,mBAAmB,+BACrBC,sDAAoB,iBAAiB,6BAA6B,GAClE;AAEJ,SAAO;GACL,GAAG;GACH,SAAS;GACV;UACM,OAAO;AACd,sCAAO,OAAO,EACZ,OAAO,SACR,CAAC"}

package/dist/cjs/buildIntlayerDictionary/writeDynamicDictionary.cjs

@@ -0,0 +1,206 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+const require_writeFileIfChanged = require('../writeFileIfChanged.cjs');
+const require_writeJsonIfChanged = require('../writeJsonIfChanged.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+let _intlayer_core_plugins = require("@intlayer/core/plugins");
+
+//#region src/buildIntlayerDictionary/writeDynamicDictionary.ts
+const DICTIONARIES_SUBDIR = "json";
+/**
+* Escapes a value interpolated into a single-quoted literal of a generated
+* loader module, so keys or segments containing `'` or `\` cannot break the
+* emitted JavaScript.
+*/
+const escapeJsLiteral = (value) => value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+/**
+* Generates the content of a dictionary entry point file.
+*/
+const generateDictionaryEntryPoint = (key, locales, format = "esm") => {
+	const sortedLocales = [...locales].sort((a, b) => String(a).localeCompare(String(b)));
+	const safeKey = escapeJsLiteral(key);
+	const localeEntries = sortedLocales.map((locale) => {
+		const safeLocale = escapeJsLiteral(locale);
+		return format === "esm" ? `  '${safeLocale}': () => import('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json').then(m => m.default)` : `  '${safeLocale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json'))`;
+	}).join(",\n");
+	if (format === "esm") return `const content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `module.exports = {\n${localeEntries}\n};\n`;
+};
+const buildLoaderExpression = (key, chunkSegments, locale, format) => {
+	const path = escapeJsLiteral(`./${DICTIONARIES_SUBDIR}/${key}/${chunkSegments.join("/")}/${locale}.json`);
+	return format === "esm" ? `() => import('${path}').then(m => m.default)` : `() => Promise.resolve(require('${path}'))`;
+};
+const buildLoaderTree = (key, entries, locale, format) => {
+	const root = {};
+	for (const { treeSegments, chunkSegments } of entries) {
+		let node = root;
+		treeSegments.forEach((segment, index) => {
+			if (index === treeSegments.length - 1) {
+				node[segment] = buildLoaderExpression(key, chunkSegments, locale, format);
+				return;
+			}
+			node[segment] = node[segment] ?? {};
+			node = node[segment];
+		});
+	}
+	return root;
+};
+const serializeLoaderTree = (tree, indentLevel) => {
+	const pad = "  ".repeat(indentLevel);
+	const innerPad = "  ".repeat(indentLevel + 1);
+	return `{\n${Object.keys(tree).sort((a, b) => a.localeCompare(b)).map((segment) => {
+		const value = tree[segment];
+		const serialized = typeof value === "string" ? value : serializeLoaderTree(value, indentLevel + 1);
+		return `${innerPad}'${escapeJsLiteral(segment)}': ${serialized}`;
+	}).join(",\n")}\n${pad}}`;
+};
+/**
+* Generates the entry point of a qualified dictionary (collection / variant,
+* possibly combined). Under each locale the loader map nests one
+* level per declared dimension (canonical order) and carries a marker listing
+* those dimensions so the runtime can walk the tree.
+*
+* One static `import()` is emitted per leaf `(locale, …segments)` chunk, which
+* keeps the output compatible with bundlers that reject template-literal
+* dynamic imports (Turbopack). Entries whose content is identical share one
+* chunk: their leaves point at the canonical entry's import path.
+*/
+const generateQualifiedDictionaryEntryPoint = (key, qualifierTypes, entries, locales, format = "esm") => {
+	const localeEntries = [...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => {
+		const tree = buildLoaderTree(key, entries, locale, format);
+		return `  '${escapeJsLiteral(locale)}': ${serializeLoaderTree(tree, 1)}`;
+	}).join(",\n");
+	const marker = `  '${_intlayer_core_dictionaryManipulator.QUALIFIER_DYNAMIC_TYPES_KEY}': ${JSON.stringify(qualifierTypes)}`;
+	if (format === "esm") return `const content = {\n${marker},\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `module.exports = {\n${marker},\n${localeEntries}\n};\n`;
+};
+/**
+* Write the localized dictionaries to the dictionariesDir
+* @param mergedDictionaries - The merged dictionaries
+* @param configuration - The configuration
+* @returns The final dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+* console.log(finalDictionaries);
+*
+* // .intlayer/dynamic_dictionary/dictionaries/en_home.json
+* // .intlayer/dynamic_dictionary/dictionaries/fr_home.json
+* ```
+*/
+const writeDynamicDictionary = async (mergedDictionaries, configuration, formats = _intlayer_config_defaultValues.OUTPUT_FORMAT) => {
+	const { locales, defaultLocale } = configuration.internationalization;
+	const { dynamicDictionariesDir } = configuration.system;
+	const dictDir = (0, node_path.resolve)(dynamicDictionariesDir, DICTIONARIES_SUBDIR);
+	await (0, node_fs_promises.mkdir)(dictDir, { recursive: true });
+	const resultDictionariesPaths = {};
+	await require_utils_parallelize.parallelize(Object.entries(mergedDictionaries).sort(([a], [b]) => String(a).localeCompare(String(b))), async ([key, dictionaryEntry]) => {
+		if (key === "undefined") return;
+		const localizedDictionariesPathsRecord = {};
+		const keyDir = (0, node_path.resolve)(dictDir, key);
+		(0, _intlayer_config_utils.assertPathWithin)(keyDir, dictDir);
+		await (0, node_fs_promises.mkdir)(keyDir, { recursive: true });
+		await require_utils_parallelize.parallelize(locales, async (locale) => {
+			const localizedDictionary = (0, _intlayer_core_plugins.getPerLocaleDictionary)(dictionaryEntry.dictionary, locale, defaultLocale);
+			const resultFilePath = (0, node_path.resolve)(keyDir, `${locale}.json`);
+			await require_writeJsonIfChanged.writeJsonIfChanged(resultFilePath, localizedDictionary).catch((err) => {
+				console.error(`Error creating localized ${key}/${locale}.json:`, err);
+			});
+			localizedDictionariesPathsRecord[locale] = {
+				dictionaryPath: resultFilePath,
+				dictionary: localizedDictionary
+			};
+		});
+		resultDictionariesPaths[key] = localizedDictionariesPathsRecord;
+		await require_utils_parallelize.parallelize(formats, async (format) => {
+			const extension = format === "cjs" ? "cjs" : "mjs";
+			const content = generateDictionaryEntryPoint(key, locales, format);
+			const dynEntryPath = (0, node_path.resolve)(dynamicDictionariesDir, `${key}.${extension}`);
+			(0, _intlayer_config_utils.assertPathWithin)(dynEntryPath, dynamicDictionariesDir);
+			await require_writeFileIfChanged.writeFileIfChanged(dynEntryPath, content).catch((err) => {
+				console.error(`Error creating dynamic ${(0, _intlayer_config_logger.colorizePath)(dynEntryPath)}:`, err);
+			});
+		});
+	});
+	return resultDictionariesPaths;
+};
+/**
+* Writes the dynamic chunks and entry points of qualified dictionaries
+* (collections, variants — possibly combined) in
+* `importMode: 'dynamic'`.
+*
+* Each entry is reduced to one per-locale chunk written to a path nested by
+* dimension — `json/{key}/{seg1}/{seg2}/{locale}.json` — and a single
+* `{key}.{ext}` entry point exposes the matching nested loader tree, so the
+* entry point is discovered and aggregated exactly like a plain dynamic one.
+*/
+const writeDynamicQualifiedDictionaries = async (qualifiedDictionaries, configuration, formats = _intlayer_config_defaultValues.OUTPUT_FORMAT) => {
+	const { locales, defaultLocale } = configuration.internationalization;
+	const { dynamicDictionariesDir } = configuration.system;
+	const dictDir = (0, node_path.resolve)(dynamicDictionariesDir, DICTIONARIES_SUBDIR);
+	await (0, node_fs_promises.mkdir)(dictDir, { recursive: true });
+	await require_utils_parallelize.parallelize(Object.entries(qualifiedDictionaries).sort(([a], [b]) => String(a).localeCompare(String(b))), async ([key, { dictionary: group }]) => {
+		if (key === "undefined") return;
+		const entryIds = Object.keys(group.content);
+		const keyDir = (0, node_path.resolve)(dictDir, key);
+		(0, _intlayer_config_utils.assertPathWithin)(keyDir, dictDir);
+		const canonicalSegmentsByContent = /* @__PURE__ */ new Map();
+		const entries = [];
+		const canonicalEntryIds = [];
+		for (const entryId of entryIds) {
+			const treeSegments = entryId.split(_intlayer_core_dictionaryManipulator.COMPOSITE_ID_SEPARATOR);
+			const contentIdentity = JSON.stringify(group.content[entryId]);
+			const canonicalSegments = canonicalSegmentsByContent.get(contentIdentity);
+			if (canonicalSegments) {
+				entries.push({
+					treeSegments,
+					chunkSegments: canonicalSegments
+				});
+				continue;
+			}
+			canonicalSegmentsByContent.set(contentIdentity, treeSegments);
+			entries.push({
+				treeSegments,
+				chunkSegments: treeSegments
+			});
+			canonicalEntryIds.push(entryId);
+		}
+		await require_utils_parallelize.parallelize(canonicalEntryIds, async (entryId) => {
+			const entry = (0, _intlayer_core_dictionaryManipulator.reconstructQualifiedEntry)(group, entryId);
+			const segments = entryId.split(_intlayer_core_dictionaryManipulator.COMPOSITE_ID_SEPARATOR);
+			const entryDir = (0, node_path.resolve)(keyDir, ...segments);
+			(0, _intlayer_config_utils.assertPathWithin)(entryDir, keyDir);
+			await (0, node_fs_promises.mkdir)(entryDir, { recursive: true });
+			await require_utils_parallelize.parallelize(locales, async (locale) => {
+				const localizedDictionary = (0, _intlayer_core_plugins.getPerLocaleDictionary)(entry, locale, defaultLocale);
+				await require_writeJsonIfChanged.writeJsonIfChanged((0, node_path.resolve)(entryDir, `${locale}.json`), localizedDictionary).catch((err) => {
+					console.error(`Error creating localized ${key}/${segments.join("/")}/${locale}.json:`, err);
+				});
+			});
+		});
+		await require_utils_parallelize.parallelize(formats, async (format) => {
+			const extension = format === "cjs" ? "cjs" : "mjs";
+			const content = generateQualifiedDictionaryEntryPoint(key, group.qualifierTypes, entries, locales, format);
+			const dynEntryPath = (0, node_path.resolve)(dynamicDictionariesDir, `${key}.${extension}`);
+			(0, _intlayer_config_utils.assertPathWithin)(dynEntryPath, dynamicDictionariesDir);
+			await require_writeFileIfChanged.writeFileIfChanged(dynEntryPath, content).catch((err) => {
+				console.error(`Error creating dynamic ${(0, _intlayer_config_logger.colorizePath)(dynEntryPath)}:`, err);
+			});
+		});
+	});
+};
+
+//#endregion
+exports.generateDictionaryEntryPoint = generateDictionaryEntryPoint;
+exports.generateQualifiedDictionaryEntryPoint = generateQualifiedDictionaryEntryPoint;
+exports.writeDynamicDictionary = writeDynamicDictionary;
+exports.writeDynamicQualifiedDictionaries = writeDynamicQualifiedDictionaries;
+//# sourceMappingURL=writeDynamicDictionary.cjs.map

package/dist/cjs/buildIntlayerDictionary/writeDynamicDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeDynamicDictionary.cjs","names":["QUALIFIER_DYNAMIC_TYPES_KEY","OUTPUT_FORMAT","parallelize","writeJsonIfChanged","writeFileIfChanged","COMPOSITE_ID_SEPARATOR"],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { assertPathWithin } from '@intlayer/config/utils';\nimport {\n  COMPOSITE_ID_SEPARATOR,\n  QUALIFIER_DYNAMIC_TYPES_KEY,\n  reconstructQualifiedEntry,\n} from '@intlayer/core/dictionaryManipulator';\nimport { getPerLocaleDictionary } from '@intlayer/core/plugins';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type {\n  Dictionary,\n  DictionaryQualifierType,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { PlainMergedDictionaryOutput } from './writeMergedDictionary';\n\nexport type DictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type LocalizedDictionaryResult = Partial<\n  Record<Locale, DictionaryResult>\n>;\n\nexport type LocalizedDictionaryOutput = Record<\n  string,\n  LocalizedDictionaryResult\n>;\n\nconst DICTIONARIES_SUBDIR = 'json'; // Necessary to add a static first dir for Turbopack\n\n/**\n * Escapes a value interpolated into a single-quoted literal of a generated\n * loader module, so keys or segments containing `'` or `\\` cannot break the\n * emitted JavaScript.\n */\nconst escapeJsLiteral = (value: string): string =>\n  value.replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\");\n\n/**\n * Generates the content of a dictionary entry point file.\n */\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const safeKey = escapeJsLiteral(key);\n\n  const localeEntries = sortedLocales\n    .map((locale) => {\n      const safeLocale = escapeJsLiteral(locale);\n      return format === 'esm'\n        ? `  '${safeLocale}': () => import('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json').then(m => m.default)`\n        : `  '${safeLocale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${safeKey}/${safeLocale}.json'))`;\n    })\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return `module.exports = {\\n${localeEntries}\\n};\\n`;\n};\n\n/**\n * A nested loader tree: one level per declared dimension, leaves are loader\n * expression strings.\n */\ntype LoaderTree = { [segment: string]: LoaderTree | string };\n\n/**\n * One entry of a qualified loader map.\n *\n * `treeSegments` is where the entry lives in the loader tree (its composite id\n * segments); `chunkSegments` is the chunk path it loads. They differ when the\n * entry aliases another entry with identical content (e.g. array-variant\n * fan-out): the alias keeps its own tree position but points at the canonical\n * entry's chunk, so equal content is emitted — and downloaded — only once.\n */\nexport type QualifiedEntrySegments = {\n  treeSegments: string[];\n  chunkSegments: string[];\n};\n\nconst buildLoaderExpression = (\n  key: string,\n  chunkSegments: string[],\n  locale: string,\n  format: 'cjs' | 'esm'\n): string => {\n  const path = escapeJsLiteral(\n    `./${DICTIONARIES_SUBDIR}/${key}/${chunkSegments.join('/')}/${locale}.json`\n  );\n\n  return format === 'esm'\n    ? `() => import('${path}').then(m => m.default)`\n    : `() => Promise.resolve(require('${path}'))`;\n};\n\nconst buildLoaderTree = (\n  key: string,\n  entries: QualifiedEntrySegments[],\n  locale: string,\n  format: 'cjs' | 'esm'\n): LoaderTree => {\n  const root: LoaderTree = {};\n\n  for (const { treeSegments, chunkSegments } of entries) {\n    let node = root;\n\n    treeSegments.forEach((segment, index) => {\n      if (index === treeSegments.length - 1) {\n        node[segment] = buildLoaderExpression(\n          key,\n          chunkSegments,\n          locale,\n          format\n        );\n        return;\n      }\n\n      node[segment] = (node[segment] as LoaderTree | undefined) ?? {};\n      node = node[segment] as LoaderTree;\n    });\n  }\n\n  return root;\n};\n\nconst serializeLoaderTree = (tree: LoaderTree, indentLevel: number): string => {\n  const pad = '  '.repeat(indentLevel);\n  const innerPad = '  '.repeat(indentLevel + 1);\n\n  const lines = Object.keys(tree)\n    .sort((a, b) => a.localeCompare(b))\n    .map((segment) => {\n      const value = tree[segment]!;\n      const serialized =\n        typeof value === 'string'\n          ? value\n          : serializeLoaderTree(value, indentLevel + 1);\n\n      return `${innerPad}'${escapeJsLiteral(segment)}': ${serialized}`;\n    });\n\n  return `{\\n${lines.join(',\\n')}\\n${pad}}`;\n};\n\n/**\n * Generates the entry point of a qualified dictionary (collection / variant,\n * possibly combined). Under each locale the loader map nests one\n * level per declared dimension (canonical order) and carries a marker listing\n * those dimensions so the runtime can walk the tree.\n *\n * One static `import()` is emitted per leaf `(locale, …segments)` chunk, which\n * keeps the output compatible with bundlers that reject template-literal\n * dynamic imports (Turbopack). Entries whose content is identical share one\n * chunk: their leaves point at the canonical entry's import path.\n */\nexport const generateQualifiedDictionaryEntryPoint = (\n  key: string,\n  qualifierTypes: DictionaryQualifierType[],\n  entries: QualifiedEntrySegments[],\n  locales: string[],\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const sortedLocales = [...locales].sort((a, b) =>\n    String(a).localeCompare(String(b))\n  );\n\n  const localeEntries = sortedLocales\n    .map((locale) => {\n      const tree = buildLoaderTree(key, entries, locale, format);\n      return `  '${escapeJsLiteral(locale)}': ${serializeLoaderTree(tree, 1)}`;\n    })\n    .join(',\\n');\n\n  const marker = `  '${QUALIFIER_DYNAMIC_TYPES_KEY}': ${JSON.stringify(qualifierTypes)}`;\n\n  if (format === 'esm') {\n    return (\n      `const content = {\\n${marker},\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return `module.exports = {\\n${marker},\\n${localeEntries}\\n};\\n`;\n};\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/dynamic_dictionary/dictionaries/en_home.json\n * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json\n * ```\n */\nexport const writeDynamicDictionary = async (\n  mergedDictionaries: PlainMergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Merge dictionaries with the same key and write to dictionariesDir\n  await parallelize(\n    Object.entries(mergedDictionaries).sort(([a], [b]) =>\n      String(a).localeCompare(String(b))\n    ),\n    async ([key, dictionaryEntry]) => {\n      if (key === 'undefined') return;\n\n      const localizedDictionariesPathsRecord: LocalizedDictionaryResult = {};\n\n      const keyDir = resolve(dictDir, key);\n      assertPathWithin(keyDir, dictDir);\n      await mkdir(keyDir, { recursive: true });\n\n      await parallelize(locales, async (locale) => {\n        const localizedDictionary = getPerLocaleDictionary(\n          dictionaryEntry.dictionary,\n          locale,\n          defaultLocale\n        );\n\n        // Directory structure: json/key/locale.json\n        const resultFilePath = resolve(keyDir, `${locale}.json`);\n\n        await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n          (err) => {\n            console.error(\n              `Error creating localized ${key}/${locale}.json:`,\n              err\n            );\n          }\n        );\n\n        localizedDictionariesPathsRecord[locale] = {\n          dictionaryPath: resultFilePath,\n          dictionary: localizedDictionary,\n        };\n      });\n\n      resultDictionariesPaths[key] = localizedDictionariesPathsRecord;\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateDictionaryEntryPoint(key, locales, format);\n\n        const dynEntryPath = resolve(\n          dynamicDictionariesDir,\n          `${key}.${extension}`\n        );\n        assertPathWithin(dynEntryPath, dynamicDictionariesDir);\n\n        await writeFileIfChanged(dynEntryPath, content).catch((err) => {\n          console.error(\n            `Error creating dynamic ${colorizePath(dynEntryPath)}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n\n  return resultDictionariesPaths;\n};\n\nexport type QualifiedMergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: QualifiedDictionaryGroup;\n};\n\nexport type QualifiedMergedDictionaryOutput = Record<\n  string,\n  QualifiedMergedDictionaryResult\n>;\n\n/**\n * Writes the dynamic chunks and entry points of qualified dictionaries\n * (collections, variants — possibly combined) in\n * `importMode: 'dynamic'`.\n *\n * Each entry is reduced to one per-locale chunk written to a path nested by\n * dimension — `json/{key}/{seg1}/{seg2}/{locale}.json` — and a single\n * `{key}.{ext}` entry point exposes the matching nested loader tree, so the\n * entry point is discovered and aggregated exactly like a plain dynamic one.\n */\nexport const writeDynamicQualifiedDictionaries = async (\n  qualifiedDictionaries: QualifiedMergedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<void> => {\n  const { locales, defaultLocale } = configuration.internationalization;\n  const { dynamicDictionariesDir } = configuration.system;\n\n  const dictDir = resolve(dynamicDictionariesDir, DICTIONARIES_SUBDIR);\n  await mkdir(dictDir, { recursive: true });\n\n  await parallelize(\n    Object.entries(qualifiedDictionaries).sort(([a], [b]) =>\n      String(a).localeCompare(String(b))\n    ),\n    async ([key, { dictionary: group }]) => {\n      if (key === 'undefined') return;\n\n      const entryIds = Object.keys(group.content);\n\n      const keyDir = resolve(dictDir, key);\n      assertPathWithin(keyDir, dictDir);\n\n      // Entries with identical content (e.g. array-variant fan-out) share one\n      // chunk: only the first entry per content identity writes files; the\n      // others become aliases whose loaders point at the canonical chunk path.\n      const canonicalSegmentsByContent = new Map<string, string[]>();\n      const entries: QualifiedEntrySegments[] = [];\n      const canonicalEntryIds: string[] = [];\n\n      for (const entryId of entryIds) {\n        const treeSegments = entryId.split(COMPOSITE_ID_SEPARATOR);\n        const contentIdentity = JSON.stringify(group.content[entryId]);\n        const canonicalSegments =\n          canonicalSegmentsByContent.get(contentIdentity);\n\n        if (canonicalSegments) {\n          entries.push({ treeSegments, chunkSegments: canonicalSegments });\n          continue;\n        }\n\n        canonicalSegmentsByContent.set(contentIdentity, treeSegments);\n        entries.push({ treeSegments, chunkSegments: treeSegments });\n        canonicalEntryIds.push(entryId);\n      }\n\n      await parallelize(canonicalEntryIds, async (entryId) => {\n        // Rebuild a resolvable dictionary from the content node + composite id\n        // so per-locale extraction sees the same `{ key, content }` shape.\n        const entry = reconstructQualifiedEntry(group, entryId);\n\n        const segments = entryId.split(COMPOSITE_ID_SEPARATOR);\n\n        const entryDir = resolve(keyDir, ...segments);\n        assertPathWithin(entryDir, keyDir);\n        await mkdir(entryDir, { recursive: true });\n\n        await parallelize(locales, async (locale) => {\n          const localizedDictionary = getPerLocaleDictionary(\n            entry,\n            locale,\n            defaultLocale\n          );\n\n          // Directory structure: json/key/<…segments>/locale.json\n          const resultFilePath = resolve(entryDir, `${locale}.json`);\n\n          await writeJsonIfChanged(resultFilePath, localizedDictionary).catch(\n            (err) => {\n              console.error(\n                `Error creating localized ${key}/${segments.join('/')}/${locale}.json:`,\n                err\n              );\n            }\n          );\n        });\n      });\n\n      await parallelize(formats, async (format) => {\n        const extension = format === 'cjs' ? 'cjs' : 'mjs';\n        const content = generateQualifiedDictionaryEntryPoint(\n          key,\n          group.qualifierTypes,\n          entries,\n          locales,\n          format\n        );\n\n        const dynEntryPath = resolve(\n          dynamicDictionariesDir,\n          `${key}.${extension}`\n        );\n        assertPathWithin(dynEntryPath, dynamicDictionariesDir);\n\n        await writeFileIfChanged(dynEntryPath, content).catch((err) => {\n          console.error(\n            `Error creating dynamic ${colorizePath(dynEntryPath)}:`,\n            err\n          );\n        });\n      });\n    }\n  );\n};\n"],"mappings":"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"}

package/dist/cjs/buildIntlayerDictionary/writeFetchDictionary.cjs

@@ -0,0 +1,59 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+const require_writeFileIfChanged = require('../writeFileIfChanged.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
+
+//#region src/buildIntlayerDictionary/writeFetchDictionary.ts
+const generateDictionaryEntryPoint = (key, locales, relativePrefix, format = "esm") => {
+	const extension = format === "cjs" ? "cjs" : "mjs";
+	const localeEntries = locales.sort((a, b) => String(a).localeCompare(String(b))).map((locale) => `  '${locale}': async () => {\n    try {\n      const res = await fetch(\`\${editor.liveSyncURL}/dictionaries/${key}/${locale}\`);\n      return await res.json();\n    } catch {\n      return dynContent['${locale}']();\n    }\n  }`).join(",\n");
+	if (format === "esm") return `import { editor } from 'intlayer';\nimport dynContent from '${relativePrefix}/${key}.${extension}';\n\nconst content = {\n${localeEntries}\n};\n\nexport default content;\n`;
+	return `const { editor } = require('intlayer');\nconst dynContent = require('${relativePrefix}/${key}.${extension}');\n\nmodule.exports = {\n${localeEntries}\n};\n`;
+};
+/**
+* Write the localized dictionaries to the dictionariesDir
+* @param mergedDictionaries - The merged dictionaries
+* @param configuration - The configuration
+* @returns The final dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+* console.log(finalDictionaries);
+*
+* // .intlayer/fetch_dictionary/home.mjs
+* // .intlayer/fetch_dictionary/home.cjs
+* ```
+*/
+const writeFetchDictionary = async (dynamicDictionaries, configuration, formats = _intlayer_config_defaultValues.OUTPUT_FORMAT) => {
+	const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;
+	const { locales } = configuration.internationalization;
+	let relativePrefix = (0, _intlayer_config_utils.normalizePath)((0, node_path.relative)(fetchDictionariesDir, dynamicDictionariesDir));
+	if (!relativePrefix.startsWith(".")) relativePrefix = `./${relativePrefix}`;
+	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(fetchDictionariesDir), { recursive: true });
+	const resultDictionariesPaths = {};
+	await require_utils_parallelize.parallelize(Object.entries(dynamicDictionaries), async ([key]) => {
+		if (key === "undefined") return;
+		await require_utils_parallelize.parallelize(formats, async (format) => {
+			const extension = format === "cjs" ? "cjs" : "mjs";
+			const content = generateDictionaryEntryPoint(key, locales, relativePrefix, format);
+			const fetchEntryPath = (0, node_path.resolve)(fetchDictionariesDir, `${key}.${extension}`);
+			(0, _intlayer_config_utils.assertPathWithin)(fetchEntryPath, fetchDictionariesDir);
+			await require_writeFileIfChanged.writeFileIfChanged(fetchEntryPath, content).catch((err) => {
+				console.error(`Error creating fetch ${(0, _intlayer_config_logger.colorizePath)(fetchEntryPath)}:`, err);
+			});
+		});
+	});
+	return resultDictionariesPaths;
+};
+
+//#endregion
+exports.generateDictionaryEntryPoint = generateDictionaryEntryPoint;
+exports.writeFetchDictionary = writeFetchDictionary;
+//# sourceMappingURL=writeFetchDictionary.cjs.map

package/dist/cjs/buildIntlayerDictionary/writeFetchDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeFetchDictionary.cjs","names":["OUTPUT_FORMAT","parallelize","writeFileIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport { OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { assertPathWithin, normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport type { LocalizedDictionaryOutput } from './writeDynamicDictionary';\n\nexport const generateDictionaryEntryPoint = (\n  key: string,\n  locales: string[],\n  relativePrefix: string,\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const localeEntries = locales\n    .sort((a, b) => String(a).localeCompare(String(b)))\n    .map(\n      (locale) =>\n        `  '${locale}': async () => {\\n` +\n        `    try {\\n` +\n        `      const res = await fetch(\\`\\${editor.liveSyncURL}/dictionaries/${key}/${locale}\\`);\\n` +\n        `      return await res.json();\\n` +\n        `    } catch {\\n` +\n        `      return dynContent['${locale}']();\\n` +\n        `    }\\n` +\n        `  }`\n    )\n    .join(',\\n');\n\n  if (format === 'esm') {\n    return (\n      `import { editor } from 'intlayer';\\n` +\n      `import dynContent from '${relativePrefix}/${key}.${extension}';\\n\\n` +\n      `const content = {\\n${localeEntries}\\n};\\n\\n` +\n      `export default content;\\n`\n    );\n  }\n  return (\n    `const { editor } = require('intlayer');\\n` +\n    `const dynContent = require('${relativePrefix}/${key}.${extension}');\\n\\n` +\n    `module.exports = {\\n${localeEntries}\\n};\\n`\n  );\n};\n\n/**\n * Write the localized dictionaries to the dictionariesDir\n * @param mergedDictionaries - The merged dictionaries\n * @param configuration - The configuration\n * @returns The final dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/fetch_dictionary/home.mjs\n * // .intlayer/fetch_dictionary/home.cjs\n * ```\n */\nexport const writeFetchDictionary = async (\n  dynamicDictionaries: LocalizedDictionaryOutput,\n  configuration: IntlayerConfig,\n  formats: ('cjs' | 'esm')[] = OUTPUT_FORMAT\n): Promise<LocalizedDictionaryOutput> => {\n  const { fetchDictionariesDir, dynamicDictionariesDir } = configuration.system;\n  const { locales } = configuration.internationalization;\n\n  // Compute relative path from fetch dir to dynamic dir\n  let relativePrefix = normalizePath(\n    relative(fetchDictionariesDir, dynamicDictionariesDir)\n  );\n  if (!relativePrefix.startsWith('.')) {\n    relativePrefix = `./${relativePrefix}`;\n  }\n\n  await mkdir(resolve(fetchDictionariesDir), { recursive: true });\n\n  const resultDictionariesPaths: LocalizedDictionaryOutput = {};\n\n  // Write entry points for each dictionary in parallel\n  await parallelize(Object.entries(dynamicDictionaries), async ([key]) => {\n    if (key === 'undefined') return;\n\n    await parallelize(formats, async (format) => {\n      const extension = format === 'cjs' ? 'cjs' : 'mjs';\n      const content = generateDictionaryEntryPoint(\n        key,\n        locales,\n        relativePrefix,\n        format\n      );\n\n      const fetchEntryPath = resolve(\n        fetchDictionariesDir,\n        `${key}.${extension}`\n      );\n      assertPathWithin(fetchEntryPath, fetchDictionariesDir);\n\n      await writeFileIfChanged(fetchEntryPath, content).catch((err) => {\n        console.error(\n          `Error creating fetch ${colorizePath(fetchEntryPath)}:`,\n          err\n        );\n      });\n    });\n  });\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,gCACX,KACA,SACA,gBACA,SAAwB,UACb;CACX,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAE7C,MAAM,gBAAgB,QACnB,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAAC,CAClD,KACE,WACC,MAAM,OAAO,mGAE0D,IAAI,GAAG,OAAO,gFAGzD,OAAO,mBAGtC,CACA,KAAK,MAAM;AAEd,KAAI,WAAW,MACb,QACE,+DAC2B,eAAe,GAAG,IAAI,GAAG,UAAU,2BACxC,cAAc;AAIxC,QACE,wEAC+B,eAAe,GAAG,IAAI,GAAG,UAAU,6BAC3C,cAAc;;;;;;;;;;;;;;;;;;AAoBzC,MAAa,uBAAuB,OAClC,qBACA,eACA,UAA6BA,iDACU;CACvC,MAAM,EAAE,sBAAsB,2BAA2B,cAAc;CACvE,MAAM,EAAE,YAAY,cAAc;CAGlC,IAAI,mFACO,sBAAsB,uBAAuB,CACvD;AACD,KAAI,CAAC,eAAe,WAAW,IAAI,CACjC,kBAAiB,KAAK;AAGxB,0DAAoB,qBAAqB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE/D,MAAM,0BAAqD,EAAE;AAG7D,OAAMC,sCAAY,OAAO,QAAQ,oBAAoB,EAAE,OAAO,CAAC,SAAS;AACtE,MAAI,QAAQ,YAAa;AAEzB,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BACd,KACA,SACA,gBACA,OACD;GAED,MAAM,wCACJ,sBACA,GAAG,IAAI,GAAG,YACX;AACD,gDAAiB,gBAAgB,qBAAqB;AAEtD,SAAMC,8CAAmB,gBAAgB,QAAQ,CAAC,OAAO,QAAQ;AAC/D,YAAQ,MACN,kEAAqC,eAAe,CAAC,IACrD,IACD;KACD;IACF;GACF;AAEF,QAAO"}

package/dist/cjs/buildIntlayerDictionary/writeMergedDictionary.cjs

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_utils_parallelize = require('../utils/parallelize.cjs');
+const require_writeJsonIfChanged = require('../writeJsonIfChanged.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
+
+//#region src/buildIntlayerDictionary/writeMergedDictionary.ts
+/**
+* Write the merged dictionaries to the dictionariesDir
+* @param groupedDictionaries - The grouped dictionaries
+* @param configuration - The configuration
+* @returns The merged dictionaries
+*
+* @example
+* ```ts
+* const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+* const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+* console.log(finalDictionaries);
+*
+* // .intlayer/dictionary/home.json
+* // { key: 'home', content: { ... } },
+* ```
+*/
+const writeMergedDictionaries = async (groupedDictionaries, configuration) => {
+	const { dictionariesDir } = configuration.system;
+	await (0, node_fs_promises.mkdir)((0, node_path.resolve)(dictionariesDir), { recursive: true });
+	const results = await require_utils_parallelize.parallelize(Object.entries(groupedDictionaries), async ([key, dictionariesEntry]) => {
+		if (key === "undefined") return;
+		const mergedDictionary = (0, _intlayer_core_dictionaryManipulator.mergeQualifiedDictionaries)((0, _intlayer_core_dictionaryManipulator.normalizeDictionaries)(dictionariesEntry.dictionaries, configuration));
+		const resultFilePath = (0, node_path.resolve)(dictionariesDir, `${key}.json`);
+		(0, _intlayer_config_utils.assertPathWithin)(resultFilePath, dictionariesDir);
+		await require_writeJsonIfChanged.writeJsonIfChanged(resultFilePath, mergedDictionary).catch((err) => {
+			console.error(`Error creating merged ${(0, _intlayer_config_logger.colorizePath)(resultFilePath)}:`, err);
+		});
+		return [key, {
+			dictionaryPath: resultFilePath,
+			dictionary: mergedDictionary
+		}];
+	});
+	return Object.fromEntries(results.filter(Boolean));
+};
+
+//#endregion
+exports.writeMergedDictionaries = writeMergedDictionaries;
+//# sourceMappingURL=writeMergedDictionary.cjs.map

package/dist/cjs/buildIntlayerDictionary/writeMergedDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeMergedDictionary.cjs","names":["parallelize","writeJsonIfChanged"],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport { colorizePath } from '@intlayer/config/logger';\nimport { assertPathWithin } from '@intlayer/config/utils';\nimport {\n  mergeQualifiedDictionaries,\n  normalizeDictionaries,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type {\n  Dictionary,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { UnmergedDictionaryOutput } from './writeUnmergedDictionary';\n\nexport type MergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary | QualifiedDictionaryGroup;\n};\n\nexport type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;\n\n/**\n * Merged output restricted to plain (unqualified) dictionaries — qualified\n * groups (collections, variants) are static-only and filtered\n * out before the dynamic/fetch build steps.\n */\nexport type PlainMergedDictionaryResult = {\n  dictionaryPath: string;\n  dictionary: Dictionary;\n};\n\nexport type PlainMergedDictionaryOutput = Record<\n  string,\n  PlainMergedDictionaryResult\n>;\n\n/**\n * Write the merged dictionaries to the dictionariesDir\n * @param groupedDictionaries - The grouped dictionaries\n * @param configuration - The configuration\n * @returns The merged dictionaries\n *\n * @example\n * ```ts\n * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);\n * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);\n * console.log(finalDictionaries);\n *\n * // .intlayer/dictionary/home.json\n * // { key: 'home', content: { ... } },\n * ```\n */\nexport const writeMergedDictionaries = async (\n  groupedDictionaries: UnmergedDictionaryOutput,\n  configuration: IntlayerConfig\n): Promise<MergedDictionaryOutput> => {\n  const { dictionariesDir } = configuration.system;\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  const results = await parallelize(\n    Object.entries(groupedDictionaries),\n    async ([key, dictionariesEntry]) => {\n      if (key === 'undefined') {\n        return undefined as unknown as readonly [\n          string,\n          MergedDictionaryResult,\n        ];\n      }\n\n      const normalizedDictionaries = normalizeDictionaries(\n        dictionariesEntry.dictionaries,\n        configuration\n      );\n\n      const mergedDictionary = mergeQualifiedDictionaries(\n        normalizedDictionaries\n      );\n\n      const outputFileName = `${key}.json`;\n      const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n      assertPathWithin(resultFilePath, dictionariesDir);\n\n      // Write the merged dictionary\n      await writeJsonIfChanged(resultFilePath, mergedDictionary).catch(\n        (err) => {\n          console.error(\n            `Error creating merged ${colorizePath(resultFilePath)}:`,\n            err\n          );\n        }\n      );\n\n      return [\n        key,\n        {\n          dictionaryPath: resultFilePath,\n          dictionary: mergedDictionary,\n        } as MergedDictionaryResult,\n      ] as const;\n    }\n  );\n\n  return Object.fromEntries(\n    results.filter(Boolean) as Array<readonly [string, MergedDictionaryResult]>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,MAAa,0BAA0B,OACrC,qBACA,kBACoC;CACpC,MAAM,EAAE,oBAAoB,cAAc;AAG1C,0DAAoB,gBAAgB,EAAE,EAAE,WAAW,MAAM,CAAC;CAE1D,MAAM,UAAU,MAAMA,sCACpB,OAAO,QAAQ,oBAAoB,EACnC,OAAO,CAAC,KAAK,uBAAuB;AAClC,MAAI,QAAQ,YACV;EAWF,MAAM,wJAJJ,kBAAkB,cAClB,cAIsB,CACvB;EAGD,MAAM,wCAAyB,iBAAiB,GADtB,IAAI,OACiC;AAE/D,+CAAiB,gBAAgB,gBAAgB;AAGjD,QAAMC,8CAAmB,gBAAgB,iBAAiB,CAAC,OACxD,QAAQ;AACP,WAAQ,MACN,mEAAsC,eAAe,CAAC,IACtD,IACD;IAEJ;AAED,SAAO,CACL,KACA;GACE,gBAAgB;GAChB,YAAY;GACb,CACF;GAEJ;AAED,QAAO,OAAO,YACZ,QAAQ,OAAO,QAAQ,CACxB"}