tiny-essentials 1.12.1 → 1.13.0

package/dist/v1/TinyEssentials.js

@@ -1,7 +1,7 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 41:
+/***/ 133:
 /***/ (() => {
 
 /* (ignored) */
@@ -1924,6 +1924,13 @@ var hexSliceLookupTable = (function () {
 })()
 
 
+/***/ }),
+
+/***/ 370:
+/***/ (() => {
+
+/* (ignored) */
+
 /***/ }),
 
 /***/ 526:
@@ -2879,6 +2886,7 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   ColorSafeStringify: () => (/* reexport */ libs_ColorSafeStringify),
+  TinyDomReadyManager: () => (/* reexport */ libs_TinyDomReadyManager),
   TinyDragDropDetector: () => (/* reexport */ libs_TinyDragDropDetector),
   TinyDragger: () => (/* reexport */ libs_TinyDragger),
   TinyLevelUp: () => (/* reexport */ userLevel),
@@ -2893,18 +2901,21 @@ __webpack_require__.d(__webpack_exports__, {
   backupFile: () => (/* reexport */ backupFile),
   checkObj: () => (/* reexport */ checkObj),
   clearDirectory: () => (/* reexport */ clearDirectory),
+  clearDirectoryAsync: () => (/* reexport */ clearDirectoryAsync),
   cloneObjTypeOrder: () => (/* reexport */ cloneObjTypeOrder),
   countObj: () => (/* reexport */ countObj),
   dirExists: () => (/* reexport */ dirExists),
   dirSize: () => (/* reexport */ dirSize),
+  dirSizeAsync: () => (/* reexport */ dirSizeAsync),
   documentIsFullScreen: () => (/* reexport */ documentIsFullScreen),
   ensureCopyFile: () => (/* reexport */ ensureCopyFile),
-  ensureDirectory: () => (/* reexport */ ensureDirectory),
+  ensureDirectory: () => (/* reexport */ normalFuncs_ensureDirectory),
   exitFullScreen: () => (/* reexport */ exitFullScreen),
   extendObjType: () => (/* reexport */ extendObjType),
   fetchJson: () => (/* reexport */ fetchJson),
-  fileExists: () => (/* reexport */ fileExists),
+  fileExists: () => (/* reexport */ normalFuncs_fileExists),
   fileSize: () => (/* reexport */ fileSize),
+  fileSizeAsync: () => (/* reexport */ fileSizeAsync),
   formatBytes: () => (/* reexport */ formatBytes),
   formatCustomTimer: () => (/* reexport */ formatCustomTimer),
   formatDayTimer: () => (/* reexport */ formatDayTimer),
@@ -2914,15 +2925,18 @@ __webpack_require__.d(__webpack_exports__, {
   getHtmlElBordersWidth: () => (/* reexport */ getHtmlElBordersWidth),
   getHtmlElMargin: () => (/* reexport */ getHtmlElMargin),
   getHtmlElPadding: () => (/* reexport */ getHtmlElPadding),
-  getLatestBackupPath: () => (/* reexport */ getLatestBackupPath),
+  getLatestBackupPath: () => (/* reexport */ normalFuncs_getLatestBackupPath),
   getSimplePerc: () => (/* reexport */ getSimplePerc),
   getTimeDuration: () => (/* reexport */ getTimeDuration),
   isDirEmpty: () => (/* reexport */ isDirEmpty),
+  isDirEmptyAsync: () => (/* reexport */ isDirEmptyAsync),
   isFullScreenMode: () => (/* reexport */ isFullScreenMode),
   isJsonObject: () => (/* reexport */ isJsonObject),
   isScreenFilled: () => (/* reexport */ isScreenFilled),
   listDirs: () => (/* reexport */ listDirs),
+  listDirsAsync: () => (/* reexport */ listDirsAsync),
   listFiles: () => (/* reexport */ listFiles),
+  listFilesAsync: () => (/* reexport */ listFilesAsync),
   objType: () => (/* reexport */ objType),
   offFullScreenChange: () => (/* reexport */ offFullScreenChange),
   onFullScreenChange: () => (/* reexport */ onFullScreenChange),
@@ -6612,10 +6626,10 @@ class TinyDragDropDetector {
 /* harmony default export */ const libs_TinyDragDropDetector = (TinyDragDropDetector);
 
 // EXTERNAL MODULE: fs (ignored)
-var fs_ignored_ = __webpack_require__(41);
+var fs_ignored_ = __webpack_require__(133);
 // EXTERNAL MODULE: ./node_modules/path-browserify/index.js
 var path_browserify = __webpack_require__(975);
-;// ./src/v1/basics/fileManager.mjs
+;// ./src/v1/fileManager/normalFuncs.mjs
 
 
 
@@ -6631,8 +6645,8 @@ var path_browserify = __webpack_require__(975);
  * @returns {any}
  */
 function readJsonFile(filePath) {
-  if (!fs_ignored_.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-  const content = fs_ignored_.readFileSync(filePath, 'utf-8');
+  if (!(0,fs_ignored_.existsSync)(filePath)) throw new Error(`File not found: ${filePath}`);
+  const content = (0,fs_ignored_.readFileSync)(filePath, 'utf-8');
   return JSON.parse(content);
 }
 
@@ -6645,32 +6659,7 @@ function readJsonFile(filePath) {
  */
 function writeJsonFile(filePath, data, spaces = 2) {
   const json = JSON.stringify(data, null, spaces);
-  fs_ignored_.writeFileSync(filePath, json, 'utf-8');
-}
-
-/**
- * Reads and parses a JSON file.
- * Throws an error if the file content is not valid JSON.
- * @param {string} filePath
- * @returns {Promise<any>}
- */
-async function readJsonFileAsync(filePath) {
-  if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-  const content = await fs.promises.readFile(filePath, 'utf-8');
-  return JSON.parse(content);
-}
-
-/**
- * Saves an object as JSON to a file.
- * Automatically creates the directory if it does not exist.
- * @param {string} filePath
- * @param {any} data
- * @param {number} [spaces=2]
- * @returns {Promise<void>}
- */
-function writeJsonFileAsync(filePath, data, spaces = 2) {
-  const json = JSON.stringify(data, null, spaces);
-  return fs.promises.writeFile(filePath, json, 'utf-8');
+  (0,fs_ignored_.writeFileSync)(filePath, json, 'utf-8');
 }
 
 /*========================*
@@ -6681,9 +6670,9 @@ function writeJsonFileAsync(filePath, data, spaces = 2) {
  * Ensures that the directory exists, creating it recursively if needed.
  * @param {string} dirPath
  */
-function ensureDirectory(dirPath) {
-  if (!fs_ignored_.existsSync(dirPath)) {
-    fs_ignored_.mkdirSync(dirPath, { recursive: true });
+function normalFuncs_ensureDirectory(dirPath) {
+  if (!(0,fs_ignored_.existsSync)(dirPath)) {
+    (0,fs_ignored_.mkdirSync)(dirPath, { recursive: true });
   }
 }
 
@@ -6692,15 +6681,15 @@ function ensureDirectory(dirPath) {
  * @param {string} dirPath
  */
 function clearDirectory(dirPath) {
-  if (!fs_ignored_.existsSync(dirPath)) return;
-  const files = fs_ignored_.readdirSync(dirPath);
+  if (!(0,fs_ignored_.existsSync)(dirPath)) return;
+  const files = (0,fs_ignored_.readdirSync)(dirPath);
   for (const file of files) {
-    const fullPath = path_browserify.join(dirPath, file);
-    const stat = fs_ignored_.lstatSync(fullPath);
-    if (stat.isDirectory()) {
-      fs_ignored_.rmSync(fullPath, { recursive: true, force: true });
+    const fullPath = (0,path_browserify.join)(dirPath, file);
+    const statData = (0,fs_ignored_.lstatSync)(fullPath);
+    if (statData.isDirectory()) {
+      (0,fs_ignored_.rmSync)(fullPath, { recursive: true, force: true });
     } else {
-      fs_ignored_.unlinkSync(fullPath);
+      (0,fs_ignored_.unlinkSync)(fullPath);
     }
   }
 }
@@ -6714,8 +6703,8 @@ function clearDirectory(dirPath) {
  * @param {string} filePath
  * @returns {boolean}
  */
-function fileExists(filePath) {
-  return fs_ignored_.existsSync(filePath) && fs_ignored_.lstatSync(filePath).isFile();
+function normalFuncs_fileExists(filePath) {
+  return (0,fs_ignored_.existsSync)(filePath) && (0,fs_ignored_.lstatSync)(filePath).isFile();
 }
 
 /**
@@ -6724,7 +6713,7 @@ function fileExists(filePath) {
  * @returns {boolean}
  */
 function dirExists(dirPath) {
-  return fs_ignored_.existsSync(dirPath) && fs_ignored_.lstatSync(dirPath).isDirectory();
+  return (0,fs_ignored_.existsSync)(dirPath) && (0,fs_ignored_.lstatSync)(dirPath).isDirectory();
 }
 
 /**
@@ -6733,7 +6722,7 @@ function dirExists(dirPath) {
  * @returns {boolean}
  */
 function isDirEmpty(dirPath) {
-  return fs_ignored_.existsSync(dirPath) && fs_ignored_.readdirSync(dirPath).length === 0;
+  return (0,fs_ignored_.readdirSync)(dirPath).length === 0;
 }
 
 /*========================*
@@ -6747,8 +6736,8 @@ function isDirEmpty(dirPath) {
  * @param {number} [mode]
  */
 function ensureCopyFile(src, dest, mode) {
-  ensureDirectory(path_browserify.dirname(dest));
-  fs_ignored_.copyFileSync(src, dest, mode);
+  normalFuncs_ensureDirectory((0,path_browserify.dirname)(dest));
+  (0,fs_ignored_.copyFileSync)(src, dest, mode);
 }
 
 /**
@@ -6757,33 +6746,8 @@ function ensureCopyFile(src, dest, mode) {
  * @returns {boolean}
  */
 function tryDeleteFile(filePath) {
-  if (fileExists(filePath)) {
-    fs_ignored_.unlinkSync(filePath);
-    return true;
-  }
-  return false;
-}
-
-/**
- * Copies a file to a destination.
- * @param {string} src
- * @param {string} dest
- * @param {number} [mode]
- * @returns {Promise<void>}
- */
-function ensureCopyFileAsync(src, dest, mode) {
-  ensureDirectory(path.dirname(dest));
-  return fs.promises.copyFile(src, dest, mode);
-}
-
-/**
- * Deletes a file (If the file exists).
- * @param {string} filePath
- * @returns {Promise<boolean>}
- */
-async function tryDeleteFileAsync(filePath) {
-  if (fileExists(filePath)) {
-    await fs.promises.unlink(filePath);
+  if (normalFuncs_fileExists(filePath)) {
+    (0,fs_ignored_.unlinkSync)(filePath);
     return true;
   }
   return false;
@@ -6797,25 +6761,12 @@ async function tryDeleteFileAsync(filePath) {
  * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
  * @param {string} filePath
  * @param {string} content
- * @param {fs.WriteFileOptions} [ops='utf-8']
+ * @param {import('fs').WriteFileOptions} [ops='utf-8']
  */
 function writeTextFile(filePath, content, ops = 'utf-8') {
-  const dir = path_browserify.dirname(filePath);
-  ensureDirectory(dir);
-  fs_ignored_.writeFileSync(filePath, content, ops);
-}
-
-/**
- * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
- * @param {string} filePath
- * @param {string} content
- * @param {fs.WriteFileOptions} [ops='utf-8']
- * @returns {Promise<void>}
- */
-function writeTextFileAsync(filePath, content, ops = 'utf-8') {
-  const dir = path.dirname(filePath);
-  ensureDirectory(dir);
-  return fs.promises.writeFile(filePath, content, ops);
+  const dir = (0,path_browserify.dirname)(filePath);
+  normalFuncs_ensureDirectory(dir);
+  (0,fs_ignored_.writeFileSync)(filePath, content, ops);
 }
 
 /*========================*
@@ -6833,11 +6784,11 @@ function listFiles(dirPath, recursive = false) {
   const results = { files: [], dirs: [] };
   if (!dirExists(dirPath)) return results;
 
-  const entries = fs_ignored_.readdirSync(dirPath);
+  const entries = (0,fs_ignored_.readdirSync)(dirPath);
   for (const entry of entries) {
-    const fullPath = path_browserify.join(dirPath, entry);
-    const stat = fs_ignored_.lstatSync(fullPath);
-    if (stat.isDirectory()) {
+    const fullPath = (0,path_browserify.join)(dirPath, entry);
+    const statData = (0,fs_ignored_.lstatSync)(fullPath);
+    if (statData.isDirectory()) {
       results.dirs.push(fullPath);
       if (recursive) {
         const results2 = listFiles(fullPath, true);
@@ -6862,11 +6813,11 @@ function listDirs(dirPath, recursive = false) {
   const results = [];
   if (!dirExists(dirPath)) return results;
 
-  const entries = fs_ignored_.readdirSync(dirPath);
+  const entries = (0,fs_ignored_.readdirSync)(dirPath);
   for (const entry of entries) {
-    const fullPath = path_browserify.join(dirPath, entry);
-    const stat = fs_ignored_.lstatSync(fullPath);
-    if (stat.isDirectory()) {
+    const fullPath = (0,path_browserify.join)(dirPath, entry);
+    const statData = (0,fs_ignored_.lstatSync)(fullPath);
+    if (statData.isDirectory()) {
       results.push(fullPath);
       if (recursive) {
         results.push(...listDirs(fullPath, true));
@@ -6886,8 +6837,8 @@ function listDirs(dirPath, recursive = false) {
  * @returns {number}
  */
 function fileSize(filePath) {
-  if (!fileExists(filePath)) return 0;
-  const stats = fs_ignored_.statSync(filePath);
+  if (!normalFuncs_fileExists(filePath)) return 0;
+  const stats = (0,fs_ignored_.statSync)(filePath);
   return stats.size;
 }
 
@@ -6915,7 +6866,7 @@ function dirSize(dirPath) {
  * @param {string} [ext='bak']
  */
 function backupFile(filePath, ext = 'bak') {
-  if (!fileExists(filePath)) return;
+  if (!normalFuncs_fileExists(filePath)) return;
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
   const backupPath = `${filePath}.${ext}.${timestamp}`;
   ensureCopyFile(filePath, backupPath);
@@ -6927,17 +6878,17 @@ function backupFile(filePath, ext = 'bak') {
  * @param {string} [ext='bak']
  * @returns {string} Full path to the most recent backup
  */
-function getLatestBackupPath(filePath, ext = 'bak') {
-  const dir = path_browserify.dirname(filePath);
-  const baseName = path_browserify.basename(filePath);
-  const backups = fs_ignored_.readdirSync(dir)
+function normalFuncs_getLatestBackupPath(filePath, ext = 'bak') {
+  const dir = (0,path_browserify.dirname)(filePath);
+  const baseName = (0,path_browserify.basename)(filePath);
+  const backups = (0,fs_ignored_.readdirSync)(dir)
     .filter((name) => name.startsWith(`${baseName}.${ext}.`))
     .sort()
     .reverse();
 
   if (backups.length === 0) throw new Error(`No backups found for ${filePath}`);
 
-  return path_browserify.join(dir, backups[0]);
+  return (0,path_browserify.join)(dir, backups[0]);
 }
 
 /**
@@ -6946,34 +6897,10 @@ function getLatestBackupPath(filePath, ext = 'bak') {
  * @param {string} [ext='bak']
  */
 function restoreLatestBackup(filePath, ext = 'bak') {
-  const latestBackup = getLatestBackupPath(filePath, ext);
+  const latestBackup = normalFuncs_getLatestBackupPath(filePath, ext);
   ensureCopyFile(latestBackup, filePath);
 }
 
-/**
- * Restores the most recent backup of a file.
- * @param {string} filePath
- * @param {string} [ext='bak']
- * @returns {Promise<void>}
- */
-function restoreLatestBackupAsync(filePath, ext = 'bak') {
-  const latestBackup = getLatestBackupPath(filePath, ext);
-  return ensureCopyFileAsync(latestBackup, filePath);
-}
-
-/**
- * Creates a backup copy of a file with .bak timestamp suffix.
- * @param {string} filePath
- * @param {string} [ext='bak']
- * @returns {Promise<void>}
- */
-async function backupFileAsync(filePath, ext = 'bak') {
-  if (!fileExists(filePath)) return;
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const backupPath = `${filePath}.${ext}.${timestamp}`;
-  return ensureCopyFileAsync(filePath, backupPath);
-}
-
 /*========================*
  * Rename Utilities
  *========================*/
@@ -6992,7 +6919,7 @@ function renameFileBatch(dirPath, renameFn, extensions = []) {
   if (typeof dirPath !== 'string') throw new TypeError('dirPath must be a string');
   if (typeof renameFn !== 'function') throw new TypeError('renameFn must be a function');
   if (!Array.isArray(extensions)) throw new TypeError('extensions must be an array of strings');
-  if (!fs_ignored_.existsSync(dirPath) || !fs_ignored_.statSync(dirPath).isDirectory())
+  if (!(0,fs_ignored_.existsSync)(dirPath) || !(0,fs_ignored_.statSync)(dirPath).isDirectory())
     throw new Error(`Directory not found or invalid: ${dirPath}`);
   for (const ext of extensions) {
     if (typeof ext !== 'string' || !ext.startsWith('.'))
@@ -7003,16 +6930,16 @@ function renameFileBatch(dirPath, renameFn, extensions = []) {
   let index = 0;
 
   for (const file of files) {
-    const ext = path_browserify.extname(file);
+    const ext = (0,path_browserify.extname)(file);
     if (extensions.length && !extensions.includes(ext)) continue;
 
-    const originalName = path_browserify.basename(file);
+    const originalName = (0,path_browserify.basename)(file);
     const newName = renameFn(originalName, index++);
-    const newPath = path_browserify.join(dirPath, newName);
+    const newPath = (0,path_browserify.join)(dirPath, newName);
 
     if (originalName === newName) continue;
 
-    fs_ignored_.renameSync(file, newPath);
+    (0,fs_ignored_.renameSync)(file, newPath);
   }
 }
 
@@ -7027,8 +6954,8 @@ function renameFileRegex(dirPath, pattern, replacement, extensions = []) {
   renameFileBatch(
     dirPath,
     (filename) => {
-      const ext = path_browserify.extname(filename);
-      const name = path_browserify.basename(filename, ext).replace(pattern, replacement);
+      const ext = (0,path_browserify.extname)(filename);
+      const name = (0,path_browserify.basename)(filename, ext).replace(pattern, replacement);
       return `${name}${ext}`;
     },
     extensions,
@@ -7045,8 +6972,8 @@ function renameFileAddPrefixSuffix(dirPath, { prefix = '', suffix = '' }, extens
   renameFileBatch(
     dirPath,
     (filename) => {
-      const ext = path_browserify.extname(filename);
-      const name = path_browserify.basename(filename, ext);
+      const ext = (0,path_browserify.extname)(filename);
+      const name = (0,path_browserify.basename)(filename, ext);
       return `${prefix}${name}${suffix}${ext}`;
     },
     extensions,
@@ -7083,9 +7010,9 @@ function renameFileNormalizeCase(
         else return text;
       };
 
-      const rawExt = path_browserify.extname(filename);
+      const rawExt = (0,path_browserify.extname)(filename);
       const ext = normalizeExt ? changeToMode(rawExt) : rawExt;
-      const name = changeToMode(path_browserify.basename(filename, rawExt));
+      const name = changeToMode((0,path_browserify.basename)(filename, rawExt));
       return `${name}${ext}`;
     },
     extensions,
@@ -7108,6 +7035,266 @@ function renameFilePadNumbers(dirPath, totalDigits = 3, extensions = []) {
   );
 }
 
+// EXTERNAL MODULE: fs/promises (ignored)
+var promises_ignored_ = __webpack_require__(370);
+;// ./src/v1/fileManager/asyncFuncs.mjs
+
+
+
+
+
+/*========================*
+ * JSON Operations
+ *========================*/
+
+/**
+ * Reads and parses a JSON file.
+ * Throws an error if the file content is not valid JSON.
+ * @param {string} filePath
+ * @returns {Promise<any>}
+ */
+async function readJsonFileAsync(filePath) {
+  if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+  const content = await readFile(filePath, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Saves an object as JSON to a file.
+ * Automatically creates the directory if it does not exist.
+ * @param {string} filePath
+ * @param {any} data
+ * @param {number} [spaces=2]
+ * @returns {Promise<void>}
+ */
+function writeJsonFileAsync(filePath, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  return writeFile(filePath, json, 'utf-8');
+}
+
+/*========================*
+ * Directory Management
+ *========================*/
+
+/**
+ * Clears all contents inside a directory but keeps the directory.
+ * @param {string} dirPath
+ */
+async function clearDirectoryAsync(dirPath) {
+  if (!(0,fs_ignored_.existsSync)(dirPath)) return;
+  const files = await (0,promises_ignored_.readdir)(dirPath);
+
+  /** @type {Record<string, import('fs').Stats>} */
+  const dataList = {};
+  const promises = [];
+
+  for (const file of files) {
+    const fullPath = (0,path_browserify.join)(dirPath, file);
+    const lsResult = (0,promises_ignored_.lstat)(fullPath);
+
+    lsResult.then((statData) => {
+      dataList[fullPath] = statData;
+      return statData;
+    });
+    promises.push(lsResult);
+  }
+
+  await Promise.all(promises);
+  const promises2 = [];
+  for (const fullPath in dataList) {
+    const statData = dataList[fullPath];
+    if (statData.isDirectory()) {
+      promises2.push((0,promises_ignored_.rm)(fullPath, { recursive: true, force: true }));
+    } else {
+      promises2.push((0,promises_ignored_.unlink)(fullPath));
+    }
+  }
+
+  await Promise.all(promises2);
+}
+
+/*========================*
+ * File Checks
+ *========================*/
+
+/**
+ * Checks whether a directory is empty.
+ * @param {string} dirPath
+ * @returns {Promise<boolean>}
+ */
+async function isDirEmptyAsync(dirPath) {
+  const data = await (0,promises_ignored_.readdir)(dirPath);
+  return data.length === 0;
+}
+
+/*========================*
+ * File Operations
+ *========================*/
+
+/**
+ * Copies a file to a destination.
+ * @param {string} src
+ * @param {string} dest
+ * @param {number} [mode]
+ * @returns {Promise<void>}
+ */
+function ensureCopyFileAsync(src, dest, mode) {
+  ensureDirectory(dirname(dest));
+  return copyFile(src, dest, mode);
+}
+
+/**
+ * Deletes a file (If the file exists).
+ * @param {string} filePath
+ * @returns {Promise<boolean>}
+ */
+async function tryDeleteFileAsync(filePath) {
+  if (fileExists(filePath)) {
+    await unlink(filePath);
+    return true;
+  }
+  return false;
+}
+
+/*========================*
+ * Text Operations
+ *========================*/
+
+/**
+ * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
+ * @param {string} filePath
+ * @param {string} content
+ * @param {import('fs').WriteFileOptions} [ops='utf-8']
+ * @returns {Promise<void>}
+ */
+function writeTextFileAsync(filePath, content, ops = 'utf-8') {
+  const dir = dirname(filePath);
+  ensureDirectory(dir);
+  return writeFile(filePath, content, ops);
+}
+
+/*========================*
+ * Directory Listings
+ *========================*/
+
+/**
+ * Lists all files and dirs in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {Promise<{ files: string[]; dirs: string[] }>}
+ */
+async function listFilesAsync(dirPath, recursive = false) {
+  /** @type {{ files: string[]; dirs: string[] }} */
+  const results = { files: [], dirs: [] };
+  if (!dirExists(dirPath)) return results;
+
+  const entries = await (0,promises_ignored_.readdir)(dirPath);
+  for (const entry of entries) {
+    const fullPath = (0,path_browserify.join)(dirPath, entry);
+    const statData = await (0,promises_ignored_.lstat)(fullPath);
+    if (statData.isDirectory()) {
+      results.dirs.push(fullPath);
+      if (recursive) {
+        const results2 = await listFilesAsync(fullPath, true);
+        results.files.push(...results2.files);
+        results.dirs.push(...results2.dirs);
+      }
+    } else {
+      results.files.push(fullPath);
+    }
+  }
+  return results;
+}
+
+/**
+ * Lists all directories in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {Promise<string[]>}
+ */
+async function listDirsAsync(dirPath, recursive = false) {
+  /** @type {string[]} */
+  const results = [];
+  if (!dirExists(dirPath)) return results;
+
+  const entries = await (0,promises_ignored_.readdir)(dirPath);
+  for (const entry of entries) {
+    const fullPath = (0,path_browserify.join)(dirPath, entry);
+    const statData = await (0,promises_ignored_.lstat)(fullPath);
+    if (statData.isDirectory()) {
+      results.push(fullPath);
+      if (recursive) {
+        results.push(...(await listDirsAsync(fullPath, true)));
+      }
+    }
+  }
+  return results;
+}
+
+/*========================*
+ * File Info
+ *========================*/
+
+/**
+ * Returns the size of a file in bytes.
+ * @param {string} filePath
+ * @returns {Promise<number>}
+ */
+async function fileSizeAsync(filePath) {
+  if (!normalFuncs_fileExists(filePath)) return 0;
+  const stats = await (0,promises_ignored_.stat)(filePath);
+  return stats.size;
+}
+
+/**
+ * Returns the total size of a directory in bytes.
+ * @param {string} dirPath
+ * @returns {Promise<number>}
+ */
+async function dirSizeAsync(dirPath) {
+  let total = 0;
+  const { files } = await listFilesAsync(dirPath, true);
+  const promises = [];
+  for (const file of files) {
+    const result = fileSizeAsync(file);
+    result.then((item) => {
+      total += item;
+      return item;
+    });
+    promises.push(result);
+  }
+  await Promise.all(promises);
+  return total;
+}
+
+/*========================*
+ * Backup Utilities
+ *========================*/
+
+/**
+ * Restores the most recent backup of a file.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+function restoreLatestBackupAsync(filePath, ext = 'bak') {
+  const latestBackup = getLatestBackupPath(filePath, ext);
+  return ensureCopyFileAsync(latestBackup, filePath);
+}
+
+/**
+ * Creates a backup copy of a file with .bak timestamp suffix.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+async function backupFileAsync(filePath, ext = 'bak') {
+  if (!fileExists(filePath)) return;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.${ext}.${timestamp}`;
+  return ensureCopyFileAsync(filePath, backupPath);
+}
+
 ;// ./src/v1/libs/TinyDragger.mjs
 
 
@@ -8014,6 +8201,180 @@ class TinyDragger {
 
 /* harmony default export */ const libs_TinyDragger = (TinyDragger);
 
+;// ./src/v1/libs/TinyDomReadyManager.mjs
+/**
+ * A basic function that performs a task when the system is ready.
+ * Used for handlers in the readiness queue.
+ *
+ * @typedef {() => void} Fn
+ */
+
+/**
+ * A function that determines whether a specific handler should be executed.
+ * Should return `true` to allow execution, or `false` to skip the handler.
+ *
+ * @typedef {() => boolean} FnFilter
+ */
+
+/**
+ * @typedef {Object} Handler
+ * @property {Fn} fn - Function to execute when ready.
+ * @property {boolean} once - Whether to execute only once.
+ * @property {number} priority - Execution order (higher priority runs first).
+ * @property {FnFilter|null} filter - Optional filter function to determine execution.
+ * @property {boolean} domOnly - Whether to run as soon as DOM is ready (before full readiness).
+ */
+
+class TinyDomReadyManager {
+  /** @type {Handler[]} */
+  #handlers = [];
+
+  /** @type {boolean} */
+  #isDomReady = false;
+
+  /** @type {boolean} */
+  #isFullyReady = false;
+
+  /** @type {Promise<any>[]} */
+  #promises = [];
+
+  /**
+   * Checks if the DOM is ready and if all Promises have been resolved.
+   */
+  #checkAllReady() {
+    if (this.#isDomReady) {
+      Promise.all(this.#promises)
+        .then(() => {
+          this.#isFullyReady = true;
+          this.#runHandlers(false); // run non-domOnly
+        })
+        .catch((err) => {
+          console.error('[TinyDomReadyManager] Promise rejected:', err);
+        });
+    }
+  }
+
+  /**
+   * Executes handlers by filtering them by `domOnly` flag and sorting by priority.
+   * @param {boolean} domOnlyOnly - Whether to run only `domOnly` handlers.
+   */
+  #runHandlers(domOnlyOnly) {
+    this.#handlers
+      .filter((h) => h.domOnly === domOnlyOnly)
+      .sort((a, b) => b.priority - a.priority)
+      .forEach((handler) => this.#invokeHandler(handler));
+
+    this.#handlers = this.#handlers.filter((h) => !(h.once && (domOnlyOnly ? h.domOnly : true)));
+  }
+
+  /**
+   * Executes a handler if its filter passes.
+   * @param {Handler} handler
+   */
+  #invokeHandler(handler) {
+    if (typeof handler.filter === 'function') {
+      try {
+        if (!handler.filter()) return;
+      } catch (err) {
+        console.warn('[TinyDomReadyManager] Filter error:', err);
+        return;
+      }
+    }
+
+    try {
+      handler.fn();
+    } catch (err) {
+      console.error('[TinyDomReadyManager] Handler error:', err);
+    }
+  }
+
+  /**
+   * Marks the system as DOM-ready and runs DOM-only handlers.
+   * @private
+   */
+  _markDomReady() {
+    this.#isDomReady = true;
+    this.#runHandlers(true); // Run domOnly
+    this.#checkAllReady(); // Then check for full readiness
+  }
+
+  /**
+   * Initializes the manager using `DOMContentLoaded`.
+   */
+  init() {
+    if (this.#isDomReady) throw new Error('[TinyDomReadyManager] init() has already been called.');
+
+    if (document.readyState === 'interactive' || document.readyState === 'complete') {
+      this._markDomReady();
+    } else {
+      document.addEventListener('DOMContentLoaded', () => this._markDomReady());
+    }
+  }
+
+  /**
+   * Adds a Promise to delay full readiness.
+   * @param {Promise<any>} promise
+   * @throws {TypeError}
+   */
+  addPromise(promise) {
+    if (!(promise instanceof Promise))
+      throw new TypeError('[TinyDomReadyManager] promise must be a valid Promise.');
+
+    if (this.#isFullyReady) return;
+    this.#promises.push(promise);
+    if (this.#isDomReady) this.#checkAllReady();
+  }
+
+  /**
+   * Registers a handler to run either after DOM is ready or after full readiness.
+   *
+   * @param {Fn} fn - Function to execute.
+   * @param {Object} [options]
+   * @param {boolean} [options.once=true] - Execute only once.
+   * @param {number} [options.priority=0] - Higher priority runs first.
+   * @param {FnFilter|null} [options.filter=null] - Optional filter function.
+   * @param {boolean} [options.domOnly=false] - If true, executes after DOM ready only.
+   * @throws {TypeError} If fn is not a function.
+   */
+  onReady(fn, { once = true, priority = 0, filter = null, domOnly = false } = {}) {
+    if (typeof fn !== 'function')
+      throw new TypeError('[TinyDomReadyManager] fn must be a function.');
+
+    const handler = { fn, once, priority, filter, domOnly };
+
+    if (domOnly && this.#isDomReady) {
+      this.#invokeHandler(handler);
+      if (!once) this.#handlers.push(handler);
+      return;
+    }
+
+    if (!domOnly && this.#isFullyReady) {
+      this.#invokeHandler(handler);
+    } else {
+      this.#handlers.push(handler);
+    }
+  }
+
+  /**
+   * Returns whether the system is fully ready (DOM + Promises).
+   * @returns {boolean}
+   */
+  isReady() {
+    return this.#isFullyReady;
+  }
+
+  /**
+   * Returns whether the DOM is ready (DOMContentLoaded has fired).
+   * Does not wait for promises.
+   * @returns {boolean}
+   */
+  isDomReady() {
+    return this.#isDomReady;
+  }
+}
+
+/* harmony default export */ const libs_TinyDomReadyManager = (TinyDomReadyManager);
+
 ;// ./src/v1/index.mjs
 
 
@@ -8030,6 +8391,11 @@ class TinyDragger {
 
 
 
+
+
+
+
+