@intlayer/chokidar 8.12.5-canary.0 → 9.0.0-canary.1

package/dist/cjs/buildIntlayerDictionary/buildIntlayerDictionary.cjs

@@ -5,7 +5,9 @@ const require_buildIntlayerDictionary_writeDynamicDictionary = require('./writeD
 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 = {
@@ -28,22 +30,37 @@ const buildDictionary = async (localDictionariesEntries, configuration, options)
 		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 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 mode = mergedResult.dictionary.importMode ?? importMode;
-		if (mode === "dynamic" || mode === "fetch") dictionariesToBuildDynamic[key] = mergedResult;
+		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 = {};

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

@@ -1 +1 @@
-{"version":3,"file":"buildIntlayerDictionary.cjs","names":["OUTPUT_FORMAT","IMPORT_MODE","readDictionariesFromDisk","writeUnmergedDictionaries","writeMergedDictionaries","writeDynamicDictionary","writeFetchDictionary"],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"sourcesContent":["import { IMPORT_MODE, OUTPUT_FORMAT } from '@intlayer/config/defaultValues';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { readDictionariesFromDisk } from '../utils/readDictionariesFromDisk';\nimport {\n  type LocalizedDictionaryOutput,\n  writeDynamicDictionary,\n} from './writeDynamicDictionary';\nimport { writeFetchDictionary } from './writeFetchDictionary';\nimport { writeMergedDictionaries } 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: typeof mergedDictionaries = {};\n  const keysToBuildFetch = new Set<string>();\n\n  for (const [key, mergedResult] of Object.entries(mergedDictionaries)) {\n    const dictionary = mergedResult.dictionary;\n    const mode = dictionary.importMode ?? importMode;\n\n    if (mode === 'dynamic' || mode === 'fetch') {\n      dictionariesToBuildDynamic[key] = mergedResult;\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  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":";;;;;;;;;;AAkBA,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,gCAAgC,QAC7B,uBACC,mBAAmB,YAAY,kBAAkB,QACpD;AAEH,iCAA6B,KAAK,GAAG,0BAA0B;;;;CAKrE,MAAM,uBAAuB,MAAMC,kFACjC,8BACA,eACA,IACD;CAED,MAAM,qBAAqB,MAAMC,8EAC/B,sBACA,cACD;CAED,MAAM,6BAAwD,EAAE;CAChE,MAAM,mCAAmB,IAAI,KAAa;AAE1C,MAAK,MAAM,CAAC,KAAK,iBAAiB,OAAO,QAAQ,mBAAmB,EAAE;EAEpE,MAAM,OADa,aAAa,WACR,cAAc;AAEtC,MAAI,SAAS,aAAa,SAAS,QACjC,4BAA2B,OAAO;AAGpC,MAAI,SAAS,QACX,kBAAiB,IAAI,IAAI;;CAI7B,IAAI,sBAAwD;AAE5D,KAAI,OAAO,KAAK,2BAA2B,CAAC,SAAS,EACnD,uBAAsB,MAAMC,8EAC1B,4BACA,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"}
+{"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 / meta records 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/writeDynamicDictionary.cjs

@@ -8,6 +8,7 @@ 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
@@ -20,6 +21,51 @@ const generateDictionaryEntryPoint = (key, locales, format = "esm") => {
 	if (format === "esm") return `const content = {\n${localeEntries}\n};\n\nexport default content;\n`;
 	return `module.exports = {\n${localeEntries}\n};\n`;
 };
+const buildLoaderExpression = (key, segments, locale, format) => {
+	const path = `./${DICTIONARIES_SUBDIR}/${key}/${segments.join("/")}/${locale}.json`;
+	return format === "esm" ? `() => import('${path}').then(m => m.default)` : `() => Promise.resolve(require('${path}'))`;
+};
+const buildLoaderTree = (key, entriesSegments, locale, format) => {
+	const root = {};
+	for (const segments of entriesSegments) {
+		let node = root;
+		segments.forEach((segment, index) => {
+			if (index === segments.length - 1) {
+				node[segment] = buildLoaderExpression(key, segments, 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];
+		return `${innerPad}'${segment}': ${typeof value === "string" ? value : serializeLoaderTree(value, indentLevel + 1)}`;
+	}).join(",\n")}\n${pad}}`;
+};
+/**
+* Generates the entry point of a qualified dictionary (collection / variant /
+* meta record, 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).
+*/
+const generateQualifiedDictionaryEntryPoint = (key, qualifierTypes, entriesSegments, locales, format = "esm") => {
+	const localeEntries = [...locales].sort((a, b) => String(a).localeCompare(String(b))).map((locale) => {
+		return `  '${locale}': ${serializeLoaderTree(buildLoaderTree(key, entriesSegments, locale, format), 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
@@ -72,8 +118,56 @@ const writeDynamicDictionary = async (mergedDictionaries, configuration, formats
 	});
 	return resultDictionariesPaths;
 };
+/**
+* Writes the dynamic chunks and entry points of qualified dictionaries
+* (collections, variants, meta records — 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 entriesSegments = [];
+		await require_utils_parallelize.parallelize(entryIds, async (entryId) => {
+			const entry = (0, _intlayer_core_dictionaryManipulator.reconstructQualifiedEntry)(group, entryId);
+			const segments = entryId.split(_intlayer_core_dictionaryManipulator.COMPOSITE_ID_SEPARATOR);
+			entriesSegments.push(segments);
+			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, entriesSegments, 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

@@ -1 +1 @@
-{"version":3,"file":"writeDynamicDictionary.cjs","names":["OUTPUT_FORMAT","parallelize","writeJsonIfChanged","writeFileIfChanged"],"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 { getPerLocaleDictionary } from '@intlayer/core/plugins';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { writeJsonIfChanged } from '../writeJsonIfChanged';\nimport type { MergedDictionaryOutput } 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 * 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 localeEntries = sortedLocales\n    .map((locale) =>\n      format === 'esm'\n        ? `  '${locale}': () => import('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json').then(m => m.default)`\n        : `  '${locale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${key}/${locale}.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 * 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: MergedDictionaryOutput,\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"],"mappings":";;;;;;;;;;;;;AA4BA,MAAM,sBAAsB;;;;AAK5B,MAAa,gCACX,KACA,SACA,SAAwB,UACb;CAKX,MAAM,gBAJgB,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAC1C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CAGD,CAChC,KAAK,WACJ,WAAW,QACP,MAAM,OAAO,qBAAqB,oBAAoB,GAAG,IAAI,GAAG,OAAO,gCACvE,MAAM,OAAO,sCAAsC,oBAAoB,GAAG,IAAI,GAAG,OAAO,UAC7F,CACA,KAAK,MAAM;AAEd,KAAI,WAAW,MACb,QACE,sBAAsB,cAAc;AAIxC,QAAO,uBAAuB,cAAc;;;;;;;;;;;;;;;;;;AAmB9C,MAAa,yBAAyB,OACpC,oBACA,eACA,UAA6BA,iDACU;CACvC,MAAM,EAAE,SAAS,kBAAkB,cAAc;CACjD,MAAM,EAAE,2BAA2B,cAAc;CAEjD,MAAM,iCAAkB,wBAAwB,oBAAoB;AACpE,mCAAY,SAAS,EAAE,WAAW,MAAM,CAAC;CAEzC,MAAM,0BAAqD,EAAE;AAG7D,OAAMC,sCACJ,OAAO,QAAQ,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,OAC7C,OAAO,EAAE,CAAC,cAAc,OAAO,EAAE,CAAC,CACnC,EACD,OAAO,CAAC,KAAK,qBAAqB;AAChC,MAAI,QAAQ,YAAa;EAEzB,MAAM,mCAA8D,EAAE;EAEtE,MAAM,gCAAiB,SAAS,IAAI;AACpC,+CAAiB,QAAQ,QAAQ;AACjC,oCAAY,QAAQ,EAAE,WAAW,MAAM,CAAC;AAExC,QAAMA,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,yEACJ,gBAAgB,YAChB,QACA,cACD;GAGD,MAAM,wCAAyB,QAAQ,GAAG,OAAO,OAAO;AAExD,SAAMC,8CAAmB,gBAAgB,oBAAoB,CAAC,OAC3D,QAAQ;AACP,YAAQ,MACN,4BAA4B,IAAI,GAAG,OAAO,SAC1C,IACD;KAEJ;AAED,oCAAiC,UAAU;IACzC,gBAAgB;IAChB,YAAY;IACb;IACD;AAEF,0BAAwB,OAAO;AAE/B,QAAMD,sCAAY,SAAS,OAAO,WAAW;GAC3C,MAAM,YAAY,WAAW,QAAQ,QAAQ;GAC7C,MAAM,UAAU,6BAA6B,KAAK,SAAS,OAAO;GAElE,MAAM,sCACJ,wBACA,GAAG,IAAI,GAAG,YACX;AACD,gDAAiB,cAAc,uBAAuB;AAEtD,SAAME,8CAAmB,cAAc,QAAQ,CAAC,OAAO,QAAQ;AAC7D,YAAQ,MACN,oEAAuC,aAAa,CAAC,IACrD,IACD;KACD;IACF;GAEL;AAED,QAAO"}
+{"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 * 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 localeEntries = sortedLocales\n    .map((locale) =>\n      format === 'esm'\n        ? `  '${locale}': () => import('./${DICTIONARIES_SUBDIR}/${key}/${locale}.json').then(m => m.default)`\n        : `  '${locale}': () => Promise.resolve(require('./${DICTIONARIES_SUBDIR}/${key}/${locale}.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\nconst buildLoaderExpression = (\n  key: string,\n  segments: string[],\n  locale: string,\n  format: 'cjs' | 'esm'\n): string => {\n  const path = `./${DICTIONARIES_SUBDIR}/${key}/${segments.join('/')}/${locale}.json`;\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  entriesSegments: string[][],\n  locale: string,\n  format: 'cjs' | 'esm'\n): LoaderTree => {\n  const root: LoaderTree = {};\n\n  for (const segments of entriesSegments) {\n    let node = root;\n\n    segments.forEach((segment, index) => {\n      if (index === segments.length - 1) {\n        node[segment] = buildLoaderExpression(key, segments, locale, format);\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}'${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 * meta record, 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).\n */\nexport const generateQualifiedDictionaryEntryPoint = (\n  key: string,\n  qualifierTypes: DictionaryQualifierType[],\n  entriesSegments: 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 localeEntries = sortedLocales\n    .map((locale) => {\n      const tree = buildLoaderTree(key, entriesSegments, locale, format);\n      return `  '${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, meta records — 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      // Per-entry segment lists (one segment per declared dimension), reused for\n      // both the chunk paths and the generated loader tree.\n      const entriesSegments: string[][] = [];\n\n      await parallelize(entryIds, async (entryId) => {\n        // Rebuild a resolvable dictionary from the content node + composite id\n        // so per-locale extraction sees the same `{ key, content, meta? }` shape.\n        const entry = reconstructQualifiedEntry(group, entryId);\n\n        const segments = entryId.split(COMPOSITE_ID_SEPARATOR);\n        entriesSegments.push(segments);\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          entriesSegments,\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/writeMergedDictionary.cjs

@@ -30,7 +30,7 @@ const writeMergedDictionaries = async (groupedDictionaries, configuration) => {
 	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.mergeDictionaries)((0, _intlayer_core_dictionaryManipulator.normalizeDictionaries)(dictionariesEntry.dictionaries, configuration));
+		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) => {

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

@@ -1 +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  mergeDictionaries,\n  normalizeDictionaries,\n} from '@intlayer/core/dictionaryManipulator';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } 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;\n};\n\nexport type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;\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 = mergeDictionaries(normalizedDictionaries);\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,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,+IAJJ,kBAAkB,cAClB,cAG+D,CAAC;EAGlE,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"}
+{"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, meta records) 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"}

package/dist/cjs/createType/createType.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createType.cjs","names":["parallelize"],"sources":["../../../src/createType/createType.ts"],"sourcesContent":["import { mkdir, writeFile } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\n\nexport const generateTypeScriptType = (dictionary: Dictionary) => {\n  const jsonString = JSON.stringify(dictionary, null, 2);\n\n  return `/* eslint-disable */\\nexport default ${jsonString} as const;\\n`;\n};\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionaries: Dictionary[],\n  configuration: IntlayerConfig\n): Promise<string[]> => {\n  const { system } = configuration;\n  const { typesDir } = system;\n\n  // Create type folders if they don't exist\n  await mkdir(typesDir, { recursive: true });\n\n  const results = await parallelize(\n    dictionaries,\n    async (dictionary): Promise<string | undefined> => {\n      if (!dictionary.key) {\n        return undefined;\n      }\n\n      const typeDefinition: string = generateTypeScriptType(dictionary);\n\n      const outputPath: string = resolve(typesDir, `${dictionary.key}.ts`);\n\n      await writeFile(outputPath, typeDefinition);\n\n      return outputPath;\n    }\n  );\n\n  return results.filter(Boolean) as string[];\n};\n"],"mappings":";;;;;;;AAMA,MAAa,0BAA0B,eAA2B;AAGhE,QAAO,wCAFY,KAAK,UAAU,YAAY,MAAM,EAEK,CAAC;;;;;AAK5D,MAAa,cAAc,OACzB,cACA,kBACsB;CACtB,MAAM,EAAE,WAAW;CACnB,MAAM,EAAE,aAAa;AAGrB,mCAAY,UAAU,EAAE,WAAW,MAAM,CAAC;AAmB1C,SAAO,MAjBeA,sCACpB,cACA,OAAO,eAA4C;AACjD,MAAI,CAAC,WAAW,IACd;EAGF,MAAM,iBAAyB,uBAAuB,WAAW;EAEjE,MAAM,oCAA6B,UAAU,GAAG,WAAW,IAAI,KAAK;AAEpE,wCAAgB,YAAY,eAAe;AAE3C,SAAO;GAEV,EAEc,OAAO,QAAQ"}
+{"version":3,"file":"createType.cjs","names":["parallelize"],"sources":["../../../src/createType/createType.ts"],"sourcesContent":["import { mkdir, writeFile } from 'node:fs/promises';\nimport { resolve } from 'node:path';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport type {\n  Dictionary,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport { parallelize } from '../utils/parallelize';\n\nexport const generateTypeScriptType = (\n  dictionary: Dictionary | QualifiedDictionaryGroup\n) => {\n  const jsonString = JSON.stringify(dictionary, null, 2);\n\n  return `/* eslint-disable */\\nexport default ${jsonString} as const;\\n`;\n};\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = async (\n  dictionaries: (Dictionary | QualifiedDictionaryGroup)[],\n  configuration: IntlayerConfig\n): Promise<string[]> => {\n  const { system } = configuration;\n  const { typesDir } = system;\n\n  // Create type folders if they don't exist\n  await mkdir(typesDir, { recursive: true });\n\n  const results = await parallelize(\n    dictionaries,\n    async (dictionary): Promise<string | undefined> => {\n      if (!dictionary.key) {\n        return undefined;\n      }\n\n      const typeDefinition: string = generateTypeScriptType(dictionary);\n\n      const outputPath: string = resolve(typesDir, `${dictionary.key}.ts`);\n\n      await writeFile(outputPath, typeDefinition);\n\n      return outputPath;\n    }\n  );\n\n  return results.filter(Boolean) as string[];\n};\n"],"mappings":";;;;;;;AASA,MAAa,0BACX,eACG;AAGH,QAAO,wCAFY,KAAK,UAAU,YAAY,MAAM,EAEK,CAAC;;;;;AAK5D,MAAa,cAAc,OACzB,cACA,kBACsB;CACtB,MAAM,EAAE,WAAW;CACnB,MAAM,EAAE,aAAa;AAGrB,mCAAY,UAAU,EAAE,WAAW,MAAM,CAAC;AAmB1C,SAAO,MAjBeA,sCACpB,cACA,OAAO,eAA4C;AACjD,MAAI,CAAC,WAAW,IACd;EAGF,MAAM,iBAAyB,uBAAuB,WAAW;EAEjE,MAAM,oCAA6B,UAAU,GAAG,WAAW,IAAI,KAAK;AAEpE,wCAAgB,YAAY,eAAe;AAE3C,SAAO;GAEV,EAEc,OAAO,QAAQ"}

package/dist/cjs/docReview/alignBlocks.cjs

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_docReview_computeSimilarity = require('./computeSimilarity.cjs');
+
+//#region src/docReview/alignBlocks.ts
+/**
+* Align the blocks of a base document with the blocks of its translation using a
+* Needleman–Wunsch global alignment over anchor similarity and block type.
+*
+* Because prose differs across languages, the score is weighted toward the
+* structural anchor (digits and symbols) rather than the words themselves.
+*
+* @param baseBlocks - Blocks of the base (source) document.
+* @param targetBlocks - Blocks of the target (translated) document.
+* @returns The ordered list of alignment pairs, including insertions and deletions.
+*/
+const alignBaseAndTargetBlocks = (baseBlocks, targetBlocks) => {
+	const baseLength = baseBlocks.length;
+	const targetLength = targetBlocks.length;
+	const scoreMatrix = Array.from({ length: baseLength + 1 }, () => Array.from({ length: targetLength + 1 }, () => 0));
+	const traceMatrix = Array.from({ length: baseLength + 1 }, () => Array.from({ length: targetLength + 1 }, () => "diagonal"));
+	const gapPenalty = -2;
+	const computeMatchScore = (baseIndex, targetIndex) => {
+		const baseBlock = baseBlocks[baseIndex];
+		const targetBlock = targetBlocks[targetIndex];
+		const typeBonus = baseBlock.type === targetBlock.type ? 2 : 0;
+		const anchorSimilarity = require_docReview_computeSimilarity.computeJaccardSimilarity(baseBlock.anchorText, targetBlock.anchorText, 3);
+		return typeBonus + (Math.min(baseBlock.content.length, targetBlock.content.length) / Math.max(baseBlock.content.length, targetBlock.content.length) > .75 ? 1 : 0) + anchorSimilarity * 8;
+	};
+	for (let i = 1; i <= baseLength; i += 1) {
+		scoreMatrix[i][0] = scoreMatrix[i - 1][0] + gapPenalty;
+		traceMatrix[i][0] = "up";
+	}
+	for (let j = 1; j <= targetLength; j += 1) {
+		scoreMatrix[0][j] = scoreMatrix[0][j - 1] + gapPenalty;
+		traceMatrix[0][j] = "left";
+	}
+	for (let i = 1; i <= baseLength; i += 1) for (let j = 1; j <= targetLength; j += 1) {
+		const match = scoreMatrix[i - 1][j - 1] + computeMatchScore(i - 1, j - 1);
+		const deleteGap = scoreMatrix[i - 1][j] + gapPenalty;
+		const insertGap = scoreMatrix[i][j - 1] + gapPenalty;
+		const best = Math.max(match, deleteGap, insertGap);
+		scoreMatrix[i][j] = best;
+		traceMatrix[i][j] = best === match ? "diagonal" : best === deleteGap ? "up" : "left";
+	}
+	const result = [];
+	let i = baseLength;
+	let j = targetLength;
+	while (i > 0 || j > 0) if (i > 0 && j > 0 && traceMatrix[i][j] === "diagonal") {
+		const baseIndex = i - 1;
+		const targetIndex = j - 1;
+		const similarityScore = require_docReview_computeSimilarity.computeJaccardSimilarity(baseBlocks[baseIndex].anchorText, targetBlocks[targetIndex].anchorText, 3);
+		result.unshift({
+			baseIndex,
+			targetIndex,
+			similarityScore
+		});
+		i -= 1;
+		j -= 1;
+	} else if (i > 0 && (j === 0 || traceMatrix[i][j] === "up")) {
+		result.unshift({
+			baseIndex: i - 1,
+			targetIndex: null,
+			similarityScore: 0
+		});
+		i -= 1;
+	} else if (j > 0 && (i === 0 || traceMatrix[i][j] === "left")) {
+		result.unshift({
+			baseIndex: -1,
+			targetIndex: j - 1,
+			similarityScore: 0
+		});
+		j -= 1;
+	}
+	return result;
+};
+
+//#endregion
+exports.alignBaseAndTargetBlocks = alignBaseAndTargetBlocks;
+//# sourceMappingURL=alignBlocks.cjs.map

package/dist/cjs/docReview/alignBlocks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignBlocks.cjs","names":["computeJaccardSimilarity"],"sources":["../../../src/docReview/alignBlocks.ts"],"sourcesContent":["import { computeJaccardSimilarity } from './computeSimilarity';\nimport type { AlignmentPair, FingerprintedBlock } from './types';\n\n/**\n * Align the blocks of a base document with the blocks of its translation using a\n * Needleman–Wunsch global alignment over anchor similarity and block type.\n *\n * Because prose differs across languages, the score is weighted toward the\n * structural anchor (digits and symbols) rather than the words themselves.\n *\n * @param baseBlocks - Blocks of the base (source) document.\n * @param targetBlocks - Blocks of the target (translated) document.\n * @returns The ordered list of alignment pairs, including insertions and deletions.\n */\nexport const alignBaseAndTargetBlocks = (\n  baseBlocks: FingerprintedBlock[],\n  targetBlocks: FingerprintedBlock[]\n): AlignmentPair[] => {\n  const baseLength = baseBlocks.length;\n  const targetLength = targetBlocks.length;\n\n  const scoreMatrix: number[][] = Array.from({ length: baseLength + 1 }, () =>\n    Array.from({ length: targetLength + 1 }, () => 0)\n  );\n  const traceMatrix: ('diagonal' | 'up' | 'left')[][] = Array.from(\n    { length: baseLength + 1 },\n    () => Array.from({ length: targetLength + 1 }, () => 'diagonal')\n  );\n\n  const gapPenalty = -2;\n\n  const computeMatchScore = (\n    baseIndex: number,\n    targetIndex: number\n  ): number => {\n    const baseBlock = baseBlocks[baseIndex];\n    const targetBlock = targetBlocks[targetIndex];\n    const typeBonus = baseBlock.type === targetBlock.type ? 2 : 0;\n    const anchorSimilarity = computeJaccardSimilarity(\n      baseBlock.anchorText,\n      targetBlock.anchorText,\n      3\n    );\n    const lengthRatio =\n      Math.min(baseBlock.content.length, targetBlock.content.length) /\n      Math.max(baseBlock.content.length, targetBlock.content.length);\n    const lengthBonus = lengthRatio > 0.75 ? 1 : 0;\n    return typeBonus + lengthBonus + anchorSimilarity * 8; // weighted toward anchor similarity\n  };\n\n  // initialize first row and column\n  for (let i = 1; i <= baseLength; i += 1) {\n    scoreMatrix[i][0] = scoreMatrix[i - 1][0] + gapPenalty;\n    traceMatrix[i][0] = 'up';\n  }\n  for (let j = 1; j <= targetLength; j += 1) {\n    scoreMatrix[0][j] = scoreMatrix[0][j - 1] + gapPenalty;\n    traceMatrix[0][j] = 'left';\n  }\n\n  // fill\n  for (let i = 1; i <= baseLength; i += 1) {\n    for (let j = 1; j <= targetLength; j += 1) {\n      const match = scoreMatrix[i - 1][j - 1] + computeMatchScore(i - 1, j - 1);\n      const deleteGap = scoreMatrix[i - 1][j] + gapPenalty;\n      const insertGap = scoreMatrix[i][j - 1] + gapPenalty;\n\n      const best = Math.max(match, deleteGap, insertGap);\n      scoreMatrix[i][j] = best;\n      traceMatrix[i][j] =\n        best === match ? 'diagonal' : best === deleteGap ? 'up' : 'left';\n    }\n  }\n\n  // traceback\n  const result: AlignmentPair[] = [];\n  let i = baseLength;\n  let j = targetLength;\n  while (i > 0 || j > 0) {\n    if (i > 0 && j > 0 && traceMatrix[i][j] === 'diagonal') {\n      const baseIndex = i - 1;\n      const targetIndex = j - 1;\n      const similarityScore = computeJaccardSimilarity(\n        baseBlocks[baseIndex].anchorText,\n        targetBlocks[targetIndex].anchorText,\n        3\n      );\n      result.unshift({ baseIndex, targetIndex, similarityScore });\n      i -= 1;\n      j -= 1;\n    } else if (i > 0 && (j === 0 || traceMatrix[i][j] === 'up')) {\n      result.unshift({\n        baseIndex: i - 1,\n        targetIndex: null,\n        similarityScore: 0,\n      });\n      i -= 1;\n    } else if (j > 0 && (i === 0 || traceMatrix[i][j] === 'left')) {\n      // target block has no corresponding base block (deleted)\n      result.unshift({\n        baseIndex: -1,\n        targetIndex: j - 1,\n        similarityScore: 0,\n      });\n      j -= 1;\n    }\n  }\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAa,4BACX,YACA,iBACoB;CACpB,MAAM,aAAa,WAAW;CAC9B,MAAM,eAAe,aAAa;CAElC,MAAM,cAA0B,MAAM,KAAK,EAAE,QAAQ,aAAa,GAAG,QACnE,MAAM,KAAK,EAAE,QAAQ,eAAe,GAAG,QAAQ,EAAE,CAClD;CACD,MAAM,cAAgD,MAAM,KAC1D,EAAE,QAAQ,aAAa,GAAG,QACpB,MAAM,KAAK,EAAE,QAAQ,eAAe,GAAG,QAAQ,WAAW,CACjE;CAED,MAAM,aAAa;CAEnB,MAAM,qBACJ,WACA,gBACW;EACX,MAAM,YAAY,WAAW;EAC7B,MAAM,cAAc,aAAa;EACjC,MAAM,YAAY,UAAU,SAAS,YAAY,OAAO,IAAI;EAC5D,MAAM,mBAAmBA,6DACvB,UAAU,YACV,YAAY,YACZ,EACD;AAKD,SAAO,aAHL,KAAK,IAAI,UAAU,QAAQ,QAAQ,YAAY,QAAQ,OAAO,GAC9D,KAAK,IAAI,UAAU,QAAQ,QAAQ,YAAY,QAAQ,OAAO,GAC9B,MAAO,IAAI,KACZ,mBAAmB;;AAItD,MAAK,IAAI,IAAI,GAAG,KAAK,YAAY,KAAK,GAAG;AACvC,cAAY,GAAG,KAAK,YAAY,IAAI,GAAG,KAAK;AAC5C,cAAY,GAAG,KAAK;;AAEtB,MAAK,IAAI,IAAI,GAAG,KAAK,cAAc,KAAK,GAAG;AACzC,cAAY,GAAG,KAAK,YAAY,GAAG,IAAI,KAAK;AAC5C,cAAY,GAAG,KAAK;;AAItB,MAAK,IAAI,IAAI,GAAG,KAAK,YAAY,KAAK,EACpC,MAAK,IAAI,IAAI,GAAG,KAAK,cAAc,KAAK,GAAG;EACzC,MAAM,QAAQ,YAAY,IAAI,GAAG,IAAI,KAAK,kBAAkB,IAAI,GAAG,IAAI,EAAE;EACzE,MAAM,YAAY,YAAY,IAAI,GAAG,KAAK;EAC1C,MAAM,YAAY,YAAY,GAAG,IAAI,KAAK;EAE1C,MAAM,OAAO,KAAK,IAAI,OAAO,WAAW,UAAU;AAClD,cAAY,GAAG,KAAK;AACpB,cAAY,GAAG,KACb,SAAS,QAAQ,aAAa,SAAS,YAAY,OAAO;;CAKhE,MAAM,SAA0B,EAAE;CAClC,IAAI,IAAI;CACR,IAAI,IAAI;AACR,QAAO,IAAI,KAAK,IAAI,EAClB,KAAI,IAAI,KAAK,IAAI,KAAK,YAAY,GAAG,OAAO,YAAY;EACtD,MAAM,YAAY,IAAI;EACtB,MAAM,cAAc,IAAI;EACxB,MAAM,kBAAkBA,6DACtB,WAAW,WAAW,YACtB,aAAa,aAAa,YAC1B,EACD;AACD,SAAO,QAAQ;GAAE;GAAW;GAAa;GAAiB,CAAC;AAC3D,OAAK;AACL,OAAK;YACI,IAAI,MAAM,MAAM,KAAK,YAAY,GAAG,OAAO,OAAO;AAC3D,SAAO,QAAQ;GACb,WAAW,IAAI;GACf,aAAa;GACb,iBAAiB;GAClB,CAAC;AACF,OAAK;YACI,IAAI,MAAM,MAAM,KAAK,YAAY,GAAG,OAAO,SAAS;AAE7D,SAAO,QAAQ;GACb,WAAW;GACX,aAAa,IAAI;GACjB,iBAAiB;GAClB,CAAC;AACF,OAAK;;AAGT,QAAO"}

package/dist/cjs/docReview/computeSimilarity.cjs

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/docReview/computeSimilarity.ts
+/**
+* Generate the set of character shingles (substrings of a fixed length) for a
+* piece of text. Whitespace is collapsed so the result is language agnostic.
+*
+* @param text - The text to shingle.
+* @param shingleLength - The length of each shingle.
+* @returns The set of unique shingles found in the text.
+*/
+const generateCharacterShingles = (text, shingleLength) => {
+	const normalized = text.replace(/\s+/g, " ").trim();
+	const set = /* @__PURE__ */ new Set();
+	if (normalized.length < shingleLength) {
+		if (normalized.length > 0) set.add(normalized);
+		return set;
+	}
+	for (let index = 0; index <= normalized.length - shingleLength; index += 1) set.add(normalized.slice(index, index + shingleLength));
+	return set;
+};
+/**
+* Compute the Jaccard similarity between two strings using character shingles.
+*
+* @param a - First string.
+* @param b - Second string.
+* @param shingleLength - The shingle length (defaults to 3).
+* @returns A score between 0 (disjoint) and 1 (identical).
+*/
+const computeJaccardSimilarity = (a, b, shingleLength = 3) => {
+	const setA = generateCharacterShingles(a, shingleLength);
+	const setB = generateCharacterShingles(b, shingleLength);
+	if (setA.size === 0 && setB.size === 0) return 1;
+	const intersectionSize = Array.from(setA).filter((token) => setB.has(token)).length;
+	const unionSize = new Set([...Array.from(setA), ...Array.from(setB)]).size;
+	return unionSize === 0 ? 0 : intersectionSize / unionSize;
+};
+
+//#endregion
+exports.computeJaccardSimilarity = computeJaccardSimilarity;
+exports.generateCharacterShingles = generateCharacterShingles;
+//# sourceMappingURL=computeSimilarity.cjs.map

package/dist/cjs/docReview/computeSimilarity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeSimilarity.cjs","names":[],"sources":["../../../src/docReview/computeSimilarity.ts"],"sourcesContent":["/**\n * Generate the set of character shingles (substrings of a fixed length) for a\n * piece of text. Whitespace is collapsed so the result is language agnostic.\n *\n * @param text - The text to shingle.\n * @param shingleLength - The length of each shingle.\n * @returns The set of unique shingles found in the text.\n */\nexport const generateCharacterShingles = (\n  text: string,\n  shingleLength: number\n): Set<string> => {\n  const normalized = text.replace(/\\s+/g, ' ').trim();\n  const set = new Set<string>();\n  if (normalized.length < shingleLength) {\n    if (normalized.length > 0) {\n      set.add(normalized);\n    }\n    return set;\n  }\n  for (let index = 0; index <= normalized.length - shingleLength; index += 1) {\n    set.add(normalized.slice(index, index + shingleLength));\n  }\n  return set;\n};\n\n/**\n * Compute the Jaccard similarity between two strings using character shingles.\n *\n * @param a - First string.\n * @param b - Second string.\n * @param shingleLength - The shingle length (defaults to 3).\n * @returns A score between 0 (disjoint) and 1 (identical).\n */\nexport const computeJaccardSimilarity = (\n  a: string,\n  b: string,\n  shingleLength: number = 3\n): number => {\n  const setA = generateCharacterShingles(a, shingleLength);\n  const setB = generateCharacterShingles(b, shingleLength);\n  if (setA.size === 0 && setB.size === 0) return 1;\n  const intersectionSize = Array.from(setA).filter((token) =>\n    setB.has(token)\n  ).length;\n  const unionSize = new Set([...Array.from(setA), ...Array.from(setB)]).size;\n  return unionSize === 0 ? 0 : intersectionSize / unionSize;\n};\n"],"mappings":";;;;;;;;;;;AAQA,MAAa,6BACX,MACA,kBACgB;CAChB,MAAM,aAAa,KAAK,QAAQ,QAAQ,IAAI,CAAC,MAAM;CACnD,MAAM,sBAAM,IAAI,KAAa;AAC7B,KAAI,WAAW,SAAS,eAAe;AACrC,MAAI,WAAW,SAAS,EACtB,KAAI,IAAI,WAAW;AAErB,SAAO;;AAET,MAAK,IAAI,QAAQ,GAAG,SAAS,WAAW,SAAS,eAAe,SAAS,EACvE,KAAI,IAAI,WAAW,MAAM,OAAO,QAAQ,cAAc,CAAC;AAEzD,QAAO;;;;;;;;;;AAWT,MAAa,4BACX,GACA,GACA,gBAAwB,MACb;CACX,MAAM,OAAO,0BAA0B,GAAG,cAAc;CACxD,MAAM,OAAO,0BAA0B,GAAG,cAAc;AACxD,KAAI,KAAK,SAAS,KAAK,KAAK,SAAS,EAAG,QAAO;CAC/C,MAAM,mBAAmB,MAAM,KAAK,KAAK,CAAC,QAAQ,UAChD,KAAK,IAAI,MAAM,CAChB,CAAC;CACF,MAAM,YAAY,IAAI,IAAI,CAAC,GAAG,MAAM,KAAK,KAAK,EAAE,GAAG,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC;AACtE,QAAO,cAAc,IAAI,IAAI,mBAAmB"}

package/dist/cjs/docReview/fingerprintBlock.cjs

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_crypto = require("node:crypto");
+node_crypto = require_runtime.__toESM(node_crypto);
+
+//#region src/docReview/fingerprintBlock.ts
+const computeStringDigest = (text) => node_crypto.default.createHash("sha256").update(text).digest("hex");
+/**
+* Compute content and context digests for a normalized block.
+*
+* The context key (digest of the surrounding blocks) lets the planner tell apart
+* two blocks that share the same content but live in different sections.
+*
+* @param block - The block to fingerprint.
+* @param previousBlock - The block immediately before, or `null` at the start.
+* @param nextBlock - The block immediately after, or `null` at the end.
+* @returns The block enriched with its digests.
+*/
+const fingerprintBlock = (block, previousBlock, nextBlock) => {
+	const semanticDigest = computeStringDigest(block.semanticText);
+	const anchorDigest = computeStringDigest(block.anchorText);
+	const compositeKey = `${semanticDigest}:${anchorDigest}`;
+	const contextKey = computeStringDigest(`${computeStringDigest(previousBlock?.semanticText ?? "")}:${computeStringDigest(nextBlock?.semanticText ?? "")}`);
+	return {
+		...block,
+		semanticDigest,
+		anchorDigest,
+		compositeKey,
+		contextKey
+	};
+};
+
+//#endregion
+exports.fingerprintBlock = fingerprintBlock;
+//# sourceMappingURL=fingerprintBlock.cjs.map

package/dist/cjs/docReview/fingerprintBlock.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprintBlock.cjs","names":["crypto"],"sources":["../../../src/docReview/fingerprintBlock.ts"],"sourcesContent":["import crypto from 'node:crypto';\nimport type { FingerprintedBlock, NormalizedBlock } from './types';\n\nconst computeStringDigest = (text: string): string =>\n  crypto.createHash('sha256').update(text).digest('hex');\n\n/**\n * Compute content and context digests for a normalized block.\n *\n * The context key (digest of the surrounding blocks) lets the planner tell apart\n * two blocks that share the same content but live in different sections.\n *\n * @param block - The block to fingerprint.\n * @param previousBlock - The block immediately before, or `null` at the start.\n * @param nextBlock - The block immediately after, or `null` at the end.\n * @returns The block enriched with its digests.\n */\nexport const fingerprintBlock = (\n  block: NormalizedBlock,\n  previousBlock: NormalizedBlock | null,\n  nextBlock: NormalizedBlock | null\n): FingerprintedBlock => {\n  const semanticDigest = computeStringDigest(block.semanticText);\n  const anchorDigest = computeStringDigest(block.anchorText);\n  const compositeKey = `${semanticDigest}:${anchorDigest}`;\n\n  const previousDigest = computeStringDigest(previousBlock?.semanticText ?? '');\n  const nextDigest = computeStringDigest(nextBlock?.semanticText ?? '');\n  const contextKey = computeStringDigest(`${previousDigest}:${nextDigest}`);\n\n  return {\n    ...block,\n    semanticDigest,\n    anchorDigest,\n    compositeKey,\n    contextKey,\n  };\n};\n"],"mappings":";;;;;;AAGA,MAAM,uBAAuB,SAC3BA,oBAAO,WAAW,SAAS,CAAC,OAAO,KAAK,CAAC,OAAO,MAAM;;;;;;;;;;;;AAaxD,MAAa,oBACX,OACA,eACA,cACuB;CACvB,MAAM,iBAAiB,oBAAoB,MAAM,aAAa;CAC9D,MAAM,eAAe,oBAAoB,MAAM,WAAW;CAC1D,MAAM,eAAe,GAAG,eAAe,GAAG;CAI1C,MAAM,aAAa,oBAAoB,GAFhB,oBAAoB,eAAe,gBAAgB,GAElB,CAAC,GADtC,oBAAoB,WAAW,gBAAgB,GACI,GAAG;AAEzE,QAAO;EACL,GAAG;EACH;EACA;EACA;EACA;EACD"}

package/dist/cjs/docReview/index.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_docReview_planActions = require('./planActions.cjs');
+const require_docReview_normalizeBlock = require('./normalizeBlock.cjs');
+const require_docReview_fingerprintBlock = require('./fingerprintBlock.cjs');
+const require_docReview_computeSimilarity = require('./computeSimilarity.cjs');
+const require_docReview_mapChangedLinesToBlocks = require('./mapChangedLinesToBlocks.cjs');
+const require_docReview_alignBlocks = require('./alignBlocks.cjs');
+const require_docReview_rebuildDocument = require('./rebuildDocument.cjs');
+const require_docReview_segmentDocument = require('./segmentDocument.cjs');
+const require_docReview_pipeline = require('./pipeline.cjs');
+const require_docReview_reviewReport = require('./reviewReport.cjs');
+
+exports.alignBaseAndTargetBlocks = require_docReview_alignBlocks.alignBaseAndTargetBlocks;
+exports.buildAlignmentPlan = require_docReview_pipeline.buildAlignmentPlan;
+exports.buildReviewReport = require_docReview_reviewReport.buildReviewReport;
+exports.computeJaccardSimilarity = require_docReview_computeSimilarity.computeJaccardSimilarity;
+exports.fingerprintBlock = require_docReview_fingerprintBlock.fingerprintBlock;
+exports.formatReviewReport = require_docReview_reviewReport.formatReviewReport;
+exports.generateCharacterShingles = require_docReview_computeSimilarity.generateCharacterShingles;
+exports.identifySegmentsToReview = require_docReview_rebuildDocument.identifySegmentsToReview;
+exports.mapChangedLinesToBlocks = require_docReview_mapChangedLinesToBlocks.mapChangedLinesToBlocks;
+exports.mergeReviewedSegments = require_docReview_rebuildDocument.mergeReviewedSegments;
+exports.normalizeBlock = require_docReview_normalizeBlock.normalizeBlock;
+exports.planAlignmentActions = require_docReview_planActions.planAlignmentActions;
+exports.segmentDocument = require_docReview_segmentDocument.segmentDocument;

package/dist/cjs/docReview/mapChangedLinesToBlocks.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/docReview/mapChangedLinesToBlocks.ts
+/**
+* Map a set of changed line numbers onto the indexes of the blocks that contain
+* them.
+*
+* @param blocks - The ordered blocks of the base document.
+* @param changedLines - 1-based line numbers that changed in the base document.
+* @returns The set of block indexes touched by at least one changed line.
+*/
+const mapChangedLinesToBlocks = (blocks, changedLines) => {
+	const changedSet = /* @__PURE__ */ new Set();
+	if (!changedLines || changedLines.length === 0) return changedSet;
+	const changedLookup = new Set(changedLines);
+	blocks.forEach((block, index) => {
+		for (let line = block.lineStart; line <= block.lineEnd; line += 1) if (changedLookup.has(line)) {
+			changedSet.add(index);
+			break;
+		}
+	});
+	return changedSet;
+};
+
+//#endregion
+exports.mapChangedLinesToBlocks = mapChangedLinesToBlocks;
+//# sourceMappingURL=mapChangedLinesToBlocks.cjs.map

package/dist/cjs/docReview/mapChangedLinesToBlocks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapChangedLinesToBlocks.cjs","names":[],"sources":["../../../src/docReview/mapChangedLinesToBlocks.ts"],"sourcesContent":["import type { Block, LineChange } from './types';\n\n/**\n * Map a set of changed line numbers onto the indexes of the blocks that contain\n * them.\n *\n * @param blocks - The ordered blocks of the base document.\n * @param changedLines - 1-based line numbers that changed in the base document.\n * @returns The set of block indexes touched by at least one changed line.\n */\nexport const mapChangedLinesToBlocks = (\n  blocks: Block[],\n  changedLines: LineChange[]\n): Set<number> => {\n  const changedSet = new Set<number>();\n  if (!changedLines || changedLines.length === 0) return changedSet;\n\n  const changedLookup = new Set<number>(changedLines);\n\n  blocks.forEach((block, index) => {\n    for (let line = block.lineStart; line <= block.lineEnd; line += 1) {\n      if (changedLookup.has(line)) {\n        changedSet.add(index);\n        break;\n      }\n    }\n  });\n\n  return changedSet;\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,2BACX,QACA,iBACgB;CAChB,MAAM,6BAAa,IAAI,KAAa;AACpC,KAAI,CAAC,gBAAgB,aAAa,WAAW,EAAG,QAAO;CAEvD,MAAM,gBAAgB,IAAI,IAAY,aAAa;AAEnD,QAAO,SAAS,OAAO,UAAU;AAC/B,OAAK,IAAI,OAAO,MAAM,WAAW,QAAQ,MAAM,SAAS,QAAQ,EAC9D,KAAI,cAAc,IAAI,KAAK,EAAE;AAC3B,cAAW,IAAI,MAAM;AACrB;;GAGJ;AAEF,QAAO"}

package/dist/cjs/docReview/normalizeBlock.cjs

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/docReview/normalizeBlock.ts
+const removeMarkdownFormatting = (text) => {
+	return text.replace(/`{1,3}[^`]*`{1,3}/g, " ").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/_([^_]+)_/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/!?\[[^\]]*\]\([^)]*\)/g, " ").replace(/^\s*#{1,6}\s+/gm, "").replace(/^\s*>\s?/gm, "").replace(/^\s*[-*+]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "");
+};
+const collapseWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+const stripLettersKeepDigitsAndSymbols = (text) => {
+	return text.replace(/\p{L}+/gu, "");
+};
+/**
+* Derive the normalized representations of a block used for matching.
+*
+* - `semanticText`: markdown-stripped, lower-cased text (used to detect identical
+*   content across versions of the same language).
+* - `anchorText`: only digits/symbols (used to align blocks across languages, as
+*   prose differs but structure such as numbers and punctuation is preserved).
+*
+* @param block - The block to normalize.
+* @returns The block enriched with its normalized texts.
+*/
+const normalizeBlock = (block) => {
+	const semanticCollapsed = collapseWhitespace(removeMarkdownFormatting(block.content).toLowerCase());
+	const anchorCollapsed = collapseWhitespace(stripLettersKeepDigitsAndSymbols(block.content));
+	return {
+		...block,
+		semanticText: semanticCollapsed,
+		anchorText: anchorCollapsed
+	};
+};
+
+//#endregion
+exports.normalizeBlock = normalizeBlock;
+//# sourceMappingURL=normalizeBlock.cjs.map

package/dist/cjs/docReview/normalizeBlock.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeBlock.cjs","names":[],"sources":["../../../src/docReview/normalizeBlock.ts"],"sourcesContent":["import type { Block, NormalizedBlock } from './types';\n\nconst removeMarkdownFormatting = (text: string): string => {\n  return text\n    .replace(/`{1,3}[^`]*`{1,3}/g, ' ')\n    .replace(/\\*\\*([^*]+)\\*\\*/g, '$1')\n    .replace(/\\*([^*]+)\\*/g, '$1')\n    .replace(/_([^_]+)_/g, '$1')\n    .replace(/~~([^~]+)~~/g, '$1')\n    .replace(/!?\\[[^\\]]*\\]\\([^)]*\\)/g, ' ')\n    .replace(/^\\s*#{1,6}\\s+/gm, '')\n    .replace(/^\\s*>\\s?/gm, '')\n    .replace(/^\\s*[-*+]\\s+/gm, '')\n    .replace(/^\\s*\\d+\\.\\s+/gm, '');\n};\n\nconst collapseWhitespace = (text: string): string =>\n  text.replace(/\\s+/g, ' ').trim();\n\nconst stripLettersKeepDigitsAndSymbols = (text: string): string => {\n  // Keep digits and non-letter characters, remove all letters (including accents)\n  return text.replace(/\\p{L}+/gu, '');\n};\n\n/**\n * Derive the normalized representations of a block used for matching.\n *\n * - `semanticText`: markdown-stripped, lower-cased text (used to detect identical\n *   content across versions of the same language).\n * - `anchorText`: only digits/symbols (used to align blocks across languages, as\n *   prose differs but structure such as numbers and punctuation is preserved).\n *\n * @param block - The block to normalize.\n * @returns The block enriched with its normalized texts.\n */\nexport const normalizeBlock = (block: Block): NormalizedBlock => {\n  const contentWithoutMarkdown = removeMarkdownFormatting(block.content);\n  const semanticLowercased = contentWithoutMarkdown.toLowerCase();\n  const semanticCollapsed = collapseWhitespace(semanticLowercased);\n\n  const anchorOnlySymbols = stripLettersKeepDigitsAndSymbols(block.content);\n  const anchorCollapsed = collapseWhitespace(anchorOnlySymbols);\n\n  return {\n    ...block,\n    semanticText: semanticCollapsed,\n    anchorText: anchorCollapsed,\n  };\n};\n"],"mappings":";;;AAEA,MAAM,4BAA4B,SAAyB;AACzD,QAAO,KACJ,QAAQ,sBAAsB,IAAI,CAClC,QAAQ,oBAAoB,KAAK,CACjC,QAAQ,gBAAgB,KAAK,CAC7B,QAAQ,cAAc,KAAK,CAC3B,QAAQ,gBAAgB,KAAK,CAC7B,QAAQ,0BAA0B,IAAI,CACtC,QAAQ,mBAAmB,GAAG,CAC9B,QAAQ,cAAc,GAAG,CACzB,QAAQ,kBAAkB,GAAG,CAC7B,QAAQ,kBAAkB,GAAG;;AAGlC,MAAM,sBAAsB,SAC1B,KAAK,QAAQ,QAAQ,IAAI,CAAC,MAAM;AAElC,MAAM,oCAAoC,SAAyB;AAEjE,QAAO,KAAK,QAAQ,YAAY,GAAG;;;;;;;;;;;;;AAcrC,MAAa,kBAAkB,UAAkC;CAG/D,MAAM,oBAAoB,mBAFK,yBAAyB,MAAM,QACb,CAAC,aACa,CAAC;CAGhE,MAAM,kBAAkB,mBADE,iCAAiC,MAAM,QACL,CAAC;AAE7D,QAAO;EACL,GAAG;EACH,cAAc;EACd,YAAY;EACb"}