tiny-essentials 1.12.1 → 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
 
 
@@ -8031,6 +8217,10 @@ class TinyDragger {
 
 
 
+
+
+
+