vivth 1.4.10 → 1.5.1

package/src/bundler/FSInlineAnalyzer.mjs

@@ -1,228 +0,0 @@
-// @ts-check
-
-import { dirname, extname, join, relative } from 'node:path';
-import { readFile, readdir } from 'node:fs/promises';
-
-import { Paths } from '../class/Paths.mjs';
-import { LitExp } from '../class/LitExp.mjs';
-import { TryAsync } from '../function/TryAsync.mjs';
-import { FSInline } from './FSInline.mjs';
-import { EsBundler } from './EsBundler.mjs';
-import { removeVivthDevCodeBlock } from './adds/ToBundledJSPlugin.mjs';
-
-/**
- * @param {string} str
- * @returns {RegExp}
- */
-const hydrateRegex = (str) => {
-	const match = str.match(/^\/(.*)\/([a-z]*)$/);
-	if (match === null) {
-		throw new Error('Invalid regex string format');
-	}
-	const [, pattern = '', flags] = match;
-	return new RegExp(pattern, flags);
-};
-
-/**
- * @description
- * - collections of static method to analyze content for `FSInline`;
- * - mostly used internally;
- */
-export class FSInlineAnalyzer {
-	/**
-	 * @description
-	 * - to be used on bundled content;
-	 * @param {string} content
-	 * @param {'cjs'|'esm'} format
-	 * @returns {ReturnType<typeof TryAsync<string>>}
-	 * @example
-	 * import { readFile } from 'node:fs/promises';
-	 *
-	 * import { FSInlineAnalyzer } from 'vivth';
-	 *
-	 * const [resultFinalContent, errorFinalContent] = await FSInlineAnalyzer.finalContent(
-	 * 	await readFile('./resultESBunlded.mjs', {encoding: 'utf-8'}),
-	 * 	'esm'
-	 * );
-	 */
-	static finalContent = async (content, format) => {
-		return await TryAsync(async () => {
-			content = removeVivthDevCodeBlock(content);
-			const [literalFile, errorPrepareFile] = LitExp.prepare({
-				FSInline: /[\w][\w\d]*/,
-				method: /\.vivthFSInlineFile\s*?\(\s*?['"]/,
-				path: false,
-				closing: /['"]\s*?\)/,
-			});
-			const [literalWorker, errorPreparWorker] = LitExp.prepare({
-				ref: /[\w][\w\d]*/,
-				method: /\.newVivthWorker\s*?\(\s*?['"]/,
-				path: false,
-				closing: /['"]\s*\)/,
-			});
-			const [literalDir, errorPrepareDir] = LitExp.prepare({
-				FSInline: /[\w][\w\d]*/,
-				method: /\.vivthFSInlineDir\s*?\(\s*?['"]/,
-				path: false,
-				methodClosing: /['"]\s*?,\s*/,
-				rule: false,
-				functionClosing: /\s*?\)/,
-			});
-			if (errorPrepareFile || errorPrepareDir || errorPreparWorker) {
-				throw { errorPrepareFile, errorPrepareDir, errorPreparWorker };
-			}
-			const templateFile = literalFile`${'FSInline'}${'method'}${'path'}${'closing'}`;
-			const templateWorker = literalWorker`${'ref'}${'method'}${'path'}${'closing'}`;
-			const templateDir = literalDir`${'FSInline'}${'method'}${'path'}${'methodClosing'}${'rule'}${'functionClosing'}`;
-			const [resultMatchingFile, errorMatchingFile] = templateFile.evaluate.matchedAllAndGrouped(
-				content,
-				{
-					flags: 'gm',
-					whiteSpaceSensitive: false,
-				}
-			);
-			const [resultMatchingWorker, errorMatchingWorker] =
-				templateWorker.evaluate.matchedAllAndGrouped(content, {
-					flags: 'gm',
-					whiteSpaceSensitive: false,
-				});
-			const [resultMatchingDir, errorMatchingDir] = templateDir.evaluate.matchedAllAndGrouped(
-				content,
-				{
-					flags: 'gm',
-					whiteSpaceSensitive: false,
-				}
-			);
-			if (errorMatchingFile || errorMatchingDir || errorMatchingWorker) {
-				throw { errorMatchingFile, errorMatchingDir, errorMatchingWorker };
-			}
-			if (Paths.root === undefined) {
-				throw new Error('Path.root undefined');
-			}
-			const {
-				result: { named: namedFile },
-			} = resultMatchingFile;
-			for (let i = 0; i < namedFile.length; i++) {
-				const res = namedFile[i];
-				if (res === undefined) {
-					continue;
-				}
-				const { path } = res;
-				if ('path' in FSInline.vivthFSInlinelists) {
-					continue;
-				}
-				FSInline.vivthFSInlinelists[path] = Buffer.from(
-					removeVivthDevCodeBlock(await readFile(join(Paths.root, path), { encoding: 'utf-8' }))
-				);
-			}
-			const {
-				result: { named: namedDir },
-			} = resultMatchingDir;
-			for (let i = 0; i < namedDir.length; i++) {
-				const res = namedDir[i];
-				if (res === undefined) {
-					continue;
-				}
-				let { path, rule } = res;
-				rule = rule.trim();
-				const results = await FSInlineAnalyzer.#dir(join(Paths.root, path), hydrateRegex(rule));
-				for (let j = 0; j < results.length; j++) {
-					const res = results[j];
-					if (res === undefined) {
-						continue;
-					}
-					const { path, buffer } = res;
-					if (path in FSInline.vivthFSInlinelists) {
-						continue;
-					}
-					FSInline.vivthFSInlinelists[path] = buffer;
-				}
-			}
-			const {
-				result: { named: namedWorker },
-			} = resultMatchingWorker;
-			for (let i = 0; i < namedWorker.length; i++) {
-				const res = namedWorker[i];
-				if (res === undefined) {
-					continue;
-				}
-				const { path } = res;
-				const fullPath = join(Paths.root, path);
-				const content = removeVivthDevCodeBlock(await readFile(fullPath, { encoding: 'utf-8' }));
-				const [contentBundled, errorBundled] = await EsBundler(
-					{
-						content,
-						// @ts-expect-error
-						extension: extname(fullPath),
-						root: dirname(fullPath),
-					},
-					{
-						minify: true,
-						format,
-					}
-				);
-				if (errorBundled) {
-					continue;
-				}
-				const [trueContent, errorFinal] = await FSInlineAnalyzer.finalContent(
-					contentBundled,
-					format
-				);
-				if (errorFinal) {
-					continue;
-				}
-				FSInline.vivthFSInlinelists[path] = Buffer.from(trueContent);
-			}
-			return content.replace(
-				/static\s*vivthFSInlinelists(?:;|)/,
-				`static vivthFSInlinelists=${JSON.stringify(FSInline.vivthFSInlinelists)}`
-			);
-		});
-	};
-	/**
-	 * @typedef {{path:string, buffer:Buffer<ArrayBuffer>}[]} _dirReturn
-	 */
-	/**
-	 * @param {string} dirName
-	 * @param {RegExp} ruleForFileFullPath
-	 * @returns {Promise<_dirReturn>}
-	 */
-	static #dir = async (dirName, ruleForFileFullPath) => {
-		/**
-		 * @type {_dirReturn}
-		 */
-		const result = [];
-		/**
-		 * @param {string} current
-		 * @returns {Promise<void>}
-		 */
-		const walk = async (current) => {
-			if (Paths.root === undefined) {
-				return;
-			}
-			const entries = await readdir(current, {
-				recursive: false,
-				withFileTypes: true,
-				encoding: 'utf-8',
-			});
-			for (const entry of entries) {
-				const fullPath = Paths.normalize(join(current, entry.name));
-				const relativePath = Paths.normalizesForRoot(relative(Paths.root, fullPath));
-				if (entry.isDirectory()) {
-					await walk(fullPath);
-					continue;
-				}
-				if (entry.isFile() && ruleForFileFullPath.test(fullPath)) {
-					result.push({
-						path: relativePath,
-						buffer: Buffer.from(
-							removeVivthDevCodeBlock(await readFile(fullPath, { encoding: 'utf-8' }))
-						),
-					});
-				}
-			}
-		};
-		await walk(dirName);
-		return result;
-	};
-}

package/src/bundler/FSInlineBundled.mjs

@@ -1,38 +0,0 @@
-// @ts-check
-
-import { join } from 'node:path';
-
-import { Paths } from '../class/Paths.mjs';
-
-export class FSInline {
-	static prefix = '';
-	/**
-	 * @param {string} filePathFromProject
-	 * @returns {Promise<Buffer<ArrayBuffer>>}
-	 */
-	static vivthFSInlineFile = async (filePathFromProject) => {
-		filePathFromProject = Paths.normalizesForRoot(filePathFromProject);
-		const bufferStored = FSInline.vivthFSInlinelists[filePathFromProject];
-		if (bufferStored === undefined) {
-			return Buffer.from([]);
-		}
-		return Buffer.from(bufferStored);
-	};
-	/**
-	 * @param {string} dirPathFromProject
-	 * @param {Object} regexRule
-	 * @param {RegExp} regexRule.dir
-	 * @param {RegExp} regexRule.file
-	 * @returns {Promise<typeof FSInline["vivthFSInlineFile"]>}
-	 * - relative to the `dirPathFromProject`
-	 */
-	static vivthFSInlineDir = async (dirPathFromProject) => {
-		dirPathFromProject = Paths.normalizesForRoot(dirPathFromProject);
-		return (path_) => FSInline.vivthFSInlineFile(join(dirPathFromProject, path_));
-	};
-	/**
-	 * - to be used as embed placeholder on `bundled` and `compiled`;
-	 * @type {Record<string, Buffer<ArrayBufferLike>>}
-	 */
-	static vivthFSInlinelists;
-}

package/src/bundler/adds/externals.mjs

@@ -1,8 +0,0 @@
-// @ts-check
-
-export const externals = [
-	'esbuild',
-	'../prelude/bootstrap.js',
-	'./common',
-	'../prelude/diagnostic.js',
-];

package/src/class/ListDerived.mjs

@@ -1,42 +0,0 @@
-// @ts-check
-
-import { Derived } from './Derived.mjs';
-import { Effect } from './Effect.mjs';
-/**
- * @description
- * - class to create `dervivedList` that satisfy `Array<Record<string, string>>`;
- * - usefull for `derivedLoops`, e.g. temporary search values;
- * - is a `Derived` instance;
- * @template {ListArg} LISTARG
- * @extends {Derived<LISTARG[]>}
- */
-export class ListDerived extends Derived {
-	/**
-	 * @typedef {import('../types/ListArg.mjs').ListArg} ListArg
-	 * @typedef {import('../common/lazie.mjs').unwrapLazy} unwrapLazy
-	 */
-	/**
-	 * @description
-	 * @param {(effectInstanceOptions:Omit<Effect["options"],
-	 * unwrapLazy>)=>
-	 * Promise<LISTARG[]>} derivedFunction
-	 * @example
-	 * import { ListSignal, ListDerived } from 'vivth';
-	 *
-	 * const listExample = new ListSignal([
-	 * 	{key1: "test1"},
-	 * 	{key1: "test2"},
-	 * ]);
-	 *
-	 * export const listDerivedExample = new ListDerived(async({ subscribe }) => {
-	 * 	// becarefull to not mutate the reference value
-	 * 	return subscribe(listExample).value.filter((val) => {
-	 * 		// subscribe(listExample).structuredClone can be used as alternative
-	 * 		// filter logic
-	 * 	})
-	 * });
-	 */
-	constructor(derivedFunction) {
-		super(derivedFunction);
-	}
-}

package/src/common/Dev.mjs

@@ -1,142 +0,0 @@
-// @ts-check
-
-import { Console } from '../class/Console.mjs';
-import { Effect } from '../class/Effect.mjs';
-import { Signal } from '../class/Signal.mjs';
-import { LazyFactory } from '../function/LazyFactory.mjs';
-import { TryAsync } from '../function/TryAsync.mjs';
-import { Trace } from './Trace.mjs';
-
-/**
- * @typedef {import("../types/VivthDevCodeBlockStringType.mjs").VivthDevCodeBlockStringType} VivthDevCodeBlockStringType
- * @typedef {import('../types/DevTestCB.mjs').DevTestCB} DevTestCB
- */
-
-/**
- * @description
- * - class helper for `devTime` only code block;
- */
-export class Dev {
-	/**
-	 * @description
-	 * - persistent variable(during `devTime` and `bundled`);
-	 * - can be used as `condition` for checking whether it is in `devTime` or `bundled`;
-	 * @type {boolean}
-	 * @example
-	 * import { Dev } from 'vivth';
-	 *
-	 * if (Dev.isDev) {
-	 * 	// this code block will presist even on `bundled`;
-	 * }
-	 */
-	static isDev = true;
-	/**
-	 * @type {Signal<Map<string,Awaited<ReturnType<typeof TryAsync<boolean>>>>>}
-	 */
-	static #notifications = LazyFactory(() => new Signal(new Map()));
-	/**
-	 * @type {DevTestCB}
-	 */
-	static #test = async (testName, testCallback) => {
-		testName = `${testName}:'${Trace(4)}'`;
-		Dev.#notifications.subscribers.notify(async ({ signalInstance }) => {
-			signalInstance.value.set(
-				testName,
-				await TryAsync(async () => {
-					return await testCallback();
-				})
-			);
-		});
-		Dev.#effectForCheck['vivth:unwrapLazy;']();
-		return {
-			removeId: () => {
-				Dev.#notifications.subscribers.notify(async ({ signalInstance }) => {
-					signalInstance.value.delete(testName);
-				});
-			},
-		};
-	};
-	static #effectForCheck = LazyFactory(
-		() =>
-			new Effect(async ({ isLastCalled, subscribe }) => {
-				const notifications = subscribe(Dev.#notifications).value;
-				if (!(await isLastCalled(100)) || !notifications.size) {
-					return;
-				}
-				/**
-				 * @type {string[]}
-				 */
-				const succeedTest = [];
-				/**
-				 * @type {string[]}
-				 */
-				const failedTest = [];
-				for (const [notificationID, [isCorrect, error]] of notifications) {
-					if (error || !isCorrect) {
-						failedTest.push(notificationID);
-						continue;
-					}
-					succeedTest.push(notificationID);
-				}
-				const size = notifications.size;
-				/**
-				 * @type {{
-				 * testCount:number,
-				 * succeed?: {count:string, testID:string[]},
-				 * failed?: {count:string, testID:string[]},
-				 * }}
-				 */
-				let warn = { testCount: size };
-				if (succeedTest.length) {
-					warn.succeed = {
-						count: `${succeedTest.length} of ${size}`,
-						testID: succeedTest,
-					};
-				}
-				if (failedTest.length) {
-					warn.failed = {
-						count: `${failedTest.length} of ${size}`,
-						testID: failedTest,
-					};
-				}
-				Console.warn(warn);
-			})
-	);
-	/**
-	 * @description
-	 * - to wrap `devTime` only code block;
-	 * - when bundled uses `EsBundler` or esbuild with `ToBundledJSPlugin` plugin, the code block will be removed on the bundled version;
-	 * @param {(options:{test:DevTestCB})=>Promise<void>} callback
-	 * - also provide `test` method for inline testing:
-	 * >- which is wrapped in `TryAsync`, throwed errors will automatically return `false`;
-	 * @param {VivthDevCodeBlockStringType} _closing
-	 * - it is needed to detect the code block closing;
-	 * - should use single or double quote and not back tick;
-	 * @returns {Promise<void>}
-	 * @example
-	 * import { Dev, Signal } from 'vivth';
-	 *
-	 * Dev.vivthDevCodeBlock(async function () {
-	 * 	// this code block will be removed on `bundled` version;
-	 * }, 'vivthDevCodeBlock');
-	 *
-	 * const numberSignal = new Signal(0);
-	 * Dev.vivthDevCodeBlock(async ({ test }) => {
-	 * 	// this code block will be removed on `bundled` version;
-	 * 	const [{ removeId: removeTest }] = await Promise.all([
-	 * 		test(async () => numberSignal.value === 0)
-	 * 	])
-	 * }, 'vivthDevCodeBlock');
-	 */
-	static vivthDevCodeBlock = async (callback, _closing) => {
-		if (
-			/**
-			 * just in case Bundler doesn't properly clearup `vivthDevCodeBlock`
-			 */
-			!Dev.isDev
-		) {
-			return;
-		}
-		await callback({ test: Dev.#test });
-	};
-}

package/src/common/DevBundled.mjs

@@ -1,5 +0,0 @@
-// @ts-check
-
-export class Dev {
-	static isDev = false;
-}

package/src/common/lazie.mjs

@@ -1,3 +0,0 @@
-// @ts-check
-
-export const unwrapLazy = 'vivth:unwrapLazy;';

package/src/types/IsListSignal.mjs

@@ -1,6 +0,0 @@
-// @ts-check
-
-/**
- * - `EnvSignal.get` argument whether signal need to be a list or not;
- * @typedef {boolean} IsListSignal
- */

package/src/types/Runtime.mjs

@@ -1,6 +0,0 @@
-// @ts-check
-
-/**
- * - for popular runtimes check;
- * @typedef {'node' | 'bun' | 'deno' | 'browser' | 'unknown'} Runtime
- */

package/src/types/VivthDevCodeBlockStringType.mjs

@@ -1,6 +0,0 @@
-// @ts-check
-
-/**
- * - closing helper for `Dev.vivthDevCodeBlock`;
- * @typedef {'vivthDevCodeBlock'} VivthDevCodeBlockStringType
- */

package/types/index.d.mts

@@ -1,58 +0,0 @@
-export { ToBundledJSPlugin } from "./src/bundler/adds/ToBundledJSPlugin.mjs";
-export { CompileJS } from "./src/bundler/CompileJS.mjs";
-export { CreateESPlugin } from "./src/bundler/CreateESPlugin.mjs";
-export { EsBundler } from "./src/bundler/EsBundler.mjs";
-export { FSInline } from "./src/bundler/FSInline.mjs";
-export { FSInlineAnalyzer } from "./src/bundler/FSInlineAnalyzer.mjs";
-export { Console } from "./src/class/Console.mjs";
-export { Derived } from "./src/class/Derived.mjs";
-export { Effect } from "./src/class/Effect.mjs";
-export { EnvSignal } from "./src/class/EnvSignal.mjs";
-export { EventSignal } from "./src/class/EventSignal.mjs";
-export { FileSafe } from "./src/class/FileSafe.mjs";
-export { ListDerived } from "./src/class/ListDerived.mjs";
-export { ListSignal } from "./src/class/ListSignal.mjs";
-export { LitExp } from "./src/class/LitExp.mjs";
-export { Paths } from "./src/class/Paths.mjs";
-export { QChannel } from "./src/class/QChannel.mjs";
-export { SafeExit } from "./src/class/SafeExit.mjs";
-export { Setup } from "./src/class/Setup.mjs";
-export { Signal } from "./src/class/Signal.mjs";
-export { WalkThrough } from "./src/class/WalkThrough.mjs";
-export { WorkerMainThread } from "./src/class/WorkerMainThread.mjs";
-export { WorkerResult } from "./src/class/WorkerResult.mjs";
-export { WorkerThread } from "./src/class/WorkerThread.mjs";
-export { Base64URL } from "./src/common/Base64URL.mjs";
-export { Base64URLFromFile } from "./src/common/Base64URLFromFile.mjs";
-export { CreateStringID } from "./src/common/CreateStringID.mjs";
-export { Dev } from "./src/common/Dev.mjs";
-export { EventNameSpace } from "./src/common/EventNameSpace.mjs";
-export { Trace } from "./src/common/Trace.mjs";
-export { TracePath } from "./src/common/TracePath.mjs";
-export { JSautoDOC } from "./src/doc/JSautoDOC.mjs";
-export { CreateImmutable } from "./src/function/CreateImmutable.mjs";
-export { EventCheck } from "./src/function/EventCheck.mjs";
-export { EventObject } from "./src/function/EventObject.mjs";
-export { GetNamedImportAlias } from "./src/function/GetNamedImportAlias.mjs";
-export { GetRuntime } from "./src/function/GetRuntime.mjs";
-export { IsAsync } from "./src/function/IsAsync.mjs";
-export { LazyFactory } from "./src/function/LazyFactory.mjs";
-export { TemplateLiteral } from "./src/function/TemplateLiteral.mjs";
-export { Timeout } from "./src/function/Timeout.mjs";
-export { Tries } from "./src/function/Tries.mjs";
-export { TryAsync } from "./src/function/TryAsync.mjs";
-export { TryNew } from "./src/function/TryNew.mjs";
-export { TrySync } from "./src/function/TrySync.mjs";
-export { TsToMjs } from "./src/function/TsToMjs.mjs";
-export type AnyButUndefined = import("./src/types/AnyButUndefined.mjs").AnyButUndefined;
-export type DevTestCB = import("./src/types/DevTestCB.mjs").DevTestCB;
-export type ExtnameType = import("./src/types/ExtnameType.mjs").ExtnameType;
-export type IsListSignal = import("./src/types/IsListSignal.mjs").IsListSignal;
-export type ListArg = import("./src/types/ListArg.mjs").ListArg;
-export type LitExpKeyType = import("./src/types/LitExpKeyType.mjs").LitExpKeyType;
-export type LitExpResultType<KEYS extends import("./src/types/LitExpKeyType.mjs").LitExpKeyType> = import("./src/types/LitExpResultType.mjs").LitExpResultType<KEYS>;
-export type MutationType = import("./src/types/MutationType.mjs").MutationType;
-export type QCBFIFOReturn = import("./src/types/QCBFIFOReturn.mjs").QCBFIFOReturn;
-export type QCBReturn = import("./src/types/QCBReturn.mjs").QCBReturn;
-export type Runtime = import("./src/types/Runtime.mjs").Runtime;
-export type VivthDevCodeBlockStringType = import("./src/types/VivthDevCodeBlockStringType.mjs").VivthDevCodeBlockStringType;

package/types/src/bundler/CompileJS.d.mts

@@ -1,119 +0,0 @@
-/**
- * @description
- * - function to compile `.ts`|`.mts`|`.mjs` file, into a single executable;
- * - also generate js representation of the `bundled` version of the target;
- * - uses [pkg](https://www.npmjs.com/package/pkg), [bun](https://bun.com/docs/bundler/executables), and [deno](https://docs.deno.com/runtime/reference/cli/compile/) compiler under the hood;
- * >- they are used only as packaging/compiler agent, and doesn't necessarily supports their advanced feature, such as, assets bundling(use [`FSInline`](#fsinline) instead);
- * >- `WorkerThread` will be converted to inline using `FSInline` too;
- *
- * !!!WARNING!!!
- * !!!WARNING!!!
- * !!!WARNING!!!
- *
- * - This function does not obfuscate and will not prevent decompilation. Do not embed environment variables or sensitive information inside `options.entryPoint`;
- * - It is designed for quick binarization, allowing execution on machines without `Node.js`, `Bun`, or `Deno` installed;
- * - The resulting binary will contain `FSInline` and `WorkerMainThread` target paths Buffers, which are loaded into memory at runtime. If your logic depends on the file system, use `node:fs` or `node:fs/promises` APIs and ship external files alongside the binary (not compiled);
- *
- * !!!WARNING!!!
- * !!!WARNING!!!
- * !!!WARNING!!!
- *
- * @param {Object} options
- * @param {string} options.entryPoint
- * - need to be manually prefixed;
- * @param {BufferEncoding} [options.encoding]
- * - read and write encoding for the sources;
- * - default: `utf-8`;
- * @param {(entryPointContent:string)=>string} [options.preprocessEntryPoint]
- * - to modify entry point before bundling;
- * - `entryPointContent` is the original string of the entry point;
- * - returned value then passed to `ESBundler`;
- * @param {boolean} options.minifyFirst
- * - minify the bundle before compilation;
- * @param {string} options.outDir
- * - need manual prefix;
- * @param {'pkg'|'bun'|'deno'} [options.compiler]
- * - default: no comilation, just bundling;
- * - `bun` and `pkg` is checked, if there's bug on `deno`, please report on github for issues;
- * @param {Record<string, string>} [options.compilerArguments]
- * - `key` are to used as `--keyName`;
- * - value are the following value of the key;
- * - no need to add the output/outdir, as it use the `options.outDir`;
- * @param {ReturnType<CreateESPlugin>[]} [options.esBundlerPlugins]
- * - plugins for `EsBundler`;
- * @return {ReturnType<typeof TryAsync<{compileResult:Promise<any>|undefined,
- * commandCalled: string|undefined;
- * compiledBinFile: string|undefined;
- * bundledJSFile:string|undefined
- * }>>}
- * @example
- * import process from 'node:process';
- * import { join } from 'node:path';
- *
- * import { CompileJS, Console, Paths, Setup } from 'vivth';
- *
- * const { paths, safeExit } = Setup;
- * new paths({
- * 	root: process.env.INIT_CWD ?? process.cwd(),
- * });
- * new safeExit({
- * 	eventNames: ['SIGINT', 'SIGTERM'],
- * 	terminator: () => process.exit(0),
- * 	listener: (eventName) => {
- * 		process.once(eventName, function () {
- * 			if (!safeExit.instance) {
- * 				return;
- * 			}
- * 			safeExit.instance.exiting.correction(true);
- * 			Console.log(`safe exit via "${eventName}"`);
- * 		});
- * 	},
- * });
- * const pathRoot = Paths.root;
- * if (pathRoot) {
- * 	const [[, error], [, errorbun]] = await Promise.all([
- * 		CompileJS({
- * 			entryPoint: join(pathRoot, '/dev/myEntryPoint.mjs'),
- * 			minifyFirst: true,
- * 			outDir: join(pathRoot, '/dev-pkg/'),
- * 			compiler: 'pkg',
- * 			compilerArguments: {
- * 				target: 'node18-win-x64',
- * 			},
- * 			encoding: 'utf-8',
- * 		}),
- * 		await CompileJS({
- * 			entryPoint: join(pathRoot, '/dev/myEntryPoint.mjs'),
- * 			minifyFirst: true,
- * 			outDir: join(pathRoot, '/dev-bun/'),
- * 			compiler: 'bun',
- * 			compilerArguments: {
- * 				target: 'bun-win-x64',
- * 			},
- * 			encoding: 'utf-8',
- * 		}),
- * 	]);
- * 	if (error || errorbun) {
- * 		Console.error({ error, errorbun });
- * 	}
- * }
- *
- */
-export function CompileJS({ entryPoint, minifyFirst, encoding, outDir, preprocessEntryPoint, compiler, compilerArguments, esBundlerPlugins, }: {
-    entryPoint: string;
-    encoding?: BufferEncoding | undefined;
-    preprocessEntryPoint?: ((entryPointContent: string) => string) | undefined;
-    minifyFirst: boolean;
-    outDir: string;
-    compiler?: "pkg" | "bun" | "deno" | undefined;
-    compilerArguments?: Record<string, string> | undefined;
-    esBundlerPlugins?: import("esbuild").Plugin[] | undefined;
-}): ReturnType<typeof TryAsync<{
-    compileResult: Promise<any> | undefined;
-    commandCalled: string | undefined;
-    compiledBinFile: string | undefined;
-    bundledJSFile: string | undefined;
-}>>;
-export type PlatformKey = "win32" | "linux" | "darwin" | string;
-export type CreateESPlugin = typeof import("./CreateESPlugin.mjs")["CreateESPlugin"];
-import { TryAsync } from '../function/TryAsync.mjs';