@intlayer/chokidar 8.4.3 → 8.4.5

package/dist/esm/utils/getChunk.mjs

@@ -1,2 +1,34 @@
-import{splitTextByLines as e}from"./splitTextByLine.mjs";const t=(t,n={})=>{let{lineStart:r,lineLength:i,charStart:a,charLength:o}=n;if(r===void 0&&i===void 0&&a===void 0&&o===void 0)return t;let s=e(t),c=e=>{if(e<=0)return 0;let t=0;for(let n=0;n<Math.min(e,s.length);n++)t+=s[n].length;return t},l=e=>{if(e>=s.length)return t.length;let n=s[e];return c(e)+n.length},u=0,d=t.length;if(r!==void 0&&(u=Math.max(u,c(r))),a!==void 0&&(u=Math.max(u,a)),i!==void 0){let e=(r??0)+i-1;d=Math.min(d,l(e))}return o!==void 0&&(d=Math.min(d,(a??u)+o)),u>=d?``:t.slice(u,d)};export{t as getChunk};
+import { splitTextByLines } from "./splitTextByLine.mjs";
+
+//#region src/utils/getChunk.ts
+const getChunk = (text, options = {}) => {
+	const { lineStart, lineLength, charStart, charLength } = options;
+	if (lineStart === void 0 && lineLength === void 0 && charStart === void 0 && charLength === void 0) return text;
+	const lines = splitTextByLines(text);
+	const getCharIndexOfLineStart = (lineNumber) => {
+		if (lineNumber <= 0) return 0;
+		let idx = 0;
+		for (let i = 0; i < Math.min(lineNumber, lines.length); i++) idx += lines[i].length;
+		return idx;
+	};
+	const getCharIndexOfLineEnd = (lineNumber) => {
+		if (lineNumber >= lines.length) return text.length;
+		const line = lines[lineNumber];
+		return getCharIndexOfLineStart(lineNumber) + line.length;
+	};
+	let effectiveStart = 0;
+	let effectiveEnd = text.length;
+	if (lineStart !== void 0) effectiveStart = Math.max(effectiveStart, getCharIndexOfLineStart(lineStart));
+	if (charStart !== void 0) effectiveStart = Math.max(effectiveStart, charStart);
+	if (lineLength !== void 0) {
+		const endLine = (lineStart ?? 0) + lineLength - 1;
+		effectiveEnd = Math.min(effectiveEnd, getCharIndexOfLineEnd(endLine));
+	}
+	if (charLength !== void 0) effectiveEnd = Math.min(effectiveEnd, (charStart ?? effectiveStart) + charLength);
+	if (effectiveStart >= effectiveEnd) return "";
+	return text.slice(effectiveStart, effectiveEnd);
+};
+
+//#endregion
+export { getChunk };
 //# sourceMappingURL=getChunk.mjs.map

package/dist/esm/utils/getChunk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getChunk.mjs","names":[],"sources":["../../../src/utils/getChunk.ts"],"sourcesContent":["import { splitTextByLines } from './splitTextByLine';\n\ntype TrunkOptions = {\n  lineStart?: number;\n  lineLength?: number;\n  charStart?: number;\n  charLength?: number;\n};\n\nexport const getChunk = (text: string, options: TrunkOptions = {}): string => {\n  const { lineStart, lineLength, charStart, charLength } = options;\n\n  // Fast-path: if no filters were provided, return the whole text\n  if (\n    lineStart === undefined &&\n    lineLength === undefined &&\n    charStart === undefined &&\n    charLength === undefined\n  ) {\n    return text;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Utility helpers to convert between line numbers and absolute char indices\n  // ---------------------------------------------------------------------------\n  const lines = splitTextByLines(text);\n\n  const getCharIndexOfLineStart = (lineNumber: number): number => {\n    if (lineNumber <= 0) return 0;\n    // Sum the length of every previous line\n    let idx = 0;\n    for (let i = 0; i < Math.min(lineNumber, lines.length); i++) {\n      idx += lines[i].length;\n    }\n    return idx;\n  };\n\n  const getCharIndexOfLineEnd = (lineNumber: number): number => {\n    // If the requested line number exceeds the number of lines, clamp to the last character\n    if (lineNumber >= lines.length) {\n      return text.length;\n    }\n    const line = lines[lineNumber];\n    const lineEnd = getCharIndexOfLineStart(lineNumber) + line.length;\n\n    return lineEnd;\n  };\n\n  // ---------------------------------------------------------------------------\n  // Compute the effective (inclusive) charStart/charEnd for the requested slice\n  // ---------------------------------------------------------------------------\n  let effectiveStart = 0; // inclusive\n  let effectiveEnd = text.length; // exclusive\n\n  // Apply line boundaries if provided\n  if (lineStart !== undefined) {\n    effectiveStart = Math.max(\n      effectiveStart,\n      getCharIndexOfLineStart(lineStart)\n    );\n  }\n\n  // Apply character boundaries if provided\n  if (charStart !== undefined) {\n    effectiveStart = Math.max(effectiveStart, charStart);\n  }\n\n  // Apply line length boundary from lineStart (or 0)\n  if (lineLength !== undefined) {\n    const endLine = (lineStart ?? 0) + lineLength - 1;\n    effectiveEnd = Math.min(effectiveEnd, getCharIndexOfLineEnd(endLine));\n  }\n\n  // Apply character length boundary from effectiveStart\n  if (charLength !== undefined) {\n    effectiveEnd = Math.min(\n      effectiveEnd,\n      (charStart ?? effectiveStart) + charLength\n    );\n  }\n\n  // If bounds do not overlap, return empty string\n  if (effectiveStart >= effectiveEnd) {\n    return '';\n  }\n\n  return text.slice(effectiveStart, effectiveEnd);\n};\n"],"mappings":"yDASA,MAAa,GAAY,EAAc,EAAwB,EAAE,GAAa,CAC5E,GAAM,CAAE,YAAW,aAAY,YAAW,cAAe,EAGzD,GACE,IAAc,IAAA,IACd,IAAe,IAAA,IACf,IAAc,IAAA,IACd,IAAe,IAAA,GAEf,OAAO,EAMT,IAAM,EAAQ,EAAiB,EAAK,CAE9B,EAA2B,GAA+B,CAC9D,GAAI,GAAc,EAAG,MAAO,GAE5B,IAAI,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,EAAI,KAAK,IAAI,EAAY,EAAM,OAAO,CAAE,IACtD,GAAO,EAAM,GAAG,OAElB,OAAO,GAGH,EAAyB,GAA+B,CAE5D,GAAI,GAAc,EAAM,OACtB,OAAO,EAAK,OAEd,IAAM,EAAO,EAAM,GAGnB,OAFgB,EAAwB,EAAW,CAAG,EAAK,QAQzD,EAAiB,EACjB,EAAe,EAAK,OAgBxB,GAbI,IAAc,IAAA,KAChB,EAAiB,KAAK,IACpB,EACA,EAAwB,EAAU,CACnC,EAIC,IAAc,IAAA,KAChB,EAAiB,KAAK,IAAI,EAAgB,EAAU,EAIlD,IAAe,IAAA,GAAW,CAC5B,IAAM,GAAW,GAAa,GAAK,EAAa,EAChD,EAAe,KAAK,IAAI,EAAc,EAAsB,EAAQ,CAAC,CAgBvE,OAZI,IAAe,IAAA,KACjB,EAAe,KAAK,IAClB,GACC,GAAa,GAAkB,EACjC,EAIC,GAAkB,EACb,GAGF,EAAK,MAAM,EAAgB,EAAa"}
+{"version":3,"file":"getChunk.mjs","names":[],"sources":["../../../src/utils/getChunk.ts"],"sourcesContent":["import { splitTextByLines } from './splitTextByLine';\n\ntype TrunkOptions = {\n  lineStart?: number;\n  lineLength?: number;\n  charStart?: number;\n  charLength?: number;\n};\n\nexport const getChunk = (text: string, options: TrunkOptions = {}): string => {\n  const { lineStart, lineLength, charStart, charLength } = options;\n\n  // Fast-path: if no filters were provided, return the whole text\n  if (\n    lineStart === undefined &&\n    lineLength === undefined &&\n    charStart === undefined &&\n    charLength === undefined\n  ) {\n    return text;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Utility helpers to convert between line numbers and absolute char indices\n  // ---------------------------------------------------------------------------\n  const lines = splitTextByLines(text);\n\n  const getCharIndexOfLineStart = (lineNumber: number): number => {\n    if (lineNumber <= 0) return 0;\n    // Sum the length of every previous line\n    let idx = 0;\n    for (let i = 0; i < Math.min(lineNumber, lines.length); i++) {\n      idx += lines[i].length;\n    }\n    return idx;\n  };\n\n  const getCharIndexOfLineEnd = (lineNumber: number): number => {\n    // If the requested line number exceeds the number of lines, clamp to the last character\n    if (lineNumber >= lines.length) {\n      return text.length;\n    }\n    const line = lines[lineNumber];\n    const lineEnd = getCharIndexOfLineStart(lineNumber) + line.length;\n\n    return lineEnd;\n  };\n\n  // ---------------------------------------------------------------------------\n  // Compute the effective (inclusive) charStart/charEnd for the requested slice\n  // ---------------------------------------------------------------------------\n  let effectiveStart = 0; // inclusive\n  let effectiveEnd = text.length; // exclusive\n\n  // Apply line boundaries if provided\n  if (lineStart !== undefined) {\n    effectiveStart = Math.max(\n      effectiveStart,\n      getCharIndexOfLineStart(lineStart)\n    );\n  }\n\n  // Apply character boundaries if provided\n  if (charStart !== undefined) {\n    effectiveStart = Math.max(effectiveStart, charStart);\n  }\n\n  // Apply line length boundary from lineStart (or 0)\n  if (lineLength !== undefined) {\n    const endLine = (lineStart ?? 0) + lineLength - 1;\n    effectiveEnd = Math.min(effectiveEnd, getCharIndexOfLineEnd(endLine));\n  }\n\n  // Apply character length boundary from effectiveStart\n  if (charLength !== undefined) {\n    effectiveEnd = Math.min(\n      effectiveEnd,\n      (charStart ?? effectiveStart) + charLength\n    );\n  }\n\n  // If bounds do not overlap, return empty string\n  if (effectiveStart >= effectiveEnd) {\n    return '';\n  }\n\n  return text.slice(effectiveStart, effectiveEnd);\n};\n"],"mappings":";;;AASA,MAAa,YAAY,MAAc,UAAwB,EAAE,KAAa;CAC5E,MAAM,EAAE,WAAW,YAAY,WAAW,eAAe;AAGzD,KACE,cAAc,UACd,eAAe,UACf,cAAc,UACd,eAAe,OAEf,QAAO;CAMT,MAAM,QAAQ,iBAAiB,KAAK;CAEpC,MAAM,2BAA2B,eAA+B;AAC9D,MAAI,cAAc,EAAG,QAAO;EAE5B,IAAI,MAAM;AACV,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IAAI,YAAY,MAAM,OAAO,EAAE,IACtD,QAAO,MAAM,GAAG;AAElB,SAAO;;CAGT,MAAM,yBAAyB,eAA+B;AAE5D,MAAI,cAAc,MAAM,OACtB,QAAO,KAAK;EAEd,MAAM,OAAO,MAAM;AAGnB,SAFgB,wBAAwB,WAAW,GAAG,KAAK;;CAQ7D,IAAI,iBAAiB;CACrB,IAAI,eAAe,KAAK;AAGxB,KAAI,cAAc,OAChB,kBAAiB,KAAK,IACpB,gBACA,wBAAwB,UAAU,CACnC;AAIH,KAAI,cAAc,OAChB,kBAAiB,KAAK,IAAI,gBAAgB,UAAU;AAItD,KAAI,eAAe,QAAW;EAC5B,MAAM,WAAW,aAAa,KAAK,aAAa;AAChD,iBAAe,KAAK,IAAI,cAAc,sBAAsB,QAAQ,CAAC;;AAIvE,KAAI,eAAe,OACjB,gBAAe,KAAK,IAClB,eACC,aAAa,kBAAkB,WACjC;AAIH,KAAI,kBAAkB,aACpB,QAAO;AAGT,QAAO,KAAK,MAAM,gBAAgB,aAAa"}

package/dist/esm/utils/getContentExtension.mjs

@@ -1,2 +1,28 @@
-const e=(e,t)=>{let n=`.ts`;switch(e){case`json`:n=`.json`;break;case`cjs`:n=`.cjs`;break;case`esm`:n=`.js`;break}return t.content.fileExtensions.find(e=>e.endsWith(n))??t.content.fileExtensions[0]??`.content${n}`};export{e as getContentExtension};
+//#region src/utils/getContentExtension.ts
+/**
+* Generates the .content file extension based on the desired format
+* and the project's fileExtensions configuration.
+*
+* Example:
+* format 'ts' -> '.content.ts'
+* format 'esm' -> '.content.js' (if matching .content.js is found in config)
+*/
+const getContentExtension = (format, configuration) => {
+	let contentFileExtension = ".ts";
+	switch (format) {
+		case "json":
+			contentFileExtension = ".json";
+			break;
+		case "cjs":
+			contentFileExtension = ".cjs";
+			break;
+		case "esm":
+			contentFileExtension = ".js";
+			break;
+	}
+	return configuration.content.fileExtensions.find((extension) => extension.endsWith(contentFileExtension)) ?? configuration.content.fileExtensions[0] ?? `.content${contentFileExtension}`;
+};
+
+//#endregion
+export { getContentExtension };
 //# sourceMappingURL=getContentExtension.mjs.map

package/dist/esm/utils/getContentExtension.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getContentExtension.mjs","names":[],"sources":["../../../src/utils/getContentExtension.ts"],"sourcesContent":["import type { IntlayerConfig } from '@intlayer/types/config';\n\n/**\n * Generates the .content file extension based on the desired format\n * and the project's fileExtensions configuration.\n *\n * Example:\n * format 'ts' -> '.content.ts'\n * format 'esm' -> '.content.js' (if matching .content.js is found in config)\n */\nexport const getContentExtension = (\n  format: 'ts' | 'esm' | 'cjs' | 'json' | 'jsonc' | 'json5' | (string & {}),\n  configuration: IntlayerConfig\n): string => {\n  let contentFileExtension = '.ts';\n  switch (format) {\n    case 'json':\n      contentFileExtension = '.json';\n      break;\n    case 'cjs':\n      contentFileExtension = '.cjs';\n      break;\n    case 'esm':\n      contentFileExtension = '.js';\n      break;\n  }\n\n  // Find the configured extension that matches the format's extension\n  const pickedFileExtension = configuration.content.fileExtensions.find(\n    (extension) => extension.endsWith(contentFileExtension)\n  );\n\n  return (\n    pickedFileExtension ??\n    configuration.content.fileExtensions[0] ??\n    `.content${contentFileExtension}`\n  );\n};\n"],"mappings":"AAUA,MAAa,GACX,EACA,IACW,CACX,IAAI,EAAuB,MAC3B,OAAQ,EAAR,CACE,IAAK,OACH,EAAuB,QACvB,MACF,IAAK,MACH,EAAuB,OACvB,MACF,IAAK,MACH,EAAuB,MACvB,MAQJ,OAJ4B,EAAc,QAAQ,eAAe,KAC9D,GAAc,EAAU,SAAS,EAAqB,CACxD,EAIC,EAAc,QAAQ,eAAe,IACrC,WAAW"}
+{"version":3,"file":"getContentExtension.mjs","names":[],"sources":["../../../src/utils/getContentExtension.ts"],"sourcesContent":["import type { IntlayerConfig } from '@intlayer/types/config';\n\n/**\n * Generates the .content file extension based on the desired format\n * and the project's fileExtensions configuration.\n *\n * Example:\n * format 'ts' -> '.content.ts'\n * format 'esm' -> '.content.js' (if matching .content.js is found in config)\n */\nexport const getContentExtension = (\n  format: 'ts' | 'esm' | 'cjs' | 'json' | 'jsonc' | 'json5' | (string & {}),\n  configuration: IntlayerConfig\n): string => {\n  let contentFileExtension = '.ts';\n  switch (format) {\n    case 'json':\n      contentFileExtension = '.json';\n      break;\n    case 'cjs':\n      contentFileExtension = '.cjs';\n      break;\n    case 'esm':\n      contentFileExtension = '.js';\n      break;\n  }\n\n  // Find the configured extension that matches the format's extension\n  const pickedFileExtension = configuration.content.fileExtensions.find(\n    (extension) => extension.endsWith(contentFileExtension)\n  );\n\n  return (\n    pickedFileExtension ??\n    configuration.content.fileExtensions[0] ??\n    `.content${contentFileExtension}`\n  );\n};\n"],"mappings":";;;;;;;;;AAUA,MAAa,uBACX,QACA,kBACW;CACX,IAAI,uBAAuB;AAC3B,SAAQ,QAAR;EACE,KAAK;AACH,0BAAuB;AACvB;EACF,KAAK;AACH,0BAAuB;AACvB;EACF,KAAK;AACH,0BAAuB;AACvB;;AAQJ,QAJ4B,cAAc,QAAQ,eAAe,MAC9D,cAAc,UAAU,SAAS,qBAAqB,CACxD,IAIC,cAAc,QAAQ,eAAe,MACrC,WAAW"}

package/dist/esm/utils/getFormatFromExtension.mjs

@@ -1,2 +1,32 @@
-const e=e=>{switch(e){case`.ts`:case`.tsx`:return`ts`;case`.cjs`:case`.cjsx`:return`cjs`;case`.js`:case`.jsx`:case`.mjs`:case`.mjsx`:return`esm`;case`.json`:case`.jsonc`:case`.json5`:return`json`}return`ts`},t=e=>{switch(e){case`ts`:return`.ts`;case`cjs`:return`.cjs`;case`json`:return`.json`;case`jsonc`:return`.jsonc`;case`json5`:return`.json5`;case`esm`:return`.mjs`}return`.ts`};export{t as getExtensionFromFormat,e as getFormatFromExtension};
+//#region src/utils/getFormatFromExtension.ts
+const getFormatFromExtension = (extension) => {
+	switch (extension) {
+		case ".ts":
+		case ".tsx": return "ts";
+		case ".cjs":
+		case ".cjsx": return "cjs";
+		case ".js":
+		case ".jsx":
+		case ".mjs":
+		case ".mjsx": return "esm";
+		case ".json":
+		case ".jsonc":
+		case ".json5": return "json";
+	}
+	return "ts";
+};
+const getExtensionFromFormat = (format) => {
+	switch (format) {
+		case "ts": return ".ts";
+		case "cjs": return ".cjs";
+		case "json": return ".json";
+		case "jsonc": return ".jsonc";
+		case "json5": return ".json5";
+		case "esm": return ".mjs";
+	}
+	return ".ts";
+};
+
+//#endregion
+export { getExtensionFromFormat, getFormatFromExtension };
 //# sourceMappingURL=getFormatFromExtension.mjs.map

package/dist/esm/utils/getFormatFromExtension.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getFormatFromExtension.mjs","names":[],"sources":["../../../src/utils/getFormatFromExtension.ts"],"sourcesContent":["export type Format = 'ts' | 'cjs' | 'esm' | 'json' | 'jsonc' | 'json5';\nexport type Extension =\n  | '.ts'\n  | '.tsx'\n  | '.js'\n  | '.jsx'\n  | '.cjs'\n  | '.cjsx'\n  | '.mjs'\n  | '.mjsx'\n  | '.json'\n  | '.jsonc'\n  | '.json5';\n\nexport const getFormatFromExtension = (\n  extension: Extension | (string & {})\n): Format => {\n  switch (extension) {\n    case '.ts':\n    case '.tsx':\n      return 'ts';\n    case '.cjs':\n    case '.cjsx':\n      return 'cjs';\n    case '.js':\n    case '.jsx':\n    case '.mjs':\n    case '.mjsx':\n      return 'esm';\n    case '.json':\n    case '.jsonc':\n    case '.json5':\n      return 'json';\n  }\n\n  return 'ts';\n};\n\nexport const getExtensionFromFormat = (\n  format: Format | (string & {})\n): Extension => {\n  switch (format) {\n    case 'ts':\n      return '.ts';\n    case 'cjs':\n      return '.cjs';\n    case 'json':\n      return '.json';\n    case 'jsonc':\n      return '.jsonc';\n    case 'json5':\n      return '.json5';\n    case 'esm':\n      return '.mjs';\n  }\n\n  return '.ts';\n};\n"],"mappings":"AAcA,MAAa,EACX,GACW,CACX,OAAQ,EAAR,CACE,IAAK,MACL,IAAK,OACH,MAAO,KACT,IAAK,OACL,IAAK,QACH,MAAO,MACT,IAAK,MACL,IAAK,OACL,IAAK,OACL,IAAK,QACH,MAAO,MACT,IAAK,QACL,IAAK,SACL,IAAK,SACH,MAAO,OAGX,MAAO,MAGI,EACX,GACc,CACd,OAAQ,EAAR,CACE,IAAK,KACH,MAAO,MACT,IAAK,MACH,MAAO,OACT,IAAK,OACH,MAAO,QACT,IAAK,QACH,MAAO,SACT,IAAK,QACH,MAAO,SACT,IAAK,MACH,MAAO,OAGX,MAAO"}
+{"version":3,"file":"getFormatFromExtension.mjs","names":[],"sources":["../../../src/utils/getFormatFromExtension.ts"],"sourcesContent":["export type Format = 'ts' | 'cjs' | 'esm' | 'json' | 'jsonc' | 'json5';\nexport type Extension =\n  | '.ts'\n  | '.tsx'\n  | '.js'\n  | '.jsx'\n  | '.cjs'\n  | '.cjsx'\n  | '.mjs'\n  | '.mjsx'\n  | '.json'\n  | '.jsonc'\n  | '.json5';\n\nexport const getFormatFromExtension = (\n  extension: Extension | (string & {})\n): Format => {\n  switch (extension) {\n    case '.ts':\n    case '.tsx':\n      return 'ts';\n    case '.cjs':\n    case '.cjsx':\n      return 'cjs';\n    case '.js':\n    case '.jsx':\n    case '.mjs':\n    case '.mjsx':\n      return 'esm';\n    case '.json':\n    case '.jsonc':\n    case '.json5':\n      return 'json';\n  }\n\n  return 'ts';\n};\n\nexport const getExtensionFromFormat = (\n  format: Format | (string & {})\n): Extension => {\n  switch (format) {\n    case 'ts':\n      return '.ts';\n    case 'cjs':\n      return '.cjs';\n    case 'json':\n      return '.json';\n    case 'jsonc':\n      return '.jsonc';\n    case 'json5':\n      return '.json5';\n    case 'esm':\n      return '.mjs';\n  }\n\n  return '.ts';\n};\n"],"mappings":";AAcA,MAAa,0BACX,cACW;AACX,SAAQ,WAAR;EACE,KAAK;EACL,KAAK,OACH,QAAO;EACT,KAAK;EACL,KAAK,QACH,QAAO;EACT,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,QACH,QAAO;EACT,KAAK;EACL,KAAK;EACL,KAAK,SACH,QAAO;;AAGX,QAAO;;AAGT,MAAa,0BACX,WACc;AACd,SAAQ,QAAR;EACE,KAAK,KACH,QAAO;EACT,KAAK,MACH,QAAO;EACT,KAAK,OACH,QAAO;EACT,KAAK,QACH,QAAO;EACT,KAAK,QACH,QAAO;EACT,KAAK,MACH,QAAO;;AAGX,QAAO"}

package/dist/esm/utils/getPathHash.mjs

@@ -1,2 +1,8 @@
-import e from"node:crypto";const t=t=>e.createHash(`sha3-256`).update(t).digest(`base64`).replace(/[^A-Z\d]/gi,``).substring(0,20);export{t as getPathHash};
+import crypto from "node:crypto";
+
+//#region src/utils/getPathHash.ts
+const getPathHash = (filePath) => crypto.createHash("sha3-256").update(filePath).digest("base64").replace(/[^A-Z\d]/gi, "").substring(0, 20);
+
+//#endregion
+export { getPathHash };
 //# sourceMappingURL=getPathHash.mjs.map

package/dist/esm/utils/getPathHash.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getPathHash.mjs","names":[],"sources":["../../../src/utils/getPathHash.ts"],"sourcesContent":["import crypto from 'node:crypto';\n\nexport const getPathHash = (filePath: string) =>\n  crypto\n    .createHash('sha3-256')\n    .update(filePath)\n    .digest('base64')\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n"],"mappings":"2BAEA,MAAa,EAAe,GAC1B,EACG,WAAW,WAAW,CACtB,OAAO,EAAS,CAChB,OAAO,SAAS,CAChB,QAAQ,aAAc,GAAG,CACzB,UAAU,EAAG,GAAG"}
+{"version":3,"file":"getPathHash.mjs","names":[],"sources":["../../../src/utils/getPathHash.ts"],"sourcesContent":["import crypto from 'node:crypto';\n\nexport const getPathHash = (filePath: string) =>\n  crypto\n    .createHash('sha3-256')\n    .update(filePath)\n    .digest('base64')\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n"],"mappings":";;;AAEA,MAAa,eAAe,aAC1B,OACG,WAAW,WAAW,CACtB,OAAO,SAAS,CAChB,OAAO,SAAS,CAChB,QAAQ,cAAc,GAAG,CACzB,UAAU,GAAG,GAAG"}

package/dist/esm/utils/index.mjs

@@ -1 +1,22 @@
-import{Queue as e,pLimit as t}from"./pLimit.mjs";import{parallelize as n}from"./parallelize.mjs";import{getPathHash as r}from"./getPathHash.mjs";import{formatLocale as i,formatPath as a}from"./formatter.mjs";import{autoDecorateContent as o}from"./autoDecorateContent.mjs";import{buildComponentFilesList as s}from"./buildComponentFilesList.mjs";import{splitTextByLines as c}from"./splitTextByLine.mjs";import{getChunk as l}from"./getChunk.mjs";import{assembleJSON as u,chunkJSON as d,reconstructFromSingleChunk as f}from"./chunkJSON.mjs";import{getContentExtension as p}from"./getContentExtension.mjs";import{getExtensionFromFormat as m,getFormatFromExtension as h}from"./getFormatFromExtension.mjs";import{mergeChunks as g}from"./mergeChunks.mjs";import{getGlobalLimiter as _,getTaskLimiter as v,parallelizeGlobal as y}from"./parallelizeGlobal.mjs";import{reduceObjectFormat as b}from"./reduceObjectFormat.mjs";import{resolveObjectPromises as x}from"./resolveObjectPromises.mjs";import{resolveRelativePath as S}from"./resolveRelativePath.mjs";import{runOnce as C}from"./runOnce.mjs";import{runParallel as w}from"./runParallel/index.mjs";import{sortAlphabetically as T}from"./sortAlphabetically.mjs";import{verifyIdenticObjectFormat as E}from"./verifyIdenticObjectFormat.mjs";export{e as Queue,u as assembleJSON,o as autoDecorateContent,s as buildComponentFilesList,d as chunkJSON,i as formatLocale,a as formatPath,l as getChunk,p as getContentExtension,m as getExtensionFromFormat,h as getFormatFromExtension,_ as getGlobalLimiter,r as getPathHash,v as getTaskLimiter,g as mergeChunks,t as pLimit,n as parallelize,y as parallelizeGlobal,f as reconstructFromSingleChunk,b as reduceObjectFormat,x as resolveObjectPromises,S as resolveRelativePath,C as runOnce,w as runParallel,T as sortAlphabetically,c as splitTextByLines,E as verifyIdenticObjectFormat};
+import { Queue, pLimit } from "./pLimit.mjs";
+import { parallelize } from "./parallelize.mjs";
+import { getPathHash } from "./getPathHash.mjs";
+import { formatLocale, formatPath } from "./formatter.mjs";
+import { autoDecorateContent } from "./autoDecorateContent.mjs";
+import { buildComponentFilesList } from "./buildComponentFilesList.mjs";
+import { splitTextByLines } from "./splitTextByLine.mjs";
+import { getChunk } from "./getChunk.mjs";
+import { assembleJSON, chunkJSON, reconstructFromSingleChunk } from "./chunkJSON.mjs";
+import { getContentExtension } from "./getContentExtension.mjs";
+import { getExtensionFromFormat, getFormatFromExtension } from "./getFormatFromExtension.mjs";
+import { mergeChunks } from "./mergeChunks.mjs";
+import { getGlobalLimiter, getTaskLimiter, parallelizeGlobal } from "./parallelizeGlobal.mjs";
+import { reduceObjectFormat } from "./reduceObjectFormat.mjs";
+import { resolveObjectPromises } from "./resolveObjectPromises.mjs";
+import { resolveRelativePath } from "./resolveRelativePath.mjs";
+import { runOnce } from "./runOnce.mjs";
+import { runParallel } from "./runParallel/index.mjs";
+import { sortAlphabetically } from "./sortAlphabetically.mjs";
+import { verifyIdenticObjectFormat } from "./verifyIdenticObjectFormat.mjs";
+
+export { Queue, assembleJSON, autoDecorateContent, buildComponentFilesList, chunkJSON, formatLocale, formatPath, getChunk, getContentExtension, getExtensionFromFormat, getFormatFromExtension, getGlobalLimiter, getPathHash, getTaskLimiter, mergeChunks, pLimit, parallelize, parallelizeGlobal, reconstructFromSingleChunk, reduceObjectFormat, resolveObjectPromises, resolveRelativePath, runOnce, runParallel, sortAlphabetically, splitTextByLines, verifyIdenticObjectFormat };

package/dist/esm/utils/mergeChunks.mjs

@@ -1,2 +1,27 @@
-const e=e=>{if(e.length===0)return{};let n=e[0];for(let r=1;r<e.length;r++)n=t(n,e[r]);return n},t=(e,n)=>{if(e==null)return n;if(n==null)return e;if(Array.isArray(e)&&Array.isArray(n)){let r=Math.max(e.length,n.length),i=[];for(let a=0;a<r;a++)i[a]=t(e[a],n[a]);return i}if(typeof e==`object`&&typeof n==`object`){let r={...e};for(let e of Object.keys(n))r[e]=t(r[e],n[e]);return r}return e};export{e as mergeChunks};
+//#region src/utils/mergeChunks.ts
+const mergeChunks = (chunks) => {
+	if (chunks.length === 0) return {};
+	let result = chunks[0];
+	for (let i = 1; i < chunks.length; i++) result = customChunkMerge(result, chunks[i]);
+	return result;
+};
+const customChunkMerge = (dest, source) => {
+	if (dest === void 0 || dest === null) return source;
+	if (source === void 0 || source === null) return dest;
+	if (Array.isArray(dest) && Array.isArray(source)) {
+		const maxLength = Math.max(dest.length, source.length);
+		const result = [];
+		for (let i = 0; i < maxLength; i++) result[i] = customChunkMerge(dest[i], source[i]);
+		return result;
+	}
+	if (typeof dest === "object" && typeof source === "object") {
+		const result = { ...dest };
+		for (const key of Object.keys(source)) result[key] = customChunkMerge(result[key], source[key]);
+		return result;
+	}
+	return dest;
+};
+
+//#endregion
+export { mergeChunks };
 //# sourceMappingURL=mergeChunks.mjs.map

package/dist/esm/utils/mergeChunks.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mergeChunks.mjs","names":[],"sources":["../../../src/utils/mergeChunks.ts"],"sourcesContent":["export const mergeChunks = (chunks: any[]): any => {\n  if (chunks.length === 0) return {};\n\n  let result = chunks[0];\n\n  for (let i = 1; i < chunks.length; i++) {\n    result = customChunkMerge(result, chunks[i]);\n  }\n\n  return result;\n};\n\nconst customChunkMerge = (dest: any, source: any): any => {\n  if (dest === undefined || dest === null) return source;\n  if (source === undefined || source === null) return dest;\n\n  if (Array.isArray(dest) && Array.isArray(source)) {\n    const maxLength = Math.max(dest.length, source.length);\n    const result = [];\n    for (let i = 0; i < maxLength; i++) {\n      result[i] = customChunkMerge(dest[i], source[i]);\n    }\n    return result;\n  }\n\n  if (typeof dest === 'object' && typeof source === 'object') {\n    const result: any = { ...dest };\n    for (const key of Object.keys(source)) {\n      result[key] = customChunkMerge(result[key], source[key]);\n    }\n    return result;\n  }\n\n  // Primitives: if we are here, both are not null.\n  // Since chunks shouldn't overlap, we can return dest.\n  return dest;\n};\n"],"mappings":"AAAA,MAAa,EAAe,GAAuB,CACjD,GAAI,EAAO,SAAW,EAAG,MAAO,EAAE,CAElC,IAAI,EAAS,EAAO,GAEpB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,OAAQ,IACjC,EAAS,EAAiB,EAAQ,EAAO,GAAG,CAG9C,OAAO,GAGH,GAAoB,EAAW,IAAqB,CACxD,GAAI,GAA+B,KAAM,OAAO,EAChD,GAAI,GAAmC,KAAM,OAAO,EAEpD,GAAI,MAAM,QAAQ,EAAK,EAAI,MAAM,QAAQ,EAAO,CAAE,CAChD,IAAM,EAAY,KAAK,IAAI,EAAK,OAAQ,EAAO,OAAO,CAChD,EAAS,EAAE,CACjB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAW,IAC7B,EAAO,GAAK,EAAiB,EAAK,GAAI,EAAO,GAAG,CAElD,OAAO,EAGT,GAAI,OAAO,GAAS,UAAY,OAAO,GAAW,SAAU,CAC1D,IAAM,EAAc,CAAE,GAAG,EAAM,CAC/B,IAAK,IAAM,KAAO,OAAO,KAAK,EAAO,CACnC,EAAO,GAAO,EAAiB,EAAO,GAAM,EAAO,GAAK,CAE1D,OAAO,EAKT,OAAO"}
+{"version":3,"file":"mergeChunks.mjs","names":[],"sources":["../../../src/utils/mergeChunks.ts"],"sourcesContent":["export const mergeChunks = (chunks: any[]): any => {\n  if (chunks.length === 0) return {};\n\n  let result = chunks[0];\n\n  for (let i = 1; i < chunks.length; i++) {\n    result = customChunkMerge(result, chunks[i]);\n  }\n\n  return result;\n};\n\nconst customChunkMerge = (dest: any, source: any): any => {\n  if (dest === undefined || dest === null) return source;\n  if (source === undefined || source === null) return dest;\n\n  if (Array.isArray(dest) && Array.isArray(source)) {\n    const maxLength = Math.max(dest.length, source.length);\n    const result = [];\n    for (let i = 0; i < maxLength; i++) {\n      result[i] = customChunkMerge(dest[i], source[i]);\n    }\n    return result;\n  }\n\n  if (typeof dest === 'object' && typeof source === 'object') {\n    const result: any = { ...dest };\n    for (const key of Object.keys(source)) {\n      result[key] = customChunkMerge(result[key], source[key]);\n    }\n    return result;\n  }\n\n  // Primitives: if we are here, both are not null.\n  // Since chunks shouldn't overlap, we can return dest.\n  return dest;\n};\n"],"mappings":";AAAA,MAAa,eAAe,WAAuB;AACjD,KAAI,OAAO,WAAW,EAAG,QAAO,EAAE;CAElC,IAAI,SAAS,OAAO;AAEpB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,UAAS,iBAAiB,QAAQ,OAAO,GAAG;AAG9C,QAAO;;AAGT,MAAM,oBAAoB,MAAW,WAAqB;AACxD,KAAI,SAAS,UAAa,SAAS,KAAM,QAAO;AAChD,KAAI,WAAW,UAAa,WAAW,KAAM,QAAO;AAEpD,KAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,QAAQ,OAAO,EAAE;EAChD,MAAM,YAAY,KAAK,IAAI,KAAK,QAAQ,OAAO,OAAO;EACtD,MAAM,SAAS,EAAE;AACjB,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,IAC7B,QAAO,KAAK,iBAAiB,KAAK,IAAI,OAAO,GAAG;AAElD,SAAO;;AAGT,KAAI,OAAO,SAAS,YAAY,OAAO,WAAW,UAAU;EAC1D,MAAM,SAAc,EAAE,GAAG,MAAM;AAC/B,OAAK,MAAM,OAAO,OAAO,KAAK,OAAO,CACnC,QAAO,OAAO,iBAAiB,OAAO,MAAM,OAAO,KAAK;AAE1D,SAAO;;AAKT,QAAO"}

package/dist/esm/utils/pLimit.mjs

@@ -1,2 +1,126 @@
-var e=class{value;next;constructor(e){this.value=e}},t=class{#e;#t;#n;constructor(){this.clear()}enqueue(t){let n=new e(t);this.#e?(this.#t.next=n,this.#t=n):(this.#e=n,this.#t=n),this.#n++}dequeue(){let e=this.#e;if(e)return this.#e=e.next,this.#n--,e.value}peek(){if(this.#e)return this.#e.value}clear(){this.#e=void 0,this.#t=void 0,this.#n=0}get size(){return this.#n}*[Symbol.iterator](){let e=this.#e;for(;e;)yield e.value,e=e.next}*drain(){for(;this.#e;)yield this.dequeue()}};const n=e=>{r(e);let n=new t,i=0,a=[],o=()=>{if(i===0&&n.size===0)for(;a.length;)a.pop()?.()},s=()=>{i<e&&n.size>0&&(i++,n.dequeue()?.())},c=()=>{i--,s()},l=async(e,t,n)=>{let r=(async()=>e(...n))();t(r);try{await r}catch{}c()},u=(t,r,a)=>{new Promise(e=>{n.enqueue(e)}).then(l.bind(void 0,t,r,a)),i<e&&s()},d=(e,...t)=>new Promise(n=>{u(e,n,t)});return Object.defineProperties(d,{activeCount:{get:()=>i},pendingCount:{get:()=>n.size},clearQueue:{value(){n.clear(),o()}},concurrency:{get:()=>e,set(t){r(t),e=t,queueMicrotask(()=>{for(;i<e&&n.size>0;)s()})}},map:{async value(e,t){let n=e.map((e,n)=>this(t,e,n));return Promise.all(n)}},onIdle:{value(){return i===0&&n.size===0?Promise.resolve():new Promise(e=>a.push(e))}}}),d},r=e=>{if(!((Number.isInteger(e)||e===1/0)&&e>0))throw TypeError("Expected `concurrency` to be a number from 1 and up")};export{t as Queue,n as pLimit};
+//#region src/utils/pLimit.ts
+var Node = class {
+	value;
+	next;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value) {
+		const node = new Node(value);
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+		this.#size++;
+	}
+	dequeue() {
+		const current = this.#head;
+		if (!current) return;
+		this.#head = current.next;
+		this.#size--;
+		return current.value;
+	}
+	peek() {
+		if (!this.#head) return;
+		return this.#head.value;
+	}
+	clear() {
+		this.#head = void 0;
+		this.#tail = void 0;
+		this.#size = 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	*[Symbol.iterator]() {
+		let current = this.#head;
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+	*drain() {
+		while (this.#head) yield this.dequeue();
+	}
+};
+const pLimit = (concurrency) => {
+	validateConcurrency(concurrency);
+	const queue = new Queue();
+	let activeCount = 0;
+	const idleWaiters = [];
+	const notifyIdleIfNeeded = () => {
+		if (activeCount === 0 && queue.size === 0) while (idleWaiters.length) idleWaiters.pop()?.();
+	};
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue()?.();
+		}
+	};
+	const next = () => {
+		activeCount--;
+		resumeNext();
+	};
+	const run = async (fn, resolve, arguments_) => {
+		const result = (async () => fn(...arguments_))();
+		resolve(result);
+		try {
+			await result;
+		} catch {}
+		next();
+	};
+	const enqueue = (fn, resolve, arguments_) => {
+		new Promise((internalResolve) => {
+			queue.enqueue(internalResolve);
+		}).then(run.bind(void 0, fn, resolve, arguments_));
+		if (activeCount < concurrency) resumeNext();
+	};
+	const generator = (fn, ...arguments_) => new Promise((resolve) => {
+		enqueue(fn, resolve, arguments_);
+	});
+	Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			queue.clear();
+			notifyIdleIfNeeded();
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+				queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
+			}
+		},
+		map: { async value(array, fn) {
+			const promises = array.map((value, index) => this(fn, value, index));
+			return Promise.all(promises);
+		} },
+		onIdle: { value() {
+			if (activeCount === 0 && queue.size === 0) return Promise.resolve();
+			return new Promise((resolve) => idleWaiters.push(resolve));
+		} }
+	});
+	return generator;
+};
+const validateConcurrency = (concurrency) => {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+};
+
+//#endregion
+export { Queue, pLimit };
 //# sourceMappingURL=pLimit.mjs.map

package/dist/esm/utils/pLimit.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pLimit.mjs","names":["#head","#tail","#size"],"sources":["../../../src/utils/pLimit.ts"],"sourcesContent":["/*\nHow it works:\n`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.\n*/\n\nclass Node<T> {\n  value: T;\n  next: Node<T> | undefined;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n}\n\nexport class Queue<T> {\n  #head: Node<T> | undefined;\n  #tail: Node<T> | undefined;\n  #size!: number;\n\n  constructor() {\n    this.clear();\n  }\n\n  enqueue(value: T): void {\n    const node = new Node(value);\n\n    if (this.#head) {\n      this.#tail!.next = node;\n      this.#tail = node;\n    } else {\n      this.#head = node;\n      this.#tail = node;\n    }\n\n    this.#size++;\n  }\n\n  dequeue(): T | undefined {\n    const current = this.#head;\n    if (!current) {\n      return;\n    }\n\n    this.#head = current.next;\n    this.#size--;\n    return current.value;\n  }\n\n  peek(): T | undefined {\n    if (!this.#head) {\n      return;\n    }\n\n    return this.#head.value;\n\n    // TODO: Node.js 18.\n    // return this.#head?.value;\n  }\n\n  clear(): void {\n    this.#head = undefined;\n    this.#tail = undefined;\n    this.#size = 0;\n  }\n\n  get size(): number {\n    return this.#size;\n  }\n\n  *[Symbol.iterator](): Generator<T, void, unknown> {\n    let current = this.#head;\n\n    while (current) {\n      yield current.value;\n      current = current.next;\n    }\n  }\n\n  *drain(): Generator<T | undefined, void, unknown> {\n    while (this.#head) {\n      yield this.dequeue();\n    }\n  }\n}\n\nexport const pLimit = (concurrency: number) => {\n  validateConcurrency(concurrency);\n\n  const queue = new Queue<() => void>();\n  let activeCount = 0;\n\n  const idleWaiters: Array<() => void> = [];\n  const notifyIdleIfNeeded = (): void => {\n    if (activeCount === 0 && queue.size === 0) {\n      while (idleWaiters.length) idleWaiters.pop()?.();\n    }\n  };\n\n  const resumeNext = (): void => {\n    // Process the next queued function if we're under the concurrency limit\n    if (activeCount < concurrency && queue.size > 0) {\n      activeCount++;\n      queue.dequeue()?.();\n    }\n  };\n\n  const next = (): void => {\n    activeCount--;\n    resumeNext();\n  };\n\n  const run = async (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): Promise<void> => {\n    // Execute the function and capture the result promise\n    const result = (async () => fn(...arguments_))();\n\n    // Resolve immediately with the promise (don't wait for completion)\n    resolve(result);\n\n    // Wait for the function to complete (success or failure)\n    // We catch errors here to prevent unhandled rejections,\n    // but the original promise rejection is preserved for the caller\n    try {\n      await result;\n    } catch {}\n\n    // Decrement active count and process next queued function\n    next();\n  };\n\n  const enqueue = (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): void => {\n    // Queue the internal resolve function instead of the run function\n    // to preserve the asynchronous execution context.\n    new Promise<void>((internalResolve) => {\n      queue.enqueue(internalResolve);\n    }).then(run.bind(undefined, fn, resolve, arguments_));\n\n    // Start processing immediately if we haven't reached the concurrency limit\n    if (activeCount < concurrency) {\n      resumeNext();\n    }\n  };\n\n  const generator = (\n    fn: (...args: any[]) => Promise<any>,\n    ...arguments_: any[]\n  ): Promise<any> =>\n    new Promise<any>((resolve) => {\n      enqueue(fn, resolve, arguments_);\n    });\n\n  Object.defineProperties(generator, {\n    activeCount: {\n      get: () => activeCount,\n    },\n    pendingCount: {\n      get: () => queue.size,\n    },\n    clearQueue: {\n      value() {\n        queue.clear();\n        notifyIdleIfNeeded();\n      },\n    },\n    concurrency: {\n      get: () => concurrency,\n\n      set(newConcurrency: number) {\n        validateConcurrency(newConcurrency);\n        concurrency = newConcurrency;\n\n        queueMicrotask(() => {\n          while (activeCount < concurrency && queue.size > 0) {\n            resumeNext();\n          }\n        });\n      },\n    },\n    map: {\n      async value<T, R>(\n        array: T[],\n        fn: (value: T, index: number) => Promise<R>\n      ): Promise<R[]> {\n        const promises = array.map((value, index) => this(fn, value, index));\n        return Promise.all(promises);\n      },\n    },\n    onIdle: {\n      /**\n       * Resolves when `activeCount === 0` and the queue is empty.\n       * Use this to wait for completion without holding a list of Promises.\n       */\n      value(): Promise<void> {\n        if (activeCount === 0 && queue.size === 0) return Promise.resolve();\n        return new Promise<void>((resolve) => idleWaiters.push(resolve));\n      },\n    },\n  });\n\n  return generator;\n};\n\nconst validateConcurrency = (concurrency: number): void => {\n  if (\n    !(\n      (Number.isInteger(concurrency) ||\n        concurrency === Number.POSITIVE_INFINITY) &&\n      concurrency > 0\n    )\n  ) {\n    throw new TypeError('Expected `concurrency` to be a number from 1 and up');\n  }\n};\n"],"mappings":"AAKA,IAAM,EAAN,KAAc,CACZ,MACA,KAEA,YAAY,EAAU,CACpB,KAAK,MAAQ,IAIJ,EAAb,KAAsB,CACpB,GACA,GACA,GAEA,aAAc,CACZ,KAAK,OAAO,CAGd,QAAQ,EAAgB,CACtB,IAAM,EAAO,IAAI,EAAK,EAAM,CAExB,MAAA,GACF,MAAA,EAAY,KAAO,EACnB,MAAA,EAAa,IAEb,MAAA,EAAa,EACb,MAAA,EAAa,GAGf,MAAA,IAGF,SAAyB,CACvB,IAAM,EAAU,MAAA,EACX,KAML,MAFA,OAAA,EAAa,EAAQ,KACrB,MAAA,IACO,EAAQ,MAGjB,MAAsB,CACf,SAAA,EAIL,OAAO,MAAA,EAAW,MAMpB,OAAc,CACZ,MAAA,EAAa,IAAA,GACb,MAAA,EAAa,IAAA,GACb,MAAA,EAAa,EAGf,IAAI,MAAe,CACjB,OAAO,MAAA,EAGT,EAAE,OAAO,WAAyC,CAChD,IAAI,EAAU,MAAA,EAEd,KAAO,GACL,MAAM,EAAQ,MACd,EAAU,EAAQ,KAItB,CAAC,OAAiD,CAChD,KAAO,MAAA,GACL,MAAM,KAAK,SAAS,GAK1B,MAAa,EAAU,GAAwB,CAC7C,EAAoB,EAAY,CAEhC,IAAM,EAAQ,IAAI,EACd,EAAc,EAEZ,EAAiC,EAAE,CACnC,MAAiC,CACrC,GAAI,IAAgB,GAAK,EAAM,OAAS,EACtC,KAAO,EAAY,QAAQ,EAAY,KAAK,IAAI,EAI9C,MAAyB,CAEzB,EAAc,GAAe,EAAM,KAAO,IAC5C,IACA,EAAM,SAAS,IAAI,GAIjB,MAAmB,CACvB,IACA,GAAY,EAGR,EAAM,MACV,EACA,EACA,IACkB,CAElB,IAAM,GAAU,SAAY,EAAG,GAAG,EAAW,GAAG,CAGhD,EAAQ,EAAO,CAKf,GAAI,CACF,MAAM,OACA,EAGR,GAAM,EAGF,GACJ,EACA,EACA,IACS,CAGT,IAAI,QAAe,GAAoB,CACrC,EAAM,QAAQ,EAAgB,EAC9B,CAAC,KAAK,EAAI,KAAK,IAAA,GAAW,EAAI,EAAS,EAAW,CAAC,CAGjD,EAAc,GAChB,GAAY,EAIV,GACJ,EACA,GAAG,IAEH,IAAI,QAAc,GAAY,CAC5B,EAAQ,EAAI,EAAS,EAAW,EAChC,CAkDJ,OAhDA,OAAO,iBAAiB,EAAW,CACjC,YAAa,CACX,QAAW,EACZ,CACD,aAAc,CACZ,QAAW,EAAM,KAClB,CACD,WAAY,CACV,OAAQ,CACN,EAAM,OAAO,CACb,GAAoB,EAEvB,CACD,YAAa,CACX,QAAW,EAEX,IAAI,EAAwB,CAC1B,EAAoB,EAAe,CACnC,EAAc,EAEd,mBAAqB,CACnB,KAAO,EAAc,GAAe,EAAM,KAAO,GAC/C,GAAY,EAEd,EAEL,CACD,IAAK,CACH,MAAM,MACJ,EACA,EACc,CACd,IAAM,EAAW,EAAM,KAAK,EAAO,IAAU,KAAK,EAAI,EAAO,EAAM,CAAC,CACpE,OAAO,QAAQ,IAAI,EAAS,EAE/B,CACD,OAAQ,CAKN,OAAuB,CAErB,OADI,IAAgB,GAAK,EAAM,OAAS,EAAU,QAAQ,SAAS,CAC5D,IAAI,QAAe,GAAY,EAAY,KAAK,EAAQ,CAAC,EAEnE,CACF,CAAC,CAEK,GAGH,EAAuB,GAA8B,CACzD,GACE,GACG,OAAO,UAAU,EAAY,EAC5B,IAAgB,MAClB,EAAc,GAGhB,MAAU,UAAU,sDAAsD"}
+{"version":3,"file":"pLimit.mjs","names":["#head","#tail","#size"],"sources":["../../../src/utils/pLimit.ts"],"sourcesContent":["/*\nHow it works:\n`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.\n*/\n\nclass Node<T> {\n  value: T;\n  next: Node<T> | undefined;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n}\n\nexport class Queue<T> {\n  #head: Node<T> | undefined;\n  #tail: Node<T> | undefined;\n  #size!: number;\n\n  constructor() {\n    this.clear();\n  }\n\n  enqueue(value: T): void {\n    const node = new Node(value);\n\n    if (this.#head) {\n      this.#tail!.next = node;\n      this.#tail = node;\n    } else {\n      this.#head = node;\n      this.#tail = node;\n    }\n\n    this.#size++;\n  }\n\n  dequeue(): T | undefined {\n    const current = this.#head;\n    if (!current) {\n      return;\n    }\n\n    this.#head = current.next;\n    this.#size--;\n    return current.value;\n  }\n\n  peek(): T | undefined {\n    if (!this.#head) {\n      return;\n    }\n\n    return this.#head.value;\n\n    // TODO: Node.js 18.\n    // return this.#head?.value;\n  }\n\n  clear(): void {\n    this.#head = undefined;\n    this.#tail = undefined;\n    this.#size = 0;\n  }\n\n  get size(): number {\n    return this.#size;\n  }\n\n  *[Symbol.iterator](): Generator<T, void, unknown> {\n    let current = this.#head;\n\n    while (current) {\n      yield current.value;\n      current = current.next;\n    }\n  }\n\n  *drain(): Generator<T | undefined, void, unknown> {\n    while (this.#head) {\n      yield this.dequeue();\n    }\n  }\n}\n\nexport const pLimit = (concurrency: number) => {\n  validateConcurrency(concurrency);\n\n  const queue = new Queue<() => void>();\n  let activeCount = 0;\n\n  const idleWaiters: Array<() => void> = [];\n  const notifyIdleIfNeeded = (): void => {\n    if (activeCount === 0 && queue.size === 0) {\n      while (idleWaiters.length) idleWaiters.pop()?.();\n    }\n  };\n\n  const resumeNext = (): void => {\n    // Process the next queued function if we're under the concurrency limit\n    if (activeCount < concurrency && queue.size > 0) {\n      activeCount++;\n      queue.dequeue()?.();\n    }\n  };\n\n  const next = (): void => {\n    activeCount--;\n    resumeNext();\n  };\n\n  const run = async (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): Promise<void> => {\n    // Execute the function and capture the result promise\n    const result = (async () => fn(...arguments_))();\n\n    // Resolve immediately with the promise (don't wait for completion)\n    resolve(result);\n\n    // Wait for the function to complete (success or failure)\n    // We catch errors here to prevent unhandled rejections,\n    // but the original promise rejection is preserved for the caller\n    try {\n      await result;\n    } catch {}\n\n    // Decrement active count and process next queued function\n    next();\n  };\n\n  const enqueue = (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): void => {\n    // Queue the internal resolve function instead of the run function\n    // to preserve the asynchronous execution context.\n    new Promise<void>((internalResolve) => {\n      queue.enqueue(internalResolve);\n    }).then(run.bind(undefined, fn, resolve, arguments_));\n\n    // Start processing immediately if we haven't reached the concurrency limit\n    if (activeCount < concurrency) {\n      resumeNext();\n    }\n  };\n\n  const generator = (\n    fn: (...args: any[]) => Promise<any>,\n    ...arguments_: any[]\n  ): Promise<any> =>\n    new Promise<any>((resolve) => {\n      enqueue(fn, resolve, arguments_);\n    });\n\n  Object.defineProperties(generator, {\n    activeCount: {\n      get: () => activeCount,\n    },\n    pendingCount: {\n      get: () => queue.size,\n    },\n    clearQueue: {\n      value() {\n        queue.clear();\n        notifyIdleIfNeeded();\n      },\n    },\n    concurrency: {\n      get: () => concurrency,\n\n      set(newConcurrency: number) {\n        validateConcurrency(newConcurrency);\n        concurrency = newConcurrency;\n\n        queueMicrotask(() => {\n          while (activeCount < concurrency && queue.size > 0) {\n            resumeNext();\n          }\n        });\n      },\n    },\n    map: {\n      async value<T, R>(\n        array: T[],\n        fn: (value: T, index: number) => Promise<R>\n      ): Promise<R[]> {\n        const promises = array.map((value, index) => this(fn, value, index));\n        return Promise.all(promises);\n      },\n    },\n    onIdle: {\n      /**\n       * Resolves when `activeCount === 0` and the queue is empty.\n       * Use this to wait for completion without holding a list of Promises.\n       */\n      value(): Promise<void> {\n        if (activeCount === 0 && queue.size === 0) return Promise.resolve();\n        return new Promise<void>((resolve) => idleWaiters.push(resolve));\n      },\n    },\n  });\n\n  return generator;\n};\n\nconst validateConcurrency = (concurrency: number): void => {\n  if (\n    !(\n      (Number.isInteger(concurrency) ||\n        concurrency === Number.POSITIVE_INFINITY) &&\n      concurrency > 0\n    )\n  ) {\n    throw new TypeError('Expected `concurrency` to be a number from 1 and up');\n  }\n};\n"],"mappings":";AAKA,IAAM,OAAN,MAAc;CACZ;CACA;CAEA,YAAY,OAAU;AACpB,OAAK,QAAQ;;;AAIjB,IAAa,QAAb,MAAsB;CACpB;CACA;CACA;CAEA,cAAc;AACZ,OAAK,OAAO;;CAGd,QAAQ,OAAgB;EACtB,MAAM,OAAO,IAAI,KAAK,MAAM;AAE5B,MAAI,MAAKA,MAAO;AACd,SAAKC,KAAO,OAAO;AACnB,SAAKA,OAAQ;SACR;AACL,SAAKD,OAAQ;AACb,SAAKC,OAAQ;;AAGf,QAAKC;;CAGP,UAAyB;EACvB,MAAM,UAAU,MAAKF;AACrB,MAAI,CAAC,QACH;AAGF,QAAKA,OAAQ,QAAQ;AACrB,QAAKE;AACL,SAAO,QAAQ;;CAGjB,OAAsB;AACpB,MAAI,CAAC,MAAKF,KACR;AAGF,SAAO,MAAKA,KAAM;;CAMpB,QAAc;AACZ,QAAKA,OAAQ;AACb,QAAKC,OAAQ;AACb,QAAKC,OAAQ;;CAGf,IAAI,OAAe;AACjB,SAAO,MAAKA;;CAGd,EAAE,OAAO,YAAyC;EAChD,IAAI,UAAU,MAAKF;AAEnB,SAAO,SAAS;AACd,SAAM,QAAQ;AACd,aAAU,QAAQ;;;CAItB,CAAC,QAAiD;AAChD,SAAO,MAAKA,KACV,OAAM,KAAK,SAAS;;;AAK1B,MAAa,UAAU,gBAAwB;AAC7C,qBAAoB,YAAY;CAEhC,MAAM,QAAQ,IAAI,OAAmB;CACrC,IAAI,cAAc;CAElB,MAAM,cAAiC,EAAE;CACzC,MAAM,2BAAiC;AACrC,MAAI,gBAAgB,KAAK,MAAM,SAAS,EACtC,QAAO,YAAY,OAAQ,aAAY,KAAK,IAAI;;CAIpD,MAAM,mBAAyB;AAE7B,MAAI,cAAc,eAAe,MAAM,OAAO,GAAG;AAC/C;AACA,SAAM,SAAS,IAAI;;;CAIvB,MAAM,aAAmB;AACvB;AACA,cAAY;;CAGd,MAAM,MAAM,OACV,IACA,SACA,eACkB;EAElB,MAAM,UAAU,YAAY,GAAG,GAAG,WAAW,GAAG;AAGhD,UAAQ,OAAO;AAKf,MAAI;AACF,SAAM;UACA;AAGR,QAAM;;CAGR,MAAM,WACJ,IACA,SACA,eACS;AAGT,MAAI,SAAe,oBAAoB;AACrC,SAAM,QAAQ,gBAAgB;IAC9B,CAAC,KAAK,IAAI,KAAK,QAAW,IAAI,SAAS,WAAW,CAAC;AAGrD,MAAI,cAAc,YAChB,aAAY;;CAIhB,MAAM,aACJ,IACA,GAAG,eAEH,IAAI,SAAc,YAAY;AAC5B,UAAQ,IAAI,SAAS,WAAW;GAChC;AAEJ,QAAO,iBAAiB,WAAW;EACjC,aAAa,EACX,WAAW,aACZ;EACD,cAAc,EACZ,WAAW,MAAM,MAClB;EACD,YAAY,EACV,QAAQ;AACN,SAAM,OAAO;AACb,uBAAoB;KAEvB;EACD,aAAa;GACX,WAAW;GAEX,IAAI,gBAAwB;AAC1B,wBAAoB,eAAe;AACnC,kBAAc;AAEd,yBAAqB;AACnB,YAAO,cAAc,eAAe,MAAM,OAAO,EAC/C,aAAY;MAEd;;GAEL;EACD,KAAK,EACH,MAAM,MACJ,OACA,IACc;GACd,MAAM,WAAW,MAAM,KAAK,OAAO,UAAU,KAAK,IAAI,OAAO,MAAM,CAAC;AACpE,UAAO,QAAQ,IAAI,SAAS;KAE/B;EACD,QAAQ,EAKN,QAAuB;AACrB,OAAI,gBAAgB,KAAK,MAAM,SAAS,EAAG,QAAO,QAAQ,SAAS;AACnE,UAAO,IAAI,SAAe,YAAY,YAAY,KAAK,QAAQ,CAAC;KAEnE;EACF,CAAC;AAEF,QAAO;;AAGT,MAAM,uBAAuB,gBAA8B;AACzD,KACE,GACG,OAAO,UAAU,YAAY,IAC5B,gBAAgB,OAAO,sBACzB,cAAc,GAGhB,OAAM,IAAI,UAAU,sDAAsD"}

package/dist/esm/utils/parallelize.mjs

@@ -1,2 +1,11 @@
-import{pLimit as e}from"./pLimit.mjs";const t=async(t,n=async e=>e,r=10)=>{let i=e(r);return Promise.all(t.map(e=>i(()=>n(e))))};export{t as parallelize};
+import { pLimit } from "./pLimit.mjs";
+
+//#region src/utils/parallelize.ts
+const parallelize = async (items, callback = async (item) => item, parallelLimit = 10) => {
+	const limit = pLimit(parallelLimit);
+	return Promise.all(items.map((item) => limit(() => callback(item))));
+};
+
+//#endregion
+export { parallelize };
 //# sourceMappingURL=parallelize.mjs.map

package/dist/esm/utils/parallelize.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"parallelize.mjs","names":[],"sources":["../../../src/utils/parallelize.ts"],"sourcesContent":["import { pLimit } from './pLimit';\n\nexport const parallelize = async <T, R>(\n  items: T[],\n  callback: (item: T) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  parallelLimit: number = 10\n): Promise<R[]> => {\n  const limit = pLimit(parallelLimit);\n  return Promise.all(items.map((item) => limit(() => callback(item))));\n};\n"],"mappings":"sCAEA,MAAa,EAAc,MACzB,EACA,EAAoC,KAAO,IACzC,EACF,EAAwB,KACP,CACjB,IAAM,EAAQ,EAAO,EAAc,CACnC,OAAO,QAAQ,IAAI,EAAM,IAAK,GAAS,MAAY,EAAS,EAAK,CAAC,CAAC,CAAC"}
+{"version":3,"file":"parallelize.mjs","names":[],"sources":["../../../src/utils/parallelize.ts"],"sourcesContent":["import { pLimit } from './pLimit';\n\nexport const parallelize = async <T, R>(\n  items: T[],\n  callback: (item: T) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  parallelLimit: number = 10\n): Promise<R[]> => {\n  const limit = pLimit(parallelLimit);\n  return Promise.all(items.map((item) => limit(() => callback(item))));\n};\n"],"mappings":";;;AAEA,MAAa,cAAc,OACzB,OACA,WAAoC,OAAO,SACzC,MACF,gBAAwB,OACP;CACjB,MAAM,QAAQ,OAAO,cAAc;AACnC,QAAO,QAAQ,IAAI,MAAM,KAAK,SAAS,YAAY,SAAS,KAAK,CAAC,CAAC,CAAC"}

package/dist/esm/utils/parallelizeGlobal.mjs

@@ -1,2 +1,27 @@
-import{pLimit as e}from"./pLimit.mjs";let t=null;const n=n=>(t?typeof n==`number`&&(t.concurrency=n):t=e(n??10),t);let r=null;const i=t=>(r?typeof t==`number`&&(r.concurrency=t):r=e(t??5),r),a=async(e,t=async e=>e,r)=>{let i=r?.limiter??n(r?.concurrency),a=r?.wrapInLimiter??!0?e=>i(e):e=>e(),o=e.map((e,n)=>a(()=>t(e,n)));return Promise.all(o)};export{n as getGlobalLimiter,i as getTaskLimiter,a as parallelizeGlobal};
+import { pLimit } from "./pLimit.mjs";
+
+//#region src/utils/parallelizeGlobal.ts
+let _globalLimiter = null;
+/** Get (and optionally configure) the single, shared limiter. */
+const getGlobalLimiter = (concurrency) => {
+	if (!_globalLimiter) _globalLimiter = pLimit(concurrency ?? 10);
+	else if (typeof concurrency === "number") _globalLimiter.concurrency = concurrency;
+	return _globalLimiter;
+};
+let _taskLimiter = null;
+/** Limits how many *tasks* run concurrently (independent from AI calls). */
+const getTaskLimiter = (concurrency) => {
+	if (!_taskLimiter) _taskLimiter = pLimit(concurrency ?? 5);
+	else if (typeof concurrency === "number") _taskLimiter.concurrency = concurrency;
+	return _taskLimiter;
+};
+const parallelizeGlobal = async (items, callback = async (item) => item, options) => {
+	const limiter = options?.limiter ?? getGlobalLimiter(options?.concurrency);
+	const run = options?.wrapInLimiter ?? true ? (fn) => limiter(fn) : (fn) => fn();
+	const promises = items.map((item, index) => run(() => callback(item, index)));
+	return Promise.all(promises);
+};
+
+//#endregion
+export { getGlobalLimiter, getTaskLimiter, parallelizeGlobal };
 //# sourceMappingURL=parallelizeGlobal.mjs.map

package/dist/esm/utils/parallelizeGlobal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"parallelizeGlobal.mjs","names":[],"sources":["../../../src/utils/parallelizeGlobal.ts"],"sourcesContent":["// === keep your Queue, Node, pLimit, validateConcurrency exactly as-is ===\n\nimport { pLimit } from './pLimit';\n\n// --- NEW: single, shared limiter for the whole process ---\nlet _globalLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Get (and optionally configure) the single, shared limiter. */\nexport const getGlobalLimiter = (concurrency?: number) => {\n  if (!_globalLimiter) {\n    _globalLimiter = pLimit(concurrency ?? 10);\n  } else if (typeof concurrency === 'number') {\n    (_globalLimiter as any).concurrency = concurrency;\n  }\n  return _globalLimiter!;\n};\n\n// --- NEW: task limiter for gating task starts ---\nlet _taskLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Limits how many *tasks* run concurrently (independent from AI calls). */\nexport const getTaskLimiter = (concurrency?: number) => {\n  if (!_taskLimiter) {\n    _taskLimiter = pLimit(concurrency ?? 5);\n  } else if (typeof concurrency === 'number') {\n    (_taskLimiter as any).concurrency = concurrency;\n  }\n  return _taskLimiter!;\n};\n\n// --- REPLACE your existing `parallelize` with this version ---\nexport const parallelizeGlobal = async <T, R>(\n  items: T[],\n  callback: (item: T, index: number) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  options?: {\n    /** Share a single limiter across the app. If omitted, uses global limiter. */\n    limiter?: ReturnType<typeof pLimit>;\n    /** If provided and no limiter is passed, configure the global limiter. */\n    concurrency?: number;\n    /**\n     * Whether to wrap *each* callback run in the limiter.\n     * - For orchestration (outer loops): set `false` (don't burn limiter slots).\n     * - For atomic work (AI calls, writes): leave `true` (default).\n     */\n    wrapInLimiter?: boolean;\n  }\n): Promise<R[]> => {\n  const limiter = options?.limiter ?? getGlobalLimiter(options?.concurrency);\n  const wrap = options?.wrapInLimiter ?? true;\n\n  const run = wrap\n    ? <U>(fn: () => Promise<U>) => limiter(fn)\n    : <U>(fn: () => Promise<U>) => fn();\n\n  const promises = items.map((item, index) => run(() => callback(item, index)));\n  return Promise.all(promises);\n};\n"],"mappings":"sCAKA,IAAI,EAAmD,KAGvD,MAAa,EAAoB,IAC1B,EAEM,OAAO,GAAgB,WAC/B,EAAuB,YAAc,GAFtC,EAAiB,EAAO,GAAe,GAAG,CAIrC,GAIT,IAAI,EAAiD,KAGrD,MAAa,EAAkB,IACxB,EAEM,OAAO,GAAgB,WAC/B,EAAqB,YAAc,GAFpC,EAAe,EAAO,GAAe,EAAE,CAIlC,GAII,EAAoB,MAC/B,EACA,EAAmD,KAAO,IACxD,EACF,IAYiB,CACjB,IAAM,EAAU,GAAS,SAAW,EAAiB,GAAS,YAAY,CAGpE,EAFO,GAAS,eAAiB,GAG/B,GAAyB,EAAQ,EAAG,CACpC,GAAyB,GAAI,CAE/B,EAAW,EAAM,KAAK,EAAM,IAAU,MAAU,EAAS,EAAM,EAAM,CAAC,CAAC,CAC7E,OAAO,QAAQ,IAAI,EAAS"}
+{"version":3,"file":"parallelizeGlobal.mjs","names":[],"sources":["../../../src/utils/parallelizeGlobal.ts"],"sourcesContent":["// === keep your Queue, Node, pLimit, validateConcurrency exactly as-is ===\n\nimport { pLimit } from './pLimit';\n\n// --- NEW: single, shared limiter for the whole process ---\nlet _globalLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Get (and optionally configure) the single, shared limiter. */\nexport const getGlobalLimiter = (concurrency?: number) => {\n  if (!_globalLimiter) {\n    _globalLimiter = pLimit(concurrency ?? 10);\n  } else if (typeof concurrency === 'number') {\n    (_globalLimiter as any).concurrency = concurrency;\n  }\n  return _globalLimiter!;\n};\n\n// --- NEW: task limiter for gating task starts ---\nlet _taskLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Limits how many *tasks* run concurrently (independent from AI calls). */\nexport const getTaskLimiter = (concurrency?: number) => {\n  if (!_taskLimiter) {\n    _taskLimiter = pLimit(concurrency ?? 5);\n  } else if (typeof concurrency === 'number') {\n    (_taskLimiter as any).concurrency = concurrency;\n  }\n  return _taskLimiter!;\n};\n\n// --- REPLACE your existing `parallelize` with this version ---\nexport const parallelizeGlobal = async <T, R>(\n  items: T[],\n  callback: (item: T, index: number) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  options?: {\n    /** Share a single limiter across the app. If omitted, uses global limiter. */\n    limiter?: ReturnType<typeof pLimit>;\n    /** If provided and no limiter is passed, configure the global limiter. */\n    concurrency?: number;\n    /**\n     * Whether to wrap *each* callback run in the limiter.\n     * - For orchestration (outer loops): set `false` (don't burn limiter slots).\n     * - For atomic work (AI calls, writes): leave `true` (default).\n     */\n    wrapInLimiter?: boolean;\n  }\n): Promise<R[]> => {\n  const limiter = options?.limiter ?? getGlobalLimiter(options?.concurrency);\n  const wrap = options?.wrapInLimiter ?? true;\n\n  const run = wrap\n    ? <U>(fn: () => Promise<U>) => limiter(fn)\n    : <U>(fn: () => Promise<U>) => fn();\n\n  const promises = items.map((item, index) => run(() => callback(item, index)));\n  return Promise.all(promises);\n};\n"],"mappings":";;;AAKA,IAAI,iBAAmD;;AAGvD,MAAa,oBAAoB,gBAAyB;AACxD,KAAI,CAAC,eACH,kBAAiB,OAAO,eAAe,GAAG;UACjC,OAAO,gBAAgB,SAChC,CAAC,eAAuB,cAAc;AAExC,QAAO;;AAIT,IAAI,eAAiD;;AAGrD,MAAa,kBAAkB,gBAAyB;AACtD,KAAI,CAAC,aACH,gBAAe,OAAO,eAAe,EAAE;UAC9B,OAAO,gBAAgB,SAChC,CAAC,aAAqB,cAAc;AAEtC,QAAO;;AAIT,MAAa,oBAAoB,OAC/B,OACA,WAAmD,OAAO,SACxD,MACF,YAYiB;CACjB,MAAM,UAAU,SAAS,WAAW,iBAAiB,SAAS,YAAY;CAG1E,MAAM,MAFO,SAAS,iBAAiB,QAG/B,OAAyB,QAAQ,GAAG,IACpC,OAAyB,IAAI;CAErC,MAAM,WAAW,MAAM,KAAK,MAAM,UAAU,UAAU,SAAS,MAAM,MAAM,CAAC,CAAC;AAC7E,QAAO,QAAQ,IAAI,SAAS"}

package/dist/esm/utils/reduceObjectFormat.mjs

@@ -1,2 +1,30 @@
-const e=(t,n)=>{if(Array.isArray(n)){let r=Array.isArray(t)?t:[];return n.map((t,n)=>e(r[n],t))}if(typeof n==`object`&&n){let r={},i=typeof t==`object`&&t&&!Array.isArray(t)?t:{};for(let t of Object.keys(n)){let a=i[t],o=n[t];r[t]=e(a,o)}return r}return t};export{e as reduceObjectFormat};
+//#region src/utils/reduceObjectFormat.ts
+/**
+* Reduce an object to only the shape provided by a format object.
+* Values are always taken from the source object; the format is used only for structure.
+*
+* Examples:
+* reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }
+* reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }
+*/
+const reduceObjectFormat = (source, format) => {
+	if (Array.isArray(format)) {
+		const sourceArray = Array.isArray(source) ? source : [];
+		return format.map((formatItem, index) => reduceObjectFormat(sourceArray[index], formatItem));
+	}
+	if (typeof format === "object" && format !== null) {
+		const result = {};
+		const sourceObject = typeof source === "object" && source !== null && !Array.isArray(source) ? source : {};
+		for (const key of Object.keys(format)) {
+			const nextSource = sourceObject[key];
+			const nextFormat = format[key];
+			result[key] = reduceObjectFormat(nextSource, nextFormat);
+		}
+		return result;
+	}
+	return source;
+};
+
+//#endregion
+export { reduceObjectFormat };
 //# sourceMappingURL=reduceObjectFormat.mjs.map

package/dist/esm/utils/reduceObjectFormat.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reduceObjectFormat.mjs","names":[],"sources":["../../../src/utils/reduceObjectFormat.ts"],"sourcesContent":["type Primitive = string | number | boolean | null | undefined;\n\ntype Recursive = Primitive | { [key: string]: Recursive } | Array<Recursive>;\n\n/**\n * Reduce an object to only the shape provided by a format object.\n * Values are always taken from the source object; the format is used only for structure.\n *\n * Examples:\n * reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }\n * reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }\n */\nexport const reduceObjectFormat = (\n  source: Recursive,\n  format: Recursive\n): Recursive => {\n  // If the format is an array, reduce each element by its counterpart in source\n  if (Array.isArray(format)) {\n    const sourceArray = Array.isArray(source) ? source : [];\n    return format.map((formatItem, index) =>\n      reduceObjectFormat(sourceArray[index], formatItem)\n    );\n  }\n\n  // If the format is an object (and not null), pick matching keys and recurse\n  if (typeof format === 'object' && format !== null) {\n    const result: Record<string, Recursive> = {};\n    const sourceObject =\n      typeof source === 'object' && source !== null && !Array.isArray(source)\n        ? (source as Record<string, Recursive>)\n        : ({} as Record<string, Recursive>);\n\n    for (const key of Object.keys(format)) {\n      const nextSource = sourceObject[key];\n      const nextFormat = (format as Record<string, Recursive>)[key];\n      result[key] = reduceObjectFormat(nextSource, nextFormat);\n    }\n    return result;\n  }\n\n  // For primitives in the format, simply return the source value (can be undefined)\n  return source as Primitive;\n};\n"],"mappings":"AAYA,MAAa,GACX,EACA,IACc,CAEd,GAAI,MAAM,QAAQ,EAAO,CAAE,CACzB,IAAM,EAAc,MAAM,QAAQ,EAAO,CAAG,EAAS,EAAE,CACvD,OAAO,EAAO,KAAK,EAAY,IAC7B,EAAmB,EAAY,GAAQ,EAAW,CACnD,CAIH,GAAI,OAAO,GAAW,UAAY,EAAiB,CACjD,IAAM,EAAoC,EAAE,CACtC,EACJ,OAAO,GAAW,UAAY,GAAmB,CAAC,MAAM,QAAQ,EAAO,CAClE,EACA,EAAE,CAET,IAAK,IAAM,KAAO,OAAO,KAAK,EAAO,CAAE,CACrC,IAAM,EAAa,EAAa,GAC1B,EAAc,EAAqC,GACzD,EAAO,GAAO,EAAmB,EAAY,EAAW,CAE1D,OAAO,EAIT,OAAO"}
+{"version":3,"file":"reduceObjectFormat.mjs","names":[],"sources":["../../../src/utils/reduceObjectFormat.ts"],"sourcesContent":["type Primitive = string | number | boolean | null | undefined;\n\ntype Recursive = Primitive | { [key: string]: Recursive } | Array<Recursive>;\n\n/**\n * Reduce an object to only the shape provided by a format object.\n * Values are always taken from the source object; the format is used only for structure.\n *\n * Examples:\n * reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }\n * reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }\n */\nexport const reduceObjectFormat = (\n  source: Recursive,\n  format: Recursive\n): Recursive => {\n  // If the format is an array, reduce each element by its counterpart in source\n  if (Array.isArray(format)) {\n    const sourceArray = Array.isArray(source) ? source : [];\n    return format.map((formatItem, index) =>\n      reduceObjectFormat(sourceArray[index], formatItem)\n    );\n  }\n\n  // If the format is an object (and not null), pick matching keys and recurse\n  if (typeof format === 'object' && format !== null) {\n    const result: Record<string, Recursive> = {};\n    const sourceObject =\n      typeof source === 'object' && source !== null && !Array.isArray(source)\n        ? (source as Record<string, Recursive>)\n        : ({} as Record<string, Recursive>);\n\n    for (const key of Object.keys(format)) {\n      const nextSource = sourceObject[key];\n      const nextFormat = (format as Record<string, Recursive>)[key];\n      result[key] = reduceObjectFormat(nextSource, nextFormat);\n    }\n    return result;\n  }\n\n  // For primitives in the format, simply return the source value (can be undefined)\n  return source as Primitive;\n};\n"],"mappings":";;;;;;;;;AAYA,MAAa,sBACX,QACA,WACc;AAEd,KAAI,MAAM,QAAQ,OAAO,EAAE;EACzB,MAAM,cAAc,MAAM,QAAQ,OAAO,GAAG,SAAS,EAAE;AACvD,SAAO,OAAO,KAAK,YAAY,UAC7B,mBAAmB,YAAY,QAAQ,WAAW,CACnD;;AAIH,KAAI,OAAO,WAAW,YAAY,WAAW,MAAM;EACjD,MAAM,SAAoC,EAAE;EAC5C,MAAM,eACJ,OAAO,WAAW,YAAY,WAAW,QAAQ,CAAC,MAAM,QAAQ,OAAO,GAClE,SACA,EAAE;AAET,OAAK,MAAM,OAAO,OAAO,KAAK,OAAO,EAAE;GACrC,MAAM,aAAa,aAAa;GAChC,MAAM,aAAc,OAAqC;AACzD,UAAO,OAAO,mBAAmB,YAAY,WAAW;;AAE1D,SAAO;;AAIT,QAAO"}

package/dist/esm/utils/resolveObjectPromises.mjs

@@ -1,2 +1,20 @@
-const e=async t=>{if(t&&typeof t.then==`function`)return e(await t);if(typeof t==`function`)return e(t());if(Array.isArray(t))return Promise.all(t.map(async t=>e(t)));if(t&&typeof t==`object`){let n={};for(let r of Object.keys(t))n[r]=await e(t[r]);return n}return t};export{e as resolveObjectPromises};
+//#region src/utils/resolveObjectPromises.ts
+/**
+* A more "unified" approach where each type (function, array, object, primitive)
+* is handled inside the main recursive body.
+*/
+const resolveObjectPromises = async (entry) => {
+	if (entry && typeof entry.then === "function") return resolveObjectPromises(await entry);
+	if (typeof entry === "function") return resolveObjectPromises(entry());
+	if (Array.isArray(entry)) return Promise.all(entry.map(async (item) => resolveObjectPromises(item)));
+	if (entry && typeof entry === "object") {
+		const result = {};
+		for (const key of Object.keys(entry)) result[key] = await resolveObjectPromises(entry[key]);
+		return result;
+	}
+	return entry;
+};
+
+//#endregion
+export { resolveObjectPromises };
 //# sourceMappingURL=resolveObjectPromises.mjs.map

package/dist/esm/utils/resolveObjectPromises.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"resolveObjectPromises.mjs","names":[],"sources":["../../../src/utils/resolveObjectPromises.ts"],"sourcesContent":["/**\n * A more \"unified\" approach where each type (function, array, object, primitive)\n * is handled inside the main recursive body.\n */\nexport const resolveObjectPromises = async <T = unknown>(\n  entry: any\n): Promise<T> => {\n  // Check if entry is a Promise (Thenable)\n  if (entry && typeof entry.then === 'function') {\n    const awaited = await entry;\n    return resolveObjectPromises(awaited);\n  }\n\n  // If entry is a function, invoke it and process the result\n  if (typeof entry === 'function') {\n    const result = entry();\n    return resolveObjectPromises(result);\n  }\n\n  if (Array.isArray(entry)) {\n    return Promise.all(\n      entry.map(async (item) => resolveObjectPromises(item))\n    ) as unknown as T;\n  }\n\n  // Handle plain objects (but not arrays)\n  if (entry && typeof entry === 'object') {\n    // Arrays are handled in the `Array.isArray` branch above, so we know `entry` is a plain object here.\n\n    const result: Record<string, any> = {};\n\n    // Iterate over keys **sequentially** to make sure the insertion order of the\n    // resulting object matches the original key order. Using `Promise.all` here\n    // could lead to out-of-order insertions when asynchronous resolutions\n    // finish at different times.\n    for (const key of Object.keys(entry)) {\n      result[key] = await resolveObjectPromises(entry[key]);\n    }\n\n    return result as T;\n  }\n\n  return entry as T;\n};\n"],"mappings":"AAIA,MAAa,EAAwB,KACnC,IACe,CAEf,GAAI,GAAS,OAAO,EAAM,MAAS,WAEjC,OAAO,EADS,MAAM,EACe,CAIvC,GAAI,OAAO,GAAU,WAEnB,OAAO,EADQ,GAAO,CACc,CAGtC,GAAI,MAAM,QAAQ,EAAM,CACtB,OAAO,QAAQ,IACb,EAAM,IAAI,KAAO,IAAS,EAAsB,EAAK,CAAC,CACvD,CAIH,GAAI,GAAS,OAAO,GAAU,SAAU,CAGtC,IAAM,EAA8B,EAAE,CAMtC,IAAK,IAAM,KAAO,OAAO,KAAK,EAAM,CAClC,EAAO,GAAO,MAAM,EAAsB,EAAM,GAAK,CAGvD,OAAO,EAGT,OAAO"}
+{"version":3,"file":"resolveObjectPromises.mjs","names":[],"sources":["../../../src/utils/resolveObjectPromises.ts"],"sourcesContent":["/**\n * A more \"unified\" approach where each type (function, array, object, primitive)\n * is handled inside the main recursive body.\n */\nexport const resolveObjectPromises = async <T = unknown>(\n  entry: any\n): Promise<T> => {\n  // Check if entry is a Promise (Thenable)\n  if (entry && typeof entry.then === 'function') {\n    const awaited = await entry;\n    return resolveObjectPromises(awaited);\n  }\n\n  // If entry is a function, invoke it and process the result\n  if (typeof entry === 'function') {\n    const result = entry();\n    return resolveObjectPromises(result);\n  }\n\n  if (Array.isArray(entry)) {\n    return Promise.all(\n      entry.map(async (item) => resolveObjectPromises(item))\n    ) as unknown as T;\n  }\n\n  // Handle plain objects (but not arrays)\n  if (entry && typeof entry === 'object') {\n    // Arrays are handled in the `Array.isArray` branch above, so we know `entry` is a plain object here.\n\n    const result: Record<string, any> = {};\n\n    // Iterate over keys **sequentially** to make sure the insertion order of the\n    // resulting object matches the original key order. Using `Promise.all` here\n    // could lead to out-of-order insertions when asynchronous resolutions\n    // finish at different times.\n    for (const key of Object.keys(entry)) {\n      result[key] = await resolveObjectPromises(entry[key]);\n    }\n\n    return result as T;\n  }\n\n  return entry as T;\n};\n"],"mappings":";;;;;AAIA,MAAa,wBAAwB,OACnC,UACe;AAEf,KAAI,SAAS,OAAO,MAAM,SAAS,WAEjC,QAAO,sBADS,MAAM,MACe;AAIvC,KAAI,OAAO,UAAU,WAEnB,QAAO,sBADQ,OAAO,CACc;AAGtC,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,QAAQ,IACb,MAAM,IAAI,OAAO,SAAS,sBAAsB,KAAK,CAAC,CACvD;AAIH,KAAI,SAAS,OAAO,UAAU,UAAU;EAGtC,MAAM,SAA8B,EAAE;AAMtC,OAAK,MAAM,OAAO,OAAO,KAAK,MAAM,CAClC,QAAO,OAAO,MAAM,sBAAsB,MAAM,KAAK;AAGvD,SAAO;;AAGT,QAAO"}

package/dist/esm/utils/resolveRelativePath.mjs

@@ -1,2 +1,20 @@
-import{dirname as e,isAbsolute as t,normalize as n,resolve as r}from"node:path";const i=(i,a,o)=>{if(t(i)){let e=n(i),t=n(o);if(i.startsWith(`/`)&&!e.startsWith(t)){let e=r(o,i.substring(1));if(!i.startsWith(`/usr/`)&&!i.startsWith(`/etc/`)&&!i.startsWith(`/var/`)&&!i.startsWith(`/home/`)&&!i.startsWith(`/Users/`)&&!i.startsWith(`/tmp/`)&&!i.startsWith(`/private/`)&&!i.startsWith(`/opt/`))return e}return e}return i.startsWith(`./`)||i.startsWith(`../`)?r(e(a),i):r(o,i)};export{i as resolveRelativePath};
+import { dirname, isAbsolute, normalize, resolve } from "node:path";
+
+//#region src/utils/resolveRelativePath.ts
+const resolveRelativePath = (path, sourcePath, baseDir) => {
+	if (isAbsolute(path)) {
+		const normalizedResult = normalize(path);
+		const normalizedBaseDir = normalize(baseDir);
+		if (path.startsWith("/") && !normalizedResult.startsWith(normalizedBaseDir)) {
+			const relativeToBase = resolve(baseDir, path.substring(1));
+			if (!path.startsWith("/usr/") && !path.startsWith("/etc/") && !path.startsWith("/var/") && !path.startsWith("/home/") && !path.startsWith("/Users/") && !path.startsWith("/tmp/") && !path.startsWith("/private/") && !path.startsWith("/opt/")) return relativeToBase;
+		}
+		return normalizedResult;
+	}
+	if (path.startsWith("./") || path.startsWith("../")) return resolve(dirname(sourcePath), path);
+	return resolve(baseDir, path);
+};
+
+//#endregion
+export { resolveRelativePath };
 //# sourceMappingURL=resolveRelativePath.mjs.map