@intlayer/chokidar 7.0.3 → 7.0.4

package/dist/cjs/_virtual/_utils_asset.cjs

@@ -64,7 +64,7 @@ const getCallerDir = () => {
 * - './' or '../' is resolved relative to the *caller module's* emitted directory.
 * - otherwise, treat as src-relative.
 *
-* @param {string} relPath - e.g. './PROMPT.md' or 'utils/AI/askDocQuestion/embeddings.json'
+* @param {string} relPath - e.g. './PROMPT.md' or 'utils/AI/askDocQuestion/embeddings/<fileKey>.json'
 * @param {BufferEncoding} [encoding='utf8']
 */
 const readAsset = (relPath, encoding = "utf8") => {

package/dist/cjs/index.cjs

@@ -37,12 +37,13 @@ const require_utils_chunkJSON = require('./utils/chunkJSON.cjs');
 const require_utils_getFormatFromExtension = require('./utils/getFormatFromExtension.cjs');
 const require_utils_parallelizeGlobal = require('./utils/parallelizeGlobal.cjs');
 const require_utils_reduceObjectFormat = require('./utils/reduceObjectFormat.cjs');
-const require_utils_runParallel = require('./utils/runParallel.cjs');
+const require_utils_runParallel_index = require('./utils/runParallel/index.cjs');
 const require_utils_verifyIdenticObjectFormat = require('./utils/verifyIdenticObjectFormat.cjs');
 const require_watcher = require('./watcher.cjs');
 const require_writeContentDeclaration_detectExportedComponentName = require('./writeContentDeclaration/detectExportedComponentName.cjs');
 const require_writeContentDeclaration_transformJSFile = require('./writeContentDeclaration/transformJSFile.cjs');
 const require_writeContentDeclaration_processContentDeclarationContent = require('./writeContentDeclaration/processContentDeclarationContent.cjs');
+const require_writeContentDeclaration_detectFormatCommand = require('./writeContentDeclaration/detectFormatCommand.cjs');
 const require_writeContentDeclaration_writeJSFile = require('./writeContentDeclaration/writeJSFile.cjs');
 const require_writeContentDeclaration_writeContentDeclaration = require('./writeContentDeclaration/writeContentDeclaration.cjs');
 
@@ -55,6 +56,7 @@ exports.createDictionaryEntryPoint = require_createDictionaryEntryPoint_createDi
 exports.createModuleAugmentation = require_createType_createModuleAugmentation.createModuleAugmentation;
 exports.createTypes = require_createType_createType.createTypes;
 exports.detectExportedComponentName = require_writeContentDeclaration_detectExportedComponentName.detectExportedComponentName;
+exports.detectFormatCommand = require_writeContentDeclaration_detectFormatCommand.detectFormatCommand;
 exports.fetchDistantDictionaries = require_fetchDistantDictionaries.fetchDistantDictionaries;
 exports.formatLocale = require_utils_formatter.formatLocale;
 exports.formatPath = require_utils_formatter.formatPath;
@@ -93,7 +95,7 @@ exports.reduceDictionaryContent = require_reduceDictionaryContent_reduceDictiona
 exports.reduceObjectFormat = require_utils_reduceObjectFormat.reduceObjectFormat;
 exports.resolveObjectPromises = require_utils_resolveObjectPromises.resolveObjectPromises;
 exports.runOnce = require_utils_runOnce.runOnce;
-exports.runParallel = require_utils_runParallel.runParallel;
+exports.runParallel = require_utils_runParallel_index.runParallel;
 exports.sortAlphabetically = require_utils_sortAlphabetically.sortAlphabetically;
 exports.splitTextByLines = require_utils_splitTextByLine.splitTextByLines;
 exports.transformJSFile = require_writeContentDeclaration_transformJSFile.transformJSFile;

package/dist/cjs/utils/runParallel/bin.cjs

@@ -0,0 +1,55 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let node_child_process = require("node:child_process");
+node_child_process = require_rolldown_runtime.__toESM(node_child_process);
+
+//#region src/utils/runParallel/bin.ts
+const stripStderr = (stderr) => {
+	if (!stderr) return;
+	let cleaned = stderr.trim();
+	cleaned = cleaned.replace(/your \d+x\d+ screen size is bogus\. expect trouble/gi, "");
+	return cleaned.trim() || void 0;
+};
+/**
+* Spawn a binary and read its stdout.
+* @param cmd The name of the binary to spawn.
+* @param args The arguments for the binary.
+* @param options Optional option for the spawn function.
+* @param done Callback function.
+*/
+const run = (cmd, args, options, done) => {
+	let normalizedOptions;
+	let normalizedDone;
+	if (typeof options === "function") {
+		normalizedDone = options;
+		normalizedOptions = void 0;
+	} else {
+		normalizedDone = done;
+		normalizedOptions = options;
+	}
+	let executed = false;
+	const ch = (0, node_child_process.spawn)(cmd, args, normalizedOptions ?? {});
+	let stdout = "";
+	let stderr = "";
+	if (ch.stdout) ch.stdout.on("data", (d) => {
+		stdout += d.toString();
+	});
+	if (ch.stderr) ch.stderr.on("data", (d) => {
+		stderr += d.toString();
+	});
+	ch.on("error", (err) => {
+		if (executed) return;
+		executed = true;
+		normalizedDone(new Error(String(err)));
+	});
+	ch.on("close", (code) => {
+		if (executed) return;
+		executed = true;
+		const cleanedStderr = stripStderr(stderr);
+		if (cleanedStderr) return normalizedDone(new Error(cleanedStderr));
+		normalizedDone(null, stdout, code ?? void 0);
+	});
+};
+
+//#endregion
+exports.run = run;
+//# sourceMappingURL=bin.cjs.map

package/dist/cjs/utils/runParallel/bin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.cjs","names":["normalizedOptions: SpawnOptions | undefined","normalizedDone: BinCallback","ch: ChildProcess"],"sources":["../../../../src/utils/runParallel/bin.ts"],"sourcesContent":["import type { ChildProcess } from 'node:child_process';\nimport { type SpawnOptions, spawn } from 'node:child_process';\n\ntype BinCallback = (err: Error | null, stdout?: string, code?: number) => void;\n\nconst stripStderr = (stderr: string | undefined): string | undefined => {\n  if (!stderr) return;\n  let cleaned = stderr.trim();\n  // Strip bogus screen size error.\n  // See https://github.com/microsoft/vscode/issues/98590\n  const regex = /your \\d+x\\d+ screen size is bogus\\. expect trouble/gi;\n  cleaned = cleaned.replace(regex, '');\n\n  return cleaned.trim() || undefined;\n};\n\n/**\n * Spawn a binary and read its stdout.\n * @param cmd The name of the binary to spawn.\n * @param args The arguments for the binary.\n * @param options Optional option for the spawn function.\n * @param done Callback function.\n */\nexport const run = (\n  cmd: string,\n  args: string[],\n  options: SpawnOptions | BinCallback | undefined,\n  done?: BinCallback\n): void => {\n  let normalizedOptions: SpawnOptions | undefined;\n  let normalizedDone: BinCallback;\n\n  if (typeof options === 'function') {\n    normalizedDone = options;\n    normalizedOptions = undefined;\n  } else {\n    normalizedDone = done!;\n    normalizedOptions = options;\n  }\n\n  let executed = false;\n  const ch: ChildProcess = spawn(cmd, args, normalizedOptions ?? {});\n  let stdout = '';\n  let stderr = '';\n\n  if (ch.stdout) {\n    ch.stdout.on('data', (d: Buffer) => {\n      stdout += d.toString();\n    });\n  }\n\n  if (ch.stderr) {\n    ch.stderr.on('data', (d: Buffer) => {\n      stderr += d.toString();\n    });\n  }\n\n  ch.on('error', (err: Error) => {\n    if (executed) return;\n    executed = true;\n    normalizedDone(new Error(String(err)));\n  });\n\n  ch.on('close', (code: number | null) => {\n    if (executed) return;\n    executed = true;\n\n    const cleanedStderr = stripStderr(stderr);\n    if (cleanedStderr) {\n      return normalizedDone(new Error(cleanedStderr));\n    }\n\n    normalizedDone(null, stdout, code ?? undefined);\n  });\n};\n"],"mappings":";;;;;AAKA,MAAM,eAAe,WAAmD;AACtE,KAAI,CAAC,OAAQ;CACb,IAAI,UAAU,OAAO,MAAM;AAI3B,WAAU,QAAQ,QADJ,wDACmB,GAAG;AAEpC,QAAO,QAAQ,MAAM,IAAI;;;;;;;;;AAU3B,MAAa,OACX,KACA,MACA,SACA,SACS;CACT,IAAIA;CACJ,IAAIC;AAEJ,KAAI,OAAO,YAAY,YAAY;AACjC,mBAAiB;AACjB,sBAAoB;QACf;AACL,mBAAiB;AACjB,sBAAoB;;CAGtB,IAAI,WAAW;CACf,MAAMC,mCAAyB,KAAK,MAAM,qBAAqB,EAAE,CAAC;CAClE,IAAI,SAAS;CACb,IAAI,SAAS;AAEb,KAAI,GAAG,OACL,IAAG,OAAO,GAAG,SAAS,MAAc;AAClC,YAAU,EAAE,UAAU;GACtB;AAGJ,KAAI,GAAG,OACL,IAAG,OAAO,GAAG,SAAS,MAAc;AAClC,YAAU,EAAE,UAAU;GACtB;AAGJ,IAAG,GAAG,UAAU,QAAe;AAC7B,MAAI,SAAU;AACd,aAAW;AACX,iBAAe,IAAI,MAAM,OAAO,IAAI,CAAC,CAAC;GACtC;AAEF,IAAG,GAAG,UAAU,SAAwB;AACtC,MAAI,SAAU;AACd,aAAW;EAEX,MAAM,gBAAgB,YAAY,OAAO;AACzC,MAAI,cACF,QAAO,eAAe,IAAI,MAAM,cAAc,CAAC;AAGjD,iBAAe,MAAM,QAAQ,QAAQ,OAAU;GAC/C"}

package/dist/cjs/utils/runParallel/bootstrap.cjs

@@ -0,0 +1,24 @@
+
+//#region src/utils/runParallel/bootstrap.ts
+const bootstrap = (_name) => {
+	switch (process.argv.slice(2)[0]) {
+		case void 0:
+		case "-h":
+		case "--help":
+			console.log("Help not implemented");
+			return;
+		case "-v":
+		case "--version":
+			console.log("Version not implemented");
+			return;
+		default:
+			process.stdout.setMaxListeners(0);
+			process.stderr.setMaxListeners(0);
+			process.stdin.setMaxListeners(0);
+			return;
+	}
+};
+
+//#endregion
+exports.bootstrap = bootstrap;
+//# sourceMappingURL=bootstrap.cjs.map

package/dist/cjs/utils/runParallel/bootstrap.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.cjs","names":[],"sources":["../../../../src/utils/runParallel/bootstrap.ts"],"sourcesContent":["//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nexport const bootstrap = (_name: string): void | Promise<void> => {\n  const argv = process.argv.slice(2);\n\n  switch (argv[0]) {\n    case undefined:\n    case '-h':\n    case '--help':\n      // Not needed for our use case\n      console.log('Help not implemented');\n      return;\n\n    case '-v':\n    case '--version':\n      // Not needed for our use case\n      console.log('Version not implemented');\n      return;\n\n    default:\n      // https://github.com/mysticatea/npm-run-all/issues/105\n      // Avoid MaxListenersExceededWarnings.\n      process.stdout.setMaxListeners(0);\n      process.stderr.setMaxListeners(0);\n      process.stdin.setMaxListeners(0);\n      return;\n  }\n};\n"],"mappings":";;AAIA,MAAa,aAAa,UAAwC;AAGhE,SAFa,QAAQ,KAAK,MAAM,EAAE,CAErB,IAAb;EACE,KAAK;EACL,KAAK;EACL,KAAK;AAEH,WAAQ,IAAI,uBAAuB;AACnC;EAEF,KAAK;EACL,KAAK;AAEH,WAAQ,IAAI,0BAA0B;AACtC;EAEF;AAGE,WAAQ,OAAO,gBAAgB,EAAE;AACjC,WAAQ,OAAO,gBAAgB,EAAE;AACjC,WAAQ,MAAM,gBAAgB,EAAE;AAChC"}

package/dist/cjs/utils/runParallel/index.cjs

@@ -0,0 +1,111 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_utils_runParallel_spawnPosix = require('./spawnPosix.cjs');
+const require_utils_runParallel_spawnWin32 = require('./spawnWin32.cjs');
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/utils/runParallel/index.ts
+/**
+* Start a cross-platform parallel process using npm-run-all approach.
+* Accepts either a single string (e.g., 'next start') or an array of tokens (e.g., ['next', 'start']).
+*/
+const runParallel = (proc) => {
+	if (!proc || Array.isArray(proc) && proc.length === 0) throw new Error("Invalid command");
+	const commandText = Array.isArray(proc) ? proc.join(" ") : proc;
+	const isArray = Array.isArray(proc);
+	const command = isArray ? proc[0] : commandText;
+	const args = isArray ? proc.slice(1) : [];
+	const cwdBin = (0, node_path.join)(process.cwd(), "node_modules", ".bin");
+	const PATH_KEY = Object.keys(process.env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+	const extendedPath = [cwdBin, process.env[PATH_KEY] ?? ""].filter(Boolean).join(node_path.delimiter);
+	const childEnv = {
+		...process.env,
+		[PATH_KEY]: extendedPath
+	};
+	const isWin = process.platform === "win32";
+	const spawnFunc = isWin ? require_utils_runParallel_spawnWin32.spawnWin32 : require_utils_runParallel_spawnPosix.spawnPosix;
+	const spawnOptions = {
+		cwd: process.cwd(),
+		stdio: "inherit",
+		env: childEnv,
+		shell: false
+	};
+	const child = isArray ? args.length === 0 && /\s/.test(command) ? isWin ? spawnFunc(process.env.ComSpec ?? "cmd.exe", [
+		"/d",
+		"/s",
+		"/c",
+		command
+	], spawnOptions) : spawnFunc(process.env.SHELL ?? "/bin/sh", ["-c", command], spawnOptions) : spawnFunc(command, args, spawnOptions) : isWin ? spawnFunc(process.env.ComSpec ?? "cmd.exe", [
+		"/d",
+		"/s",
+		"/c",
+		commandText
+	], spawnOptions) : spawnFunc(process.env.SHELL ?? "/bin/sh", ["-c", commandText], spawnOptions);
+	const result = new Promise((resolve, reject) => {
+		child.on("error", (err) => {
+			try {
+				console.error(`[runParallel] Failed to start: ${err?.message ?? String(err)}`);
+			} catch {}
+			cleanupHandlers();
+			reject(err);
+		});
+		child.on("exit", (code, signal) => {
+			cleanupHandlers();
+			if (code === 0 || signal && [
+				"SIGINT",
+				"SIGTERM",
+				"SIGQUIT",
+				"SIGHUP"
+			].includes(signal)) resolve();
+			else reject(Object.assign(/* @__PURE__ */ new Error("Parallel process failed"), {
+				code,
+				signal
+			}));
+		});
+	});
+	const cleanup = () => {
+		try {
+			child.kill("SIGTERM");
+		} catch {}
+	};
+	const signalHandlers = [
+		{
+			event: "SIGINT",
+			handler: cleanup
+		},
+		{
+			event: "SIGTERM",
+			handler: cleanup
+		},
+		{
+			event: "SIGQUIT",
+			handler: cleanup
+		},
+		{
+			event: "SIGHUP",
+			handler: cleanup
+		}
+	];
+	signalHandlers.forEach(({ event, handler }) => {
+		process.on(event, handler);
+	});
+	const cleanupHandlers = () => {
+		signalHandlers.forEach(({ event, handler }) => {
+			process.off(event, handler);
+		});
+	};
+	const kill = () => {
+		try {
+			child.kill("SIGTERM");
+		} catch {}
+	};
+	return {
+		kill,
+		result,
+		commandText
+	};
+};
+
+//#endregion
+exports.runParallel = runParallel;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/utils/runParallel/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["delimiter","spawnWin32","spawnPosix","signalHandlers: { event: string; handler: (...args: any[]) => void }[]"],"sources":["../../../../src/utils/runParallel/index.ts"],"sourcesContent":["import { delimiter, join } from 'node:path';\nimport { spawnPosix } from './spawnPosix';\nimport { spawnWin32 } from './spawnWin32';\n\nexport type ParallelHandle = {\n  kill: () => void;\n  result: Promise<any>;\n  commandText: string;\n};\n\n/**\n * Start a cross-platform parallel process using npm-run-all approach.\n * Accepts either a single string (e.g., 'next start') or an array of tokens (e.g., ['next', 'start']).\n */\nexport const runParallel = (proc?: string | string[]): ParallelHandle => {\n  if (!proc || (Array.isArray(proc) && proc.length === 0))\n    throw new Error('Invalid command');\n\n  const commandText = Array.isArray(proc) ? proc.join(' ') : proc;\n\n  const isArray = Array.isArray(proc);\n  const command = isArray ? (proc as string[])[0] : commandText;\n  const args = isArray ? (proc as string[]).slice(1) : [];\n\n  // Ensure local binaries (node_modules/.bin) are resolvable\n  const cwdBin = join(process.cwd(), 'node_modules', '.bin');\n  const PATH_KEY =\n    Object.keys(process.env).find((key) => key.toLowerCase() === 'path') ??\n    'PATH';\n\n  const extendedPath = [cwdBin, process.env[PATH_KEY] ?? '']\n    .filter(Boolean)\n    .join(delimiter);\n\n  const childEnv = {\n    ...process.env,\n    [PATH_KEY]: extendedPath,\n  } as NodeJS.ProcessEnv;\n\n  const isWin = process.platform === 'win32';\n  const spawnFunc = isWin ? spawnWin32 : spawnPosix;\n\n  // Spawn options\n  const spawnOptions = {\n    cwd: process.cwd(),\n    stdio: 'inherit' as const,\n    env: childEnv,\n    shell: false,\n  };\n\n  // Spawn the child process\n  const child = isArray\n    ? // If provided as a single string element that includes spaces, treat it like a shell command\n      args.length === 0 && /\\s/.test(command)\n      ? isWin\n        ? spawnFunc(\n            process.env.ComSpec ?? 'cmd.exe',\n            ['/d', '/s', '/c', command],\n            spawnOptions\n          )\n        : spawnFunc(\n            process.env.SHELL ?? '/bin/sh',\n            ['-c', command],\n            spawnOptions\n          )\n      : spawnFunc(command, args, spawnOptions)\n    : isWin\n      ? spawnFunc(\n          process.env.ComSpec ?? 'cmd.exe',\n          ['/d', '/s', '/c', commandText],\n          spawnOptions\n        )\n      : spawnFunc(\n          process.env.SHELL ?? '/bin/sh',\n          ['-c', commandText],\n          spawnOptions\n        );\n\n  const result = new Promise<void>((resolve, reject) => {\n    child.on('error', (err) => {\n      try {\n        console.error(\n          `[runParallel] Failed to start: ${err?.message ?? String(err)}`\n        );\n      } catch {}\n      cleanupHandlers();\n      reject(err);\n    });\n\n    child.on('exit', (code, signal) => {\n      cleanupHandlers();\n\n      // Treat common termination signals as graceful exits, not failures\n      const gracefulSignals = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP'];\n      if (code === 0 || (signal && gracefulSignals.includes(signal))) {\n        resolve();\n      } else {\n        reject(\n          Object.assign(new Error('Parallel process failed'), { code, signal })\n        );\n      }\n    });\n  });\n\n  const cleanup = () => {\n    try {\n      child.kill('SIGTERM');\n    } catch {\n      // Best effort\n    }\n  };\n\n  const signalHandlers: { event: string; handler: (...args: any[]) => void }[] =\n    [\n      { event: 'SIGINT', handler: cleanup },\n      { event: 'SIGTERM', handler: cleanup },\n      { event: 'SIGQUIT', handler: cleanup },\n      { event: 'SIGHUP', handler: cleanup },\n    ];\n\n  // Register signal handlers\n  signalHandlers.forEach(({ event, handler }) => {\n    process.on(event as any, handler as any);\n  });\n\n  const cleanupHandlers = () => {\n    signalHandlers.forEach(({ event, handler }) => {\n      process.off(event as any, handler as any);\n    });\n  };\n\n  const kill = () => {\n    try {\n      child.kill('SIGTERM');\n    } catch {\n      // Best effort\n    }\n  };\n\n  return { kill, result, commandText };\n};\n"],"mappings":";;;;;;;;;;;AAcA,MAAa,eAAe,SAA6C;AACvE,KAAI,CAAC,QAAS,MAAM,QAAQ,KAAK,IAAI,KAAK,WAAW,EACnD,OAAM,IAAI,MAAM,kBAAkB;CAEpC,MAAM,cAAc,MAAM,QAAQ,KAAK,GAAG,KAAK,KAAK,IAAI,GAAG;CAE3D,MAAM,UAAU,MAAM,QAAQ,KAAK;CACnC,MAAM,UAAU,UAAW,KAAkB,KAAK;CAClD,MAAM,OAAO,UAAW,KAAkB,MAAM,EAAE,GAAG,EAAE;CAGvD,MAAM,6BAAc,QAAQ,KAAK,EAAE,gBAAgB,OAAO;CAC1D,MAAM,WACJ,OAAO,KAAK,QAAQ,IAAI,CAAC,MAAM,QAAQ,IAAI,aAAa,KAAK,OAAO,IACpE;CAEF,MAAM,eAAe,CAAC,QAAQ,QAAQ,IAAI,aAAa,GAAG,CACvD,OAAO,QAAQ,CACf,KAAKA,oBAAU;CAElB,MAAM,WAAW;EACf,GAAG,QAAQ;GACV,WAAW;EACb;CAED,MAAM,QAAQ,QAAQ,aAAa;CACnC,MAAM,YAAY,QAAQC,kDAAaC;CAGvC,MAAM,eAAe;EACnB,KAAK,QAAQ,KAAK;EAClB,OAAO;EACP,KAAK;EACL,OAAO;EACR;CAGD,MAAM,QAAQ,UAEV,KAAK,WAAW,KAAK,KAAK,KAAK,QAAQ,GACrC,QACE,UACE,QAAQ,IAAI,WAAW,WACvB;EAAC;EAAM;EAAM;EAAM;EAAQ,EAC3B,aACD,GACD,UACE,QAAQ,IAAI,SAAS,WACrB,CAAC,MAAM,QAAQ,EACf,aACD,GACH,UAAU,SAAS,MAAM,aAAa,GACxC,QACE,UACE,QAAQ,IAAI,WAAW,WACvB;EAAC;EAAM;EAAM;EAAM;EAAY,EAC/B,aACD,GACD,UACE,QAAQ,IAAI,SAAS,WACrB,CAAC,MAAM,YAAY,EACnB,aACD;CAEP,MAAM,SAAS,IAAI,SAAe,SAAS,WAAW;AACpD,QAAM,GAAG,UAAU,QAAQ;AACzB,OAAI;AACF,YAAQ,MACN,kCAAkC,KAAK,WAAW,OAAO,IAAI,GAC9D;WACK;AACR,oBAAiB;AACjB,UAAO,IAAI;IACX;AAEF,QAAM,GAAG,SAAS,MAAM,WAAW;AACjC,oBAAiB;AAIjB,OAAI,SAAS,KAAM,UADK;IAAC;IAAU;IAAW;IAAW;IAAS,CACrB,SAAS,OAAO,CAC3D,UAAS;OAET,QACE,OAAO,uBAAO,IAAI,MAAM,0BAA0B,EAAE;IAAE;IAAM;IAAQ,CAAC,CACtE;IAEH;GACF;CAEF,MAAM,gBAAgB;AACpB,MAAI;AACF,SAAM,KAAK,UAAU;UACf;;CAKV,MAAMC,iBACJ;EACE;GAAE,OAAO;GAAU,SAAS;GAAS;EACrC;GAAE,OAAO;GAAW,SAAS;GAAS;EACtC;GAAE,OAAO;GAAW,SAAS;GAAS;EACtC;GAAE,OAAO;GAAU,SAAS;GAAS;EACtC;AAGH,gBAAe,SAAS,EAAE,OAAO,cAAc;AAC7C,UAAQ,GAAG,OAAc,QAAe;GACxC;CAEF,MAAM,wBAAwB;AAC5B,iBAAe,SAAS,EAAE,OAAO,cAAc;AAC7C,WAAQ,IAAI,OAAc,QAAe;IACzC;;CAGJ,MAAM,aAAa;AACjB,MAAI;AACF,SAAM,KAAK,UAAU;UACf;;AAKV,QAAO;EAAE;EAAM;EAAQ;EAAa"}

package/dist/cjs/utils/runParallel/pidTree.cjs

@@ -0,0 +1,145 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_utils_runParallel_ps = require('./ps.cjs');
+const require_utils_runParallel_wmic = require('./wmic.cjs');
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os);
+
+//#region src/utils/runParallel/pidTree.ts
+const platformToMethod = {
+	darwin: "ps",
+	sunos: "ps",
+	freebsd: "ps",
+	netbsd: "ps",
+	win: "wmic",
+	linux: "ps",
+	aix: "ps"
+};
+const methodToFn = {
+	ps: require_utils_runParallel_ps.ps,
+	wmic: require_utils_runParallel_wmic.wmic
+};
+let platform = node_os.platform();
+if (platform.startsWith("win")) platform = "win";
+const method = platformToMethod[platform];
+/**
+* Gets the list of all the pids of the system.
+*/
+const getAll = (callback) => {
+	if (method === void 0) {
+		callback(/* @__PURE__ */ new Error(node_os.platform() + " is not supported yet, please open an issue (https://github.com/simonepri/pidtree)"), void 0);
+		return;
+	}
+	const listFn = methodToFn[method];
+	listFn(callback);
+};
+/**
+* Get the list of children and grandchildren pids of the given PID.
+* @param PID A PID. If -1 will return all the pids.
+* @param options Optional options object.
+* @param callback Called when the list is ready.
+*/
+const pidtree = (PID, options, callback) => {
+	let normalizedOptions;
+	let normalizedCallback;
+	if (typeof options === "function") {
+		normalizedCallback = options;
+		normalizedOptions = {};
+	} else {
+		normalizedCallback = callback;
+		normalizedOptions = typeof options === "object" ? options : {};
+	}
+	const parsedPID = parseInt(String(PID), 10);
+	if (Number.isNaN(parsedPID) || parsedPID < -1) {
+		normalizedCallback(/* @__PURE__ */ new TypeError("The pid provided is invalid"), void 0);
+		return;
+	}
+	getAll((err, processList) => {
+		if (err) {
+			normalizedCallback(err, void 0);
+			return;
+		}
+		if (!processList) {
+			normalizedCallback(/* @__PURE__ */ new Error("Failed to get process list"), void 0);
+			return;
+		}
+		if (parsedPID === -1) {
+			const result = processList.map(([ppid, pid]) => normalizedOptions.advanced ? {
+				ppid,
+				pid
+			} : pid);
+			normalizedCallback(null, result);
+			return;
+		}
+		let root;
+		for (let l = 0; l < processList.length; l++) {
+			if (processList[l][1] === parsedPID) {
+				root = normalizedOptions.advanced ? {
+					ppid: processList[l][0],
+					pid: parsedPID
+				} : parsedPID;
+				break;
+			}
+			if (processList[l][0] === parsedPID) root = normalizedOptions.advanced ? { pid: parsedPID } : parsedPID;
+		}
+		if (root === void 0) {
+			normalizedCallback(/* @__PURE__ */ new Error("No matching pid found"), void 0);
+			return;
+		}
+		const tree = {};
+		const listCopy = [...processList];
+		while (listCopy.length > 0) {
+			const element = listCopy.pop();
+			if (tree[element[0]]) tree[element[0]].push(element[1]);
+			else tree[element[0]] = [element[1]];
+		}
+		let idx = 0;
+		const pids = [root];
+		while (idx < pids.length) {
+			const curpid = normalizedOptions.advanced ? pids[idx++].pid : pids[idx++];
+			if (!tree[curpid]) continue;
+			const length = tree[curpid].length;
+			for (let j = 0; j < length; j++) pids.push(normalizedOptions.advanced ? {
+				ppid: curpid,
+				pid: tree[curpid][j]
+			} : tree[curpid][j]);
+			delete tree[curpid];
+		}
+		if (!normalizedOptions.root) pids.shift();
+		normalizedCallback(null, pids);
+	});
+};
+const pify = (fn, arg1, arg2) => {
+	return new Promise((resolve, reject) => {
+		fn(arg1, arg2, (err, data) => {
+			if (err) return reject(err);
+			if (data === void 0) return reject(/* @__PURE__ */ new Error("No data returned"));
+			resolve(data);
+		});
+	});
+};
+/* istanbul ignore if */
+if (!String.prototype.startsWith) String.prototype.startsWith = function(suffix) {
+	return this.substring(0, suffix.length) === suffix;
+};
+/**
+* Get the list of children pids of the given pid.
+* @param pid A PID. If -1 will return all the pids.
+* @param options Optional options object.
+* @param callback Called when the list is ready. If not provided a promise is returned instead.
+* @returns Only when the callback is not provided.
+*/
+const list = (pid, options, callback) => {
+	if (typeof options === "function") {
+		pidtree(pid, void 0, options);
+		return;
+	}
+	if (typeof callback === "function") {
+		pidtree(pid, options, callback);
+		return;
+	}
+	return pify(pidtree, pid, options);
+};
+
+//#endregion
+exports.list = list;
+//# sourceMappingURL=pidTree.cjs.map

package/dist/cjs/utils/runParallel/pidTree.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pidTree.cjs","names":["platformToMethod: Record<Platform, Method>","methodToFn: Record<Method, ProcessListFn>","platform: string","os","method: Method | undefined","normalizedOptions: ListOptions","normalizedCallback: ListCallback<T>","root: ProcessInfo | number | undefined","tree: Record<number, number[]>","pids: (ProcessInfo | number)[]"],"sources":["../../../../src/utils/runParallel/pidTree.ts"],"sourcesContent":["import * as os from 'node:os';\nimport { ps } from './ps';\nimport { wmic } from './wmic';\n\ntype Platform =\n  | 'darwin'\n  | 'sunos'\n  | 'freebsd'\n  | 'netbsd'\n  | 'win'\n  | 'linux'\n  | 'aix';\ntype Method = 'ps' | 'wmic';\n\ntype ProcessList = [number, number][]; // [PPID, PID][]\n\ninterface ListOptions {\n  root?: boolean;\n  advanced?: boolean;\n}\n\ntype ProcessInfo = { pid: number; ppid?: number };\ntype ResultType<T extends ListOptions | undefined> = T extends {\n  advanced: true;\n}\n  ? ProcessInfo[]\n  : number[];\n\ntype ProcessListCallback = (err: Error | null, list?: ProcessList) => void;\ntype ListCallback<T extends ListOptions | undefined> = (\n  err: Error | null,\n  list?: ResultType<T>\n) => void;\n\ntype ProcessListFn = (callback: ProcessListCallback) => void;\n\nconst platformToMethod: Record<Platform, Method> = {\n  darwin: 'ps',\n  sunos: 'ps',\n  freebsd: 'ps',\n  netbsd: 'ps',\n  win: 'wmic',\n  linux: 'ps',\n  aix: 'ps',\n};\n\nconst methodToFn: Record<Method, ProcessListFn> = {\n  ps,\n  wmic,\n};\n\nlet platform: string = os.platform();\nif (platform.startsWith('win')) {\n  platform = 'win';\n}\n\nconst method: Method | undefined = platformToMethod[platform as Platform];\n\n/**\n * Gets the list of all the pids of the system.\n */\nconst getAll = (callback: ProcessListCallback): void => {\n  if (method === undefined) {\n    callback(\n      new Error(\n        os.platform() +\n          ' is not supported yet, please open an issue (https://github.com/simonepri/pidtree)'\n      ),\n      undefined\n    );\n    return;\n  }\n\n  const listFn = methodToFn[method];\n  listFn(callback);\n};\n\n/**\n * Get the list of children and grandchildren pids of the given PID.\n * @param PID A PID. If -1 will return all the pids.\n * @param options Optional options object.\n * @param callback Called when the list is ready.\n */\nconst pidtree = <T extends ListOptions | undefined>(\n  PID: number | string,\n  options: T | ListCallback<T> | undefined,\n  callback?: ListCallback<T>\n): void => {\n  let normalizedOptions: ListOptions;\n  let normalizedCallback: ListCallback<T>;\n\n  if (typeof options === 'function') {\n    normalizedCallback = options;\n    normalizedOptions = {};\n  } else {\n    normalizedCallback = callback!;\n    normalizedOptions = typeof options === 'object' ? options : {};\n  }\n\n  const parsedPID = parseInt(String(PID), 10);\n  if (Number.isNaN(parsedPID) || parsedPID < -1) {\n    normalizedCallback(\n      new TypeError('The pid provided is invalid') as Error,\n      undefined\n    );\n    return;\n  }\n\n  getAll((err, processList) => {\n    if (err) {\n      normalizedCallback(err, undefined);\n      return;\n    }\n\n    if (!processList) {\n      normalizedCallback(new Error('Failed to get process list'), undefined);\n      return;\n    }\n\n    // If the user wants the whole list just return it\n    if (parsedPID === -1) {\n      const result = processList.map(([ppid, pid]) =>\n        normalizedOptions.advanced ? { ppid, pid } : pid\n      ) as ResultType<T>;\n\n      normalizedCallback(null, result);\n      return;\n    }\n\n    let root: ProcessInfo | number | undefined;\n    for (let l = 0; l < processList.length; l++) {\n      if (processList[l][1] === parsedPID) {\n        root = normalizedOptions.advanced\n          ? { ppid: processList[l][0], pid: parsedPID }\n          : parsedPID;\n        break;\n      }\n\n      if (processList[l][0] === parsedPID) {\n        root = normalizedOptions.advanced ? { pid: parsedPID } : parsedPID; // Special pids like 0 on *nix\n      }\n    }\n\n    if (root === undefined) {\n      normalizedCallback(new Error('No matching pid found'), undefined);\n      return;\n    }\n\n    // Build the adjacency Hash Map (pid -> [children of pid])\n    const tree: Record<number, number[]> = {};\n    const listCopy = [...processList];\n    while (listCopy.length > 0) {\n      const element = listCopy.pop()!;\n      if (tree[element[0]]) {\n        tree[element[0]].push(element[1]);\n      } else {\n        tree[element[0]] = [element[1]];\n      }\n    }\n\n    // Starting by the PID provided by the user, traverse the tree using the\n    // adjacency Hash Map until the whole subtree is visited.\n    // Each pid encountered while visiting is added to the pids array.\n    let idx = 0;\n    const pids: (ProcessInfo | number)[] = [root];\n    while (idx < pids.length) {\n      const curpid = normalizedOptions.advanced\n        ? (pids[idx++] as ProcessInfo).pid\n        : (pids[idx++] as number);\n      if (!tree[curpid]) continue;\n      const length = tree[curpid].length;\n      for (let j = 0; j < length; j++) {\n        pids.push(\n          normalizedOptions.advanced\n            ? { ppid: curpid, pid: tree[curpid][j] }\n            : tree[curpid][j]\n        );\n      }\n\n      delete tree[curpid];\n    }\n\n    if (!normalizedOptions.root) {\n      pids.shift(); // Remove root\n    }\n\n    normalizedCallback(null, pids as ResultType<T>);\n  });\n};\n\nconst pify = <T extends ListOptions | undefined>(\n  fn: typeof pidtree,\n  arg1: number | string,\n  arg2: T | undefined\n): Promise<ResultType<T>> => {\n  return new Promise((resolve, reject) => {\n    fn(arg1, arg2, (err, data) => {\n      if (err) return reject(err);\n      if (data === undefined) {\n        return reject(new Error('No data returned'));\n      }\n      resolve(data);\n    });\n  });\n};\n\n// Node versions prior to 4.0.0 do not define have `startsWith`.\n/* istanbul ignore if */\nif (!String.prototype.startsWith) {\n  String.prototype.startsWith = function (suffix: string): boolean {\n    return this.substring(0, suffix.length) === suffix;\n  };\n}\n\n/**\n * Get the list of children pids of the given pid.\n * @param pid A PID. If -1 will return all the pids.\n * @param options Optional options object.\n * @param callback Called when the list is ready. If not provided a promise is returned instead.\n * @returns Only when the callback is not provided.\n */\nexport const list = <T extends ListOptions | undefined>(\n  pid: number | string,\n  options?: T | ListCallback<T>,\n  callback?: ListCallback<T>\n): Promise<ResultType<T>> | undefined => {\n  if (typeof options === 'function') {\n    pidtree(pid, undefined, options);\n    return;\n  }\n\n  if (typeof callback === 'function') {\n    pidtree(pid, options, callback);\n    return;\n  }\n\n  return pify(pidtree, pid, options);\n};\n"],"mappings":"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"}

package/dist/cjs/utils/runParallel/ps.cjs

@@ -0,0 +1,49 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_utils_runParallel_bin = require('./bin.cjs');
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os);
+
+//#region src/utils/runParallel/ps.ts
+/**
+* Gets the list of all the pids of the system through the ps command.
+* @param callback Callback function with error and process list.
+*/
+const ps = (callback) => {
+	require_utils_runParallel_bin.run("ps", [
+		"-A",
+		"-o",
+		"ppid,pid"
+	], (err, stdout, code) => {
+		if (err) {
+			callback(err);
+			return;
+		}
+		if (code !== 0) {
+			callback(/* @__PURE__ */ new Error(`pidtree ps command exited with code ${code}`));
+			return;
+		}
+		if (!stdout) {
+			callback(/* @__PURE__ */ new Error("No stdout received from ps command"));
+			return;
+		}
+		try {
+			const lines = stdout.split(node_os.EOL);
+			const list = [];
+			for (let i = 1; i < lines.length; i++) {
+				const trimmed = lines[i].trim();
+				if (!trimmed) continue;
+				const parts = trimmed.split(/\s+/);
+				const ppid = parseInt(parts[0], 10);
+				const pid = parseInt(parts[1], 10);
+				if (!Number.isNaN(ppid) && !Number.isNaN(pid)) list.push([ppid, pid]);
+			}
+			callback(null, list);
+		} catch (error) {
+			callback(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+};
+
+//#endregion
+exports.ps = ps;
+//# sourceMappingURL=ps.cjs.map

package/dist/cjs/utils/runParallel/ps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps.cjs","names":["os","list: ProcessList"],"sources":["../../../../src/utils/runParallel/ps.ts"],"sourcesContent":["import * as os from 'node:os';\nimport { run } from './bin';\n\ntype ProcessList = [number, number][]; // [PPID, PID][]\ntype ProcessListCallback = (err: Error | null, list?: ProcessList) => void;\n\n/**\n * Gets the list of all the pids of the system through the ps command.\n * @param callback Callback function with error and process list.\n */\nexport const ps = (callback: ProcessListCallback): void => {\n  const args = ['-A', '-o', 'ppid,pid'];\n\n  run('ps', args, (err, stdout, code) => {\n    if (err) {\n      callback(err);\n      return;\n    }\n    if (code !== 0) {\n      callback(new Error(`pidtree ps command exited with code ${code}`));\n      return;\n    }\n\n    // Example of stdout\n    //\n    // PPID   PID\n    //    1   430\n    //  430   432\n    //    1   727\n    //    1  7166\n\n    if (!stdout) {\n      callback(new Error('No stdout received from ps command'));\n      return;\n    }\n\n    try {\n      const lines = stdout.split(os.EOL);\n\n      const list: ProcessList = [];\n      for (let i = 1; i < lines.length; i++) {\n        const trimmed = lines[i].trim();\n        if (!trimmed) continue;\n        const parts = trimmed.split(/\\s+/);\n        const ppid = parseInt(parts[0], 10); // PPID\n        const pid = parseInt(parts[1], 10); // PID\n        if (!Number.isNaN(ppid) && !Number.isNaN(pid)) {\n          list.push([ppid, pid]);\n        }\n      }\n\n      callback(null, list);\n    } catch (error) {\n      callback(error instanceof Error ? error : new Error(String(error)));\n    }\n  });\n};\n"],"mappings":";;;;;;;;;;AAUA,MAAa,MAAM,aAAwC;AAGzD,mCAAI,MAFS;EAAC;EAAM;EAAM;EAAW,GAEpB,KAAK,QAAQ,SAAS;AACrC,MAAI,KAAK;AACP,YAAS,IAAI;AACb;;AAEF,MAAI,SAAS,GAAG;AACd,4BAAS,IAAI,MAAM,uCAAuC,OAAO,CAAC;AAClE;;AAWF,MAAI,CAAC,QAAQ;AACX,4BAAS,IAAI,MAAM,qCAAqC,CAAC;AACzD;;AAGF,MAAI;GACF,MAAM,QAAQ,OAAO,MAAMA,QAAG,IAAI;GAElC,MAAMC,OAAoB,EAAE;AAC5B,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;IACrC,MAAM,UAAU,MAAM,GAAG,MAAM;AAC/B,QAAI,CAAC,QAAS;IACd,MAAM,QAAQ,QAAQ,MAAM,MAAM;IAClC,MAAM,OAAO,SAAS,MAAM,IAAI,GAAG;IACnC,MAAM,MAAM,SAAS,MAAM,IAAI,GAAG;AAClC,QAAI,CAAC,OAAO,MAAM,KAAK,IAAI,CAAC,OAAO,MAAM,IAAI,CAC3C,MAAK,KAAK,CAAC,MAAM,IAAI,CAAC;;AAI1B,YAAS,MAAM,KAAK;WACb,OAAO;AACd,YAAS,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC,CAAC;;GAErE"}

package/dist/cjs/utils/runParallel/runTask.cjs

@@ -0,0 +1,155 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let node_stream = require("node:stream");
+node_stream = require_rolldown_runtime.__toESM(node_stream);
+
+//#region src/utils/runParallel/runTask.ts
+/**
+* Remove the given value from the array.
+*/
+const remove = (array, x) => {
+	const index = array.indexOf(x);
+	if (index !== -1) array.splice(index, 1);
+};
+const signals = {
+	SIGABRT: 6,
+	SIGALRM: 14,
+	SIGBUS: 10,
+	SIGCHLD: 20,
+	SIGCONT: 19,
+	SIGFPE: 8,
+	SIGHUP: 1,
+	SIGILL: 4,
+	SIGINT: 2,
+	SIGKILL: 9,
+	SIGPIPE: 13,
+	SIGQUIT: 3,
+	SIGSEGV: 11,
+	SIGSTOP: 17,
+	SIGTERM: 15,
+	SIGTRAP: 5,
+	SIGTSTP: 18,
+	SIGTTIN: 21,
+	SIGTTOU: 22,
+	SIGUSR1: 30,
+	SIGUSR2: 31
+};
+/**
+* Converts a signal name to a number.
+*/
+const convert = (signal) => {
+	return signals[signal] || 0;
+};
+/**
+* Simple in-memory writable stream
+*/
+var MemoryStream = class extends node_stream.Writable {
+	chunks = [];
+	_write(chunk, _encoding, callback) {
+		this.chunks.push(chunk);
+		callback();
+	}
+	toString() {
+		return Buffer.concat(this.chunks).toString("utf8");
+	}
+};
+/**
+* Run npm-scripts of given names in parallel.
+*
+* If a npm-script exited with a non-zero code, this aborts other all npm-scripts.
+*
+* Note: This is a simplified version for our use case.
+* The full implementation would require the actual runTask function from npm-run-all.
+*/
+const runTasks = (tasks, options) => {
+	return new Promise((resolve, reject) => {
+		if (tasks.length === 0) {
+			resolve([]);
+			return;
+		}
+		const results = tasks.map((task) => ({
+			name: task,
+			code: void 0
+		}));
+		const queue = tasks.map((task, index) => ({
+			name: task,
+			index
+		}));
+		const promises = [];
+		let error = null;
+		let aborted = false;
+		/**
+		* Done.
+		*/
+		const done = () => {
+			if (error == null) resolve(results);
+			else reject(error);
+		};
+		/**
+		* Aborts all tasks.
+		*/
+		const abort = () => {
+			if (aborted) return;
+			aborted = true;
+			if (promises.length === 0) done();
+			else {
+				for (const p of promises) p.abort?.();
+				Promise.all(promises).then(done, reject);
+			}
+		};
+		/**
+		* Runs a next task.
+		*/
+		const next = () => {
+			if (aborted) return;
+			if (queue.length === 0) {
+				if (promises.length === 0) done();
+				return;
+			}
+			const originalOutputStream = options.stdout;
+			const optionsClone = { ...options };
+			const writer = new MemoryStream();
+			if (options.aggregateOutput) optionsClone.stdout = writer;
+			const task = queue.shift();
+			const promise = Promise.resolve({
+				name: task.name,
+				code: 0,
+				signal: null
+			});
+			promises.push(promise);
+			promise.then((result) => {
+				remove(promises, promise);
+				if (aborted) return;
+				if (options.aggregateOutput) originalOutputStream.write(writer.toString());
+				if (result.code === null && result.signal !== null && result.signal !== void 0) result.code = 128 + convert(result.signal);
+				results[task.index].code = result.code;
+				if (result.code) {
+					error = /* @__PURE__ */ new Error(`Task ${result.name} failed with code ${result.code}`);
+					if (!options.continueOnError) {
+						abort();
+						return;
+					}
+				}
+				if (options.race && !result.code) {
+					abort();
+					return;
+				}
+				next();
+			}, (thisError) => {
+				remove(promises, promise);
+				if (!options.continueOnError || options.race) {
+					error = thisError;
+					abort();
+					return;
+				}
+				next();
+			});
+		};
+		const max = options.maxParallel;
+		const end = typeof max === "number" && max > 0 ? Math.min(tasks.length, max) : tasks.length;
+		for (let i = 0; i < end; ++i) next();
+	});
+};
+
+//#endregion
+exports.runTasks = runTasks;
+//# sourceMappingURL=runTask.cjs.map