tiny-essentials 1.12.0 → 1.12.2

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:
@@ -2893,18 +2900,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 +2924,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 +6625,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 +6644,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 +6658,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 +6669,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 +6680,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 +6702,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 +6712,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 +6721,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 +6735,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 +6745,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 +6760,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 +6783,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 +6812,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 +6836,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 +6865,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 +6877,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 +6896,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 +6918,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 +6929,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 +6953,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 +6971,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 +7009,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 +7034,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
 
 
@@ -7132,6 +7318,7 @@ class TinyDragger {
   #offsetY = 0;
   #offsetX = 0;
 
+  #multiCollision = false;
   #lockInsideJail = false;
   #revertOnDrop = false;
   #dragging = false;
@@ -7176,6 +7363,7 @@ class TinyDragger {
    * @param {string} [options.classDragCollision='dragging-collision'] - CSS class applied to collision element.
    * @param {boolean} [options.lockInsideJail=false] - Restrict movement within the jail container.
    * @param {boolean} [options.dropInJailOnly=false] - Restrict drop within the jail container.
+   * @param {boolean} [options.multiCollision=false] - Enables returning multiple collided elements.
    * @param {VibrationPatterns|false} [options.vibration=false] - Vibration feedback configuration.
    * @param {boolean} [options.revertOnDrop=false] - Whether to return to original position on drop.
    * @param {string} [options.classHidden='drag-hidden'] - CSS class to hide original element during dragging.
@@ -7222,6 +7410,7 @@ class TinyDragger {
     validateBoolean(options.lockInsideJail, 'lockInsideJail');
     validateBoolean(options.dropInJailOnly, 'dropInJailOnly');
     validateBoolean(options.revertOnDrop, 'revertOnDrop');
+    validateBoolean(options.multiCollision, 'multiCollision');
 
     validateString(options.classDragging, 'classDragging');
     validateString(options.classBodyDragging, 'classBodyDragging');
@@ -7255,6 +7444,7 @@ class TinyDragger {
     if (typeof options.revertOnDrop === 'boolean') this.#revertOnDrop = options.revertOnDrop;
     if (typeof options.lockInsideJail === 'boolean') this.#lockInsideJail = options.lockInsideJail;
     if (typeof options.dropInJailOnly === 'boolean') this.#dropInJailOnly = options.dropInJailOnly;
+    if (typeof options.multiCollision === 'boolean') this.#multiCollision = options.multiCollision;
 
     /** @private */
     this._onMouseDown = this.#startDrag.bind(this);
@@ -7446,22 +7636,67 @@ class TinyDragger {
     this.#dispatchEvent('drag');
   }
 
+  /** @type {HTMLElement[]} */
+  #collisionsMarked = [];
+
+  /**
+   * Marks an element as currently collided by adding the collision CSS class.
+   * The element is stored in an internal list for easy removal later.
+   *
+   * @param {HTMLElement|null} el - The element to mark as collided.
+   */
+  #addCollision(el) {
+    if (!el) return;
+    el.classList.add(this.#classDragCollision);
+    this.#collisionsMarked.push(el);
+  }
+
+  /**
+   * Removes the collision CSS class from all previously marked elements.
+   * Also clears the last single collision element, if set.
+   *
+   */
+  #removeCollision() {
+    while (this.#collisionsMarked.length > 0) {
+      const el = this.#collisionsMarked.shift();
+      if (el) el.classList.remove(this.#classDragCollision);
+    }
+    if (!this.#lastCollision) return;
+    this.#lastCollision.classList.remove(this.#classDragCollision);
+  }
+
   /**
    * Handles dragging collision.
    * @param {MouseEvent|Touch} event - The drag event.
    */
   checkDragCollision(event) {
-    const { collidedElement: collided } = this.execCollision(event);
-    if (collided && collided !== this.#lastCollision) {
-      if (navigator.vibrate && Array.isArray(this.#vibration.collide)) {
-        navigator.vibrate(this.#vibration.collide);
+    const { collidedElements } = this.execCollision(event);
+    const first = collidedElements[0] || null;
+
+    // Removes old marking if necessary
+    if (this.#lastCollision && !collidedElements.includes(this.#lastCollision)) {
+      this.#removeCollision();
+    }
+
+    // Adds Marking for All Colluded
+    collidedElements.forEach((el) => this.#addCollision(el));
+
+    // Removes markings from who no longer collided
+    this.#collidables.forEach((el) => {
+      if (!collidedElements.includes(el)) {
+        el.classList.remove(this.#classDragCollision);
       }
-      this.#lastCollision = collided;
-      if (this.#lastCollision) this.#lastCollision.classList.add(this.#classDragCollision);
-    } else if (!collided) {
-      if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
-      this.#lastCollision = null;
+    });
+
+    if (
+      navigator.vibrate &&
+      Array.isArray(this.#vibration.collide) &&
+      collidedElements.length > 0
+    ) {
+      navigator.vibrate(this.#vibration.collide);
     }
+
+    this.#lastCollision = first;
   }
 
   /**
@@ -7508,37 +7743,48 @@ class TinyDragger {
   /**
    * Handles the collision of a drag.
    * @param {MouseEvent|Touch} event - The release event.
-   * @returns {{ inJail: boolean; collidedElement: HTMLElement|null }}
+   * @returns {{ inJail: boolean; collidedElements: (HTMLElement | null)[] }}
    */
   execCollision(event) {
-    if (this.#destroyed || !this.#dragProxy) return { inJail: false, collidedElement: null };
+    if (this.#destroyed || !this.#dragProxy) return { inJail: false, collidedElements: [] };
 
-    let collidedElement;
+    let collidedElements = [];
     let inJail = true;
     const jailRect = this.#jail?.getBoundingClientRect();
+
     if (this.#collisionByMouse) {
       const x = event.clientX;
       const y = event.clientY;
+
       if (this.#dropInJailOnly && this.#jail && jailRect) {
         inJail =
           x >= jailRect.left && x <= jailRect.right && y >= jailRect.top && y <= jailRect.bottom;
       }
 
-      collidedElement = inJail ? this.getCollidedElement(x, y) : null;
+      collidedElements = inJail
+        ? this.#multiCollision
+          ? this.getAllCollidedElements(x, y)
+          : [this.getCollidedElement(x, y)].filter(Boolean)
+        : [];
     } else {
-      const targetRect = this.#dragProxy.getBoundingClientRect();
+      const rect = this.#dragProxy.getBoundingClientRect();
+
       if (this.#dropInJailOnly && this.#jail && jailRect) {
         inJail =
-          targetRect.left >= jailRect.left &&
-          targetRect.right <= jailRect.right &&
-          targetRect.top >= jailRect.top &&
-          targetRect.bottom <= jailRect.bottom;
+          rect.left >= jailRect.left &&
+          rect.right <= jailRect.right &&
+          rect.top >= jailRect.top &&
+          rect.bottom <= jailRect.bottom;
       }
 
-      collidedElement = inJail ? this.getCollidedElementByRect(targetRect) : null;
+      collidedElements = inJail
+        ? this.#multiCollision
+          ? this.getAllCollidedElementsByRect(rect)
+          : [this.getCollidedElementByRect(rect)].filter(Boolean)
+        : [];
     }
 
-    return { inJail, collidedElement };
+    return { inJail, collidedElements };
   }
 
   /**
@@ -7561,7 +7807,7 @@ class TinyDragger {
 
     document.removeEventListener('touchmove', this._onTouchMove);
     document.removeEventListener('touchend', this._onTouchEnd);
-    const { collidedElement } = this.execCollision(event);
+    const { collidedElements } = this.execCollision(event);
 
     if (navigator.vibrate && Array.isArray(this.#vibration.end)) {
       navigator.vibrate(this.#vibration.end);
@@ -7574,7 +7820,7 @@ class TinyDragger {
       this.#dragProxy = null;
     }
 
-    if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
+    if (this.#lastCollision) this.#removeCollision();
     this.#lastCollision = null;
 
     this.#target.classList.remove(this.#dragHiddenClass);
@@ -7585,13 +7831,50 @@ class TinyDragger {
 
     const dropEvent = new CustomEvent('drop', {
       detail: {
-        target: collidedElement,
+        targets: collidedElements,
+        first: collidedElements[0] || null,
       },
     });
-
     this.#target.dispatchEvent(dropEvent);
   }
 
+  /**
+   * Checks if the provided element intersects with the given bounding rectangle.
+   *
+   * @param {HTMLElement} el - The element to test for collision.
+   * @param {DOMRect} rect - The bounding rectangle to check against.
+   * @returns {boolean} True if the element intersects with the rectangle.
+   */
+  #getCollidedElementByRect(el, rect) {
+    const elRect = el.getBoundingClientRect();
+    return !(
+      rect.right < elRect.left ||
+      rect.left > elRect.right ||
+      rect.bottom < elRect.top ||
+      rect.top > elRect.bottom
+    );
+  }
+
+  /**
+   * Returns all elements currently colliding with the given rectangle.
+   *
+   * @param {DOMRect} rect - Bounding rectangle of the dragged proxy.
+   * @returns {HTMLElement[]} A list of all collided elements.
+   * @throws {Error} If the input is not a valid DOMRect with numeric bounds.
+   */
+  getAllCollidedElementsByRect(rect) {
+    this.#checkDestroy();
+    if (
+      !(rect instanceof DOMRect) ||
+      typeof rect.left !== 'number' ||
+      typeof rect.right !== 'number' ||
+      typeof rect.top !== 'number' ||
+      typeof rect.bottom !== 'number'
+    )
+      throw new Error('getCollidedElementByRect expects a valid DOMRect object.');
+    return this.#collidables.filter((el) => this.#getCollidedElementByRect(el, rect));
+  }
+
   /**
    * Detects collision based on rectangle intersection.
    * @param {DOMRect} rect - Bounding rectangle of the dragged proxy.
@@ -7608,18 +7891,32 @@ class TinyDragger {
       typeof rect.bottom !== 'number'
     )
       throw new Error('getCollidedElementByRect expects a valid DOMRect object.');
+    return this.#collidables.find((el) => this.#getCollidedElementByRect(el, rect)) || null;
+  }
 
-    return (
-      this.#collidables.find((el) => {
-        const elRect = el.getBoundingClientRect();
-        return !(
-          rect.right < elRect.left ||
-          rect.left > elRect.right ||
-          rect.bottom < elRect.top ||
-          rect.top > elRect.bottom
-        );
-      }) || null
-    );
+  /**
+   * Checks whether a given (x, y) coordinate is inside the bounding rectangle of an element.
+   *
+   * @param {HTMLElement} el - The element to test for collision.
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {boolean} True if the point is within the element's bounds.
+   */
+  #getCollidedElement(el, x, y) {
+    const rect = el.getBoundingClientRect();
+    return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+  }
+
+  /**
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {HTMLElement[]} The collided element or null.
+   */
+  getAllCollidedElements(x, y) {
+    this.#checkDestroy();
+    if (typeof x !== 'number' || typeof y !== 'number')
+      throw new Error('getCollidedElement expects numeric x and y coordinates.');
+    return this.#collidables.filter((el) => this.#getCollidedElement(el, x, y));
   }
 
   /**
@@ -7632,13 +7929,7 @@ class TinyDragger {
     this.#checkDestroy();
     if (typeof x !== 'number' || typeof y !== 'number')
       throw new Error('getCollidedElement expects numeric x and y coordinates.');
-
-    return (
-      this.#collidables.find((el) => {
-        const rect = el.getBoundingClientRect();
-        return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
-      }) || null
-    );
+    return this.#collidables.find((el) => this.#getCollidedElement(el, x, y)) || null;
   }
 
   /**
@@ -7888,7 +8179,7 @@ class TinyDragger {
     document.removeEventListener('touchmove', this._onTouchMove);
     document.removeEventListener('touchend', this._onTouchEnd);
 
-    if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
+    if (this.#lastCollision) this.#removeCollision();
     if (this.#dragProxy) {
       this.#dragProxy.remove();
       this.#dragProxy = null;
@@ -7926,6 +8217,10 @@ class TinyDragger {
 
 
 
+
+
+
+