vivth 1.2.3 → 1.3.0

package/tsconfig.json

@@ -1,14 +1,36 @@
 {
 	"compilerOptions": {
-		"allowJs": true,
+		"checkJs": true,
 		"declaration": true,
 		"emitDeclarationOnly": true,
 		"outDir": "./types",
-		"module": "esnext",
-		"target": "esnext",
-		"moduleResolution": "node",
 		"esModuleInterop": true,
-		"skipLibCheck": true
+		"removeComments": false,
+
+		// Environment setup & latest features
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "Preserve",
+		"moduleDetection": "force",
+		"allowJs": true,
+
+		// Bundler mode
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": false,
+
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedIndexedAccess": true,
+		"noImplicitOverride": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false
 	},
 	"include": ["./index.mjs", "./src", "./dev"]
 }

package/types/dev/workerThreadClass.d.mts

@@ -4,7 +4,7 @@
  */
 export const workerThreadClass: {
     new (handler: (ev: any, isLastOnQ: () => boolean) => any): WorkerThread<any, any>;
-    #refs: Parameters<(typeof WorkerThread)["setup"]>[0];
+    #refs: Parameters<(typeof WorkerThread)["setup"]>[0] | undefined;
     setup<RECEIVE, POST>(refs: {
         parentPort: typeof import("worker_threads")["parentPort"];
     }): typeof WorkerThread<RECEIVE, POST>;

package/types/index.d.mts

@@ -1,8 +1,9 @@
+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 { CompileJS } from "./src/bundler/CompileJS.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";
@@ -10,29 +11,28 @@ 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 { Console } from "./src/class/Console.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 { LitExp } from "./src/class/LitExp.mjs";
+export { CreateImmutable } from "./src/function/CreateImmutable.mjs";
 export { EventCheck } from "./src/function/EventCheck.mjs";
 export { EventObject } from "./src/function/EventObject.mjs";
-export { IsAsync } from "./src/function/IsAsync.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";
 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 { Base64URL } from "./src/common/Base64URL.mjs";
-export { CreateImmutable } from "./src/function/CreateImmutable.mjs";
 export { WorkerResult } from "./src/class/WorkerResult.mjs";
 export { WorkerThread } from "./src/class/WorkerThread.mjs";
 export { ToBundledJSPlugin } from "./src/bundler/adds/ToBundledJSPlugin.mjs";
@@ -41,6 +41,7 @@ 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;

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

@@ -37,10 +37,10 @@
  * - no need to add the output/outdir, as it use the `options.outDir`;
  * @param {ReturnType<CreateESPlugin>[]} [options.esBundlerPlugins]
  * - plugins for `EsBundler`;
- * @return {ReturnType<TryAsync<{compileResult:Promise<any>,
- * commandCalled: string;
- * compiledBinFile: string;
- * bundledJSFile:string
+ * @return {ReturnType<typeof TryAsync<{compileResult:Promise<any>|undefined,
+ * commandCalled: string|undefined;
+ * compiledBinFile: string|undefined;
+ * bundledJSFile:string|undefined
  * }>>}
  * @example
  * import { join } from 'node:path';
@@ -72,13 +72,18 @@
  */
 export function CompileJS({ entryPoint, minifyFirst, encoding, outDir, compiler, compilerArguments, esBundlerPlugins, }: {
     entryPoint: string;
-    encoding?: BufferEncoding;
+    encoding?: BufferEncoding | undefined;
     minifyFirst: boolean;
     outDir: string;
-    compiler?: "pkg" | "bun" | "deno";
-    compilerArguments?: Record<string, string>;
-    esBundlerPlugins?: ReturnType<CreateESPlugin>[];
-}): ReturnType<typeof TryAsync>;
+    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';

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

@@ -30,7 +30,7 @@ export function EsBundler({ content, extension, root, withBinHeader }: {
     content: string;
     root: string;
     extension: ".mts" | ".ts" | ".mjs";
-    withBinHeader?: boolean;
+    withBinHeader?: boolean | undefined;
 }, 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/class/Derived.d.mts

@@ -9,7 +9,7 @@ export class Derived<VALUE> extends Signal<VALUE> {
      * @description
      * - Derived used [Signal](#signal) and [Effect](#effect) under the hood;
      * @param {(effectInstanceOptions:Omit<Effect["options"] &
-     * Derived["options"], unwrapLazy>) =>
+     * Derived<VALUE>["options"], unwrapLazy>) =>
      * Promise<VALUE>} derivedFunction
      * @example
      * import { Signal, Derived } from  'vivth';
@@ -27,67 +27,7 @@ export class Derived<VALUE> extends Signal<VALUE> {
      *
      * count.value++;
      */
-    constructor(derivedFunction: (effectInstanceOptions: Omit<Effect["options"] & ({
-        /**
-         * @instance options
-         * @description
-         * - return this value tandem with `isLastCalled`, to not to update the value of this instance, even when returning early;
-         * @type {Object}
-         * @example
-         * import { Signal, Derived } from  'vivth';
-         *
-         * const count = new Signal(0);
-         * const double = new Derived(async({
-         * 		subscribe,
-         * 		dontUpdate,
-         * 		isLastCalled,
-         * 	}) => {
-         * 		const currentValue = subscribe(count).value;
-         * 		if (!(await isLastCalled(10))) {
-         *			return dontUpdate;
-         * 		}
-         * 		const res = await fetch(`some/path/${curentValue.toString()}`);
-         * 		if (!(await isLastCalled())) {
-         *			return dontUpdate; // this will prevent race condition, even if the earlier fetch return late;
-         * 		}
-         * 		return res;
-         * });
-         *
-         * count.value++;
-         */
-        dontUpdate: any;
-    } & {
-        "vivth:unwrapLazy;": () => {
-            /**
-             * @instance options
-             * @description
-             * - return this value tandem with `isLastCalled`, to not to update the value of this instance, even when returning early;
-             * @type {Object}
-             * @example
-             * import { Signal, Derived } from  'vivth';
-             *
-             * const count = new Signal(0);
-             * const double = new Derived(async({
-             * 		subscribe,
-             * 		dontUpdate,
-             * 		isLastCalled,
-             * 	}) => {
-             * 		const currentValue = subscribe(count).value;
-             * 		if (!(await isLastCalled(10))) {
-             *			return dontUpdate;
-             * 		}
-             * 		const res = await fetch(`some/path/${curentValue.toString()}`);
-             * 		if (!(await isLastCalled())) {
-             *			return dontUpdate; // this will prevent race condition, even if the earlier fetch return late;
-             * 		}
-             * 		return res;
-             * });
-             *
-             * count.value++;
-             */
-            dontUpdate: any;
-        };
-    }), "vivth:unwrapLazy;">) => Promise<VALUE>);
+    constructor(derivedFunction: (effectInstanceOptions: Omit<Effect["options"] & Derived<VALUE>["options"], "vivth:unwrapLazy;">) => Promise<VALUE>);
     /**
      * @description
      * - additional helper to be accessed on effect;
@@ -120,7 +60,7 @@ export class Derived<VALUE> extends Signal<VALUE> {
          *
          * count.value++;
          */
-        dontUpdate: any;
+        dontUpdate: Object;
     } & {
         "vivth:unwrapLazy;": () => {
             /**
@@ -150,7 +90,7 @@ export class Derived<VALUE> extends Signal<VALUE> {
              *
              * count.value++;
              */
-            dontUpdate: any;
+            dontUpdate: Object;
         };
     };
 }

package/types/src/class/Effect.d.mts

@@ -71,9 +71,9 @@ export class Effect {
          * @instance options
          * @description
          * - normally it's passed as argument to constructor, however it is also accessible from `options` property;
-         * @template {Signal} SIGNAL
-         * @param {SIGNAL} signal
-         * @returns {SIGNAL}
+         * @template V
+         * @param {Signal<V>} signal
+         * @returns {Signal<V>}
          * @example
          * import { Effect } from 'vivth';
          *
@@ -82,7 +82,7 @@ export class Effect {
          * })
          * effect.options.subscribe(signalInstance);
          */
-        subscribe: <SIGNAL extends Signal<any>>(signal: SIGNAL) => SIGNAL;
+        subscribe: <V>(signal: Signal<V>) => Signal<V>;
         /**
          * @instance options
          * @description
@@ -127,9 +127,9 @@ export class Effect {
              * @instance options
              * @description
              * - normally it's passed as argument to constructor, however it is also accessible from `options` property;
-             * @template {Signal} SIGNAL
-             * @param {SIGNAL} signal
-             * @returns {SIGNAL}
+             * @template V
+             * @param {Signal<V>} signal
+             * @returns {Signal<V>}
              * @example
              * import { Effect } from 'vivth';
              *
@@ -138,7 +138,7 @@ export class Effect {
              * })
              * effect.options.subscribe(signalInstance);
              */
-            subscribe: <SIGNAL extends Signal<any>>(signal: SIGNAL) => SIGNAL;
+            subscribe: <V>(signal: Signal<V>) => Signal<V>;
             /**
              * @instance options
              * @description

package/types/src/class/EnvSignal.d.mts

@@ -1,6 +1,5 @@
 /**
  * @description
- * - non browser API;
  * - uses [Signal](#signal) and [Derived](#derived) under the hood;
  * @template VALUE
  */

package/types/src/class/EventSignal.d.mts

@@ -12,7 +12,7 @@ export class EventSignal<ISLIST extends boolean> {
     /**
      * @description
      * - `Map` of `EventSignal`, using the `stringName` of the `EventSignal_instance` as `key`;
-     * @type {Map<string, EventSignal>}
+     * @type {Map<string, EventSignal<any>>}
      */
     static map: Map<string, EventSignal<any>>;
     /**
@@ -26,13 +26,13 @@ export class EventSignal<ISLIST extends boolean> {
      * >- the `Promise` nature is to prevent race condition on creating the instance;
      * @param {string} stringName
      * @param {IsListSignal} [isList_]
-     * @returns {Promise<EventSignal>}
+     * @returns {Promise<EventSignal<any>>}
      * @example
      * import { EventSignal } from 'vivth';
      *
      * const myEventSignal = await EventSignal.get('dataEvent');
      */
-    static get(stringName: string, isList_?: boolean): Promise<EventSignal<any>>;
+    static get: (stringName: string, isList_?: boolean) => Promise<EventSignal<any>>;
     /**
      * @description
      * - methods of this static property is lazily created;
@@ -132,7 +132,7 @@ export class EventSignal<ISLIST extends boolean> {
      * - is [Signal](#signal) or [ListSignal](#listsignal) instance, depending on the `isList` argument;
      * - if needed to pass along the messages, it can be used as `dispatcher` and `listener` at the same time;
      * - is `lazily` created;
-     * @type {Signal|ListSignal}
+     * @type {Signal<any>|ListSignal<any>}
      * @example
      * import { EventSignal, Effect, Console } from 'vivth';
      *
@@ -151,7 +151,7 @@ export class EventSignal<ISLIST extends boolean> {
      * - is [Derived](#derived) or [ListDerived](#listderived) instance, depending on the `isList` argument;
      * - can be used as listener when passed down value shouldn't be modified manually;
      * - is `lazily` created along with `dispatch`, if `listen` is accessed first, then `dispatch` will also be created automatically;
-     * @type {Derived|ListDerived}
+     * @type {Derived<any>|ListDerived<any>}
      * @example
      * import { EventSignal, Effect, Console } from 'vivth';
      *

package/types/src/class/FileSafe.d.mts

@@ -73,14 +73,14 @@ export class FileSafe {
      * - also returning promise of result & error as value;
      * @param {Parameters<mkdir>[0]} outDir
      * - absolute path
-     * @returns {ReturnType<typeof TryAsync<string>>}
+     * @returns {ReturnType<typeof TryAsync<string|undefined>>}
      * @example
      * import { join } from 'node:path';
      * import { FileSafe, Paths } from 'vivth';
      *
      * const [str, errorMkDir] = await FileSafe.mkdir(join(Paths.root, '/some/path/example'));
      */
-    static mkdir: (outDir: Parameters<typeof mkdir>[0]) => ReturnType<typeof TryAsync<string>>;
+    static mkdir: (outDir: Parameters<typeof mkdir>[0]) => ReturnType<typeof TryAsync<string | undefined>>;
 }
 import { TryAsync } from '../function/TryAsync.mjs';
 import { writeFile } from 'node:fs/promises';

package/types/src/class/ListSignal.d.mts

@@ -16,7 +16,7 @@ export class ListSignal<LISTARG extends import("../types/ListArg.mjs").ListArg>
      * @param {unknown} value - The value to validate.
      * @returns {value is Array<Record<string, string>>} True if the first item is a valid string record or array is empty.
      */
-    static isValid: (value: unknown) => value is Array<Record<string, string>>;
+    static isValid(value: unknown): value is Array<Record<string, string>>;
     /**
      * @description
      * - usefull for `loops`;

package/types/src/class/LitExp.d.mts

@@ -13,6 +13,19 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
     /**
      * @typedef {import("../types/LitExpKeyType.mjs").LitExpKeyType} LitExpKeyType
      */
+    /**
+     * @description
+     * - to escape special chars from string literal;
+     * - returned value can be used to create instance of RegExp;
+     * @param {string} string
+     * @returns {string}
+     * @example
+     * import { LitExp } from 'vivt';
+     *
+     * const escapedLiteral = LitExp.escape(`something[][;alerk325]`);
+     * new RegExp(escapedLiteral, 'g');
+     */
+    static escape: (string: string) => string;
     /**
      * @description
      * - constructor helper;
@@ -52,7 +65,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
      * 	// recommended to end the template literal with any string but `key`;
      * })()
      */
-    static prepare: (keysAndDefaultValuePair: KEYS_1) => ReturnType<typeof TrySync<(templateStringArray: TemplateStringsArray, ...values: (keyof KEYS_1)[]) => LitExp<KEYS_1>>>;
+    static prepare<KEYS_1 extends import("../types/LitExpKeyType.mjs").LitExpKeyType>(keysAndDefaultValuePair: KEYS_1): ReturnType<typeof TrySync<(templateStringArray: TemplateStringsArray, ...values: (keyof KEYS_1)[]) => LitExp<KEYS_1>>>;
     /**
      * @template {LitExpKeyType} KEYS
      * @param {KEYS} instance_rules
@@ -61,14 +74,14 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
      * @param {TemplateStringsArray} strings
      * @returns {ReturnType<typeof TrySync<string[]>>}
      */
-    static #processTemplate: (instance_rules: KEYS_1, intance_values: (keyof KEYS_1)[], valueHandler: (value: keyof KEYS_1, regex: RegExp | false) => ReturnType<typeof TrySync<string>>, strings: TemplateStringsArray) => ReturnType<typeof TrySync<string[]>>;
+    static #processTemplate<KEYS_1 extends import("../types/LitExpKeyType.mjs").LitExpKeyType>(instance_rules: KEYS_1, intance_values: (keyof KEYS_1)[], valueHandler: (value: keyof KEYS_1, regex: RegExp | false) => ReturnType<typeof TrySync<string>>, strings: TemplateStringsArray): ReturnType<typeof TrySync<string[]>>;
     /**
      * @template {LitExpKeyType} KEYS
      * @param {RegExp|false} regex
      * @param {keyof KEYS} value
      * @returns {ReturnType<typeof TrySync<string>>}
      */
-    static #namedChapture: (value: keyof KEYS_1, regex: RegExp | false) => ReturnType<typeof TrySync<string>>;
+    static #namedChapture<KEYS_1 extends import("../types/LitExpKeyType.mjs").LitExpKeyType>(value: keyof KEYS_1, regex: RegExp | false): ReturnType<typeof TrySync<string>>;
     /**
      * @private
      * @param {KEYS} keys
@@ -76,6 +89,11 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
      * @param {...(keyof KEYS)} values
      */
     private constructor();
+    /**
+     * @typedef {ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>} ExecGroups
+     * @typedef {ExecGroups extends [infer First, ...any] ? First : undefined} FirstGroup
+     * @typedef {FirstGroup extends { result: any } ? Partial<FirstGroup["result"]> : undefined} Overrides
+     */
     /**
      * @description
      * - instance methods for generating things;
@@ -85,8 +103,8 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          * @instance make
          * @description
          * - to make string based on the template literal;
-         * @param {Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]} overrides
-         * @returns {string}
+         * @param {Partial<{ [K in keyof KEYS]?: string }>} overrides
+         * @returns {string|undefined}
          * @example
          * import { LitExp } from 'vivth';
          *
@@ -103,15 +121,15 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          *
          * console.log(result); // "templateLiteral:actualvalue;"
          */
-        string: (overrides: Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]) => string;
+        string: (overrides: Partial<{ [K in keyof KEYS]?: string; }>) => string | undefined;
     } & {
         "vivth:unwrapLazy;": () => {
             /**
              * @instance make
              * @description
              * - to make string based on the template literal;
-             * @param {Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]} overrides
-             * @returns {string}
+             * @param {Partial<{ [K in keyof KEYS]?: string }>} overrides
+             * @returns {string|undefined}
              * @example
              * import { LitExp } from 'vivth';
              *
@@ -128,7 +146,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              *
              * console.log(result); // "templateLiteral:actualvalue;"
              */
-            string: (overrides: Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]) => string;
+            string: (overrides: Partial<{ [K in keyof KEYS]?: string; }>) => string | undefined;
         };
     };
     /**
@@ -179,11 +197,11 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          * console.log(whole); // "templateLiteral:Something;"
          * console.log(myKey); // "Something"
          */
-        execGroups: (string: string, options: {
+        execGroups(string: string, options: {
             flags: ConstructorParameters<typeof RegExp>[1];
             whiteSpaceSensitive: boolean;
             absoluteLeadAndFollowing: boolean;
-        }) => ReturnType<typeof TrySync<{
+        }): ReturnType<typeof TrySync<{
             result: {
                 whole: string;
                 named: Record<keyof KEYS, string>;
@@ -196,8 +214,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          * - to match all and grouped based on `key`;
          * @param {Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0]} string
          * @param {Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], 'absoluteLeadAndFollowing'>} options
-         * @returns {ReturnType<typeof TrySync<{result:{whole:string[], named:Array<Record<keyof KEYS, string>>},
-         * regexp: RegExp}>>
+         * @returns {ReturnType<typeof TrySync<import('../types/LitExpResultType.mjs').LitExpResultType<KEYS>>>
          * }
          * @example
          * import { LitExp, Console } from 'vivth';
@@ -221,29 +238,19 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          * 		return;
          * 	}
          * 	const {
-         * 		result: {
-         * 				whole: [whole0, whole1],
-         * 				named: [
-         * 					{ myKey: myKeyExec0, },
-         * 					{ myKey: myKeyExec1, },
-         * 				],
-         * 			},
+         * 		result: { whole, named },
          * 		regexp
          * 	} = resultOfMatchedAllAndGrouped;
          *
-         * 	console.log(whole0); // "templateLiteral:Something;"
-         * 	console.log(whole1); // "templateLiteral:SomethingElse;"
-         * 	console.log(myKeyExec0); // "Something"
-         * 	console.log(myKeyExec1); // "SomethingElse"
+         *	named.foreach(({myKey})=>{
+         *		// code
+         *	})
+         *	whole.foreach((capturedString)=>{
+         *		// code
+         *	})
          * })()
          */
-        matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<{
-            result: {
-                whole: string[];
-                named: Array<Record<keyof KEYS, string>>;
-            };
-            regexp: RegExp;
-        }>>;
+        matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<import("../types/LitExpResultType.mjs").LitExpResultType<KEYS>>>;
     } & {
         "vivth:unwrapLazy;": () => {
             /**
@@ -289,11 +296,11 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              * console.log(whole); // "templateLiteral:Something;"
              * console.log(myKey); // "Something"
              */
-            execGroups: (string: string, options: {
+            execGroups(string: string, options: {
                 flags: ConstructorParameters<typeof RegExp>[1];
                 whiteSpaceSensitive: boolean;
                 absoluteLeadAndFollowing: boolean;
-            }) => ReturnType<typeof TrySync<{
+            }): ReturnType<typeof TrySync<{
                 result: {
                     whole: string;
                     named: Record<keyof KEYS, string>;
@@ -306,8 +313,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              * - to match all and grouped based on `key`;
              * @param {Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0]} string
              * @param {Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], 'absoluteLeadAndFollowing'>} options
-             * @returns {ReturnType<typeof TrySync<{result:{whole:string[], named:Array<Record<keyof KEYS, string>>},
-             * regexp: RegExp}>>
+             * @returns {ReturnType<typeof TrySync<import('../types/LitExpResultType.mjs').LitExpResultType<KEYS>>>
              * }
              * @example
              * import { LitExp, Console } from 'vivth';
@@ -331,29 +337,19 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              * 		return;
              * 	}
              * 	const {
-             * 		result: {
-             * 				whole: [whole0, whole1],
-             * 				named: [
-             * 					{ myKey: myKeyExec0, },
-             * 					{ myKey: myKeyExec1, },
-             * 				],
-             * 			},
+             * 		result: { whole, named },
              * 		regexp
              * 	} = resultOfMatchedAllAndGrouped;
              *
-             * 	console.log(whole0); // "templateLiteral:Something;"
-             * 	console.log(whole1); // "templateLiteral:SomethingElse;"
-             * 	console.log(myKeyExec0); // "Something"
-             * 	console.log(myKeyExec1); // "SomethingElse"
+             *	named.foreach(({myKey})=>{
+             *		// code
+             *	})
+             *	whole.foreach((capturedString)=>{
+             *		// code
+             *	})
              * })()
              */
-            matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<{
-                result: {
-                    whole: string[];
-                    named: Array<Record<keyof KEYS, string>>;
-                };
-                regexp: RegExp;
-            }>>;
+            matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<import("../types/LitExpResultType.mjs").LitExpResultType<KEYS>>>;
         };
     };
     #private;

package/types/src/class/Paths.d.mts

@@ -6,18 +6,18 @@
  */
 export class Paths {
     /**
-     * @type {Paths}
+     * @type {Paths|undefined}
      */
-    static #instance: Paths;
+    static #instance: Paths | undefined;
     /**
      * @description
      * - reference for rootPath
      * - `Paths` needed to be instantiated via:
      * >- `Paths` constructor;
      * >- `Setup.paths` constructor;
-     * @type {string}
+     * @type {string|undefined}
      */
-    static get root(): string;
+    static get root(): string | undefined;
     /**
      * @description
      * - normalize path separator to forward slash `/`;

package/types/src/class/QChannel.d.mts

@@ -30,7 +30,7 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
      * - ensures that each id has only one task running at a time.
      * - calls with the same id will wait for the previous call to finish.
      * @param {AnyButUndefined} id
-     * @param {QChannel} instance
+     * @param {QChannel<any>} instance
      * @returns {Promise<QCBReturn>} Resolves when it's safe to proceed for the given id, returning a cleanup function
      */
     static #uniqueCB: (id: import("../types/AnyButUndefined.mjs").AnyButUndefined, instance: QChannel<any>) => Promise<import("../types/QCBReturn.mjs").QCBReturn>;

package/types/src/class/SafeExit.d.mts

@@ -12,9 +12,9 @@ export class SafeExit {
     /**
      * @description
      * - only accessible after instantiation;
-     * @type {SafeExit}
+     * @type {SafeExit|undefined}
      */
-    static instance: SafeExit;
+    static instance: SafeExit | undefined;
     /**
      * @description
      * @param {Object} options
@@ -76,7 +76,7 @@ export class SafeExit {
     constructor({ eventNames, terminator, listener }: {
         eventNames: [string, ...string[]];
         terminator: () => void;
-        listener?: (eventName: string) => void;
+        listener?: ((eventName: string) => void) | undefined;
     });
     /**
      * @description