@intlayer/chokidar 6.0.2 → 6.1.1

package/dist/cjs/{transpiler/dictionary_to_main → createDictionaryEntryPoint}/createDictionaryEntryPoint.cjs

@@ -24,14 +24,14 @@ module.exports = __toCommonJS(createDictionaryEntryPoint_exports);
 var import_config = require("@intlayer/config");
 var import_promises = require("fs/promises");
 var import_path = require("path");
-var import_getBuiltDictionariesPath = require('../../getBuiltDictionariesPath.cjs');
-var import_getBuiltDynamicDictionariesPath = require('../../getBuiltDynamicDictionariesPath.cjs');
-var import_getBuiltFetchDictionariesPath = require('../../getBuiltFetchDictionariesPath.cjs');
-var import_getBuiltRemoteDictionariesPath = require('../../getBuiltRemoteDictionariesPath.cjs');
-var import_getBuiltUnmergedDictionariesPath = require('../../getBuiltUnmergedDictionariesPath.cjs');
-var import_parallelize = require('../../utils/parallelize.cjs');
-var import_writeFileIfChanged = require('../../writeFileIfChanged.cjs');
+var import_parallelize = require('../utils/parallelize.cjs');
+var import_writeFileIfChanged = require('../writeFileIfChanged.cjs');
 var import_generateDictionaryListContent = require('./generateDictionaryListContent.cjs');
+var import_getBuiltDictionariesPath = require('./getBuiltDictionariesPath.cjs');
+var import_getBuiltDynamicDictionariesPath = require('./getBuiltDynamicDictionariesPath.cjs');
+var import_getBuiltFetchDictionariesPath = require('./getBuiltFetchDictionariesPath.cjs');
+var import_getBuiltRemoteDictionariesPath = require('./getBuiltRemoteDictionariesPath.cjs');
+var import_getBuiltUnmergedDictionariesPath = require('./getBuiltUnmergedDictionariesPath.cjs');
 const filterDictionaries = (paths, keys) => {
   if (!keys) return paths;
   return paths.filter(

package/dist/cjs/createDictionaryEntryPoint/createDictionaryEntryPoint.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts"],"sourcesContent":["import { getConfiguration } from '@intlayer/config';\nimport { mkdir } from 'fs/promises';\nimport { resolve } from 'path';\nimport { parallelize } from '../utils/parallelize';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { generateDictionaryListContent } from './generateDictionaryListContent';\nimport { getBuiltDictionariesPath } from './getBuiltDictionariesPath';\nimport { getBuiltDynamicDictionariesPath } from './getBuiltDynamicDictionariesPath';\nimport { getBuiltFetchDictionariesPath } from './getBuiltFetchDictionariesPath';\nimport { getBuiltRemoteDictionariesPath } from './getBuiltRemoteDictionariesPath';\nimport { getBuiltUnmergedDictionariesPath } from './getBuiltUnmergedDictionariesPath';\n\nconst filterDictionaries = (paths: string[], keys?: string[]) => {\n  if (!keys) return paths;\n  return paths.filter((path) =>\n    keys.some((key) => path.endsWith(`${key}.json`))\n  );\n};\n\nconst writeDictionaryFiles = async (\n  paths: string[],\n  fileName: string,\n  functionName: string,\n  format: 'cjs' | 'esm',\n  configuration = getConfiguration()\n) => {\n  const content = generateDictionaryListContent(\n    paths,\n    functionName,\n    format,\n    configuration\n  );\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const { mainDir } = configuration.content;\n\n  await writeFileIfChanged(\n    resolve(mainDir, `${fileName}.${extension}`),\n    content\n  );\n};\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const createDictionaryEntryPoint = async (\n  configuration = getConfiguration(),\n  dictionariesKeys?: string[],\n  formats?: ('cjs' | 'esm')[]\n) => {\n  const outputFormats = formats ?? configuration.build.outputFormat;\n  const { mainDir } = configuration.content;\n\n  await mkdir(mainDir, { recursive: true });\n\n  const remoteDictionariesPath = getBuiltRemoteDictionariesPath(configuration);\n  const dictionariesPath = filterDictionaries(\n    getBuiltDictionariesPath(configuration),\n    dictionariesKeys\n  );\n  const unmergedDictionariesPath =\n    getBuiltUnmergedDictionariesPath(configuration);\n\n  const writeOperations = [\n    ...outputFormats.map((format) => ({\n      paths: remoteDictionariesPath,\n      functionName: 'getRemoteDictionaries',\n      fileName: 'remote_dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: dictionariesPath,\n      functionName: 'getDictionaries',\n      fileName: 'dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: unmergedDictionariesPath,\n      functionName: 'getUnmergedDictionaries',\n      fileName: 'unmerged_dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: getBuiltDynamicDictionariesPath(configuration, format),\n      functionName: 'getDynamicDictionaries',\n      fileName: 'dynamic_dictionaries' as const,\n      format,\n    })),\n    ...outputFormats.map((format) => ({\n      paths: getBuiltFetchDictionariesPath(configuration, format),\n      functionName: 'getFetchDictionaries',\n      fileName: 'fetch_dictionaries' as const,\n      format,\n    })),\n  ];\n\n  await parallelize(\n    writeOperations,\n    async ({ paths, fileName, format, functionName }) =>\n      writeDictionaryFiles(paths, fileName, functionName, format, configuration)\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AACjC,sBAAsB;AACtB,kBAAwB;AACxB,yBAA4B;AAC5B,gCAAmC;AACnC,2CAA8C;AAC9C,sCAAyC;AACzC,6CAAgD;AAChD,2CAA8C;AAC9C,4CAA+C;AAC/C,8CAAiD;AAEjD,MAAM,qBAAqB,CAAC,OAAiB,SAAoB;AAC/D,MAAI,CAAC,KAAM,QAAO;AAClB,SAAO,MAAM;AAAA,IAAO,CAAC,SACnB,KAAK,KAAK,CAAC,QAAQ,KAAK,SAAS,GAAG,GAAG,OAAO,CAAC;AAAA,EACjD;AACF;AAEA,MAAM,uBAAuB,OAC3B,OACA,UACA,cACA,QACA,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,cAAU;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAE7C,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,YAAM;AAAA,QACJ,qBAAQ,SAAS,GAAG,QAAQ,IAAI,SAAS,EAAE;AAAA,IAC3C;AAAA,EACF;AACF;AAKO,MAAM,6BAA6B,OACxC,oBAAgB,gCAAiB,GACjC,kBACA,YACG;AACH,QAAM,gBAAgB,WAAW,cAAc,MAAM;AACrD,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,YAAM,uBAAM,SAAS,EAAE,WAAW,KAAK,CAAC;AAExC,QAAM,6BAAyB,sEAA+B,aAAa;AAC3E,QAAM,mBAAmB;AAAA,QACvB,0DAAyB,aAAa;AAAA,IACtC;AAAA,EACF;AACA,QAAM,+BACJ,0EAAiC,aAAa;AAEhD,QAAM,kBAAkB;AAAA,IACtB,GAAG,cAAc,IAAI,CAAC,YAAY;AAAA,MAChC,OAAO;AAAA,MACP,cAAc;AAAA,MACd,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,cAAc,IAAI,CAAC,YAAY;AAAA,MAChC,OAAO;AAAA,MACP,cAAc;AAAA,MACd,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,cAAc,IAAI,CAAC,YAAY;AAAA,MAChC,OAAO;AAAA,MACP,cAAc;AAAA,MACd,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,cAAc,IAAI,CAAC,YAAY;AAAA,MAChC,WAAO,wEAAgC,eAAe,MAAM;AAAA,MAC5D,cAAc;AAAA,MACd,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,IACF,GAAG,cAAc,IAAI,CAAC,YAAY;AAAA,MAChC,WAAO,oEAA8B,eAAe,MAAM;AAAA,MAC1D,cAAc;AAAA,MACd,UAAU;AAAA,MACV;AAAA,IACF,EAAE;AAAA,EACJ;AAEA,YAAM;AAAA,IACJ;AAAA,IACA,OAAO,EAAE,OAAO,UAAU,QAAQ,aAAa,MAC7C,qBAAqB,OAAO,UAAU,cAAc,QAAQ,aAAa;AAAA,EAC7E;AACF;","names":[]}

package/dist/cjs/{transpiler/dictionary_to_main → createDictionaryEntryPoint}/generateDictionaryListContent.cjs

@@ -23,7 +23,7 @@ __export(generateDictionaryListContent_exports, {
 module.exports = __toCommonJS(generateDictionaryListContent_exports);
 var import_config = require("@intlayer/config");
 var import_path = require("path");
-var import_getFileHash = require('../../utils/getFileHash.cjs');
+var import_getFileHash = require('../utils/getFileHash.cjs');
 const generateDictionaryListContent = (dictionaries, functionName, format = "esm", configuration = (0, import_config.getConfiguration)()) => {
   const { mainDir } = configuration.content;
   let content = "";

package/dist/cjs/createDictionaryEntryPoint/generateDictionaryListContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/generateDictionaryListContent.ts"],"sourcesContent":["import { getConfiguration, normalizePath } from '@intlayer/config';\nimport { basename, extname, relative } from 'path';\nimport { getFileHash } from '../utils/getFileHash';\n\n/**\n * This function generates the content of the dictionary list file\n */\nexport const generateDictionaryListContent = (\n  dictionaries: string[],\n  functionName: string,\n  format: 'cjs' | 'esm' = 'esm',\n  configuration = getConfiguration()\n): string => {\n  const { mainDir } = configuration.content;\n\n  let content = '';\n\n  const dictionariesRef = dictionaries.map((dictionaryPath) => ({\n    relativePath: normalizePath(relative(mainDir, dictionaryPath)),\n    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    if (format === 'esm')\n      content += `import ${dictionary.hash} from '${dictionary.relativePath}' with { type: 'json' };\\n`;\n    if (format === 'cjs')\n      content += `const ${dictionary.hash} = require('${dictionary.relativePath}');\\n`;\n  });\n\n  content += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `  \"${dictionary.id}\": ${dictionary.hash}`)\n    .join(',\\n');\n\n  content += `const dictionaries = {\\n${formattedDictionaryMap}\\n};\\n`;\n  content += `const ${functionName} = () => dictionaries;\\n`;\n\n  if (format === 'esm') {\n    content += `\\n`;\n    content += `export { ${functionName} };\\n`;\n    content += `export default dictionaries;\\n`;\n  }\n\n  if (format === 'cjs') {\n    content += `\\n`;\n    content += `module.exports.${functionName} = ${functionName};\\n`;\n    content += `module.exports = dictionaries;\\n`;\n  }\n\n  return content;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAChD,kBAA4C;AAC5C,yBAA4B;AAKrB,MAAM,gCAAgC,CAC3C,cACA,cACA,SAAwB,OACxB,oBAAgB,gCAAiB,MACtB;AACX,QAAM,EAAE,QAAQ,IAAI,cAAc;AAElC,MAAI,UAAU;AAEd,QAAM,kBAAkB,aAAa,IAAI,CAAC,oBAAoB;AAAA,IAC5D,kBAAc,iCAAc,sBAAS,SAAS,cAAc,CAAC;AAAA,IAC7D,QAAI,sBAAS,oBAAgB,qBAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,QAAI,gCAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,QAAI,WAAW;AACb,iBAAW,UAAU,WAAW,IAAI,UAAU,WAAW,YAAY;AAAA;AACvE,QAAI,WAAW;AACb,iBAAW,SAAS,WAAW,IAAI,eAAe,WAAW,YAAY;AAAA;AAAA,EAC7E,CAAC;AAED,aAAW;AAGX,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,MAAM,WAAW,EAAE,MAAM,WAAW,IAAI,EAAE,EAC9D,KAAK,KAAK;AAEb,aAAW;AAAA,EAA2B,sBAAsB;AAAA;AAAA;AAC5D,aAAW,SAAS,YAAY;AAAA;AAEhC,MAAI,WAAW,OAAO;AACpB,eAAW;AAAA;AACX,eAAW,YAAY,YAAY;AAAA;AACnC,eAAW;AAAA;AAAA,EACb;AAEA,MAAI,WAAW,OAAO;AACpB,eAAW;AAAA;AACX,eAAW,kBAAkB,YAAY,MAAM,YAAY;AAAA;AAC3D,eAAW;AAAA;AAAA,EACb;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/createDictionaryEntryPoint/getBuiltDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/getBuiltDictionariesPath.ts"],"sourcesContent":["import { getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { existsSync, mkdirSync } from 'fs';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltDictionariesPath = (\n  configuration = getConfiguration()\n) => {\n  const { dictionariesDir, mainDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    mkdirSync(mainDir, { recursive: true });\n  }\n\n  const dictionariesPath: string[] = fg.sync(\n    `${normalizePath(dictionariesDir)}/**/*.json`\n  );\n\n  return dictionariesPath;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAChD,uBAAe;AACf,gBAAsC;AAK/B,MAAM,2BAA2B,CACtC,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,EAAE,iBAAiB,QAAQ,IAAI,cAAc;AAGnD,MAAI,KAAC,sBAAW,OAAO,GAAG;AACxB,6BAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,mBAA6B,iBAAAA,QAAG;AAAA,IACpC,OAAG,6BAAc,eAAe,CAAC;AAAA,EACnC;AAEA,SAAO;AACT;","names":["fg"]}

package/dist/cjs/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.ts"],"sourcesContent":["import { getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { existsSync, mkdirSync } from 'fs';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltDynamicDictionariesPath = (\n  configuration = getConfiguration(),\n  format: 'cjs' | 'esm' = 'esm'\n) => {\n  const { dynamicDictionariesDir, mainDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    mkdirSync(mainDir, { recursive: true });\n  }\n\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const dictionariesPath: string[] = fg.sync(\n    `${normalizePath(dynamicDictionariesDir)}/**/*.${extension}`\n  );\n\n  return dictionariesPath;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAChD,uBAAe;AACf,gBAAsC;AAK/B,MAAM,kCAAkC,CAC7C,oBAAgB,gCAAiB,GACjC,SAAwB,UACrB;AACH,QAAM,EAAE,wBAAwB,QAAQ,IAAI,cAAc;AAG1D,MAAI,KAAC,sBAAW,OAAO,GAAG;AACxB,6BAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAE7C,QAAM,mBAA6B,iBAAAA,QAAG;AAAA,IACpC,OAAG,6BAAc,sBAAsB,CAAC,SAAS,SAAS;AAAA,EAC5D;AAEA,SAAO;AACT;","names":["fg"]}

package/dist/cjs/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.ts"],"sourcesContent":["import { getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { existsSync, mkdirSync } from 'fs';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltFetchDictionariesPath = (\n  configuration = getConfiguration(),\n  format: 'cjs' | 'esm' = 'esm'\n) => {\n  const { fetchDictionariesDir, mainDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    mkdirSync(mainDir, { recursive: true });\n  }\n\n  const extension = format === 'cjs' ? 'cjs' : 'mjs';\n\n  const dictionariesPath: string[] = fg.sync(\n    `${normalizePath(fetchDictionariesDir)}/**/*.${extension}`\n  );\n\n  return dictionariesPath;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAChD,uBAAe;AACf,gBAAsC;AAK/B,MAAM,gCAAgC,CAC3C,oBAAgB,gCAAiB,GACjC,SAAwB,UACrB;AACH,QAAM,EAAE,sBAAsB,QAAQ,IAAI,cAAc;AAGxD,MAAI,KAAC,sBAAW,OAAO,GAAG;AACxB,6BAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAE7C,QAAM,mBAA6B,iBAAAA,QAAG;AAAA,IACpC,OAAG,6BAAc,oBAAoB,CAAC,SAAS,SAAS;AAAA,EAC1D;AAEA,SAAO;AACT;","names":["fg"]}

package/dist/cjs/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.ts"],"sourcesContent":["import { getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { existsSync, mkdirSync } from 'fs';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltRemoteDictionariesPath = (\n  configuration = getConfiguration()\n) => {\n  const { remoteDictionariesDir, mainDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    mkdirSync(mainDir, { recursive: true });\n  }\n\n  const dictionariesPath: string[] = fg.sync(\n    `${normalizePath(remoteDictionariesDir)}/**/*.json`\n  );\n\n  return dictionariesPath;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAChD,uBAAe;AACf,gBAAsC;AAK/B,MAAM,iCAAiC,CAC5C,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,EAAE,uBAAuB,QAAQ,IAAI,cAAc;AAGzD,MAAI,KAAC,sBAAW,OAAO,GAAG;AACxB,6BAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,mBAA6B,iBAAAA,QAAG;AAAA,IACpC,OAAG,6BAAc,qBAAqB,CAAC;AAAA,EACzC;AAEA,SAAO;AACT;","names":["fg"]}

package/dist/cjs/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.ts"],"sourcesContent":["import { getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { existsSync, mkdirSync } from 'fs';\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const getBuiltUnmergedDictionariesPath = (\n  configuration = getConfiguration()\n) => {\n  const { unmergedDictionariesDir, mainDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    mkdirSync(mainDir, { recursive: true });\n  }\n\n  const dictionariesPath: string[] = fg.sync(\n    `${normalizePath(unmergedDictionariesDir)}/**/*.json`\n  );\n\n  return dictionariesPath;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAChD,uBAAe;AACf,gBAAsC;AAK/B,MAAM,mCAAmC,CAC9C,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,EAAE,yBAAyB,QAAQ,IAAI,cAAc;AAG3D,MAAI,KAAC,sBAAW,OAAO,GAAG;AACxB,6BAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,mBAA6B,iBAAAA,QAAG;AAAA,IACpC,OAAG,6BAAc,uBAAuB,CAAC;AAAA,EAC3C;AAEA,SAAO;AACT;","names":["fg"]}

package/dist/cjs/createDictionaryEntryPoint/index.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createDictionaryEntryPoint_exports = {};
+module.exports = __toCommonJS(createDictionaryEntryPoint_exports);
+__reExport(createDictionaryEntryPoint_exports, require('./createDictionaryEntryPoint.cjs'), module.exports);
+__reExport(createDictionaryEntryPoint_exports, require('./generateDictionaryListContent.cjs'), module.exports);
+__reExport(createDictionaryEntryPoint_exports, require('./getBuiltDictionariesPath.cjs'), module.exports);
+__reExport(createDictionaryEntryPoint_exports, require('./getBuiltDynamicDictionariesPath.cjs'), module.exports);
+__reExport(createDictionaryEntryPoint_exports, require('./getBuiltFetchDictionariesPath.cjs'), module.exports);
+__reExport(createDictionaryEntryPoint_exports, require('./getBuiltRemoteDictionariesPath.cjs'), module.exports);
+__reExport(createDictionaryEntryPoint_exports, require('./getBuiltUnmergedDictionariesPath.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./createDictionaryEntryPoint.cjs'),
+  ...require('./generateDictionaryListContent.cjs'),
+  ...require('./getBuiltDictionariesPath.cjs'),
+  ...require('./getBuiltDynamicDictionariesPath.cjs'),
+  ...require('./getBuiltFetchDictionariesPath.cjs'),
+  ...require('./getBuiltRemoteDictionariesPath.cjs'),
+  ...require('./getBuiltUnmergedDictionariesPath.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/createDictionaryEntryPoint/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createDictionaryEntryPoint/index.ts"],"sourcesContent":["export * from './createDictionaryEntryPoint';\nexport * from './generateDictionaryListContent';\nexport * from './getBuiltDictionariesPath';\nexport * from './getBuiltDynamicDictionariesPath';\nexport * from './getBuiltFetchDictionariesPath';\nexport * from './getBuiltRemoteDictionariesPath';\nexport * from './getBuiltUnmergedDictionariesPath';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+CAAc,yCAAd;AACA,+CAAc,4CADd;AAEA,+CAAc,uCAFd;AAGA,+CAAc,8CAHd;AAIA,+CAAc,4CAJd;AAKA,+CAAc,6CALd;AAMA,+CAAc,+CANd;","names":[]}

package/dist/cjs/{transpiler/dictionary_to_type → createType}/createModuleAugmentation.cjs

@@ -36,9 +36,9 @@ var import_config = require("@intlayer/config");
 var import_fast_glob = __toESM(require("fast-glob"));
 var import_promises = require("fs/promises");
 var import_path = require("path");
-var import_getFileHash = require('../../utils/getFileHash.cjs');
-var import_kebabCaseToCamelCase = require('../../utils/kebabCaseToCamelCase.cjs');
-var import_writeFileIfChanged = require('../../writeFileIfChanged.cjs');
+var import_getFileHash = require('../utils/getFileHash.cjs');
+var import_kebabCaseToCamelCase = require('../utils/kebabCaseToCamelCase.cjs');
+var import_writeFileIfChanged = require('../writeFileIfChanged.cjs');
 const getTypeName = (key) => `${(0, import_kebabCaseToCamelCase.kebabCaseToCamelCase)(key)}Content`;
 const formatLocales = (locales) => locales.map((locale) => {
   for (const key in import_config.Locales) {

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createType/createModuleAugmentation.ts"],"sourcesContent":["import { Locales, getConfiguration, normalizePath } from '@intlayer/config';\nimport fg from 'fast-glob';\nimport { mkdir } from 'fs/promises';\nimport { basename, extname, join, relative } from 'path';\nimport { getFileHash } from '../utils/getFileHash';\nimport { kebabCaseToCamelCase } from '../utils/kebabCaseToCamelCase';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\n\nexport const getTypeName = (key: string): string =>\n  `${kebabCaseToCamelCase(key)}Content`;\n\nconst formatLocales = (locales: Locales[]): string =>\n  locales\n    .map((locale) => {\n      for (const key in Locales) {\n        if (Locales[key as keyof typeof Locales] === locale) {\n          return `Locales.${key}`;\n        }\n      }\n    })\n    .join(' | ');\n\n/**\n * This function generates the content of the module augmentation file\n */\nconst generateTypeIndexContent = (\n  typeFiles: string[],\n  configuration = getConfiguration()\n): string => {\n  const { content, internationalization } = configuration;\n  const { moduleAugmentationDir } = content;\n  const { locales, requiredLocales, strictMode } = internationalization;\n\n  let fileContent =\n    \"/* eslint-disable */\\nimport { Locales } from 'intlayer';\\n\";\n\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: `./${relative(moduleAugmentationDir, dictionaryPath)}`,\n    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id (without the extension)\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    fileContent += `import ${dictionary.hash} from '${dictionary.relativePath}';\\n`;\n  });\n\n  fileContent += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": typeof ${dictionary.hash};`)\n    .join('\\n');\n\n  const requiredLocalesValues =\n    requiredLocales.length > 0\n      ? requiredLocales.filter((locale) =>\n          locales.map((locale) => String(locale)).includes(String(locale))\n        )\n      : locales;\n\n  const formattedLocales = formatLocales(locales);\n  const formattedRequiredLocales = formatLocales(requiredLocalesValues);\n\n  const strictModeRecord =\n    strictMode === 'strict'\n      ? `interface IConfigLocales<Content> extends Record<DeclaredLocales, Content> {}`\n      : strictMode === 'inclusive'\n        ? `interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}`\n        : `interface IConfigLocales<Content> extends Partial<Record<Locales, Content>> {}`;\n\n  /**\n   * Write the module augmentation to extend the intlayer module with the dictionaries types\n   * Will suggest the type resulting of the dictionaries\n   *\n   * declare module 'intlayer' {\n   *   interface IntlayerDictionaryTypesConnector = {\n   *     dictionaries: {\n   *       id: DictionaryType;\n   *     }\n   *   }\n   *\n   *   type ConfigLocales = Locales.ENGLISH | Locales.FRENCH | Locales.SPANISH;\n   *   type ExtractedLocales = Extract<Locales, ConfigLocales>;\n   *\n   *   interface IConfigLocales<Content> extends Record<ExtractedLocales, Content>, Partial<Record<ExcludedLocales, Content>> {}\n   *\n   *\n   * }\n   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation\n   */\n  fileContent += `declare module 'intlayer' {\\n`;\n  fileContent += `  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  fileContent += `  type DeclaredLocales = ${formattedLocales};\\n`;\n  fileContent += `  type RequiredLocales = ${formattedRequiredLocales};\\n`;\n  fileContent += `  type ExtractedLocales = Extract<Locales, RequiredLocales>;\\n`;\n  fileContent += `  type ExcludedLocales = Exclude<Locales, RequiredLocales>;\\n`;\n  fileContent += `  ${strictModeRecord}\\n`;\n  fileContent += `}`;\n\n  return fileContent;\n};\n\n/**\n * This function generates a index file merging all the types\n */\nexport const createModuleAugmentation = async (\n  configuration = getConfiguration()\n) => {\n  const { moduleAugmentationDir, typesDir } = configuration.content;\n\n  // Create main directory if it doesn't exist\n  await mkdir(moduleAugmentationDir, { recursive: true });\n\n  const dictionariesTypesDefinitions: string[] = fg.sync(\n    normalizePath(`${typesDir}/*.ts`),\n    {\n      ignore: ['**/*.d.ts'],\n    }\n  );\n\n  // Create the dictionary list file\n  const tsContent = generateTypeIndexContent(dictionariesTypesDefinitions);\n\n  const tsFilePath = join(moduleAugmentationDir, 'intlayer.d.ts');\n\n  await writeFileIfChanged(tsFilePath, tsContent);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAyD;AACzD,uBAAe;AACf,sBAAsB;AACtB,kBAAkD;AAClD,yBAA4B;AAC5B,kCAAqC;AACrC,gCAAmC;AAE5B,MAAM,cAAc,CAAC,QAC1B,OAAG,kDAAqB,GAAG,CAAC;AAE9B,MAAM,gBAAgB,CAAC,YACrB,QACG,IAAI,CAAC,WAAW;AACf,aAAW,OAAO,uBAAS;AACzB,QAAI,sBAAQ,GAA2B,MAAM,QAAQ;AACnD,aAAO,WAAW,GAAG;AAAA,IACvB;AAAA,EACF;AACF,CAAC,EACA,KAAK,KAAK;AAKf,MAAM,2BAA2B,CAC/B,WACA,oBAAgB,gCAAiB,MACtB;AACX,QAAM,EAAE,SAAS,qBAAqB,IAAI;AAC1C,QAAM,EAAE,sBAAsB,IAAI;AAClC,QAAM,EAAE,SAAS,iBAAiB,WAAW,IAAI;AAEjD,MAAI,cACF;AAEF,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAK,sBAAS,uBAAuB,cAAc,CAAC;AAAA,IAClE,QAAI,sBAAS,oBAAgB,qBAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,QAAI,gCAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,mBAAe,UAAU,WAAW,IAAI,UAAU,WAAW,YAAY;AAAA;AAAA,EAC3E,CAAC;AAED,iBAAe;AAGf,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,QAAQ,WAAW,EAAE,aAAa,WAAW,IAAI,GAAG,EACxE,KAAK,IAAI;AAEZ,QAAM,wBACJ,gBAAgB,SAAS,IACrB,gBAAgB;AAAA,IAAO,CAAC,WACtB,QAAQ,IAAI,CAACA,YAAW,OAAOA,OAAM,CAAC,EAAE,SAAS,OAAO,MAAM,CAAC;AAAA,EACjE,IACA;AAEN,QAAM,mBAAmB,cAAc,OAAO;AAC9C,QAAM,2BAA2B,cAAc,qBAAqB;AAEpE,QAAM,mBACJ,eAAe,WACX,kFACA,eAAe,cACb,8HACA;AAsBR,iBAAe;AAAA;AACf,iBAAe;AAAA,EAAmD,sBAAsB;AAAA;AAAA;AAAA;AACxF,iBAAe,4BAA4B,gBAAgB;AAAA;AAC3D,iBAAe,4BAA4B,wBAAwB;AAAA;AACnE,iBAAe;AAAA;AACf,iBAAe;AAAA;AACf,iBAAe,KAAK,gBAAgB;AAAA;AACpC,iBAAe;AAEf,SAAO;AACT;AAKO,MAAM,2BAA2B,OACtC,oBAAgB,gCAAiB,MAC9B;AACH,QAAM,EAAE,uBAAuB,SAAS,IAAI,cAAc;AAG1D,YAAM,uBAAM,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAEtD,QAAM,+BAAyC,iBAAAC,QAAG;AAAA,QAChD,6BAAc,GAAG,QAAQ,OAAO;AAAA,IAChC;AAAA,MACE,QAAQ,CAAC,WAAW;AAAA,IACtB;AAAA,EACF;AAGA,QAAM,YAAY,yBAAyB,4BAA4B;AAEvE,QAAM,iBAAa,kBAAK,uBAAuB,eAAe;AAE9D,YAAM,8CAAmB,YAAY,SAAS;AAChD;","names":["locale","fg"]}

package/dist/cjs/{transpiler/dictionary_to_type → createType}/createType.cjs

@@ -25,7 +25,7 @@ module.exports = __toCommonJS(createType_exports);
 var import_config = require("@intlayer/config");
 var import_promises = require("fs/promises");
 var import_path = require("path");
-var import_parallelize = require('../../utils/parallelize.cjs');
+var import_parallelize = require('../utils/parallelize.cjs');
 const requireUncached = (module2) => {
   delete import_config.ESMxCJSRequire.cache[import_config.ESMxCJSRequire.resolve(module2)];
   return (0, import_config.ESMxCJSRequire)(module2);

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createType/createType.ts"],"sourcesContent":["import {\n  ESMxCJSRequire,\n  getConfiguration,\n  IntlayerConfig,\n} from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { parallelize } from '../utils/parallelize';\n\nconst requireUncached = (module: string) => {\n  delete ESMxCJSRequire.cache[ESMxCJSRequire.resolve(module)];\n  return ESMxCJSRequire(module);\n};\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  dictionariesPaths: string[],\n  configuration: IntlayerConfig = getConfiguration()\n): Promise<string[]> => {\n  const { typesDir } = configuration.content;\n\n  // Create type folders if they don't exist\n  await mkdir(typesDir, { recursive: true });\n\n  const results = await parallelize(\n    dictionariesPaths,\n    async (dictionaryPath): Promise<string | undefined> => {\n      const dictionary: Dictionary = requireUncached(dictionaryPath);\n\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":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAIO;AAEP,sBAAiC;AACjC,kBAAwB;AACxB,yBAA4B;AAE5B,MAAM,kBAAkB,CAACA,YAAmB;AAC1C,SAAO,6BAAe,MAAM,6BAAe,QAAQA,OAAM,CAAC;AAC1D,aAAO,8BAAeA,OAAM;AAC9B;AAEO,MAAM,yBAAyB,CAAC,eAA2B;AAChE,QAAM,aAAa,KAAK,UAAU,YAAY,MAAM,CAAC;AAErD,SAAO;AAAA,iBAAwC,UAAU;AAAA;AAC3D;AAIO,MAAM,cAAc,OACzB,mBACA,oBAAgC,gCAAiB,MAC3B;AACtB,QAAM,EAAE,SAAS,IAAI,cAAc;AAGnC,YAAM,uBAAM,UAAU,EAAE,WAAW,KAAK,CAAC;AAEzC,QAAM,UAAU,UAAM;AAAA,IACpB;AAAA,IACA,OAAO,mBAAgD;AACrD,YAAM,aAAyB,gBAAgB,cAAc;AAE7D,UAAI,CAAC,WAAW,KAAK;AACnB,eAAO;AAAA,MACT;AAEA,YAAM,iBAAyB,uBAAuB,UAAU;AAEhE,YAAM,iBAAqB,qBAAQ,UAAU,GAAG,WAAW,GAAG,KAAK;AAEnE,gBAAM,2BAAU,YAAY,cAAc;AAE1C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,QAAQ,OAAO,OAAO;AAC/B;","names":["module"]}

package/dist/cjs/{transpiler/dictionary_to_type → createType}/index.cjs

@@ -13,10 +13,10 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dictionary_to_type_exports = {};
-module.exports = __toCommonJS(dictionary_to_type_exports);
-__reExport(dictionary_to_type_exports, require('./createModuleAugmentation.cjs'), module.exports);
-__reExport(dictionary_to_type_exports, require('./createType.cjs'), module.exports);
+var createType_exports = {};
+module.exports = __toCommonJS(createType_exports);
+__reExport(createType_exports, require('./createModuleAugmentation.cjs'), module.exports);
+__reExport(createType_exports, require('./createType.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require('./createModuleAugmentation.cjs'),

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/createType/index.ts"],"sourcesContent":["export * from './createModuleAugmentation';\nexport * from './createType';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,uCAAd;AACA,+BAAc,yBADd;","names":[]}

package/dist/cjs/filterInvalidDictionaries.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,54 +15,48 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var filterInvalidDictionaries_exports = {};
 __export(filterInvalidDictionaries_exports, {
-  filterInvalidDictionaries: () => filterInvalidDictionaries
+  filterInvalidDictionaries: () => filterInvalidDictionaries,
+  isInvalidDictionary: () => isInvalidDictionary
 });
 module.exports = __toCommonJS(filterInvalidDictionaries_exports);
-var import_built = __toESM(require("@intlayer/config/built"));
 var import_client = require("@intlayer/config/client");
 var import_formatter = require('./utils/formatter.cjs');
-const filterInvalidDictionaries = (dictionaries) => {
-  const appLogger = (0, import_client.getAppLogger)(import_built.default);
-  return (dictionaries ?? [])?.filter((dictionary) => {
-    if (!dictionary) return false;
-    const isLocal = Boolean(dictionary.location === "locale");
-    const location = isLocal ? "Local" : "Remote";
-    const hasKey = Boolean(dictionary.key);
-    const hasContent = Boolean(dictionary.content);
-    if (!hasKey) {
-      appLogger(`${location} dictionary has no key`, {
-        level: "error"
-      });
-      appLogger(JSON.stringify(dictionary, null, 2), {
+const isInvalidDictionary = (dictionary, configuration) => {
+  const appLogger = (0, import_client.getAppLogger)(configuration);
+  if (!dictionary) return false;
+  const isLocal = Boolean(dictionary.location === "locale");
+  const location = isLocal ? "Local" : "Remote";
+  const hasKey = Boolean(dictionary.key);
+  const hasContent = Boolean(dictionary.content);
+  if (!hasKey) {
+    appLogger(`${location} dictionary has no key`, {
+      level: "error"
+    });
+    appLogger(JSON.stringify(dictionary, null, 2), {
+      level: "error"
+    });
+    return false;
+  }
+  if (!hasContent) {
+    appLogger(
+      `${location} dictionary ${(0, import_client.colorizeKey)(dictionary.key)} has no content - ${dictionary.filePath ? (0, import_formatter.formatPath)(dictionary.filePath) : (0, import_client.colorizePath)("Remote")}`,
+      {
         level: "error"
-      });
-      return false;
-    }
-    if (!hasContent) {
-      appLogger(
-        `${location} dictionary ${(0, import_client.colorizeKey)(dictionary.key)} has no content - ${dictionary.filePath ? (0, import_formatter.formatPath)(dictionary.filePath) : (0, import_client.colorizePath)("Remote")}`,
-        {
-          level: "error"
-        }
-      );
-      return false;
-    }
-    return true;
-  });
+      }
+    );
+    return false;
+  }
+  return true;
 };
+const filterInvalidDictionaries = (dictionaries, configuration) => (dictionaries ?? [])?.filter(
+  (dictionary) => isInvalidDictionary(dictionary, configuration)
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  filterInvalidDictionaries
+  filterInvalidDictionaries,
+  isInvalidDictionary
 });
 //# sourceMappingURL=filterInvalidDictionaries.cjs.map

package/dist/cjs/filterInvalidDictionaries.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/filterInvalidDictionaries.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport {\n  colorizeKey,\n  colorizePath,\n  getAppLogger,\n} from '@intlayer/config/client';\nimport type { Dictionary } from '@intlayer/core';\nimport { formatPath } from './utils/formatter';\n\nexport const filterInvalidDictionaries = (\n  dictionaries: (Dictionary | undefined)[] | undefined\n): Dictionary[] => {\n  const appLogger = getAppLogger(configuration);\n\n  return (dictionaries ?? [])?.filter((dictionary) => {\n    if (!dictionary) return false;\n\n    const isLocal = Boolean(dictionary.location === 'locale');\n    const location = isLocal ? 'Local' : 'Remote';\n    const hasKey = Boolean(dictionary.key);\n    const hasContent = Boolean(dictionary.content);\n\n    if (!hasKey) {\n      appLogger(`${location} dictionary has no key`, {\n        level: 'error',\n      });\n      appLogger(JSON.stringify(dictionary, null, 2), {\n        level: 'error',\n      });\n      return false;\n    }\n\n    if (!hasContent) {\n      appLogger(\n        `${location} dictionary ${colorizeKey(dictionary.key)} has no content - ${dictionary.filePath ? formatPath(dictionary.filePath) : colorizePath('Remote')}`,\n        {\n          level: 'error',\n        }\n      );\n      return false;\n    }\n\n    return true;\n  }) as Dictionary[];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAC1B,oBAIO;AAEP,uBAA2B;AAEpB,MAAM,4BAA4B,CACvC,iBACiB;AACjB,QAAM,gBAAY,4BAAa,aAAAA,OAAa;AAE5C,UAAQ,gBAAgB,CAAC,IAAI,OAAO,CAAC,eAAe;AAClD,QAAI,CAAC,WAAY,QAAO;AAExB,UAAM,UAAU,QAAQ,WAAW,aAAa,QAAQ;AACxD,UAAM,WAAW,UAAU,UAAU;AACrC,UAAM,SAAS,QAAQ,WAAW,GAAG;AACrC,UAAM,aAAa,QAAQ,WAAW,OAAO;AAE7C,QAAI,CAAC,QAAQ;AACX,gBAAU,GAAG,QAAQ,0BAA0B;AAAA,QAC7C,OAAO;AAAA,MACT,CAAC;AACD,gBAAU,KAAK,UAAU,YAAY,MAAM,CAAC,GAAG;AAAA,QAC7C,OAAO;AAAA,MACT,CAAC;AACD,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,YAAY;AACf;AAAA,QACE,GAAG,QAAQ,mBAAe,2BAAY,WAAW,GAAG,CAAC,qBAAqB,WAAW,eAAW,6BAAW,WAAW,QAAQ,QAAI,4BAAa,QAAQ,CAAC;AAAA,QACxJ;AAAA,UACE,OAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT,CAAC;AACH;","names":["configuration"]}
+{"version":3,"sources":["../../src/filterInvalidDictionaries.ts"],"sourcesContent":["import { type IntlayerConfig } from '@intlayer/config';\nimport {\n  colorizeKey,\n  colorizePath,\n  getAppLogger,\n} from '@intlayer/config/client';\nimport type { Dictionary } from '@intlayer/core';\nimport { formatPath } from './utils/formatter';\n\nexport const isInvalidDictionary = (\n  dictionary: Dictionary | undefined,\n  configuration?: IntlayerConfig\n): boolean => {\n  const appLogger = getAppLogger(configuration);\n\n  if (!dictionary) return false;\n\n  const isLocal = Boolean(dictionary.location === 'locale');\n  const location = isLocal ? 'Local' : 'Remote';\n  const hasKey = Boolean(dictionary.key);\n  const hasContent = Boolean(dictionary.content);\n\n  if (!hasKey) {\n    appLogger(`${location} dictionary has no key`, {\n      level: 'error',\n    });\n    appLogger(JSON.stringify(dictionary, null, 2), {\n      level: 'error',\n    });\n    return false;\n  }\n\n  if (!hasContent) {\n    appLogger(\n      `${location} dictionary ${colorizeKey(dictionary.key)} has no content - ${dictionary.filePath ? formatPath(dictionary.filePath) : colorizePath('Remote')}`,\n      {\n        level: 'error',\n      }\n    );\n    return false;\n  }\n\n  return true;\n};\n\nexport const filterInvalidDictionaries = (\n  dictionaries: (Dictionary | undefined)[] | undefined,\n  configuration?: IntlayerConfig\n): Dictionary[] =>\n  (dictionaries ?? [])?.filter((dictionary) =>\n    isInvalidDictionary(dictionary, configuration)\n  ) as Dictionary[];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAIO;AAEP,uBAA2B;AAEpB,MAAM,sBAAsB,CACjC,YACA,kBACY;AACZ,QAAM,gBAAY,4BAAa,aAAa;AAE5C,MAAI,CAAC,WAAY,QAAO;AAExB,QAAM,UAAU,QAAQ,WAAW,aAAa,QAAQ;AACxD,QAAM,WAAW,UAAU,UAAU;AACrC,QAAM,SAAS,QAAQ,WAAW,GAAG;AACrC,QAAM,aAAa,QAAQ,WAAW,OAAO;AAE7C,MAAI,CAAC,QAAQ;AACX,cAAU,GAAG,QAAQ,0BAA0B;AAAA,MAC7C,OAAO;AAAA,IACT,CAAC;AACD,cAAU,KAAK,UAAU,YAAY,MAAM,CAAC,GAAG;AAAA,MAC7C,OAAO;AAAA,IACT,CAAC;AACD,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,YAAY;AACf;AAAA,MACE,GAAG,QAAQ,mBAAe,2BAAY,WAAW,GAAG,CAAC,qBAAqB,WAAW,eAAW,6BAAW,WAAW,QAAQ,QAAI,4BAAa,QAAQ,CAAC;AAAA,MACxJ;AAAA,QACE,OAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,MAAM,4BAA4B,CACvC,cACA,mBAEC,gBAAgB,CAAC,IAAI;AAAA,EAAO,CAAC,eAC5B,oBAAoB,YAAY,aAAa;AAC/C;","names":[]}

package/dist/cjs/handleAdditionalContentDeclarationFile.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handleAdditionalContentDeclarationFile_exports = {};
+__export(handleAdditionalContentDeclarationFile_exports, {
+  handleAdditionalContentDeclarationFile: () => handleAdditionalContentDeclarationFile
+});
+module.exports = __toCommonJS(handleAdditionalContentDeclarationFile_exports);
+var import_config = require("@intlayer/config");
+var import_buildIntlayerDictionary = require('./buildIntlayerDictionary/buildIntlayerDictionary.cjs');
+var import_createDictionaryEntryPoint = require('./createDictionaryEntryPoint/createDictionaryEntryPoint.cjs');
+var import_createType = require('./createType/index.cjs');
+var import_loadLocalDictionaries = require('./loadDictionaries/loadLocalDictionaries.cjs');
+var import_formatter = require('./utils/formatter.cjs');
+const handleAdditionalContentDeclarationFile = async (filePath, config) => {
+  const appLogger = (0, import_config.getAppLogger)(config);
+  appLogger(`Additional file detected: ${(0, import_formatter.formatPath)(filePath)}`, {
+    isVerbose: true
+  });
+  const localeDictionaries = await (0, import_loadLocalDictionaries.loadLocalDictionaries)(filePath, config);
+  const dictionariesOutput = await (0, import_buildIntlayerDictionary.buildDictionary)(localeDictionaries, config);
+  const dictionariesPaths = Object.values(
+    dictionariesOutput?.mergedDictionaries ?? {}
+  ).map((dictionary) => dictionary.dictionaryPath);
+  await (0, import_createType.createTypes)(dictionariesPaths);
+  await (0, import_createDictionaryEntryPoint.createDictionaryEntryPoint)(config);
+  appLogger("Dictionaries built", {
+    isVerbose: true
+  });
+  (0, import_createType.createModuleAugmentation)(config);
+  appLogger("Module augmentation built", {
+    isVerbose: true
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleAdditionalContentDeclarationFile
+});
+//# sourceMappingURL=handleAdditionalContentDeclarationFile.cjs.map

package/dist/cjs/handleAdditionalContentDeclarationFile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/handleAdditionalContentDeclarationFile.ts"],"sourcesContent":["import { type IntlayerConfig, getAppLogger } from '@intlayer/config';\nimport { buildDictionary } from './buildIntlayerDictionary/buildIntlayerDictionary';\nimport { createDictionaryEntryPoint } from './createDictionaryEntryPoint/createDictionaryEntryPoint';\nimport { createModuleAugmentation, createTypes } from './createType/index';\nimport { loadLocalDictionaries } from './loadDictionaries/loadLocalDictionaries';\nimport { formatPath } from './utils/formatter';\n\nexport const handleAdditionalContentDeclarationFile = async (\n  filePath: string,\n  config: IntlayerConfig\n) => {\n  const appLogger = getAppLogger(config);\n\n  // Process the file with the functionToRun\n  appLogger(`Additional file detected: ${formatPath(filePath)}`, {\n    isVerbose: true,\n  });\n\n  const localeDictionaries = await loadLocalDictionaries(filePath, config);\n\n  const dictionariesOutput = await buildDictionary(localeDictionaries, config);\n\n  const dictionariesPaths = Object.values(\n    dictionariesOutput?.mergedDictionaries ?? {}\n  ).map((dictionary) => dictionary.dictionaryPath);\n\n  await createTypes(dictionariesPaths);\n\n  await createDictionaryEntryPoint(config);\n\n  appLogger('Dictionaries built', {\n    isVerbose: true,\n  });\n\n  createModuleAugmentation(config);\n\n  appLogger('Module augmentation built', {\n    isVerbose: true,\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAkD;AAClD,qCAAgC;AAChC,wCAA2C;AAC3C,wBAAsD;AACtD,mCAAsC;AACtC,uBAA2B;AAEpB,MAAM,yCAAyC,OACpD,UACA,WACG;AACH,QAAM,gBAAY,4BAAa,MAAM;AAGrC,YAAU,iCAA6B,6BAAW,QAAQ,CAAC,IAAI;AAAA,IAC7D,WAAW;AAAA,EACb,CAAC;AAED,QAAM,qBAAqB,UAAM,oDAAsB,UAAU,MAAM;AAEvE,QAAM,qBAAqB,UAAM,gDAAgB,oBAAoB,MAAM;AAE3E,QAAM,oBAAoB,OAAO;AAAA,IAC/B,oBAAoB,sBAAsB,CAAC;AAAA,EAC7C,EAAE,IAAI,CAAC,eAAe,WAAW,cAAc;AAE/C,YAAM,+BAAY,iBAAiB;AAEnC,YAAM,8DAA2B,MAAM;AAEvC,YAAU,sBAAsB;AAAA,IAC9B,WAAW;AAAA,EACb,CAAC;AAED,kDAAyB,MAAM;AAE/B,YAAU,6BAA6B;AAAA,IACrC,WAAW;AAAA,EACb,CAAC;AACH;","names":[]}

package/dist/cjs/handleContentDeclarationFileChange.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handleContentDeclarationFileChange_exports = {};
+__export(handleContentDeclarationFileChange_exports, {
+  handleContentDeclarationFileChange: () => handleContentDeclarationFileChange
+});
+module.exports = __toCommonJS(handleContentDeclarationFileChange_exports);
+var import_config = require("@intlayer/config");
+var import_buildIntlayerDictionary = require('./buildIntlayerDictionary/buildIntlayerDictionary.cjs');
+var import_createDictionaryEntryPoint = require('./createDictionaryEntryPoint/createDictionaryEntryPoint.cjs');
+var import_getBuiltDictionariesPath = require('./createDictionaryEntryPoint/getBuiltDictionariesPath.cjs');
+var import_createType = require('./createType/index.cjs');
+var import_loadLocalDictionaries = require('./loadDictionaries/loadLocalDictionaries.cjs');
+var import_formatter = require('./utils/formatter.cjs');
+const handleContentDeclarationFileChange = async (filePath, config) => {
+  const appLogger = (0, import_config.getAppLogger)(config);
+  appLogger(`Change detected: ${(0, import_formatter.formatPath)(filePath)}`, {
+    isVerbose: true
+  });
+  const localeDictionaries = await (0, import_loadLocalDictionaries.loadLocalDictionaries)(filePath, config);
+  const dictionariesOutput = await (0, import_buildIntlayerDictionary.buildDictionary)(localeDictionaries, config);
+  const updatedDictionariesPaths = Object.values(
+    dictionariesOutput?.mergedDictionaries ?? {}
+  ).map((dictionary) => dictionary.dictionaryPath);
+  const allDictionariesPaths = (0, import_getBuiltDictionariesPath.getBuiltDictionariesPath)(config);
+  (0, import_createType.createTypes)(updatedDictionariesPaths);
+  appLogger("TypeScript types built", {
+    isVerbose: true
+  });
+  if (updatedDictionariesPaths.some(
+    (updatedDictionaryPath) => !allDictionariesPaths.includes(updatedDictionaryPath)
+  )) {
+    await (0, import_createDictionaryEntryPoint.createDictionaryEntryPoint)(config);
+    appLogger("Dictionary list built", {
+      isVerbose: true
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleContentDeclarationFileChange
+});
+//# sourceMappingURL=handleContentDeclarationFileChange.cjs.map

package/dist/cjs/handleContentDeclarationFileChange.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/handleContentDeclarationFileChange.ts"],"sourcesContent":["import { type IntlayerConfig, getAppLogger } from '@intlayer/config';\nimport { buildDictionary } from './buildIntlayerDictionary/buildIntlayerDictionary';\nimport { createDictionaryEntryPoint } from './createDictionaryEntryPoint/createDictionaryEntryPoint';\nimport { getBuiltDictionariesPath } from './createDictionaryEntryPoint/getBuiltDictionariesPath';\nimport { createTypes } from './createType';\nimport { loadLocalDictionaries } from './loadDictionaries/loadLocalDictionaries';\nimport { formatPath } from './utils/formatter';\n\nexport const handleContentDeclarationFileChange = async (\n  filePath: string,\n  config: IntlayerConfig\n) => {\n  const appLogger = getAppLogger(config);\n\n  // Process the file with the functionToRun\n  appLogger(`Change detected: ${formatPath(filePath)}`, {\n    isVerbose: true,\n  });\n\n  const localeDictionaries = await loadLocalDictionaries(filePath, config);\n\n  const dictionariesOutput = await buildDictionary(localeDictionaries, config);\n  const updatedDictionariesPaths = Object.values(\n    dictionariesOutput?.mergedDictionaries ?? {}\n  ).map((dictionary) => dictionary.dictionaryPath);\n\n  const allDictionariesPaths: string[] = getBuiltDictionariesPath(config);\n\n  createTypes(updatedDictionariesPaths);\n  appLogger('TypeScript types built', {\n    isVerbose: true,\n  });\n\n  if (\n    updatedDictionariesPaths.some(\n      (updatedDictionaryPath) =>\n        !allDictionariesPaths.includes(updatedDictionaryPath)\n    )\n  ) {\n    await createDictionaryEntryPoint(config);\n\n    appLogger('Dictionary list built', {\n      isVerbose: true,\n    });\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAkD;AAClD,qCAAgC;AAChC,wCAA2C;AAC3C,sCAAyC;AACzC,wBAA4B;AAC5B,mCAAsC;AACtC,uBAA2B;AAEpB,MAAM,qCAAqC,OAChD,UACA,WACG;AACH,QAAM,gBAAY,4BAAa,MAAM;AAGrC,YAAU,wBAAoB,6BAAW,QAAQ,CAAC,IAAI;AAAA,IACpD,WAAW;AAAA,EACb,CAAC;AAED,QAAM,qBAAqB,UAAM,oDAAsB,UAAU,MAAM;AAEvE,QAAM,qBAAqB,UAAM,gDAAgB,oBAAoB,MAAM;AAC3E,QAAM,2BAA2B,OAAO;AAAA,IACtC,oBAAoB,sBAAsB,CAAC;AAAA,EAC7C,EAAE,IAAI,CAAC,eAAe,WAAW,cAAc;AAE/C,QAAM,2BAAiC,0DAAyB,MAAM;AAEtE,qCAAY,wBAAwB;AACpC,YAAU,0BAA0B;AAAA,IAClC,WAAW;AAAA,EACb,CAAC;AAED,MACE,yBAAyB;AAAA,IACvB,CAAC,0BACC,CAAC,qBAAqB,SAAS,qBAAqB;AAAA,EACxD,GACA;AACA,cAAM,8DAA2B,MAAM;AAEvC,cAAU,yBAAyB;AAAA,MACjC,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/cjs/handleUnlikedContentDeclarationFile.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handleUnlikedContentDeclarationFile_exports = {};
+__export(handleUnlikedContentDeclarationFile_exports, {
+  handleUnlikedContentDeclarationFile: () => handleUnlikedContentDeclarationFile
+});
+module.exports = __toCommonJS(handleUnlikedContentDeclarationFile_exports);
+var import_config = require("@intlayer/config");
+var import_buildIntlayerDictionary = require('./buildIntlayerDictionary/buildIntlayerDictionary.cjs');
+var import_createDictionaryEntryPoint = require('./createDictionaryEntryPoint/createDictionaryEntryPoint.cjs');
+var import_createType = require('./createType/index.cjs');
+var import_createModuleAugmentation = require('./createType/createModuleAugmentation.cjs');
+var import_listDictionariesPath = require('./listDictionariesPath.cjs');
+var import_loadLocalDictionaries = require('./loadDictionaries/loadLocalDictionaries.cjs');
+var import_formatter = require('./utils/formatter.cjs');
+const handleUnlikedContentDeclarationFile = async (filePath, config) => {
+  const appLogger = (0, import_config.getAppLogger)(config);
+  appLogger(`Unlinked detected: ${(0, import_formatter.formatPath)(filePath)}`, {
+    isVerbose: true
+  });
+  const files = (0, import_listDictionariesPath.listDictionaries)(config);
+  const localeDictionaries = await (0, import_loadLocalDictionaries.loadLocalDictionaries)(files, config);
+  const dictionariesOutput = await (0, import_buildIntlayerDictionary.buildDictionary)(localeDictionaries, config);
+  const dictionariesPaths = Object.values(
+    dictionariesOutput?.mergedDictionaries ?? {}
+  ).map((dictionary) => dictionary.dictionaryPath);
+  await (0, import_createType.createTypes)(dictionariesPaths);
+  await (0, import_createDictionaryEntryPoint.createDictionaryEntryPoint)();
+  appLogger("Dictionaries rebuilt", {
+    isVerbose: true
+  });
+  await (0, import_createModuleAugmentation.createModuleAugmentation)();
+  appLogger("Module augmentation built", {
+    isVerbose: true
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleUnlikedContentDeclarationFile
+});
+//# sourceMappingURL=handleUnlikedContentDeclarationFile.cjs.map

package/dist/cjs/handleUnlikedContentDeclarationFile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/handleUnlikedContentDeclarationFile.ts"],"sourcesContent":["import { type IntlayerConfig, getAppLogger } from '@intlayer/config';\nimport { buildDictionary } from './buildIntlayerDictionary/buildIntlayerDictionary';\nimport { createDictionaryEntryPoint } from './createDictionaryEntryPoint/createDictionaryEntryPoint';\nimport { createTypes } from './createType';\nimport { createModuleAugmentation } from './createType/createModuleAugmentation';\nimport { listDictionaries } from './listDictionariesPath';\nimport { loadLocalDictionaries } from './loadDictionaries/loadLocalDictionaries';\nimport { formatPath } from './utils/formatter';\n\nexport const handleUnlikedContentDeclarationFile = async (\n  filePath: string,\n  config: IntlayerConfig\n) => {\n  const appLogger = getAppLogger(config);\n\n  // Process the file with the functionToRun\n  appLogger(`Unlinked detected: ${formatPath(filePath)}`, {\n    isVerbose: true,\n  });\n\n  const files: string[] = listDictionaries(config);\n\n  const localeDictionaries = await loadLocalDictionaries(files, config);\n\n  const dictionariesOutput = await buildDictionary(localeDictionaries, config);\n\n  const dictionariesPaths = Object.values(\n    dictionariesOutput?.mergedDictionaries ?? {}\n  ).map((dictionary) => dictionary.dictionaryPath);\n\n  await createTypes(dictionariesPaths);\n\n  await createDictionaryEntryPoint();\n\n  appLogger('Dictionaries rebuilt', {\n    isVerbose: true,\n  });\n\n  await createModuleAugmentation();\n\n  appLogger('Module augmentation built', {\n    isVerbose: true,\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAkD;AAClD,qCAAgC;AAChC,wCAA2C;AAC3C,wBAA4B;AAC5B,sCAAyC;AACzC,kCAAiC;AACjC,mCAAsC;AACtC,uBAA2B;AAEpB,MAAM,sCAAsC,OACjD,UACA,WACG;AACH,QAAM,gBAAY,4BAAa,MAAM;AAGrC,YAAU,0BAAsB,6BAAW,QAAQ,CAAC,IAAI;AAAA,IACtD,WAAW;AAAA,EACb,CAAC;AAED,QAAM,YAAkB,8CAAiB,MAAM;AAE/C,QAAM,qBAAqB,UAAM,oDAAsB,OAAO,MAAM;AAEpE,QAAM,qBAAqB,UAAM,gDAAgB,oBAAoB,MAAM;AAE3E,QAAM,oBAAoB,OAAO;AAAA,IAC/B,oBAAoB,sBAAsB,CAAC;AAAA,EAC7C,EAAE,IAAI,CAAC,eAAe,WAAW,cAAc;AAE/C,YAAM,+BAAY,iBAAiB;AAEnC,YAAM,8DAA2B;AAEjC,YAAU,wBAAwB;AAAA,IAChC,WAAW;AAAA,EACb,CAAC;AAED,YAAM,0DAAyB;AAE/B,YAAU,6BAA6B;AAAA,IACrC,WAAW;AAAA,EACb,CAAC;AACH;","names":[]}