vivth 1.4.9 → 1.5.0

package/src/doc/cleanPreserveTypedef.mjs

@@ -0,0 +1,27 @@
+// @ts-check
+
+/**
+ * Checks for a @preserve JSDoc block containing literal '@'+'[blank]'+'typedef'.
+ * Returns the modified string, or false if no such block exists.
+ * @param {string} sourceCode - The full source string/file content.
+ * @returns {string | false} The modified full string, or false if no target block matches.
+ */
+export const cleanPreserveTypedef = (sourceCode) => {
+	// A strict regex that ensures a block has both @preserve AND [blank] inside it
+	const validationRegex = /\/\*\*([\s\S]*?@preserve[\s\S]*?@\[blank\]typedef[\s\S]*?)\*\//i;
+
+	// 1. If the file doesn't have the target block combination, bail out immediately
+	if (!validationRegex.test(sourceCode)) {
+		return false;
+	}
+
+	// 2. We have a guaranteed match, now safely perform the replacement loop
+	const jsDocRegex = /\/\*\*([\s\S]*?)\*\//g;
+
+	return sourceCode.replace(jsDocRegex, (fullMatch, commentContent) => {
+		if (commentContent.includes('@preserve')) {
+			return fullMatch.replace(/@\[blank\]typedef/gi, '@typedef');
+		}
+		return fullMatch;
+	});
+};

package/src/doc/correctBeforeParse.mjs

@@ -7,48 +7,12 @@ import { TryAsync } from '../function/TryAsync.mjs';
 import { Console } from '../class/Console.mjs';
 import { Timeout } from '../function/Timeout.mjs';
 import { LitExp } from '../class/LitExp.mjs';
+import { Preferrence } from '../common/Preferrence.mjs';
 
 /**
  * @typedef {'shouldProceedNextCheck'|'waitForRewrite'|'doNotProcess'} RetType
  */
 
-/**
- * @param {string} path
- * @param {BufferEncoding} [encoding]
- * @returns {Promise<RetType>}
- */
-export const correctBeforeParse = async (path, encoding = 'utf-8') => {
-	const validExportName = basename(path).split('.')[0] ?? '';
-	const firstLetter = validExportName[0];
-	const isStartWithCapital = firstLetter?.toUpperCase() === firstLetter;
-	if (validExportName === '' || isStartWithCapital === false) {
-		return 'doNotProcess';
-	}
-	const content = (await readFile(path, { encoding: 'utf-8' })).toString();
-	const [resFunctionCheck, errorFunctionCheck] = await checkIsFunction(
-		content,
-		validExportName,
-		path,
-		encoding
-	);
-	if (errorFunctionCheck) {
-		return 'doNotProcess';
-	}
-	if (resFunctionCheck === 'waitForRewrite') {
-		return 'waitForRewrite';
-	}
-	const [resClassCheck, errorClassCheck] = await checkIsClass(
-		content,
-		validExportName,
-		path,
-		encoding
-	);
-	if (errorClassCheck) {
-		return 'doNotProcess';
-	}
-	return resClassCheck;
-};
-
 /**
  * @type {(content:string,
  * validExportName:string,
@@ -59,7 +23,7 @@ const checkIsFunction = async (content, validExportName, path, encoding) => {
 	return await TryAsync(async () => {
 		const regexConst = new RegExp(
 			`export\\s+const\\s+${validExportName}\\s+\\=\\s*?(?:async|)\\s*?\\(([\\s\\S]*?)\\)\\s*?\=\>`,
-			'g'
+			'g',
 		);
 		const matches = content.matchAll(regexConst).toArray()[0];
 		const useConst = regexConst.test(content);
@@ -69,9 +33,13 @@ const checkIsFunction = async (content, validExportName, path, encoding) => {
 			const newContent = content.replace(fullString, declaratorReplaceMent);
 			await Timeout(100); // to wait for pretify on autoSave;
 			await writeFile(path, newContent, { encoding });
-			Console.info({
-				vivthJSAutoDoc: `successfully modify '${path}' exported function to regullar function declaration, for correct type emition;`,
-			});
+			Console.info(
+				`successfully modify '${path}' exported function to regullar function declaration, for correct type emition;`,
+
+				{
+					now: true,
+				},
+			);
 			return 'waitForRewrite';
 		}
 		return 'shouldProceedNextCheck';
@@ -91,7 +59,7 @@ const checkIsClass = async (content, validExportName, path, encoding) => {
 		 */
 		async () => {
 			const isAClassRegex = new RegExp(`export\\s+class\\s+${validExportName}`, 'g');
-			if (isAClassRegex.test(content) === false) {
+			if (!isAClassRegex.test(content)) {
 				return 'shouldProceedNextCheck';
 			}
 			let rewrite = false;
@@ -105,9 +73,9 @@ const checkIsClass = async (content, validExportName, path, encoding) => {
 					const check = new RegExp(
 						`(?<opening>${LitExp.escape(val).replace(
 							/\s+/g,
-							`\\\s*`
+							`\\\s*`,
 						)}\\\s*?(?:static\\\s+|))(?<funcname>(?:\#|)[a-zA-Z0-9]*)\\\s*?\\\=\\\s*?(?<async_>async\\\s*?|)\\\((?<parameters>[\\\s\\\S]*?)\\\)\\\s*?=>`,
-						'g'
+						'g',
 					);
 					const [checkContent] = content.matchAll(check).toArray();
 					if (checkContent === undefined) {
@@ -128,12 +96,53 @@ const checkIsClass = async (content, validExportName, path, encoding) => {
 			if (rewrite) {
 				await Timeout(100); // to wait for pretify on autoSave;
 				await writeFile(path, content, { encoding });
-				Console.info({
-					vivthJSAutoDoc: `successfully modify '${path}' class/instance method(s), that has generic template, for correct type emition;`,
-				});
+				Console.info(
+					`successfully modify '${path}' class/instance method(s), that has generic template, for correct type emition;`,
+
+					{
+						now: true,
+					},
+				);
 				return 'waitForRewrite';
 			}
 			return 'shouldProceedNextCheck';
-		}
+		},
+	);
+};
+
+/**
+ * @param {string} path
+ * @param {BufferEncoding} [encoding]
+ * @returns {Promise<RetType>}
+ */
+export const correctBeforeParse = async (path, encoding = Preferrence.encoding) => {
+	const validExportName = basename(path).split('.')[0] ?? '';
+	const firstLetter = validExportName[0];
+	const isStartWithCapital = firstLetter?.toUpperCase() === firstLetter;
+	if (validExportName === '' || !isStartWithCapital) {
+		return 'doNotProcess';
+	}
+	const content = (await readFile(path, { encoding })).toString();
+	const [resFunctionCheck, errorFunctionCheck] = await checkIsFunction(
+		content,
+		validExportName,
+		path,
+		encoding,
 	);
+	if (errorFunctionCheck) {
+		return 'doNotProcess';
+	}
+	if (resFunctionCheck === 'waitForRewrite') {
+		return 'waitForRewrite';
+	}
+	const [resClassCheck, errorClassCheck] = await checkIsClass(
+		content,
+		validExportName,
+		path,
+		encoding,
+	);
+	if (errorClassCheck) {
+		return 'doNotProcess';
+	}
+	return resClassCheck;
 };

package/src/doc/{parsedFile.mjs → parsedFileForDOC.mjs}

@@ -2,15 +2,20 @@
 
 import { readFile } from 'node:fs/promises';
 import { Stats } from 'node:fs';
-import { normalize, basename, join, relative, extname, dirname, resolve } from 'node:path';
+import { basename, join, relative, extname, dirname, resolve } from 'node:path';
 
 import { Paths } from '../class/Paths.mjs';
 import { LazyFactory } from '../function/LazyFactory.mjs';
 import { TrySync } from '../function/TrySync.mjs';
 import { Console } from '../class/Console.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
+import { Preferrence } from '../common/Preferrence.mjs';
+import { GetModuleEsbuildPlatform } from '../function/GetModuleEsbuildPlatform.mjs';
+import { multiExportEntryPointsPath } from './JSautoDOC.mjs';
+import { SafeImport } from '../function/SafeImport.mjs';
+import { isModuleTheBundledVersion } from '../bundler/adds/isModuleTheBundledVersion.mjs';
 
-export class parsedFile {
+export class parsedFileForDOC {
 	/**
 	 * @typedef {{
 	 *	instanceOrStatic:{parent:string, type:string},
@@ -23,25 +28,29 @@ export class parsedFile {
 	 * }} refType
 	 */
 	/**
-	 * @param {string} path__
-	 * @param {import('fs').Stats} _stats
+	 * @param {string} path
+	 * - `relative`(to `Paths.root`) OR `absolute`, both are accepted;
+	 * @param {import('fs').Stats} [stats]
 	 * @param {BufferEncoding} [encoding]
 	 */
-	constructor(path__, _stats, encoding = 'utf-8') {
-		if (Paths.root === undefined) {
-			return;
-		}
-		this.#stats = _stats;
+	constructor(path, stats, encoding = Preferrence.encoding) {
+		this.#stats = stats;
 		const root = Paths.root.replace(/\\/g, '/');
-		if (Paths.normalize(path__).startsWith(root)) {
-			this.#fullPath = path__;
-		} else {
-			this.#fullPath = join(root, path__);
-		}
-		this.#relativePath = Paths.normalize(relative(root, this.#fullPath));
+		this.#fullPath = Paths.diskAbsolute(path);
+		this.#relativePath = Paths.normalize(
+			relative(join(root, multiExportEntryPointsPath), this.#fullPath),
+		);
 		this.#encoding = encoding;
+		this.platform = GetModuleEsbuildPlatform(this.#fullPath);
 	}
+	/**
+	 * @type {Promise<"browser" | "node" | "neutral" | "unsupported">}
+	 */
+	platform;
 	parse = async () => {
+		if (isModuleTheBundledVersion(this.path.full, this.ext.withDot)) {
+			return;
+		}
 		const { details, error, exportName } = await this.content.parsed();
 		if (error || exportName === undefined) {
 			return;
@@ -74,11 +83,11 @@ export class parsedFile {
 			const interpreted = this.#interpreteArrayDesc(
 				exportName,
 				instanceOrStaticDef,
-				fullDescription,
+				fullDescription.replace(/\[at\]/g, '@'),
 				isExport,
 				typeOfVar,
 				getterOrSetter,
-				namedVar
+				namedVar,
 			);
 			if (interpreted === undefined) {
 				return;
@@ -88,6 +97,13 @@ export class parsedFile {
 	};
 	documented = LazyFactory(() => {
 		return {
+			/**
+			 *
+			 * @returns {Promise<{
+			 * 	module: string;
+			 * 	readme: string;
+			 * } | undefined>}
+			 */
 			typedef: async () => {
 				const relativePath = this.path.relative;
 				if (relativePath === '') {
@@ -129,11 +145,11 @@ export class parsedFile {
 	 * @param {string} exportName
 	 * @param {string} relativePath
 	 * @param {string} content
-	 * @returns {parsedFile["parsedType"]}
+	 * @returns {parsedFileForDOC["parsedType"]}
 	 */
 	#parseTypedef = (exportName, relativePath, content) => {
 		const rootPath = Paths.root;
-		if (rootPath === undefined || parsedFile.#isExportNameValid(exportName) === false) {
+		if (!parsedFileForDOC.#isExportNameValid(exportName)) {
 			return undefined;
 		}
 		if (this.parsedType === undefined) {
@@ -145,7 +161,7 @@ export class parsedFile {
 					if (val === undefined) {
 						return;
 					}
-					if (/import\(['"][\s\S]*['"]\)/g.test(val) === false) {
+					if (!/import\(['"][\s\S]*['"]\)/g.test(val)) {
 						return val;
 					}
 					const res = /import\(['"]([\s\S]*)['"]\)/g.exec(val);
@@ -156,10 +172,10 @@ export class parsedFile {
 					if (importDec === undefined) {
 						return;
 					}
-					const correctedPath = Paths.normalize(normalize(join(relativeDir, importDec)));
+					const correctedPath = Paths.normalize(join(relativeDir, importDec));
 					const rep = val.replace(
 						importDec,
-						correctedPath.startsWith('.') ? correctedPath : `./${correctedPath}`
+						correctedPath.startsWith('.') ? correctedPath : `./${correctedPath}`,
 					);
 					return rep;
 				})
@@ -169,18 +185,15 @@ export class parsedFile {
 					return false;
 				}
 				return new RegExp(
-					`(?:@typedef|@callback)[\\s\\S]*?${baseNameNoExt}\\s?[\\s\\S]*?`,
-					''
+					`(?:@typedef|@callback)[\\s\\S]*?${baseNameNoExt}[\\s]?[\\s\\S]*?`,
+					'',
 				).test(captured);
 			});
 			if (res0 === undefined) {
 				return undefined;
 			}
 			const [res] = res0;
-			if (
-				//
-				!res.length
-			) {
+			if (!res.length) {
 				return undefined;
 			}
 			const templates = res
@@ -192,15 +205,15 @@ export class parsedFile {
 
 			this.parsedType = {
 				module: `/**-templates-
- * @typedef {import('./${relativePath}').${exportName}${
-					templates.length
-						? `<${templates
-								.map(({ name }) => {
-									return name;
-								})
-								.join(',')}>`
-						: ''
-				}} ${exportName}
+ * @typedef {import('${relativePath}').${exportName}${
+		templates.length
+			? `<${templates
+					.map(({ name }) => {
+						return name;
+					})
+					.join(',')}>`
+			: ''
+ }} ${exportName}
  */`
 					.replace(/\\/g, '/')
 					.replace(
@@ -213,15 +226,18 @@ export class parsedFile {
 											if (matched && comment) {
 												comment = comment.replace(
 													matched,
-													`.${Paths.normalizesForRoot(
-														relative(rootPath, resolve(dirname(this.#fullPath), matched))
-													)}`
+													`.${Paths.normalizeForRoot(
+														relative(
+															join(rootPath, multiExportEntryPointsPath),
+															resolve(dirname(this.#fullPath), matched),
+														),
+													)}`,
 												);
 											}
 											return comment;
 										})
 										.join('\n')
-							: ''
+							: '',
 					),
 				readme,
 			};
@@ -245,15 +261,15 @@ export class parsedFile {
 		isExport_,
 		typeOfVar,
 		getterOrSetter,
-		namedVar
+		namedVar,
 	) => {
 		const type = instanceOrStaticDef.includes('@instance')
 			? 'instance'
 			: instanceOrStaticDef.includes('@static')
-			? 'static'
-			: instanceOrStaticDef.includes('@helper')
-			? 'helper'
-			: '';
+				? 'static'
+				: instanceOrStaticDef.includes('@helper')
+					? 'helper'
+					: '';
 		const parentSrc = instanceOrStaticDef
 			.matchAll(/(?:@instance|@static|@helper)\s+(\w+)/gm)
 			.toArray();
@@ -283,10 +299,10 @@ export class parsedFile {
 				reference = isExport
 					? `${exportName}`
 					: typeOfVar === 'static'
-					? `${exportName}.${namedVar}`
-					: typeOfVar === ''
-					? `${exportName}_instance.${namedVar}`
-					: '';
+						? `${exportName}.${namedVar}`
+						: typeOfVar === ''
+							? `${exportName}_instance.${namedVar}`
+							: '';
 				break;
 		}
 		if (getterOrSetter !== '') {
@@ -325,10 +341,16 @@ export class parsedFile {
 			.replace(/\s*(?<!\\)\*\s/g, '\n')
 			.trim();
 		fullDescTrue.shift();
-		let example;
+		/**
+		 * @type {string}
+		 */
+		let example = '';
 		let jsPreview = `\n\`\`\`js
 /**
- * @${fullDescTrue.join('@').replace(/(?<!\\)\*/g, '\n *')}
+ * @${fullDescTrue
+		.join('@')
+		.replace(/(?<!\\)\*/g, '\n *')
+		.replace(/\s+\*/g, '\n\t\*')}
  */\n\`\`\``;
 		const [example_] = jsPreview.matchAll(/@example([\s\S]*)\*\//gm).toArray();
 		if (example_ === undefined) {
@@ -348,33 +370,41 @@ export class parsedFile {
 				? `${jsPreview
 						.replace(/\/\*\*[\s\*]*\*\//g, '')
 						.replace(/\`\`\`js[\s]*\`\`\`/gm, '')
-						.replace(/\*[\*\s]*\*\//g, '*/')}${
-						example ? `\n - <i>example</i>:\n\`\`\`js${example}\n\`\`\``.replace(/\\\*/g, '*') : ''
-				  }`
+						.replace(/\*[\*\s]*\*\//g, '*/')
+						.replace(/\[at\]/g, '@')}${
+						!!example
+							? `\n - <i>example</i>:\n\`\`\`js\n${`${
+									/** */
+									example.trimEnd().replace(/\\\@/g, '@')
+								}\n`
+									.replace(/\n+/g, '\n')
+									.replace(/^\s([\w\W])/, '$1')}\`\`\``.replace(/\\\*/g, '*')
+							: ''
+					}`.replace(/\[at\]/g, '@')
 				: '',
 		};
 	};
 	/**
 	 * @type {undefined|{exportName:undefined, details:undefined, error:{fullpath:string, message:string}}
-	 * | {exportName:string|undefined, details:ReturnType<typeof parsedFile["getDescription"]>, error:undefined}
+	 * | {exportName:string|undefined, details:ReturnType<typeof parsedFileForDOC["getDescription"]>, error:undefined}
 	 * }
 	 */
 	#parsed;
 	/**
 	 * @returns {Promise<{exportName:undefined, details:undefined, error:{fullpath:string, message:string}}
-	 * | {exportName:string|undefined, details:ReturnType<typeof parsedFile["getDescription"]>, error:undefined}
+	 * | {exportName:string|undefined, details:ReturnType<typeof parsedFileForDOC["getDescription"]>, error:undefined}
 	 * >}
 	 */
 	#parse = async () => {
 		const fullpath = this.#fullPath;
 		const content = await this.content.string();
 		if (content === undefined) {
-			const error = { fullpath, message: 'invalid file content' };
-			Console.error(error);
-			return { exportName: undefined, details: undefined, error };
+			const errorParse = { fullpath, message: 'invalid file content' };
+			Console.error({ errorParse }, { now: true });
+			return { exportName: undefined, details: undefined, error: errorParse };
 		}
 		const supposedName = this.baseName.noExt.split('.')[0];
-		if (supposedName === undefined || this.#getTopExport(supposedName, content) === false) {
+		if (supposedName === undefined || !this.#getTopExport(supposedName, content)) {
 			return {
 				details: undefined,
 				exportName: undefined,
@@ -383,7 +413,7 @@ export class parsedFile {
 		}
 		this.hasValidExportObject = true;
 		return {
-			details: parsedFile.getDescription(content),
+			details: parsedFileForDOC.getDescription(content),
 			exportName: supposedName,
 			error: undefined,
 		};
@@ -395,12 +425,12 @@ export class parsedFile {
 	 * @returns {boolean}
 	 */
 	#getTopExport = (name, content) => {
-		if (parsedFile.#isExportNameValid(name) === false) {
+		if (!parsedFileForDOC.#isExportNameValid(name)) {
 			return false;
 		}
 		const regex = new RegExp(
-			`export\\s*(?:(?:async\\s*|)function|const|class|\\{)\\s*${name}`,
-			'g'
+			`export\\s*(?:(?:async\\s*|)function|const|class|\\{)\\s*${name}\[\\W\]`,
+			'g',
 		);
 		return regex.test(content);
 	};
@@ -410,8 +440,8 @@ export class parsedFile {
 	 */
 	static getDescription = (content) => {
 		const regexp =
-			/(\/\*\*([\s\S]*?)(?:@description)([\s\S]*?)\*\/\s?(export|\s?)\s?(static|class|const|function|async\s+function|\s?)\s?(?:async|)\s?(get|set|)\s+?(\w+))/gm;
-		const modified = content.replace(/\r\n+/g, ' ');
+			/(\/\*\*([\s\S]*?)(?:@description)([\s\S]*?)\*\/\s*(?:@\w+(?:\([\s\S]*?\))?\s*)*(export|\s?)\s?(static|class|const|function|async\s+function|\s?)\s?(?:async|)\s?(get|set|)\s+?(\w+))/gm;
+		const modified = content.replace(/\s*\/\/\s+\@ts-[\w-]+\s*/gm, ' ').replace(/\r\n+/g, ' ');
 		const matches = modified.matchAll(regexp).toArray();
 		return matches;
 	};
@@ -424,33 +454,28 @@ export class parsedFile {
 	 */
 	#relativePath = '';
 	/**
-	 * @returns {Promise<boolean>}
+	 * @returns {boolean|undefined}
 	 */
-	isFile = async () => {
-		return this.#stats.isFile();
-	};
+	get isFile() {
+		return this.#stats?.isFile();
+	}
 	/**
-	 * @returns {Promise<boolean>}
+	 * @returns {boolean|undefined}
 	 */
-	isDirectory = async () => {
-		return this.#stats.isDirectory();
-	};
-
+	get isDirectory() {
+		return this.#stats?.isDirectory();
+	}
 	baseName = LazyFactory(() => {
 		const this_ = this;
 		return {
 			/**
 			 * @returns {string}
 			 */
-			get withExt() {
-				return basename(this_.#fullPath);
-			},
+			withExt: basename(this_.#fullPath),
 			/**
 			 * @returns {string}
 			 */
-			get noExt() {
-				return basename(this_.#fullPath, extname(this_.#fullPath));
-			},
+			noExt: basename(this_.#fullPath, extname(this_.#fullPath)),
 		};
 	});
 	path = LazyFactory(() => {
@@ -476,15 +501,11 @@ export class parsedFile {
 			/**
 			 * @returns {string}
 			 */
-			get relative() {
-				return dirname(this_.#relativePath);
-			},
+			relative: dirname(this_.#relativePath),
 			/**
 			 * @returns {string}
 			 */
-			get full() {
-				return dirname(this_.#fullPath);
-			},
+			full: dirname(this_.#fullPath),
 		};
 	}
 	get ext() {
@@ -493,15 +514,11 @@ export class parsedFile {
 			/**
 			 * @returns {string|undefined}
 			 */
-			get withDot() {
-				return extname(this_.#fullPath);
-			},
+			withDot: extname(this_.#fullPath),
 			/**
 			 * @returns {string|undefined}
 			 */
-			get noDot() {
-				return extname(this_.#fullPath).replace(/^\./, '');
-			},
+			noDot: extname(this_.#fullPath).replace(/^\./, ''),
 		};
 	}
 	/**
@@ -509,24 +526,23 @@ export class parsedFile {
 	 */
 	#encoding;
 	/**
-	 * @type {Stats}
+	 * @type {Stats|undefined}
 	 */
-	// @ts-expect-error
 	#stats;
 	get timeStamp() {
 		const this_ = this;
 		return {
 			/**
-			 * @returns {Promise<number>}
+			 * @returns {Promise<number|undefined>}
 			 */
 			lastModified: async () => {
-				return this_.#stats.mtimeMs;
+				return this_.#stats?.mtimeMs;
 			},
 			/**
-			 * @returns {Promise<number>}
+			 * @returns {Promise<number|undefined>}
 			 */
 			createdAt: async () => {
-				return this_.#stats.birthtimeMs;
+				return this_.#stats?.birthtimeMs;
 			},
 		};
 	}
@@ -541,7 +557,7 @@ export class parsedFile {
 			 * @return {Promise<string|undefined>}
 			 */
 			string: async () => {
-				if ((await this_.isFile()) === false) {
+				if (!this_.isFile) {
 					return undefined;
 				}
 				const [raw, error] = await TryAsync(async () => {
@@ -551,13 +567,21 @@ export class parsedFile {
 					this_.#rawContent = raw;
 					return this_.#rawContent;
 				}
-				Console.error({
-					error,
-					fullPath: this_.#fullPath,
-					message2: 'failed to read fullPath',
-				});
+				Console.error(
+					{
+						error,
+						fullPath: this_.#fullPath,
+						message: 'failed to read fullPath',
+					},
+					{ now: true },
+				);
 				return undefined;
 			},
+			/**
+			 *
+			 * @returns {Promise<{exportName:undefined, details:undefined, error:{fullpath:string, message:string}}|
+			 *  {exportName:string|undefined, details:ReturnType<typeof parsedFileForDOC["getDescription"]>, error:undefined}>}
+			 */
 			parsed: async () => {
 				if (this_.#parsed === undefined) {
 					this_.#parsed = await this_.#parse();
@@ -566,24 +590,13 @@ export class parsedFile {
 			},
 		};
 	});
+
 	/**
 	 * @returns {ReturnType<typeof TryAsync<any>>}
 	 */
 	importAsModuleJS = async () => {
-		const realTimePath = `${this.#fullPath}?${Date.now()}`;
-		let [importedModule, error] = await TryAsync(async () => {
-			return await import(`file://${realTimePath}`);
-		});
-		if (error === undefined) {
-			return [importedModule, undefined];
-		}
-		[importedModule, error] = await TryAsync(async () => {
-			return await import(realTimePath);
+		return await TryAsync(async () => {
+			return await SafeImport(this.path.full);
 		});
-		if (error === undefined) {
-			return [importedModule, undefined];
-		}
-		Console.error({ error, timeStamp: Date.now() });
-		return [undefined, error];
 	};
 }