vivth 1.1.2 → 1.2.1

package/src/function/LazyFactory.mjs

@@ -6,14 +6,15 @@ import { unwrapLazy } from '../common/lazie.mjs';
  * @description
  * - function helper for creating lazyObject:
  * >- usefull for lazily instantiating an object, since instance naturally have props/methods;
- * @template T
- * @param {() => T} factory
- * @returns {T & {[unwrapLazy]: string}}
+ * @template FACTORY
+ * @param {() => FACTORY} factory
+ * @returns {FACTORY & {[unwrapLazy]: ()=> FACTORY}}
  * - the unwrapLazy prop can be accessed to force instatiation/call;
  * >- `unwrapLazy` prop name can be checked by checking the list of possible prop, from your ide;
- * >- as of version 1.0.0, value is `vivth:unwrapLazy;`;
+ * >- as of version `1.0.0`, value is `vivth:unwrapLazy;`;
  * @example
  * import { LazyFactory } from  'vivth';
+ *
  * class MyClass{
  *    constructor() {
  *      this.myProp = 1; // will only available when accessed;
@@ -31,29 +32,28 @@ import { unwrapLazy } from '../common/lazie.mjs';
  *
  * const a = myInstance; // not yet initiated;
  * const b = a.myProp // imediately initiated;
+ * // OR
+ * myInstance["vivth:unwrapLazy;"]() // forcefully call the callback;
  */
-export const LazyFactory = (factory) => {
+export function LazyFactory(factory) {
 	let instance;
 	// @ts-expect-error
 	return new Proxy(
 		{},
 		{
 			get(_, prop) {
-				if (!instance) {
-					instance = factory();
-				}
 				if (prop === unwrapLazy) {
 					if (!instance) {
 						instance = factory();
 					}
-					return instance;
+					return () => instance;
+				}
+				if (!instance) {
+					instance = factory();
 				}
 				return instance[prop];
 			},
 			set(_, prop, newValue) {
-				if (prop === unwrapLazy) {
-					instance = factory();
-				}
 				if (!instance) {
 					instance = factory();
 				}
@@ -68,4 +68,4 @@ export const LazyFactory = (factory) => {
 			},
 		}
 	);
-};
+}

package/src/function/Timeout.mjs

@@ -16,8 +16,8 @@
  * }
  * test();
  */
-export const Timeout = (timeMS) => {
+export function Timeout(timeMS) {
 	return new Promise((resolve) => {
 		setTimeout(resolve, timeMS);
 	});
-};
+}

package/src/function/Try.mjs

@@ -1,5 +1,6 @@
 // @ts-check
 
+import { Console } from '../class/Console.mjs';
 import { TryAsync } from './TryAsync.mjs';
 
 /**
@@ -9,28 +10,28 @@ import { TryAsync } from './TryAsync.mjs';
  * - usefull to flatten indentation for error handlings;
  * - caveat:
  * >- run in sequence, awaiting each key bofore running next key;
- * @template {string} Key
- * @template ReturnType_
+ * @template {string} KEY
+ * @template RETURNTYPE
  * @template {Record<
- * 	Key,
- * 	() => Promise<ReturnType_>
+ * 	KEY,
+ * 	(err:{prevError:undefined|Error}) => Promise<RETURNTYPE>
  * >} RecordTryType
  * @param {RecordTryType} tryRecord
  * @returns {Promise<
- * 	[[keyof RecordTryType, ReturnType_], undefined]
+ * 	[[keyof RecordTryType, RETURNTYPE], undefined]
  * 	| [[undefined, undefined], Error]
  * >}
  * @example
  * import { Try } from 'vivth';
  *
  * const [[key, result], error] = await Try({
- * 	someRuntime: async () => {
+ * 	someRuntime: async ( prevError ) => {
  * 		// asuming on this one doesn't naturally throw error,
  * 		// yet you need to continue to next key,
  * 		// instead of returning,
  * 		// you should throw new Error(something);
  * 	},
- * 	browser: async () => {
+ * 	browser: async ( prevError ) => {
  * 		return location?.origin;
  * 		// if no error, stop other key function from running;
  * 		// key = 'browser'
@@ -39,7 +40,7 @@ import { TryAsync } from './TryAsync.mjs';
  * 		// if error;
  * 		// run nodeOrBun;
  * 	},
- * 	nodeOrBun: async () => {
+ * 	nodeOrBun: async ( prevError ) => {
  * 		return process?.env?.INIT_CWD ?? process?.cwd();
  * 		// if no error;
  * 		// key = 'nodeOrBun'
@@ -51,14 +52,18 @@ import { TryAsync } from './TryAsync.mjs';
  * 	},
  * });
  */
-export const Try = async (tryRecord) => {
+export async function Try(tryRecord) {
+	let prevError = undefined;
 	for (const key in tryRecord) {
 		const callback = tryRecord[key];
-		const [result, error] = await TryAsync(callback);
+		const [result, error] = await TryAsync(async () => {
+			return await callback({ prevError });
+		});
 		if (error) {
+			prevError = error;
 			continue;
 		}
 		return [[key, result], undefined];
 	}
-	return [[undefined, undefined], new Error('unable to run any key')];
-};
+	return [[undefined, undefined], prevError];
+}

package/src/function/TryAsync.mjs

@@ -4,9 +4,9 @@
  * @description
  * - function for error as value for asynchronous operation;
  * - usefull to flatten indentation for error handlings;
- * @template ResultType
- * @param {()=>Promise<ResultType>} asyncFunction_
- * @returns {Promise<[ResultType|undefined, Error|undefined]>}
+ * @template RESULT
+ * @param {()=>Promise<RESULT>} asyncFunction_
+ * @returns {Promise<[RESULT|undefined, Error|undefined]>}
  * @example
  * import { TryAsync } from 'vivth';
  *
@@ -21,11 +21,11 @@
  * 	return await res.json();
  * })
  */
-export const TryAsync = async (asyncFunction_) => {
+export async function TryAsync(asyncFunction_) {
 	try {
 		const result = await asyncFunction_();
 		return [result, undefined];
 	} catch (error) {
 		return [undefined, error];
 	}
-};
+}

package/src/function/TrySync.mjs

@@ -4,9 +4,9 @@
  * @description
  * - function for error as value for synchronous operation;
  * - usefull to flatten indentation for error handlings;
- * @template ResultType
- * @param {()=>ResultType} function_
- * @returns {[ResultType|undefined, Error|undefined]}
+ * @template RESULT
+ * @param {()=>RESULT} function_
+ * @returns {[RESULT|undefined, Error|undefined]}
  * @example
  * import { readFileSync } from 'fs';
  * import { TrySync } from './yourModule.js';
@@ -15,11 +15,11 @@
  * 	return readFileSync('./some/file.txt', 'utf-8');
  * });
  */
-export const TrySync = (function_) => {
+export function TrySync(function_) {
 	try {
 		const result = function_();
 		return [result, undefined];
 	} catch (error) {
 		return [undefined, error];
 	}
-};
+}

package/src/function/TsToMjs.mjs

@@ -8,7 +8,7 @@ import { transform } from 'esbuild';
 import { Console } from '../class/Console.mjs';
 import { Paths } from '../class/Paths.mjs';
 import { TryAsync } from './TryAsync.mjs';
-import { WriteFileSafe } from './WriteFileSafe.mjs';
+import { FileSafe } from '../class/FileSafe.mjs';
 
 /**
  * @description
@@ -16,6 +16,7 @@ import { WriteFileSafe } from './WriteFileSafe.mjs';
  * - on certain circumstance where `.mjs` result needed to be typed, you need to manually add `jsdoc`;
  * >- uses `"at"preserve` to register `jsdoc` inline;
  * @param {string} path_
+ * - path from `Paths.root`;
  * @param {Object} [options]
  * @param {string} [options.overrideDir]
  * - default: write conversion to same directory;
@@ -28,7 +29,7 @@ import { WriteFileSafe } from './WriteFileSafe.mjs';
  *
  * TsToMjs('./myFile.mts', { encoding: 'utf-8', overrideDir: './other/dir' });
  */
-export const TsToMjs = async (path_, { overrideDir = undefined, encoding = 'utf-8' } = {}) => {
+export async function TsToMjs(path_, { overrideDir = undefined, encoding = 'utf-8' } = {}) {
 	const rootPath = Paths.normalize(Paths.root);
 	if (!Paths.normalize(path_).startsWith(rootPath)) {
 		path_ = Paths.normalize(join(rootPath, path_));
@@ -59,9 +60,9 @@ export const TsToMjs = async (path_, { overrideDir = undefined, encoding = 'utf-
 	}
 	const outputDir = overrideDir ? join(rootPath, overrideDir) : dirname(path_);
 	const outputPath = join(outputDir, basename(path_).replace(ext, '.mjs'));
-	const [_, writeError] = await WriteFileSafe(outputPath, result.code, { encoding });
+	const [_, writeError] = await FileSafe.write(outputPath, result.code, { encoding });
 	if (!writeError) {
 		return;
 	}
 	Console.error(writeError);
-};
+}

package/src/types/LitExpKeyType.mjs

@@ -0,0 +1,5 @@
+// @ts-check
+
+/**
+ * @typedef {Record<string, RegExp|false>} LitExpKeyType
+ */

package/src/types/QCBReturn.mjs

@@ -2,5 +2,5 @@
 
 /**
  * - return type of Q callback;
- * @typedef {{resume:()=>void, isLastOnQ:boolean}} QCBReturn
+ * @typedef {{resume:()=>void, isLastOnQ:()=>boolean}} QCBReturn
  */

package/src/types/Runtime.mjs

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

package/types/dev/fsInline.d.mts

@@ -0,0 +1 @@
+export {};

package/types/dev/test.d.mts

@@ -0,0 +1 @@
+export {};

package/types/dev/testWorker.d.mts

@@ -0,0 +1,7 @@
+/**
+ * @type {WorkerThread<{a:number}, number>}
+ */
+export const testWorker: WorkerThread<{
+    a: number;
+}, number>;
+import { WorkerThread } from '../index.mjs';

package/types/dev/testbundle.d.mts

@@ -0,0 +1 @@
+export {};

package/types/dev/workerThreadClass.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @description
+ * `workerThreadClass` description placeholder;
+ */
+export const workerThreadClass: {
+    new (handler: (ev: any, isLastOnQ: () => boolean) => any): WorkerThread<any, any>;
+    #refs: Parameters<(typeof WorkerThread)["setup"]>[0];
+    setup<RECEIVE, POST>(refs: {
+        parentPort: typeof import("worker_threads")["parentPort"];
+    }): typeof WorkerThread<RECEIVE, POST>;
+    #isCloseWorkerEvent: (ev: any) => boolean;
+};
+import { WorkerThread } from '../index.mjs';

package/types/index.d.mts

@@ -1,26 +1,31 @@
-export { CompileMJS } from "./src/bundler/CompileMJS.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 { 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 { EventNameSpace } from "./src/common/EventNameSpace.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 { GetRuntime } from "./src/function/GetRuntime.mjs";
 export { IsAsync } from "./src/function/IsAsync.mjs";
 export { LazyFactory } from "./src/function/LazyFactory.mjs";
 export { Timeout } from "./src/function/Timeout.mjs";
@@ -28,11 +33,15 @@ export { Try } from "./src/function/Try.mjs";
 export { TryAsync } from "./src/function/TryAsync.mjs";
 export { TrySync } from "./src/function/TrySync.mjs";
 export { TsToMjs } from "./src/function/TsToMjs.mjs";
-export { WriteFileSafe } from "./src/function/WriteFileSafe.mjs";
+export { WorkerResult } from "./src/class/WorkerResult.mjs";
+export { WorkerThread } from "./src/class/WorkerThread.mjs";
+export { ToBundledJSPlugin } from "./src/bundler/adds/ToBundledJSPlugin.mjs";
 export type AnyButUndefined = import("./src/types/AnyButUndefined.mjs").AnyButUndefined;
 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 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;

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

@@ -0,0 +1,78 @@
+/**
+ * @description
+ * - function to compile `.ts`|`.mts`|`.mjs` file, into a single executable;
+ * - also generate js representation;
+ * - 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 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]
+ * - write and read encoding for the sources;
+ * - default: `utf-8`;
+ * @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`;
+ * @return {ReturnType<TryAsync<{compileResult:Promise<any>,
+ * commandCalled: string;
+ * compiledBinFile: string;
+ * bundledJSFile:string
+ * }>>}
+ * @example
+ * import { join } from 'node:path';
+ *
+ * import { CompileJS, Paths } from 'vivth';
+ *
+ * const [[resultPkg, errorPkg], [resultBun, errorBun]] = await Promise.all([
+ * 	CompileJS({
+ * 		entryPoint: join(Paths.root, '/dev'),
+ * 		minifyFirst: true,
+ * 		outDir: join(Paths.root, '/dev-pkg'),
+ * 		compiler: 'pkg',
+ * 		compilerArguments: {
+ * 			target: ['node18-win-x64'],
+ * 		}
+ * 	}),
+ * 	CompileJS({
+ * 		entryPoint: join(Paths.root, '/dev'),
+ * 		minifyFirst: true,
+ * 		outDir: join(Paths.root, '/dev-pkg'),
+ * 		compiler: 'bun',
+ * 		compilerArguments: {
+ * 			target: ['bun-win-x64'],
+ * 		}
+ * 	}),
+ * ])
+ */
+export function CompileJS({ entryPoint, minifyFirst, encoding, outDir, compiler, compilerArguments, }: {
+    entryPoint: string;
+    encoding?: BufferEncoding;
+    minifyFirst: boolean;
+    outDir: string;
+    compiler?: "pkg" | "bun" | "deno";
+    compilerArguments?: Record<string, string>;
+}): ReturnType<typeof TryAsync>;
+export type PlatformKey = "win32" | "linux" | "darwin" | string;
+import { TryAsync } from '../function/TryAsync.mjs';

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

@@ -0,0 +1,17 @@
+/**
+ * @description
+ * - typed esbuild Plugin generator;
+ * @param {string} name
+ * @param {import('esbuild').Plugin["setup"]} setup
+ * @returns {import('esbuild').Plugin}
+ * @example
+ * import { CreateESPlugin } from 'vivth';
+ *
+ * export const pluginAddCopyRight = CreateESPlugin(
+ * 	'MyCopyrightDeclaration',
+ * 	async (build) => {
+ * 		// build script;
+ * 	}
+ * );
+ */
+export function CreateESPlugin(name: string, setup: import("esbuild").Plugin["setup"]): import("esbuild").Plugin;

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

@@ -1,7 +1,36 @@
-export function EsBundler({ content, extension, asBinary }: {
+/**
+ * @description
+ * - opinionated bundler for extension below using esbuild;
+ * - bundles all imports into a single output string;
+ * @param {Object} options
+ * @param {string} options.content
+ * - the code can also uses composites from the result from multiple readFiles;
+ * @param {string} options.root
+ * - use dirname of said fileString path;
+ * @param {'.mts'|'.ts'|'.mjs'} options.extension
+ * @param {boolean} [options.withBinHeader]
+ * @param {Omit<Parameters<build>[0],
+ * 'entryPoints'|'bundle'|'write'|'sourcemap'>
+ * } [esbuildOptions]
+ * @returns {ReturnType<typeof TryAsync<string>>}
+ * @example
+ * import { EsBundler } from 'vivth';
+ *
+ * const bundledString = EsBundler(
+ * 	{
+ * 		content: ``,
+ * 		extension: '.mts',
+ * 		...options
+ * 	},
+ * 	{
+ * 	...esbuildOptions,
+ * });
+ */
+export function EsBundler({ content, extension, root, withBinHeader }: {
     content: string;
-    extension: string;
-    asBinary?: boolean;
-}, esbuildOptions?: Omit<Parameters<typeof build>[0], "entryPoints" | "bundle" | "write" | "format" | "sourcemap" | "external" | "stdin">): Promise<ReturnType<typeof TryAsync<string>>>;
+    root: string;
+    extension: ".mts" | ".ts" | ".mjs";
+    withBinHeader?: boolean;
+}, esbuildOptions?: Omit<Parameters<typeof build>[0], "entryPoints" | "bundle" | "write" | "sourcemap">): ReturnType<typeof TryAsync<string>>;
 import { build } from 'esbuild';
 import { TryAsync } from '../function/TryAsync.mjs';

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

@@ -0,0 +1,43 @@
+/**
+ * @description
+ * - class helper to inline file;
+ * - use only if you are planning to use [CompileJS](#compilejs);
+ */
+export class FSInline {
+    /**
+     * @description
+     * - declare entrypoint of file inlining;
+     * >- on the dev time, it's just regullar `readFile` from `node:fs/promises`;
+     * >- on the compiled, it will read file from `FSInline.vivthFSInlinelists`
+     * @param {string} filePathFromProject
+     * - doesn't require prefix;
+     * @returns {Promise<Buffer<ArrayBuffer>>}
+     * @example
+     * import { FSInline } from 'vivth';
+     *
+     * (await FSInline.vivthFSInlineFile('/assets/text.txt')).toString('utf-8');
+     */
+    static vivthFSInlineFile: (filePathFromProject: string) => Promise<Buffer<ArrayBuffer>>;
+    /**
+     * @description
+     * - declare entrypoint of file inlining, include all files on `dir` and `subdir` that match the `fileRule`;
+     * @param {string} dirPathFromProject
+     * - doesn't require prefix;
+     * @param {RegExp} fileRule
+     * @returns {Promise<typeof FSInline["vivthFSInlineFile"]>}
+     * @example
+     * import { FSInline } from 'vivth';
+     *
+     * export const pngAssets = await FSInline.vivthFSInlineDir('/assets', /.png$/g);
+     */
+    static vivthFSInlineDir: (dirPathFromProject: string, fileRule: RegExp) => Promise<(typeof FSInline)["vivthFSInlineFile"]>;
+    /**
+     * @description
+     * - placeholder for FSInline;
+     * - it's remain publicly accessible so it doesn't mess with regex analyze on bundle;
+     * - shouldn't be manually accessed;
+     * >- access via `FSInline.vivthFSInlineFile` or `FSInline.vivthFSInlineDir`;
+     * @type {Record<string, Buffer<ArrayBuffer>>}
+     */
+    static vivthFSInlinelists: Record<string, Buffer<ArrayBuffer>>;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * @description
+ * - collections of static method to analyze content for `FSInline`;
+ */
+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: (content: string, format: "cjs" | "esm") => ReturnType<typeof TryAsync<string>>;
+    /**
+     * @typedef {{path:string, buffer:Buffer<ArrayBuffer>}[]} _dirReturn
+     */
+    /**
+     * @param {string} dirName
+     * @param {RegExp} ruleForFileFullPath
+     * @returns {Promise<_dirReturn>}
+     */
+    static #dir: (dirName: string, ruleForFileFullPath: RegExp) => Promise<{
+        path: string;
+        buffer: Buffer<ArrayBuffer>;
+    }[]>;
+}
+import { TryAsync } from '../function/TryAsync.mjs';

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

@@ -0,0 +1,22 @@
+export class FSInline {
+    static prefix: string;
+    /**
+     * @param {string} filePathFromProject
+     * @returns {Promise<Buffer<ArrayBuffer>>}
+     */
+    static vivthFSInlineFile: (filePathFromProject: string) => Promise<Buffer<ArrayBuffer>>;
+    /**
+     * @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: (dirPathFromProject: string) => Promise<(typeof FSInline)["vivthFSInlineFile"]>;
+    /**
+     * - to be used as embed placeholder on `bundled` and `compiled`;
+     * @type {Record<string, Buffer<ArrayBufferLike>>}
+     */
+    static vivthFSInlinelists: Record<string, Buffer<ArrayBufferLike>>;
+}

package/types/src/bundler/adds/ToBundledJSPlugin.d.mts

@@ -0,0 +1,16 @@
+/**
+ * @description
+ * - generate `esbuild.Plugin` for changing dev time file into runtime file;
+ * - on using esbuild with this plugin, it will replace any module that have similiar file name but ended with Bundled(before extname);
+ * >- works on `.mts`|`.ts`|`.mjs`|`.cjs`|`.js`;
+ * >- `anyFileName.mjs` -> seek for and use `anyFileNameBundled.mjs`, if not found use `anyFileName.mjs`;
+ * @param {string} includedInPath
+ * - is generalized, you can freely uses forward or backward slash;
+ * @returns {ReturnType<CreateESPlugin>}
+ * @example
+ * import { ToBundledJSPlugin } from 'vivth';
+ *
+ * export const myBundledPlugin = ToBundledJSPlugin('/myProjectName/src/');
+ */
+export function ToBundledJSPlugin(includedInPath: string): ReturnType<typeof CreateESPlugin>;
+import { CreateESPlugin } from '../CreateESPlugin.mjs';

package/types/src/bundler/adds/externals.d.mts

@@ -0,0 +1 @@
+export const externals: string[];

package/types/src/bundler/adds/pluginVivthBundle.d.mts

@@ -0,0 +1 @@
+export const pluginVivthBundle: import("esbuild").Plugin;