tiny-essentials 1.10.2 → 1.12.0

package/dist/{TinyEssentials.js → v1/TinyBasicsEs.js}

@@ -1,6 +1,13 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
+/***/ 41:
+/***/ (() => {
+
+/* (ignored) */
+
+/***/ }),
+
 /***/ 251:
 /***/ ((__unused_webpack_module, exports) => {
 
@@ -2075,6 +2082,735 @@ function fromByteArray (uint8) {
 }
 
 
+/***/ }),
+
+/***/ 606:
+/***/ ((module) => {
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+
+/***/ }),
+
+/***/ 975:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/* provided dependency */ var process = __webpack_require__(606);
+// 'path' module extracted from Node.js v8.11.1 (only the posix part)
+// transplited with Babel
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+function assertPath(path) {
+  if (typeof path !== 'string') {
+    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));
+  }
+}
+
+// Resolves . and .. elements in a path with directory names
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = '';
+  var lastSegmentLength = 0;
+  var lastSlash = -1;
+  var dots = 0;
+  var code;
+  for (var i = 0; i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47 /*/*/)
+      break;
+    else
+      code = 47 /*/*/;
+    if (code === 47 /*/*/) {
+      if (lastSlash === i - 1 || dots === 1) {
+        // NOOP
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf('/');
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = '';
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = '';
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += '/..';
+          else
+            res = '..';
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += '/' + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === 46 /*.*/ && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root;
+  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+
+var posix = {
+  // path.resolve([from ...], to)
+  resolve: function resolve() {
+    var resolvedPath = '';
+    var resolvedAbsolute = false;
+    var cwd;
+
+    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      var path;
+      if (i >= 0)
+        path = arguments[i];
+      else {
+        if (cwd === undefined)
+          cwd = process.cwd();
+        path = cwd;
+      }
+
+      assertPath(path);
+
+      // Skip empty entries
+      if (path.length === 0) {
+        continue;
+      }
+
+      resolvedPath = path + '/' + resolvedPath;
+      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    }
+
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+
+    // Normalize the path
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+
+    if (resolvedAbsolute) {
+      if (resolvedPath.length > 0)
+        return '/' + resolvedPath;
+      else
+        return '/';
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    } else {
+      return '.';
+    }
+  },
+
+  normalize: function normalize(path) {
+    assertPath(path);
+
+    if (path.length === 0) return '.';
+
+    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;
+
+    // Normalize the path
+    path = normalizeStringPosix(path, !isAbsolute);
+
+    if (path.length === 0 && !isAbsolute) path = '.';
+    if (path.length > 0 && trailingSeparator) path += '/';
+
+    if (isAbsolute) return '/' + path;
+    return path;
+  },
+
+  isAbsolute: function isAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;
+  },
+
+  join: function join() {
+    if (arguments.length === 0)
+      return '.';
+    var joined;
+    for (var i = 0; i < arguments.length; ++i) {
+      var arg = arguments[i];
+      assertPath(arg);
+      if (arg.length > 0) {
+        if (joined === undefined)
+          joined = arg;
+        else
+          joined += '/' + arg;
+      }
+    }
+    if (joined === undefined)
+      return '.';
+    return posix.normalize(joined);
+  },
+
+  relative: function relative(from, to) {
+    assertPath(from);
+    assertPath(to);
+
+    if (from === to) return '';
+
+    from = posix.resolve(from);
+    to = posix.resolve(to);
+
+    if (from === to) return '';
+
+    // Trim any leading backslashes
+    var fromStart = 1;
+    for (; fromStart < from.length; ++fromStart) {
+      if (from.charCodeAt(fromStart) !== 47 /*/*/)
+        break;
+    }
+    var fromEnd = from.length;
+    var fromLen = fromEnd - fromStart;
+
+    // Trim any leading backslashes
+    var toStart = 1;
+    for (; toStart < to.length; ++toStart) {
+      if (to.charCodeAt(toStart) !== 47 /*/*/)
+        break;
+    }
+    var toEnd = to.length;
+    var toLen = toEnd - toStart;
+
+    // Compare paths to find the longest common path from root
+    var length = fromLen < toLen ? fromLen : toLen;
+    var lastCommonSep = -1;
+    var i = 0;
+    for (; i <= length; ++i) {
+      if (i === length) {
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === 47 /*/*/) {
+            // We get here if `from` is the exact base path for `to`.
+            // For example: from='/foo/bar'; to='/foo/bar/baz'
+            return to.slice(toStart + i + 1);
+          } else if (i === 0) {
+            // We get here if `from` is the root
+            // For example: from='/'; to='/foo'
+            return to.slice(toStart + i);
+          }
+        } else if (fromLen > length) {
+          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {
+            // We get here if `to` is the exact base path for `from`.
+            // For example: from='/foo/bar/baz'; to='/foo/bar'
+            lastCommonSep = i;
+          } else if (i === 0) {
+            // We get here if `to` is the root.
+            // For example: from='/foo'; to='/'
+            lastCommonSep = 0;
+          }
+        }
+        break;
+      }
+      var fromCode = from.charCodeAt(fromStart + i);
+      var toCode = to.charCodeAt(toStart + i);
+      if (fromCode !== toCode)
+        break;
+      else if (fromCode === 47 /*/*/)
+        lastCommonSep = i;
+    }
+
+    var out = '';
+    // Generate the relative path based on the path difference between `to`
+    // and `from`
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {
+        if (out.length === 0)
+          out += '..';
+        else
+          out += '/..';
+      }
+    }
+
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts
+    if (out.length > 0)
+      return out + to.slice(toStart + lastCommonSep);
+    else {
+      toStart += lastCommonSep;
+      if (to.charCodeAt(toStart) === 47 /*/*/)
+        ++toStart;
+      return to.slice(toStart);
+    }
+  },
+
+  _makeLong: function _makeLong(path) {
+    return path;
+  },
+
+  dirname: function dirname(path) {
+    assertPath(path);
+    if (path.length === 0) return '.';
+    var code = path.charCodeAt(0);
+    var hasRoot = code === 47 /*/*/;
+    var end = -1;
+    var matchedSlash = true;
+    for (var i = path.length - 1; i >= 1; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          if (!matchedSlash) {
+            end = i;
+            break;
+          }
+        } else {
+        // We saw the first non-path separator
+        matchedSlash = false;
+      }
+    }
+
+    if (end === -1) return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1) return '//';
+    return path.slice(0, end);
+  },
+
+  basename: function basename(path, ext) {
+    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('"ext" argument must be a string');
+    assertPath(path);
+
+    var start = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i;
+
+    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+      if (ext.length === path.length && ext === path) return '';
+      var extIdx = ext.length - 1;
+      var firstNonSlashEnd = -1;
+      for (i = path.length - 1; i >= 0; --i) {
+        var code = path.charCodeAt(i);
+        if (code === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else {
+          if (firstNonSlashEnd === -1) {
+            // We saw the first non-path separator, remember this index in case
+            // we need it if the extension ends up not matching
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            // Try to match the explicit extension
+            if (code === ext.charCodeAt(extIdx)) {
+              if (--extIdx === -1) {
+                // We matched the extension, so mark this as the end of our path
+                // component
+                end = i;
+              }
+            } else {
+              // Extension does not match, so our result is the entire path
+              // component
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+
+      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;
+      return path.slice(start, end);
+    } else {
+      for (i = path.length - 1; i >= 0; --i) {
+        if (path.charCodeAt(i) === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else if (end === -1) {
+          // We saw the first non-path separator, mark this as the end of our
+          // path component
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+
+      if (end === -1) return '';
+      return path.slice(start, end);
+    }
+  },
+
+  extname: function extname(path) {
+    assertPath(path);
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+    for (var i = path.length - 1; i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1)
+            startDot = i;
+          else if (preDotState !== 1)
+            preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      return '';
+    }
+    return path.slice(startDot, end);
+  },
+
+  format: function format(pathObject) {
+    if (pathObject === null || typeof pathObject !== 'object') {
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+    }
+    return _format('/', pathObject);
+  },
+
+  parse: function parse(path) {
+    assertPath(path);
+
+    var ret = { root: '', dir: '', base: '', ext: '', name: '' };
+    if (path.length === 0) return ret;
+    var code = path.charCodeAt(0);
+    var isAbsolute = code === 47 /*/*/;
+    var start;
+    if (isAbsolute) {
+      ret.root = '/';
+      start = 1;
+    } else {
+      start = 0;
+    }
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i = path.length - 1;
+
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+
+    // Get non-dir info
+    for (; i >= start; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;
+        } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      if (end !== -1) {
+        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);
+      }
+    } else {
+      if (startPart === 0 && isAbsolute) {
+        ret.name = path.slice(1, startDot);
+        ret.base = path.slice(1, end);
+      } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+      }
+      ret.ext = path.slice(startDot, end);
+    }
+
+    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';
+
+    return ret;
+  },
+
+  sep: '/',
+  delimiter: ':',
+  win32: null,
+  posix: null
+};
+
+posix.posix = posix;
+
+module.exports = posix;
+
+
 /***/ })
 
 /******/ 	});
@@ -2142,33 +2878,93 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  ColorSafeStringify: () => (/* reexport */ libs_ColorSafeStringify),
-  TinyLevelUp: () => (/* reexport */ userLevel),
-  TinyPromiseQueue: () => (/* reexport */ libs_TinyPromiseQueue),
-  TinyRateLimiter: () => (/* reexport */ libs_TinyRateLimiter),
   addAiMarkerShortcut: () => (/* reexport */ addAiMarkerShortcut),
+  areHtmlElsColliding: () => (/* reexport */ areHtmlElsColliding),
   arraySortPositions: () => (/* reexport */ arraySortPositions),
   asyncReplace: () => (/* reexport */ asyncReplace),
-  checkObj: () => (/* reexport */ checkObj),
+  backupFile: () => (/* reexport */ backupFile),
+  clearDirectory: () => (/* reexport */ clearDirectory),
   cloneObjTypeOrder: () => (/* reexport */ cloneObjTypeOrder),
   countObj: () => (/* reexport */ countObj),
+  dirExists: () => (/* reexport */ dirExists),
+  dirSize: () => (/* reexport */ dirSize),
+  documentIsFullScreen: () => (/* reexport */ documentIsFullScreen),
+  ensureCopyFile: () => (/* reexport */ ensureCopyFile),
+  ensureDirectory: () => (/* reexport */ ensureDirectory),
+  exitFullScreen: () => (/* reexport */ exitFullScreen),
   extendObjType: () => (/* reexport */ extendObjType),
+  fetchJson: () => (/* reexport */ fetchJson),
+  fileExists: () => (/* reexport */ fileExists),
+  fileSize: () => (/* reexport */ fileSize),
   formatBytes: () => (/* reexport */ formatBytes),
   formatCustomTimer: () => (/* reexport */ formatCustomTimer),
   formatDayTimer: () => (/* reexport */ formatDayTimer),
   formatTimer: () => (/* reexport */ formatTimer),
   getAge: () => (/* reexport */ getAge),
+  getHtmlElBorders: () => (/* reexport */ getHtmlElBorders),
+  getHtmlElBordersWidth: () => (/* reexport */ getHtmlElBordersWidth),
+  getHtmlElMargin: () => (/* reexport */ getHtmlElMargin),
+  getHtmlElPadding: () => (/* reexport */ getHtmlElPadding),
+  getLatestBackupPath: () => (/* reexport */ getLatestBackupPath),
   getSimplePerc: () => (/* reexport */ getSimplePerc),
   getTimeDuration: () => (/* reexport */ getTimeDuration),
+  isDirEmpty: () => (/* reexport */ isDirEmpty),
+  isFullScreenMode: () => (/* reexport */ isFullScreenMode),
   isJsonObject: () => (/* reexport */ isJsonObject),
+  isScreenFilled: () => (/* reexport */ isScreenFilled),
+  listDirs: () => (/* reexport */ listDirs),
+  listFiles: () => (/* reexport */ listFiles),
   objType: () => (/* reexport */ objType),
+  offFullScreenChange: () => (/* reexport */ offFullScreenChange),
+  onFullScreenChange: () => (/* reexport */ onFullScreenChange),
+  readJsonBlob: () => (/* reexport */ readJsonBlob),
+  readJsonFile: () => (/* reexport */ readJsonFile),
+  renameFileAddPrefixSuffix: () => (/* reexport */ renameFileAddPrefixSuffix),
+  renameFileBatch: () => (/* reexport */ renameFileBatch),
+  renameFileNormalizeCase: () => (/* reexport */ renameFileNormalizeCase),
+  renameFilePadNumbers: () => (/* reexport */ renameFilePadNumbers),
+  renameFileRegex: () => (/* reexport */ renameFileRegex),
   reorderObjTypeOrder: () => (/* reexport */ reorderObjTypeOrder),
+  requestFullScreen: () => (/* reexport */ requestFullScreen),
+  restoreLatestBackup: () => (/* reexport */ restoreLatestBackup),
   ruleOfThree: () => (/* reexport */ ruleOfThree),
+  saveJsonFile: () => (/* reexport */ saveJsonFile),
   shuffleArray: () => (/* reexport */ shuffleArray),
   toTitleCase: () => (/* reexport */ toTitleCase),
-  toTitleCaseLowerFirst: () => (/* reexport */ toTitleCaseLowerFirst)
+  toTitleCaseLowerFirst: () => (/* reexport */ toTitleCaseLowerFirst),
+  tryDeleteFile: () => (/* reexport */ tryDeleteFile),
+  writeJsonFile: () => (/* reexport */ writeJsonFile),
+  writeTextFile: () => (/* reexport */ writeTextFile)
 });
 
+;// ./src/legacy/libs/arraySortPositions.mjs
+/**
+ * Generates a comparator function to sort an array of objects by a given key.
+ *
+ * @param {string} item - The object key to sort by.
+ * @param {boolean} [isReverse=false] - If `true`, the sorting will be in descending order.
+ * @returns {(a: Object<string|number, *>, b: Object<string|number, *>) => number} Comparator function compatible with Array.prototype.sort().
+ *
+ * @example
+ * const arr = [{ pos: 2 }, { pos: 1 }, { pos: 3 }];
+ * arr.sort(arraySortPositions('pos')); // Ascending: [{pos: 1}, {pos: 2}, {pos: 3}]
+ *
+ * @example
+ * const arr = [{ pos: 2 }, { pos: 1 }, { pos: 3 }];
+ * arr.sort(arraySortPositions('pos', true)); // Descending: [{pos: 3}, {pos: 2}, {pos: 1}]
+ */
+function arraySortPositions(item, isReverse = false) {
+  if (!isReverse) {
+    return function (a, b) {
+      return a[item] < b[item] ? -1 : a[item] > b[item] ? 1 : 0;
+    };
+  } else {
+    return function (a, b) {
+      return a[item] > b[item] ? -1 : a[item] < b[item] ? 1 : 0;
+    };
+  }
+}
+
 ;// ./src/legacy/libs/replaceAsync.mjs
 /**
  * Asynchronously replaces matches in a string using a regex and an async function.
@@ -2202,348 +2998,68 @@ async function asyncReplace(str, regex, asyncFn) {
   return str.replace(regex, () => data.shift());
 }
 
-;// ./src/legacy/libs/userLevel.mjs
+;// ./src/v1/basics/array.mjs
+// https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+
 /**
- * Represents a user object used.
+ * Randomly shuffles the elements of an array in place using the Fisher–Yates algorithm.
  *
- * @typedef {Object} UserEditor
- * @property {number} exp - Current experience points of the user.
- * @property {number} level - Current level of the user.
- * @property {number} totalExp - Total accumulated experience.
+ * This implementation ensures a uniform distribution of permutations.
+ * Original algorithm source: StackOverflow (link above).
+ *
+ * @param {any[]} items - The array to shuffle.
+ * @returns {any[]} The same array instance, now shuffled in place.
  */
+function shuffleArray(items) {
+  let currentIndex = items.length,
+    randomIndex;
+
+  // While there remain elements to shuffle...
+  while (currentIndex !== 0) {
+    // Pick a remaining element...
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+
+    // And swap it with the current element.
+    [items[currentIndex], items[randomIndex]] = [items[randomIndex], items[currentIndex]];
+  }
+
+  return items;
+}
 
+;// ./src/v1/basics/clock.mjs
 /**
- * Class to manage user level-up logic based on experience points.
+ * Calculates the time duration between the current time and a given time offset.
+ *
+ * @param {Date} timeData - The target time as a Date object.
+ * @param {string} [durationType='asSeconds'] - The type of duration to return. Can be 'asMilliseconds', 'asSeconds', 'asMinutes', 'asHours', 'asDays'.
+ * @param {Date|null} [now=null] - The current time as a Date object. Defaults to the current date and time if not provided.
+ * @returns {number|null} The calculated duration in the specified unit, or `null` if `timeData` is not provided.
  */
-class TinyLevelUp {
-  /**
-   * Constructor
-   * @param {number} giveExp - Base experience value for random experience generation.
-   * @param {number} expLevel - Base experience needed to level up (per level).
-   */
-  constructor(giveExp, expLevel) {
-    if (typeof giveExp !== 'number' || Number.isNaN(giveExp))
-      throw new Error('giveExp must be a valid number');
-    if (typeof expLevel !== 'number' || Number.isNaN(expLevel))
-      throw new Error('expLevel must be a valid number');
-    this.giveExp = giveExp;
-    this.expLevel = expLevel;
-  }
+function getTimeDuration(timeData = new Date(), durationType = 'asSeconds', now = null) {
+  if (timeData instanceof Date) {
+    const currentTime = now instanceof Date ? now : new Date();
+    /** @type {number} */
+    const diffMs = timeData.getTime() - currentTime.getTime();
 
-  /**
-   * Creates a new user object starting at level 0 with 0 experience.
-   * @returns {UserEditor} A fresh user object.
-   */
-  createUser() {
-    return {
-      exp: 0,
-      level: 1,
-      totalExp: 0,
-    };
+    switch (durationType) {
+      case 'asMilliseconds':
+        return diffMs;
+      case 'asSeconds':
+        return diffMs / 1000;
+      case 'asMinutes':
+        return diffMs / (1000 * 60);
+      case 'asHours':
+        return diffMs / (1000 * 60 * 60);
+      case 'asDays':
+        return diffMs / (1000 * 60 * 60 * 24);
+      default:
+        return diffMs / 1000; // default to seconds
+    }
   }
 
-  /**
-   * Validates if the given user object has valid numeric properties.
-   * Throws an error if any property is invalid.
-   *
-   * @param {UserEditor} user - The user object to validate.
-   * @throws {Error} If any property (exp, level, totalExp) is not a valid number.
-   */
-  validateUser(user) {
-    if (typeof user.exp !== 'number' || Number.isNaN(user.exp))
-      throw new Error('exp must be a valid number');
-    if (typeof user.level !== 'number' || Number.isNaN(user.level))
-      throw new Error('level must be a valid number');
-    if (user.level < 1) throw new Error('level must be at least 1');
-    if (typeof user.totalExp !== 'number' || Number.isNaN(user.totalExp))
-      throw new Error('totalExp must be a valid number');
-  }
-
-  /**
-   * Checks if the given user object is valid by verifying its numeric properties.
-   *
-   * @param {UserEditor} user - The user object to check.
-   * @returns {boolean} `true` if all properties (exp, level, totalExp) are valid numbers; otherwise `false`.
-   */
-  isValidUser(user) {
-    if (typeof user.exp !== 'number' || Number.isNaN(user.exp)) return false;
-    if (typeof user.level !== 'number' || Number.isNaN(user.level)) return false;
-    if (user.level < 1) return false;
-    if (typeof user.totalExp !== 'number' || Number.isNaN(user.totalExp)) return false;
-    return true;
-  }
-
-  /**
-   * Returns the base experience value used for random experience generation.
-   * Throws an error if the internal giveExp value is not a valid number.
-   *
-   * @returns {number} The base experience value.
-   * @throws {Error} If giveExp is not a valid number.
-   */
-  getGiveExpBase() {
-    if (typeof this.giveExp !== 'number' || Number.isNaN(this.giveExp))
-      throw new Error('giveExp must be a valid number');
-    return this.giveExp;
-  }
-
-  /**
-   * Returns the base experience required to level up.
-   * Throws an error if the internal expLevel value is not a valid number.
-   *
-   * @returns {number} The base experience needed per level.
-   * @throws {Error} If expLevel is not a valid number.
-   */
-  getExpLevelBase() {
-    if (typeof this.expLevel !== 'number' || Number.isNaN(this.expLevel))
-      throw new Error('expLevel must be a valid number');
-    return this.expLevel;
-  }
-
-  /**
-   * Validates and adjusts the user's level based on their current experience.
-   * @param {UserEditor} user - The user object containing experience and level properties.
-   * @returns {UserEditor} The updated user object.
-   * @throws {Error} If any property (exp, level, totalExp) is not a valid number.
-   */
-  expValidator(user) {
-    const expLevel = this.getExpLevelBase();
-    this.validateUser(user);
-
-    let extraValue = 0;
-    const nextLevelExp = expLevel * user.level;
-
-    // Level Up
-    if (user.exp >= nextLevelExp) {
-      user.level++;
-      extraValue = user.exp - nextLevelExp;
-      user.exp = 0;
-
-      if (extraValue > 0) return this.give(user, extraValue, 'extra');
-    }
-
-    // Level Down
-    if (user.exp < 1 && user.level > 1) {
-      user.level--;
-      extraValue = Math.abs(user.exp);
-      user.exp = expLevel * user.level;
-
-      if (extraValue > 0) return this.remove(user, extraValue, 'extra');
-    }
-
-    return user;
-  }
-
-  /**
-   * Calculates the total experience based on the user's level.
-   * @param {UserEditor} user - The user object containing experience and level properties.
-   * @returns {number} The total experience of the user.
-   * @throws {Error} If any property (exp, level, totalExp) is not a valid number.
-   */
-  getTotalExp(user) {
-    this.validateUser(user);
-    let totalExp = 0;
-    for (let p = 1; p <= user.level; p++) totalExp += this.getExpLevelBase() * p;
-    totalExp += user.exp;
-    return totalExp;
-  }
-
-  /**
-   * Generates random experience points based on the configured multiplier.
-   * @param {number} [multi] - A multiplier for the generated experience.
-   * @returns {number} The generated experience points.
-   */
-  expGenerator(multi = 1) {
-    if (typeof multi !== 'number' || Number.isNaN(multi))
-      throw new Error('multi must be a valid number');
-    return Math.floor(Math.random() * this.getGiveExpBase()) * multi;
-  }
-
-  /**
-   * Calculates how much experience is missing to next level.
-   * @param {UserEditor} user
-   * @returns {number}
-   * @throws {Error} If any property (exp, level, totalExp) is not a valid number.
-   */
-  getMissingExp(user) {
-    return this.getProgress(user) - user.exp;
-  }
-
-  /**
-   * Gets the experience points required to reach the next level.
-   * @param {UserEditor} user - The user object containing the level.
-   * @returns {number} The experience required for the next level.
-   * @throws {Error} If any property (exp, level, totalExp) is not a valid number.
-   */
-  progress(user) {
-    return this.getProgress(user);
-  }
-
-  /**
-   * Gets the experience points required to reach the next level.
-   * @param {UserEditor} user - The user object containing the level.
-   * @returns {number} The experience required for the next level.
-   * @throws {Error} If any property (exp, level, totalExp) is not a valid number.
-   */
-  getProgress(user) {
-    this.validateUser(user);
-    return this.getExpLevelBase() * user.level;
-  }
-
-  /**
-   * Sets the experience value for the user, adjusting their level if necessary.
-   * @param {UserEditor} user - The user object.
-   * @param {number} value - The new experience value to set.
-   * @returns {UserEditor} The updated user object.
-   */
-  set(user, value) {
-    if (typeof value !== 'number' || Number.isNaN(value))
-      throw new Error('value must be a valid number');
-
-    user.exp = value;
-    this.expValidator(user);
-    user.totalExp = this.getTotalExp(user);
-    return user;
-  }
-
-  /**
-   * Adds experience to the user, adjusting their level if necessary.
-   * @param {UserEditor} user - The user object.
-   * @param {number} [extraExp] - Additional experience to be added.
-   * @param {'add' | 'extra'} [type] - Type of addition ('add' or 'extra').
-   * @param {number} [multi] - Multiplier for experience generation.
-   * @returns {UserEditor} The updated user object.
-   */
-  give(user, extraExp = 0, type = 'add', multi = 1) {
-    if (typeof multi !== 'number' || Number.isNaN(multi))
-      throw new Error('multi must be a valid number');
-    if (typeof extraExp !== 'number' || Number.isNaN(extraExp))
-      throw new Error('extraExp must be a valid number');
-    if (typeof type !== 'string') throw new Error('type must be a valid string');
-
-    if (type === 'add') user.exp += this.expGenerator(multi) + extraExp;
-    else if (type === 'extra') user.exp += extraExp;
-
-    this.expValidator(user);
-    user.totalExp = this.getTotalExp(user);
-    return user;
-  }
-
-  /**
-   * Removes experience from the user, adjusting their level if necessary.
-   * @param {UserEditor} user - The user object.
-   * @param {number} [extraExp] - Additional experience to remove.
-   * @param {'add' | 'extra'} [type] - Type of removal ('add' or 'extra').
-   * @param {number} [multi] - Multiplier for experience generation.
-   * @returns {UserEditor} The updated user object.
-   */
-  remove(user, extraExp = 0, type = 'add', multi = 1) {
-    if (typeof multi !== 'number' || Number.isNaN(multi))
-      throw new Error('multi must be a valid number');
-    if (typeof extraExp !== 'number' || Number.isNaN(extraExp))
-      throw new Error('extraExp must be a valid number');
-    if (typeof type !== 'string') throw new Error('type must be a valid string');
-
-    if (type === 'add') user.exp -= this.expGenerator(multi) + extraExp;
-    else if (type === 'extra') user.exp -= extraExp;
-
-    this.expValidator(user);
-    user.totalExp = this.getTotalExp(user);
-    return user;
-  }
-}
-
-/* harmony default export */ const userLevel = (TinyLevelUp);
-
-;// ./src/legacy/libs/arraySortPositions.mjs
-/**
- * Generates a comparator function to sort an array of objects by a given key.
- *
- * @param {string} item - The object key to sort by.
- * @param {boolean} [isReverse=false] - If `true`, the sorting will be in descending order.
- * @returns {(a: Object<string|number, *>, b: Object<string|number, *>) => number} Comparator function compatible with Array.prototype.sort().
- *
- * @example
- * const arr = [{ pos: 2 }, { pos: 1 }, { pos: 3 }];
- * arr.sort(arraySortPositions('pos')); // Ascending: [{pos: 1}, {pos: 2}, {pos: 3}]
- *
- * @example
- * const arr = [{ pos: 2 }, { pos: 1 }, { pos: 3 }];
- * arr.sort(arraySortPositions('pos', true)); // Descending: [{pos: 3}, {pos: 2}, {pos: 1}]
- */
-function arraySortPositions(item, isReverse = false) {
-  if (!isReverse) {
-    return function (a, b) {
-      return a[item] < b[item] ? -1 : a[item] > b[item] ? 1 : 0;
-    };
-  } else {
-    return function (a, b) {
-      return a[item] > b[item] ? -1 : a[item] < b[item] ? 1 : 0;
-    };
-  }
-}
-
-;// ./src/v1/basics/array.mjs
-// https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
-
-/**
- * Randomly shuffles the elements of an array in place using the Fisher–Yates algorithm.
- *
- * This implementation ensures a uniform distribution of permutations.
- * Original algorithm source: StackOverflow (link above).
- *
- * @param {any[]} items - The array to shuffle.
- * @returns {any[]} The same array instance, now shuffled in place.
- */
-function shuffleArray(items) {
-  let currentIndex = items.length,
-    randomIndex;
-
-  // While there remain elements to shuffle...
-  while (currentIndex !== 0) {
-    // Pick a remaining element...
-    randomIndex = Math.floor(Math.random() * currentIndex);
-    currentIndex--;
-
-    // And swap it with the current element.
-    [items[currentIndex], items[randomIndex]] = [items[randomIndex], items[currentIndex]];
-  }
-
-  return items;
-}
-
-;// ./src/v1/basics/clock.mjs
-/**
- * Calculates the time duration between the current time and a given time offset.
- *
- * @param {Date} timeData - The target time as a Date object.
- * @param {string} [durationType='asSeconds'] - The type of duration to return. Can be 'asMilliseconds', 'asSeconds', 'asMinutes', 'asHours', 'asDays'.
- * @param {Date|null} [now=null] - The current time as a Date object. Defaults to the current date and time if not provided.
- * @returns {number|null} The calculated duration in the specified unit, or `null` if `timeData` is not provided.
- */
-function getTimeDuration(timeData = new Date(), durationType = 'asSeconds', now = null) {
-  if (timeData instanceof Date) {
-    const currentTime = now instanceof Date ? now : new Date();
-    /** @type {number} */
-    const diffMs = timeData.getTime() - currentTime.getTime();
-
-    switch (durationType) {
-      case 'asMilliseconds':
-        return diffMs;
-      case 'asSeconds':
-        return diffMs / 1000;
-      case 'asMinutes':
-        return diffMs / (1000 * 60);
-      case 'asHours':
-        return diffMs / (1000 * 60 * 60);
-      case 'asDays':
-        return diffMs / (1000 * 60 * 60 * 24);
-      default:
-        return diffMs / 1000; // default to seconds
-    }
-  }
-
-  return null;
-}
+  return null;
+}
 
 /**
  * Formats a custom timer string based on total seconds and a detail level.
@@ -3088,94 +3604,473 @@ extendObjType([
   ],
 ]);
 
-;// ./src/v1/basics/simpleMath.mjs
+;// ./src/v1/basics/html.mjs
+
+
 /**
- * Executes a Rule of Three calculation.
- *
- * @param {number} val1 - The first reference value (numerator in direct proportion, denominator in inverse).
- * @param {number} val2 - The second reference value (denominator in direct proportion, numerator in inverse).
- * @param {number} val3 - The third value (numerator in direct proportion, denominator in inverse).
- * @param {boolean} [inverse] - Whether the calculation should use inverse proportion (true for inverse, false for direct).
- * @returns {number} The result of the Rule of Three operation.
- *
- * Rule of Three Formula (Direct Proportion):
- *      val1 / val2 = val3 / result
- *
- * For Inverse Proportion:
- *      val1 / val3 = val2 / result
- *
- * Visual Representation:
- *
- * For Direct Proportion:
- *      val1      val2
- *      -----  =  ------
- *      val3      result
- *
- * For Inverse Proportion:
- *      val1      val2
- *      -----  =  ------
- *      val3      result
- *
- * @example
- * // Direct proportion:
- * ruleOfThree.execute(2, 6, 3, false); // → 9
+ * Checks if two DOM elements are colliding on the screen.
  *
- * @example
- * // Inverse proportion:
- * ruleOfThree.execute(2, 6, 3, true); // → 4
+ * @param {Element} elem1 - First DOM element.
+ * @param {Element} elem2 - Second DOM element.
+ * @returns {boolean} - Returns true if the elements are colliding.
  */
-function ruleOfThree(val1, val2, val3, inverse = false) {
-  return inverse ? Number(val1 * val2) / val3 : Number(val3 * val2) / val1;
+function areHtmlElsColliding(elem1, elem2) {
+  const rect1 = elem1.getBoundingClientRect();
+  const rect2 = elem2.getBoundingClientRect();
+
+  return !(
+    rect1.right < rect2.left ||
+    rect1.left > rect2.right ||
+    rect1.bottom < rect2.top ||
+    rect1.top > rect2.bottom
+  );
 }
 
 /**
- * Calculates a percentage of a given base value.
- * @param {number} price - The base value.
- * @param {number} percentage - The percentage to apply.
- * @returns {number} The result of the percentage calculation.
- *
- * @example
- * getSimplePerc(200, 15); // 30
+ * Reads and parses a JSON data using FileReader.
+ * Throws an error if the content is not valid JSON.
+ * @param {File} file
+ * @returns {Promise<any>}
  */
-function getSimplePerc(price, percentage) {
-  return price * (percentage / 100);
+function readJsonBlob(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+
+    reader.onload = () => {
+      try {
+        // @ts-ignore
+        const result = JSON.parse(reader.result);
+        resolve(result);
+      } catch (error) {
+        // @ts-ignore
+        reject(new Error(`Invalid JSON in file: ${file.name}\n${error.message}`));
+      }
+    };
+
+    reader.onerror = () => {
+      reject(new Error(`Error reading file: ${file.name}`));
+    };
+
+    reader.readAsText(file);
+  });
 }
 
 /**
- * Calculates the age based on the given date.
+ * Saves a JSON object as a downloadable file.
+ * @param {string} filename
+ * @param {any} data
+ * @param {number} [spaces=2]
+ */
+function saveJsonFile(filename, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  const blob = new Blob([json], { type: 'application/json' });
+  const url = URL.createObjectURL(blob);
+
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+
+  URL.revokeObjectURL(url);
+}
+
+/**
+ * Loads and parses a JSON from a remote URL using Fetch API.
  *
- * @param {number|string|Date} timeData - The birth date (can be a timestamp, ISO string, or Date object).
- * @param {Date|null} [now=null] - The Date object representing the current date. Defaults to the current date and time if not provided.
- * @returns {number|null} The age in years, or null if `timeData` is not provided or invalid.
+ * @param {string} url - The full URL to fetch JSON from.
+ * @param {Object} [options] - Optional settings.
+ * @param {string} [options.method="GET"] - HTTP method to use (GET, POST, etc.).
+ * @param {any} [options.body] - Request body (only for methods like POST, PUT).
+ * @param {number} [options.timeout=0] - Timeout in milliseconds (ignored if signal is provided).
+ * @param {number} [options.retries=0] - Number of retry attempts (ignored if signal is provided).
+ * @param {Headers|Record<string, *>} [options.headers={}] - Additional headers.
+ * @param {AbortSignal|null} [options.signal] - External AbortSignal; disables timeout and retries.
+ * @returns {Promise<*>} Parsed JSON object.
+ * @throws {Error} Throws if fetch fails, times out, or returns invalid JSON.
  */
-function getAge(timeData = 0, now = null) {
-  if (typeof timeData !== 'undefined' && timeData !== null && timeData !== 0) {
-    const birthDate = new Date(timeData);
-    if (Number.isNaN(birthDate.getTime())) return null;
+async function fetchJson(
+  url,
+  { method = 'GET', body, timeout = 0, retries = 0, headers = {}, signal = null } = {},
+) {
+  if (
+    typeof url !== 'string' ||
+    (!url.startsWith('../') &&
+      !url.startsWith('./') &&
+      !url.startsWith('/') &&
+      !url.startsWith('https://') &&
+      !url.startsWith('http://'))
+  )
+    throw new Error('Invalid URL: must be a valid http or https address.');
 
-    const currentDate = now instanceof Date ? now : new Date();
+  if (typeof method !== 'string' || !method.trim())
+    throw new Error('Invalid method: must be a non-empty string.');
 
-    let age = currentDate.getFullYear() - birthDate.getFullYear();
+  if (!signal) {
+    if (
+      typeof timeout !== 'number' ||
+      !Number.isFinite(timeout) ||
+      Number.isNaN(timeout) ||
+      timeout < 0
+    )
+      throw new Error('Invalid timeout: must be a positive number.');
 
-    const currentMonth = currentDate.getMonth();
-    const birthMonth = birthDate.getMonth();
+    if (
+      typeof retries !== 'number' ||
+      !Number.isFinite(retries) ||
+      Number.isNaN(retries) ||
+      retries < 0
+    )
+      throw new Error('Invalid retries: must be a positive number.');
+  }
 
-    const currentDay = currentDate.getDate();
-    const birthDay = birthDate.getDate();
+  const attempts = signal ? 1 : retries + 1;
+  /** @type {Error|null} */
+  let lastError = null;
 
-    // Adjust if birthday hasn't occurred yet this year
-    if (currentMonth < birthMonth || (currentMonth === birthMonth && currentDay < birthDay)) age--;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    const controller = signal ? null : new AbortController();
+    const localSignal = signal || (controller?.signal ?? null);
+    const timer =
+      !signal && timeout && controller ? setTimeout(() => controller.abort(), timeout) : null;
 
-    return Math.abs(age);
+    try {
+      const response = await fetch(url, {
+        method: method.toUpperCase(),
+        headers: {
+          Accept: 'application/json',
+          ...headers,
+        },
+        body: body !== undefined ? (isJsonObject(body) ? JSON.stringify(body) : body) : undefined,
+        signal: localSignal,
+      });
+
+      if (timer) clearTimeout(timer);
+
+      if (!response.ok) throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+
+      const contentType = response.headers.get('content-type') || '';
+      if (!contentType.includes('application/json'))
+        throw new Error(`Unexpected content-type: ${contentType}`);
+
+      const data = await response.json();
+
+      if (!isJsonObject(data)) throw new Error('Received invalid data instead of valid JSON.');
+
+      return data;
+    } catch (err) {
+      lastError = /** @type {Error} */ (err);
+      if (signal) break; // if an external signal came, it does not retry
+      if (attempt < retries)
+        await new Promise((resolve) => setTimeout(resolve, 300 * (attempt + 1)));
+    }
   }
 
-  return null;
+  throw new Error(
+    `Failed to fetch JSON from "${url}"${lastError ? `: ${lastError.message}` : '.'}`,
+  );
 }
 
 /**
- * @typedef {Object} FormattedByteResult
- * @property {string|null} unit - The resulting unit (e.g., 'MB', 'GB') or null if input is invalid.
- * @property {number|null} value - The numerical value in the chosen unit, or null if input is invalid.
+ * @typedef {Object} HtmlElBoxSides
+ * @property {number} x - Total horizontal size (left + right)
+ * @property {number} y - Total vertical size (top + bottom)
+ * @property {number} left
+ * @property {number} right
+ * @property {number} top
+ * @property {number} bottom
+ */
+
+/**
+ * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
+ */
+const getHtmlElBordersWidth = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.borderLeftWidth) || 0;
+  const right = parseFloat(styles.borderRightWidth) || 0;
+  const top = parseFloat(styles.borderTopWidth) || 0;
+  const bottom = parseFloat(styles.borderBottomWidth) || 0;
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+/**
+ * Returns the total border size and individual sides from `border{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
+ */
+const getHtmlElBorders = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.borderLeft) || 0;
+  const right = parseFloat(styles.borderRight) || 0;
+  const top = parseFloat(styles.borderTop) || 0;
+  const bottom = parseFloat(styles.borderBottom) || 0;
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+/**
+ * Returns the total margin and individual sides from `margin{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
+ */
+const getHtmlElMargin = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.marginLeft) || 0;
+  const right = parseFloat(styles.marginRight) || 0;
+  const top = parseFloat(styles.marginTop) || 0;
+  const bottom = parseFloat(styles.marginBottom) || 0;
+
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+/**
+ * Returns the total padding and individual sides from `padding{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
+ */
+const getHtmlElPadding = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.paddingLeft) || 0;
+  const right = parseFloat(styles.paddingRight) || 0;
+  const top = parseFloat(styles.paddingTop) || 0;
+  const bottom = parseFloat(styles.paddingBottom) || 0;
+
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+;// ./src/v1/basics/fullScreen.mjs
+/**
+ * Checks if the document is currently in fullscreen mode.
+ *
+ * @returns {boolean}
+ */
+const documentIsFullScreen = () =>
+  !!(
+    document.fullscreenElement ||
+    // @ts-ignore
+    document.webkitFullscreenElement ||
+    // @ts-ignore
+    document.mozFullScreenElement ||
+    // @ts-ignore
+    document.msFullscreenElement ||
+    // @ts-ignore
+    document.webkitIsFullScreen ||
+    // @ts-ignore
+    document.mozFullScreen
+  );
+
+/**
+ * Checks if the window occupies the entire screen dimensions.
+ *
+ * @returns {boolean}
+ */
+const isScreenFilled = () =>
+  window.innerHeight === screen.height && window.innerWidth === screen.width;
+
+/**
+ * Checks if fullscreen mode is active either via document API or by matching screen dimensions.
+ *
+ * @returns {boolean}
+ */
+const isFullScreenMode = () => documentIsFullScreen() || isScreenFilled();
+
+/**
+ * Requests fullscreen mode for the document.
+ *
+ * @param {FullscreenOptions} [ops]
+ * @returns {Promise<void>}
+ */
+const requestFullScreen = (ops) =>
+  new Promise(async (resolve, reject) => {
+    const docElm = document.documentElement;
+    try {
+      if (docElm.requestFullscreen) {
+        await docElm.requestFullscreen(ops);
+        // @ts-ignore
+      } else if (docElm.mozRequestFullScreen) {
+        // @ts-ignore
+        docElm.mozRequestFullScreen(ops);
+        // @ts-ignore
+      } else if (docElm.webkitRequestFullScreen) {
+        // @ts-ignore
+        docElm.webkitRequestFullScreen(ops);
+        // @ts-ignore
+      } else if (docElm.msRequestFullscreen) {
+        // @ts-ignore
+        docElm.msRequestFullscreen(ops);
+      }
+      resolve();
+    } catch (err) {
+      reject(err);
+    }
+  });
+
+/**
+ * Exits fullscreen mode.
+ *
+ * @returns {Promise<void>}
+ */
+const exitFullScreen = () =>
+  new Promise((resolve, reject) => {
+    if (document.exitFullscreen) {
+      document.exitFullscreen().then(resolve).catch(reject);
+    } else {
+      try {
+        // @ts-ignore
+        if (document.mozCancelFullScreen) document.mozCancelFullScreen();
+        // @ts-ignore
+        else if (document.webkitCancelFullScreen) document.webkitCancelFullScreen();
+        // @ts-ignore
+        else if (document.msExitFullscreen) document.msExitFullscreen();
+        else throw new Error('Fullscreen API is not supported');
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    }
+  });
+
+/** @type {readonly string[]} */
+const fullScreenEvents = [
+  'fullscreenchange',
+  'webkitfullscreenchange',
+  'mozfullscreenchange',
+  'MSFullscreenChange',
+];
+
+/**
+ * Attaches a listener to fullscreen change events.
+ *
+ * @param {EventListenerOrEventListenerObject} listener
+ * @param {boolean|AddEventListenerOptions} [ops]
+ * @returns {void}
+ */
+const onFullScreenChange = (listener, ops) => {
+  fullScreenEvents.forEach((event) => {
+    document.addEventListener(event, listener, ops);
+  });
+};
+
+/**
+ * Removes a listener from fullscreen change events.
+ *
+ * @param {EventListenerOrEventListenerObject} listener
+ * @param {boolean|AddEventListenerOptions} [ops]
+ * @returns {void}
+ */
+const offFullScreenChange = (listener, ops) => {
+  fullScreenEvents.forEach((event) => {
+    document.removeEventListener(event, listener, ops);
+  });
+};
+
+;// ./src/v1/basics/simpleMath.mjs
+/**
+ * Executes a Rule of Three calculation.
+ *
+ * @param {number} val1 - The first reference value (numerator in direct proportion, denominator in inverse).
+ * @param {number} val2 - The second reference value (denominator in direct proportion, numerator in inverse).
+ * @param {number} val3 - The third value (numerator in direct proportion, denominator in inverse).
+ * @param {boolean} [inverse] - Whether the calculation should use inverse proportion (true for inverse, false for direct).
+ * @returns {number} The result of the Rule of Three operation.
+ *
+ * Rule of Three Formula (Direct Proportion):
+ *      val1 / val2 = val3 / result
+ *
+ * For Inverse Proportion:
+ *      val1 / val3 = val2 / result
+ *
+ * Visual Representation:
+ *
+ * For Direct Proportion:
+ *      val1      val2
+ *      -----  =  ------
+ *      val3      result
+ *
+ * For Inverse Proportion:
+ *      val1      val2
+ *      -----  =  ------
+ *      val3      result
+ *
+ * @example
+ * // Direct proportion:
+ * ruleOfThree.execute(2, 6, 3, false); // → 9
+ *
+ * @example
+ * // Inverse proportion:
+ * ruleOfThree.execute(2, 6, 3, true); // → 4
+ */
+function ruleOfThree(val1, val2, val3, inverse = false) {
+  return inverse ? Number(val1 * val2) / val3 : Number(val3 * val2) / val1;
+}
+
+/**
+ * Calculates a percentage of a given base value.
+ * @param {number} price - The base value.
+ * @param {number} percentage - The percentage to apply.
+ * @returns {number} The result of the percentage calculation.
+ *
+ * @example
+ * getSimplePerc(200, 15); // 30
+ */
+function getSimplePerc(price, percentage) {
+  return price * (percentage / 100);
+}
+
+/**
+ * Calculates the age based on the given date.
+ *
+ * @param {number|string|Date} timeData - The birth date (can be a timestamp, ISO string, or Date object).
+ * @param {Date|null} [now=null] - The Date object representing the current date. Defaults to the current date and time if not provided.
+ * @returns {number|null} The age in years, or null if `timeData` is not provided or invalid.
+ */
+function getAge(timeData = 0, now = null) {
+  if (typeof timeData !== 'undefined' && timeData !== null && timeData !== 0) {
+    const birthDate = new Date(timeData);
+    if (Number.isNaN(birthDate.getTime())) return null;
+
+    const currentDate = now instanceof Date ? now : new Date();
+
+    let age = currentDate.getFullYear() - birthDate.getFullYear();
+
+    const currentMonth = currentDate.getMonth();
+    const birthMonth = birthDate.getMonth();
+
+    const currentDay = currentDate.getDate();
+    const birthDay = birthDate.getDate();
+
+    // Adjust if birthday hasn't occurred yet this year
+    if (currentMonth < birthMonth || (currentMonth === birthMonth && currentDay < birthDay)) age--;
+
+    return Math.abs(age);
+  }
+
+  return null;
+}
+
+/**
+ * @typedef {Object} FormattedByteResult
+ * @property {string|null} unit - The resulting unit (e.g., 'MB', 'GB') or null if input is invalid.
+ * @property {number|null} value - The numerical value in the chosen unit, or null if input is invalid.
  */
 
 /**
@@ -3304,1035 +4199,504 @@ function KeyPressHandler() {
 export default KeyPressHandler;
 */
 
-;// ./src/v1/libs/ColorSafeStringify.mjs
-/**
- * @typedef {Record<string, string>} ColorsList
- * Represents a mapping of color keys to ANSI escape codes.
- */
+// EXTERNAL MODULE: fs (ignored)
+var fs_ignored_ = __webpack_require__(41);
+// EXTERNAL MODULE: ./node_modules/path-browserify/index.js
+var path_browserify = __webpack_require__(975);
+;// ./src/v1/basics/fileManager.mjs
 
-class ColorSafeStringify {
-  /**
-   * Currently active color configuration.
-   * @type {ColorsList}
-   */
-  #colors;
 
-  /**
-   * Preset collections (internal and user-defined).
-   * @type {Record<string, ColorsList>}
-   * @static
-   */
-  static #PRESETS = {
-    default: {
-      reset: '\x1b[0m',
-      key: '\x1b[36m', // Cyan (object keys)
-      string: '\x1b[32m', // Green (regular strings)
-      string_url: '\x1b[34m', // Blue (URLs)
-      string_bool: '\x1b[35m', // Magenta (boolean/null in string form)
-      string_number: '\x1b[33m', // Yellow (numbers in string form)
-      number: '\x1b[33m', // Yellow (raw numbers)
-      boolean: '\x1b[35m', // Magenta (true/false)
-      null: '\x1b[1;30m', // Gray (null)
-      special: '\x1b[31m', // Red (e.g., [Circular], [undefined])
-      func: '\x1b[90m', // Dim (function string representations)
-    },
-    solarized: {
-      reset: '\x1b[0m',
-      key: '\x1b[38;5;37m',
-      string: '\x1b[38;5;136m',
-      string_url: '\x1b[38;5;33m',
-      string_bool: '\x1b[38;5;166m',
-      string_number: '\x1b[38;5;136m',
-      number: '\x1b[38;5;136m',
-      boolean: '\x1b[38;5;166m',
-      null: '\x1b[38;5;241m',
-      special: '\x1b[38;5;160m',
-      func: '\x1b[38;5;244m',
-    },
-    monokai: {
-      reset: '\x1b[0m',
-      key: '\x1b[38;5;81m',
-      string: '\x1b[38;5;114m',
-      string_url: '\x1b[38;5;75m',
-      string_bool: '\x1b[38;5;204m',
-      string_number: '\x1b[38;5;221m',
-      number: '\x1b[38;5;221m',
-      boolean: '\x1b[38;5;204m',
-      null: '\x1b[38;5;241m',
-      special: '\x1b[38;5;160m',
-      func: '\x1b[38;5;102m',
-    },
-  };
 
-  /**
-   * Constructs a new instance with an optional base preset or custom override.
-   * @param {ColorsList} [defaultColors] - Optional override for the default color scheme.
-   */
-  constructor(defaultColors = {}) {
-    this.#colors = { ...ColorSafeStringify.#PRESETS.default, ...defaultColors };
-  }
 
-  /**
-   * Internal method to apply ANSI color codes to different parts of a JSON string.
-   * @param {string} str - Raw JSON string to be colorized.
-   * @param {ColorsList} colors - ANSI color mapping to be applied to each JSON element type.
-   * @returns {string} Colorized JSON string.
-   */
-  #colorizeJSON(str, colors) {
-    /** @type {{ marker: string, key: string }[]} */
-    const keyMatches = [];
-
-    // Colorize numeric values
-    str = str.replace(
-      /(?<!")\b(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b(?!")/g,
-      `${colors.number}$1${colors.reset}`,
-    );
+/*========================*
+ * JSON Operations
+ *========================*/
 
-    // Replace keys with temporary markers for later colorization
-    str = str.replace(/"([^"]+)":/g, (_, key) => {
-      const marker = `___KEY${keyMatches.length}___`;
-      keyMatches.push({ marker, key });
-      return `${marker}:`; // Keep the colon for valid syntax
-    });
+/**
+ * Reads and parses a JSON file.
+ * Throws an error if the file content is not valid JSON.
+ * @param {string} filePath
+ * @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');
+  return JSON.parse(content);
+}
 
-    // Replace strings and apply specific colors based on their content
-    str = str.replace(/"(?:\\.|[^"\\])*?"/g, (match) => {
-      const val = match.slice(1, -1); // Remove surrounding quotes
+/**
+ * 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]
+ */
+function writeJsonFile(filePath, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  fs_ignored_.writeFileSync(filePath, json, 'utf-8');
+}
 
-      if (/^(https?|ftp):\/\/[^\s]+$/i.test(val)) {
-        return `${colors.string_url}${match}${colors.reset}`;
-      }
+/**
+ * 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);
+}
 
-      if (/^(true|false|null)$/.test(val)) {
-        return `${colors.string_bool}${match}${colors.reset}`;
-      }
+/**
+ * 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');
+}
 
-      if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(val)) {
-        return `${colors.string_number}${match}${colors.reset}`;
-      }
+/*========================*
+ * Directory Management
+ *========================*/
 
-      return `${colors.string}${match}${colors.reset}`;
-    });
+/**
+ * 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 });
+  }
+}
 
-    // Replace markers with colorized keys
-    for (const { marker, key } of keyMatches) {
-      const regex = new RegExp(marker, 'g');
-      str = str.replace(regex, `${colors.key}"${key}"${colors.reset}`);
+/**
+ * Clears all contents inside a directory but keeps the directory.
+ * @param {string} dirPath
+ */
+function clearDirectory(dirPath) {
+  if (!fs_ignored_.existsSync(dirPath)) return;
+  const files = 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 });
+    } else {
+      fs_ignored_.unlinkSync(fullPath);
     }
+  }
+}
 
-    // Colorize boolean values
-    str = str.replace(/(?<!")\b(true|false)\b(?!")/g, `${colors.boolean}$1${colors.reset}`);
-
-    // Colorize null values
-    str = str.replace(/(?<!")\bnull\b(?!")/g, `${colors.null}null${colors.reset}`);
-
-    // Highlight special placeholder values
-    str = str.replace(/\[Circular\]/g, `${colors.special}[Circular]${colors.reset}`);
-    str = str.replace(/\[undefined\]/g, `${colors.special}[undefined]${colors.reset}`);
+/*========================*
+ * File Checks
+ *========================*/
 
-    // Colorize function string representations
-    str = str.replace(/"function.*?[^\\]"/gs, `${colors.func}$&${colors.reset}`);
-    return str;
-  }
+/**
+ * Checks whether a file exists.
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function fileExists(filePath) {
+  return fs_ignored_.existsSync(filePath) && fs_ignored_.lstatSync(filePath).isFile();
+}
 
-  /**
-   * Colorizes a JSON string using the active or optionally overridden color set.
-   * @param {string} json - The JSON string to format.
-   * @param {ColorsList} [customColors] - Optional temporary color override.
-   * @returns {string}
-   */
-  colorize(json, customColors = {}) {
-    const colors = { ...this.#colors, ...customColors };
-    return this.#colorizeJSON(json, colors);
-  }
+/**
+ * Checks whether a directory exists.
+ * @param {string} dirPath
+ * @returns {boolean}
+ */
+function dirExists(dirPath) {
+  return fs_ignored_.existsSync(dirPath) && fs_ignored_.lstatSync(dirPath).isDirectory();
+}
 
-  /**
-   * Returns the currently active color scheme.
-   * @returns {ColorsList}
-   */
-  getColors() {
-    return { ...this.#colors };
-  }
+/**
+ * Checks whether a directory is empty.
+ * @param {string} dirPath
+ * @returns {boolean}
+ */
+function isDirEmpty(dirPath) {
+  return fs_ignored_.existsSync(dirPath) && fs_ignored_.readdirSync(dirPath).length === 0;
+}
 
-  /**
-   * Updates the current color scheme with a partial override.
-   * @param {Partial<ColorsList>} newColors
-   */
-  updateColors(newColors) {
-    Object.assign(this.#colors, newColors);
-  }
+/*========================*
+ * File Operations
+ *========================*/
 
-  /**
-   * Resets the current color scheme to the default preset.
-   */
-  resetColors() {
-    this.#colors = { ...ColorSafeStringify.#PRESETS.default };
-  }
+/**
+ * Copies a file to a destination.
+ * @param {string} src
+ * @param {string} dest
+ * @param {number} [mode]
+ */
+function ensureCopyFile(src, dest, mode) {
+  ensureDirectory(path_browserify.dirname(dest));
+  fs_ignored_.copyFileSync(src, dest, mode);
+}
 
-  /**
-   * Loads a color preset by name.
-   * @param {string} presetName - Name of the preset to load.
-   * @throws Will throw if the preset doesn't exist.
-   */
-  loadColorPreset(presetName) {
-    const preset = ColorSafeStringify.#PRESETS[presetName];
-    if (!preset) throw new Error(`Preset "${presetName}" not found.`);
-    this.#colors = { ...preset };
+/**
+ * Deletes a file (If the file exists).
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function tryDeleteFile(filePath) {
+  if (fileExists(filePath)) {
+    fs_ignored_.unlinkSync(filePath);
+    return true;
   }
+  return false;
+}
 
-  /**
-   * Saves a new custom color preset.
-   * @param {string} name - Name of the new preset.
-   * @param {ColorsList} colors - ANSI color map to save.
-   */
-  saveColorPreset(name, colors) {
-    ColorSafeStringify.#PRESETS[name] = { ...colors };
-  }
+/**
+ * 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);
+}
 
-  /**
-   * Returns a list of all available color preset names.
-   * @returns {string[]}
-   */
-  getAvailablePresets() {
-    return Object.keys(ColorSafeStringify.#PRESETS);
+/**
+ * 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);
+    return true;
   }
+  return false;
 }
 
-/* harmony default export */ const libs_ColorSafeStringify = (ColorSafeStringify);
+/*========================*
+ * Text Operations
+ *========================*/
 
-;// ./src/v1/libs/TinyPromiseQueue.mjs
 /**
- * @typedef {Object} QueuedTask
- * @property {(...args: any[]) => Promise<any>|Promise<any>} task - The async task to execute.
- * @property {(value: any) => any} resolve - The resolve function from the Promise.
- * @property {(reason?: any) => any} reject - The reject function from the Promise.
- * @property {string|undefined} [id] - Optional identifier for the task.
- * @property {string|null|undefined} [marker] - Optional marker for the task.
- * @property {number|null|undefined} [delay] - Optional delay (in ms) before the task is executed.
+ * 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']
  */
+function writeTextFile(filePath, content, ops = 'utf-8') {
+  const dir = path_browserify.dirname(filePath);
+  ensureDirectory(dir);
+  fs_ignored_.writeFileSync(filePath, content, ops);
+}
 
 /**
- * A queue system for managing and executing asynchronous tasks sequentially, one at a time.
- *
- * Tasks can be delayed, reordered, canceled, and processed in strict order. The queue ensures that each task
- * is executed after the previous one finishes, and any task can be skipped or canceled if needed.
- *
- * @class
+ * 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>}
  */
-class TinyPromiseQueue {
-  /** @type {QueuedTask[]} */
-  #queue = [];
-  #running = false;
-  /** @type {Record<string, ReturnType<typeof setTimeout>>} */
-  #timeouts = {};
-  /** @type {Set<string>} */
-  #blacklist = new Set();
+function writeTextFileAsync(filePath, content, ops = 'utf-8') {
+  const dir = path.dirname(filePath);
+  ensureDirectory(dir);
+  return fs.promises.writeFile(filePath, content, ops);
+}
 
-  /**
-   * Returns whether the queue is currently processing a task.
-   *
-   * @returns {boolean}
-   */
-  isRunning() {
-    return this.#running;
-  }
-
-  /**
-   * Processes the a normal task.
-   *
-   * @param {QueuedTask} data
-   *
-   * @returns {Promise<void>}
-   */
-  async #normalProcessQueue(data) {
-    if (
-      data &&
-      typeof data.task === 'function' &&
-      typeof data.resolve === 'function' &&
-      typeof data.reject === 'function'
-    ) {
-      const { task, resolve, reject, delay, id } = data;
-      try {
-        if (id && this.#blacklist.has(id)) {
-          reject(new Error('The function was canceled on TinyPromiseQueue.'));
-          this.#blacklist.delete(id);
-          this.#running = false;
-          this.#processQueue();
-          return;
-        }
-
-        if (delay && id) {
-          await new Promise((resolveDelay) => {
-            const timeoutId = setTimeout(() => {
-              delete this.#timeouts[id];
-              resolveDelay(null);
-            }, delay);
-            this.#timeouts[id] = timeoutId;
-          });
-        }
-
-        const result = await task();
-        resolve(result);
-      } catch (error) {
-        reject(error);
-      } finally {
-        this.#running = false;
-        this.#processQueue();
-      }
-    }
-  }
-
-  /**
-   * Processes a group task.
-   *
-   * @returns {Promise<void>}
-   */
-  async #groupProcessQueue() {
-    /** @type {Array<QueuedTask>} */
-    const grouped = [];
-    while (this.#queue.length && this.#queue[0]?.marker === 'POINT_MARKER') {
-      // @ts-ignore
-      grouped.push(this.#queue.shift());
-    }
-
-    if (grouped.length === 0) {
-      this.#running = false;
-      this.#processQueue();
-      return;
-    }
-
-    await Promise.all(
-      grouped.map(
-        ({ task, resolve, reject, id }) =>
-          new Promise(async (pResolve) => {
-            if (id && this.#blacklist.has(id)) {
-              this.#blacklist.delete(id);
-              reject(new Error('The function was canceled on TinyPromiseQueue.'));
-              pResolve(true);
-              return;
-            }
-            await task().then(resolve).catch(reject);
-            pResolve(true);
-          }),
-      ),
-    );
-
-    this.#running = false;
-    this.#processQueue();
-  }
-
-  /**
-   * Processes the next task in the queue if not already running.
-   * Ensures tasks are executed in order, one at a time.
-   *
-   * @returns {Promise<void>}
-   */
-  async #processQueue() {
-    if (this.#running || this.#queue.length === 0) return;
-    this.#running = true;
-    if (typeof this.#queue[0]?.marker !== 'string' || this.#queue[0]?.marker !== 'POINT_MARKER') {
-      const data = this.#queue.shift();
-      // @ts-ignore
-      this.#normalProcessQueue(data);
-    } else this.#groupProcessQueue();
-  }
-
-  /**
-   * Returns the index of a task by its ID.
-   *
-   * @param {string} id The ID of the task to locate.
-   * @returns {number} The index of the task in the queue, or -1 if not found.
-   */
-  getIndexById(id) {
-    return this.#queue.findIndex((item) => item.id === id);
-  }
-
-  /**
-   * Returns a list of IDs for all tasks currently in the queue.
-   *
-   * @returns {{ index: number, id: string }[]} An array of task IDs currently queued.
-   */
-  getQueuedIds() {
-    // @ts-ignore
-    return this.#queue
-      .map((item, index) => ({ index, id: item.id }))
-      .filter((entry) => typeof entry.id === 'string');
-  }
-
-  /**
-   * Reorders a task in the queue from one index to another.
-   *
-   * @param {number} fromIndex The current index of the task to move.
-   * @param {number} toIndex The index where the task should be placed.
-   */
-  reorderQueue(fromIndex, toIndex) {
-    if (
-      typeof fromIndex !== 'number' ||
-      typeof toIndex !== 'number' ||
-      fromIndex < 0 ||
-      toIndex < 0 ||
-      fromIndex >= this.#queue.length ||
-      toIndex >= this.#queue.length
-    )
-      return;
-    const [item] = this.#queue.splice(fromIndex, 1);
-    this.#queue.splice(toIndex, 0, item);
-  }
-
-  /**
-   * Inserts a point in the queue where subsequent tasks will be grouped and executed together in a Promise.all.
-   * If the queue is currently empty, behaves like a regular promise.
-   *
-   * @param {(...args: any[]) => Promise<any>|Promise<any>} task A function that returns a Promise.
-   * @param {string} [id] Optional ID to identify the task in the queue.
-   * @returns {Promise<any>} A Promise that resolves or rejects with the result of the task once it's processed.
-   * @throws {Error} Throws if param is invalid.
-   */
-  async enqueuePoint(task, id) {
-    if (typeof task !== 'function')
-      return Promise.reject(new Error('Task must be a function returning a Promise.'));
-    if (typeof id !== 'undefined' && typeof id !== 'string')
-      throw new Error('The "id" parameter must be a string.');
-    if (!this.#running) return task();
-    return new Promise((resolve, reject) => {
-      this.#queue.push({ marker: 'POINT_MARKER', task, resolve, reject, id });
-      this.#processQueue();
-    });
-  }
-
-  /**
-   * Adds a new async task to the queue and ensures it runs in order after previous tasks.
-   * Optionally, a delay can be added before the task is executed.
-   *
-   * If the task is canceled before execution, it will be rejected with the message:
-   * "The function was canceled on TinyPromiseQueue."
-   *
-   * @param {(...args: any[]) => Promise<any>|Promise<any>} task A function that returns a Promise to be executed sequentially.
-   * @param {number|null} [delay] Optional delay (in ms) before the task is executed.
-   * @param {string} [id] Optional ID to identify the task in the queue.
-   * @returns {Promise<any>} A Promise that resolves or rejects with the result of the task once it's processed.
-   * @throws {Error} Throws if param is invalid.
-   */
-  enqueue(task, delay, id) {
-    if (typeof task !== 'function')
-      return Promise.reject(new Error('Task must be a function returning a Promise.'));
-    if (typeof delay !== 'undefined' && (typeof delay !== 'number' || delay < 0))
-      return Promise.reject(new Error('Delay must be a positive number or undefined.'));
-    if (typeof id !== 'undefined' && typeof id !== 'string')
-      throw new Error('The "id" parameter must be a string.');
-
-    return new Promise((resolve, reject) => {
-      this.#queue.push({ task, resolve, reject, id, delay });
-      this.#processQueue();
-    });
-  }
-
-  /**
-   * Cancels a scheduled delay and removes the task from the queue.
-   * Adds the ID to a blacklist so the task is skipped if already being processed.
-   *
-   * @param {string} id The ID of the task to cancel.
-   * @returns {boolean} True if a delay was cancelled and the task was removed.
-   * @throws {Error} Throws if `id` is not a string.
-   */
-  cancelTask(id) {
-    if (typeof id !== 'string') throw new Error('The "id" parameter must be a string.');
-    let cancelled = false;
-
-    if (id in this.#timeouts) {
-      clearTimeout(this.#timeouts[id]);
-      delete this.#timeouts[id];
-      cancelled = true;
-    }
-
-    const index = this.getIndexById(id);
-    if (index !== -1) {
-      const [removed] = this.#queue.splice(index, 1);
-      removed?.reject?.(new Error('The function was canceled on TinyPromiseQueue.'));
-      cancelled = true;
-    }
-
-    if (cancelled) this.#blacklist.add(id);
-
-    return cancelled;
-  }
-}
-
-/* harmony default export */ const libs_TinyPromiseQueue = (TinyPromiseQueue);
-
-;// ./src/v1/libs/TinyRateLimiter.mjs
-/** @typedef {(groupId: string) => void} OnMemoryExceeded */
-
-/** @typedef {(groupId: string) => void} OnGroupExpired */
+/*========================*
+ * Directory Listings
+ *========================*/
 
 /**
- * Class representing a flexible rate limiter per user or group.
- *
- * This rate limiter supports limiting per user or per group by mapping
- * userIds to a common groupId. All users within the same group share
- * rate limits.
+ * Lists all files and dirs in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {{ files: string[]; dirs: string[] }}
  */
-class TinyRateLimiter {
-  /** @type {number|null} */
-  #maxMemory = null;
-
-  /** @type {NodeJS.Timeout|null} */
-  #cleanupTimer = null;
-
-  /** @type {number|null|undefined} */
-  #maxHits = null;
-
-  /** @type {number|null|undefined} */
-  #interval = null;
-
-  /** @type {number|null|undefined} */
-  #cleanupInterval = null;
-
-  /** @type {number|null|undefined} */
-  #maxIdle = null;
-
-  /** @type {Map<string, number[]>} */
-  groupData = new Map(); // groupId -> timestamps[]
-
-  /** @type {Map<string, number>} */
-  lastSeen = new Map(); // groupId -> timestamp
-
-  /** @type {Map<string, string>} */
-  userToGroup = new Map(); // userId -> groupId
-
-  /** @type {Map<string, boolean>} */
-  groupFlags = new Map(); // groupId -> boolean
-
-  /**
-   * @type {Map<string, number>}
-   * Stores TTL (in ms) for each groupId individually
-   */
-  groupTTL = new Map();
-
-  /**
-   * @type {null|OnMemoryExceeded}
-   */
-  #onMemoryExceeded = null;
-
-  /**
-   * Set the callback to be triggered when a group exceeds its limit
-   * @param {OnMemoryExceeded} callback
-   */
-  setOnMemoryExceeded(callback) {
-    if (typeof callback !== 'function') throw new Error('onMemoryExceeded must be a function');
-    this.#onMemoryExceeded = callback;
-  }
-
-  /**
-   * Clear the onMemoryExceeded callback
-   */
-  clearOnMemoryExceeded() {
-    this.#onMemoryExceeded = null;
-  }
-
-  /**
-   * @type {null|OnGroupExpired}
-   */
-  #onGroupExpired = null;
-
-  /**
-   * Set the callback to be triggered when a group expires and is removed.
-   *
-   * This callback is called automatically during cleanup when a group
-   * becomes inactive for longer than its TTL.
-   *
-   * @param {OnGroupExpired} callback - A function that receives the expired groupId.
-   */
-  setOnGroupExpired(callback) {
-    if (typeof callback !== 'function') throw new Error('onGroupExpired must be a function');
-    this.#onGroupExpired = callback;
-  }
-
-  /**
-   * Clear the onGroupExpired callback
-   */
-  clearOnGroupExpired() {
-    this.#onGroupExpired = null;
-  }
-
-  /**
-   * @param {Object} options
-   * @param {number|null} [options.maxMemory] - Max memory allowed
-   * @param {number} [options.maxHits] - Max interactions allowed
-   * @param {number} [options.interval] - Time window in milliseconds
-   * @param {number} [options.cleanupInterval] - Interval for automatic cleanup (ms)
-   * @param {number} [options.maxIdle=300000] - Max idle time for a user before being cleaned (ms)
-   */
-  constructor({ maxHits, interval, cleanupInterval, maxIdle = 300000, maxMemory = 100000 }) {
-    /** @param {number|undefined} val */
-    const isPositiveInteger = (val) =>
-      typeof val === 'number' && Number.isFinite(val) && val >= 1 && Number.isInteger(val);
-
-    const isMaxHitsValid = isPositiveInteger(maxHits);
-    const isIntervalValid = isPositiveInteger(interval);
-    const isCleanupValid = isPositiveInteger(cleanupInterval);
-    const isMaxIdleValid = isPositiveInteger(maxIdle);
-
-    if (!isMaxHitsValid && !isIntervalValid)
-      throw new Error("RateLimiter requires at least one valid option: 'maxHits' or 'interval'.");
-    if (maxHits !== undefined && !isMaxHitsValid)
-      throw new Error("'maxHits' must be a positive integer if defined.");
-    if (interval !== undefined && !isIntervalValid)
-      throw new Error("'interval' must be a positive integer in milliseconds if defined.");
-    if (cleanupInterval !== undefined && !isCleanupValid)
-      throw new Error("'cleanupInterval' must be a positive integer in milliseconds if defined.");
-    if (!isMaxIdleValid) throw new Error("'maxIdle' must be a positive integer in milliseconds.");
-
-    if (typeof maxMemory === 'number' && Number.isFinite(maxMemory) && maxMemory > 0) {
-      this.#maxMemory = Math.floor(maxMemory);
-    } else if (maxMemory === null || maxMemory === undefined) {
-      this.#maxMemory = null;
-    } else {
-      throw new Error('maxMemory must be a positive number or null');
-    }
-
-    this.#maxHits = isMaxHitsValid ? maxHits : null;
-    this.#interval = isIntervalValid ? interval : null;
-    this.#cleanupInterval = isCleanupValid ? cleanupInterval : null;
-    this.#maxIdle = maxIdle;
-
-    // Start automatic cleanup only if cleanupInterval is valid
-    if (this.#cleanupInterval !== null)
-      this.#cleanupTimer = setInterval(() => this._cleanup(), this.#cleanupInterval);
-  }
-
-  /**
-   * Check if a given ID is a groupId (not a userId)
-   * @param {string} id
-   * @returns {boolean}
-   */
-  isGroupId(id) {
-    const result = this.groupFlags.get(id);
-    return typeof result === 'boolean' ? result : false;
-  }
-
-  /**
-   * Get all user IDs that belong to a given group.
-   * @param {string} groupId
-   * @returns {string[]}
-   */
-  getUsersInGroup(groupId) {
-    const users = [];
-    for (const [userId, assignedGroup] of this.userToGroup.entries()) {
-      if (assignedGroup === groupId) {
-        users.push(userId);
+function listFiles(dirPath, recursive = false) {
+  /** @type {{ files: string[]; dirs: string[] }} */
+  const results = { files: [], dirs: [] };
+  if (!dirExists(dirPath)) return results;
+
+  const entries = 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()) {
+      results.dirs.push(fullPath);
+      if (recursive) {
+        const results2 = listFiles(fullPath, true);
+        results.files.push(...results2.files);
+        results.dirs.push(...results2.dirs);
       }
-    }
-
-    return users;
-  }
-
-  /**
-   * Set TTL (in milliseconds) for a specific group
-   * @param {string} groupId
-   * @param {number} ttl
-   */
-  setGroupTTL(groupId, ttl) {
-    if (typeof ttl !== 'number' || !Number.isFinite(ttl) || ttl <= 0)
-      throw new Error('TTL must be a positive number in milliseconds');
-    this.groupTTL.set(groupId, ttl);
-  }
-
-  /**
-   * Get TTL (in ms) for a specific group.
-   * @param {string} groupId
-   * @returns {number|null}
-   */
-  getGroupTTL(groupId) {
-    return this.groupTTL.get(groupId) ?? null;
-  }
-
-  /**
-   * Delete the TTL setting for a specific group
-   * @param {string} groupId
-   */
-  deleteGroupTTL(groupId) {
-    this.groupTTL.delete(groupId);
-  }
-
-  /**
-   * Assign a userId to a groupId, with merge if user has existing data.
-   * @param {string} userId
-   * @param {string} groupId
-   * @throws {Error} If userId is already assigned to a different group
-   */
-  assignToGroup(userId, groupId) {
-    const existingGroup = this.userToGroup.get(userId);
-    if (existingGroup && existingGroup !== groupId)
-      throw new Error(`User ${userId} is already assigned to group ${existingGroup}`);
-
-    // If the user is already in the group, nothing needs to be done
-    if (existingGroup === groupId) return;
-    const userData = this.groupData.get(userId);
-
-    // Associates the user to the group
-    if (this.isGroupId(userId)) {
-      for (const [uid, gId] of this.userToGroup.entries())
-        if (gId === userId) this.userToGroup.set(uid, groupId);
-      this.userToGroup.delete(userId);
-    } else this.userToGroup.set(userId, groupId);
-
-    // If the user has no data, nothing needs to be done
-    if (!userData) return;
-
-    const groupData = this.groupData.get(groupId);
-    if (groupData) {
-      for (const item of userData) groupData.push(item);
     } else {
-      const newData = [];
-      for (const item of userData) newData.push(item);
-      this.groupData.set(groupId, newData);
+      results.files.push(fullPath);
     }
-
-    this.lastSeen.set(groupId, Date.now());
-
-    // Removes individual data as they are now in the group
-    this.groupFlags.delete(userId);
-    this.groupData.delete(userId);
-    this.lastSeen.delete(userId);
-    this.groupTTL.delete(userId);
-    this.groupFlags.set(groupId, true);
-  }
-
-  /**
-   * Get the groupId for a given userId
-   * @param {string} userId
-   * @returns {string}
-   */
-  getGroupId(userId) {
-    return this.userToGroup.get(userId) || userId; // fallback: use userId as own group
   }
+  return results;
+}
 
-  /**
-   * Register a hit for a specific user
-   * @param {string} userId
-   */
-  hit(userId) {
-    const groupId = this.getGroupId(userId);
-    const now = Date.now();
-
-    if (!this.groupData.has(groupId)) {
-      this.groupData.set(groupId, []);
-      this.groupFlags.set(groupId, false);
-    }
-
-    const history = this.groupData.get(groupId);
-    if (!history) throw new Error(`No data found for groupId: ${groupId}`);
-
-    history.push(now);
-    this.lastSeen.set(groupId, now);
-
-    // Clean up old entries
-    if (this.#interval !== null) {
-      const interval = this.getInterval();
-      const cutoff = now - interval;
-      while (history.length && history[0] < cutoff) {
-        history.shift();
-      }
-    }
-
-    // Optional: keep only the last N entries for memory optimization
-    if (this.#maxMemory !== null && typeof this.#maxMemory === 'number') {
-      if (history.length > this.#maxMemory) {
-        history.splice(0, history.length - this.#maxMemory);
-        if (typeof this.#onMemoryExceeded === 'function') this.#onMemoryExceeded(groupId);
+/**
+ * Lists all directories in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {string[]}
+ */
+function listDirs(dirPath, recursive = false) {
+  /** @type {string[]} */
+  const results = [];
+  if (!dirExists(dirPath)) return results;
+
+  const entries = 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()) {
+      results.push(fullPath);
+      if (recursive) {
+        results.push(...listDirs(fullPath, true));
       }
     }
   }
+  return results;
+}
 
-  /**
-   * Check if the user (via their group) is currently rate limited
-   * @param {string} userId
-   * @returns {boolean}
-   */
-  isRateLimited(userId) {
-    const groupId = this.getGroupId(userId);
-    if (!this.groupData.has(groupId)) return false;
-
-    const history = this.groupData.get(groupId);
-    if (!history) throw new Error(`No data found for groupId: ${groupId}`);
-
-    if (this.#interval !== null) {
-      const now = Date.now();
-      const interval = this.getInterval();
-      const cutoff = now - interval;
-      let count = 0;
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i] > cutoff) count++;
-        else break;
-      }
-      if (this.#maxHits !== null) return count > this.getMaxHits();
-      return count > 0;
-    }
+/*========================*
+ * File Info
+ *========================*/
 
-    if (this.#maxHits !== null) {
-      return history.length > this.getMaxHits();
-    }
+/**
+ * Returns the size of a file in bytes.
+ * @param {string} filePath
+ * @returns {number}
+ */
+function fileSize(filePath) {
+  if (!fileExists(filePath)) return 0;
+  const stats = fs_ignored_.statSync(filePath);
+  return stats.size;
+}
 
-    return false;
+/**
+ * Returns the total size of a directory in bytes.
+ * @param {string} dirPath
+ * @returns {number}
+ */
+function dirSize(dirPath) {
+  let total = 0;
+  const files = listFiles(dirPath, true).files;
+  for (const file of files) {
+    total += fileSize(file);
   }
+  return total;
+}
 
-  /**
-   * Manually reset group data
-   * @param {string} groupId
-   */
-  resetGroup(groupId) {
-    this.groupFlags.delete(groupId);
-    this.groupData.delete(groupId);
-    this.lastSeen.delete(groupId);
-    this.groupTTL.delete(groupId);
-  }
+/*========================*
+ * Backup Utilities
+ *========================*/
 
-  /**
-   * Manually reset user data.
-   *
-   * @deprecated Use `resetUserGroup(userId)` instead. This method will be removed in future versions.
-   * @param {string} userId
-   * @returns {void}
-   */
-  reset(userId) {
-    if (false)
-      {}
-    return this.resetUserGroup(userId);
-  }
-
-  /**
-   * Manually reset a user mapping
-   * @param {string} userId
-   */
-  resetUserGroup(userId) {
-    this.userToGroup.delete(userId);
-  }
+/**
+ * Creates a backup copy of a file with .bak timestamp suffix.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ */
+function backupFile(filePath, ext = 'bak') {
+  if (!fileExists(filePath)) return;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.${ext}.${timestamp}`;
+  ensureCopyFile(filePath, backupPath);
+}
 
-  /**
-   * Set custom timestamps to a group
-   * @param {string} groupId
-   * @param {number[]} timestamps
-   */
-  setData(groupId, timestamps) {
-    if (!Array.isArray(timestamps)) throw new Error('timestamps must be an array of numbers.');
-    for (const t of timestamps) {
-      if (typeof t !== 'number' || !Number.isFinite(t)) {
-        throw new Error('All timestamps must be finite numbers.');
-      }
-    }
-    if (!this.groupData.has(groupId)) this.groupFlags.set(groupId, false);
-    this.groupData.set(groupId, timestamps);
-    this.lastSeen.set(groupId, Date.now());
-  }
+/**
+ * Returns the most recent backup file path for a given file.
+ * @param {string} filePath
+ * @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)
+    .filter((name) => name.startsWith(`${baseName}.${ext}.`))
+    .sort()
+    .reverse();
 
-  /**
-   * Check if a group has data
-   * @param {string} groupId
-   * @returns {boolean}
-   */
-  hasData(groupId) {
-    return this.groupData.has(groupId);
-  }
+  if (backups.length === 0) throw new Error(`No backups found for ${filePath}`);
 
-  /**
-   * Get timestamps from a group
-   * @param {string} groupId
-   * @returns {number[]}
-   */
-  getData(groupId) {
-    return this.groupData.get(groupId) || [];
-  }
+  return path_browserify.join(dir, backups[0]);
+}
 
-  /**
-   * Get the maximum idle time (in milliseconds) before a group is considered expired.
-   * @returns {number}
-   */
-  getMaxIdle() {
-    if (typeof this.#maxIdle !== 'number' || !Number.isFinite(this.#maxIdle) || this.#maxIdle < 0) {
-      throw new Error("'maxIdle' must be a non-negative finite number.");
-    }
-    return this.#maxIdle;
-  }
+/**
+ * Restores the most recent backup of a file.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ */
+function restoreLatestBackup(filePath, ext = 'bak') {
+  const latestBackup = getLatestBackupPath(filePath, ext);
+  ensureCopyFile(latestBackup, filePath);
+}
 
-  /**
-   * Set the maximum idle time (in milliseconds) before a group is considered expired.
-   * @param {number} ms
-   */
-  setMaxIdle(ms) {
-    if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0) {
-      throw new Error("'maxIdle' must be a non-negative finite number.");
-    }
-    this.#maxIdle = ms;
-  }
+/**
+ * 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);
+}
 
-  /**
-   * Cleanup old/inactive groups with individual TTLs
-   * @private
-   */
-  _cleanup() {
-    const now = Date.now();
-    for (const [groupId, last] of this.lastSeen.entries()) {
-      const ttl = this.getGroupTTL(groupId) ?? this.getMaxIdle();
-      if (now - last > ttl) {
-        this.groupFlags.delete(groupId);
-        this.groupData.delete(groupId);
-        this.lastSeen.delete(groupId);
-        this.groupTTL.delete(groupId);
-
-        // Notify subclass or external binding
-        if (typeof this.#onGroupExpired === 'function') {
-          this.#onGroupExpired(groupId);
-        }
-      }
-    }
-  }
+/**
+ * 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);
+}
 
-  /**
-   * Get list of active group IDs
-   * @returns {string[]}
-   */
-  getActiveGroups() {
-    return Array.from(this.groupData.keys());
-  }
+/*========================*
+ * Rename Utilities
+ *========================*/
 
-  /**
-   * Get a shallow copy of all user-to-group mappings as a plain object
-   * @returns {Record<string, string>}
-   */
-  getAllUserMappings() {
-    return Object.fromEntries(this.userToGroup);
+/**
+ * Renames multiple files in a directory using a rename function.
+ * @param {string} dirPath - The target directory.
+ * @param {(original: string, index: number) => string} renameFn - Function that returns new filename.
+ * @param {string[]} [extensions] - Optional: Only rename files with these extensions.
+ *
+ * @throws {TypeError} If any argument has an invalid type.
+ * @throws {Error} If the directory does not exist or contains invalid files.
+ */
+function renameFileBatch(dirPath, renameFn, extensions = []) {
+  // Validate types
+  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())
+    throw new Error(`Directory not found or invalid: ${dirPath}`);
+  for (const ext of extensions) {
+    if (typeof ext !== 'string' || !ext.startsWith('.'))
+      throw new TypeError(`Invalid extension: ${ext}`);
   }
 
-  /**
-   * Get the interval window in milliseconds.
-   * @returns {number}
-   */
-  getInterval() {
-    if (typeof this.#interval !== 'number' || !Number.isFinite(this.#interval)) {
-      throw new Error("'interval' is not a valid finite number.");
-    }
-    return this.#interval;
-  }
+  const files = listFiles(dirPath).files;
+  let index = 0;
 
-  /**
-   * Get the maximum number of allowed hits.
-   * @returns {number}
-   */
-  getMaxHits() {
-    if (typeof this.#maxHits !== 'number' || !Number.isFinite(this.#maxHits)) {
-      throw new Error("'maxHits' is not a valid finite number.");
-    }
-    return this.#maxHits;
-  }
+  for (const file of files) {
+    const ext = path_browserify.extname(file);
+    if (extensions.length && !extensions.includes(ext)) continue;
 
-  /**
-   * Get the total number of hits recorded for a group.
-   * @param {string} groupId
-   * @returns {number}
-   */
-  getTotalHits(groupId) {
-    const history = this.groupData.get(groupId);
-    return Array.isArray(history) ? history.length : 0;
-  }
+    const originalName = path_browserify.basename(file);
+    const newName = renameFn(originalName, index++);
+    const newPath = path_browserify.join(dirPath, newName);
 
-  /**
-   * Get the timestamp of the last hit for a group.
-   * @param {string} groupId
-   * @returns {number|null}
-   */
-  getLastHit(groupId) {
-    const history = this.groupData.get(groupId);
-    return history?.length ? history[history.length - 1] : null;
-  }
+    if (originalName === newName) continue;
 
-  /**
-   * Get milliseconds since the last hit for a group.
-   * @param {string} groupId
-   * @returns {number|null}
-   */
-  getTimeSinceLastHit(groupId) {
-    const last = this.getLastHit(groupId);
-    return last !== null ? Date.now() - last : null;
+    fs_ignored_.renameSync(file, newPath);
   }
+}
 
-  /**
-   * Internal utility to compute average spacing
-   * @private
-   * @param {number[]|undefined} history
-   * @returns {number|null}
-   */
-  _calculateAverageSpacing(history) {
-    if (!Array.isArray(history) || history.length < 2) return null;
-    let total = 0;
-    for (let i = 1; i < history.length; i++) {
-      total += history[i] - history[i - 1];
-    }
-    return total / (history.length - 1);
-  }
+/**
+ * Renames files using regex replacement.
+ * @param {string} dirPath
+ * @param {RegExp} pattern - Regex to match in the filename.
+ * @param {string} replacement - Replacement string.
+ * @param {string[]} [extensions]
+ */
+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);
+      return `${name}${ext}`;
+    },
+    extensions,
+  );
+}
 
-  /**
-   * Get average time between hits for a group (ms).
-   * @param {string} groupId
-   * @returns {number|null}
-   */
-  getAverageHitSpacing(groupId) {
-    return this._calculateAverageSpacing(this.groupData.get(groupId));
-  }
+/**
+ * Adds a prefix or suffix to filenames.
+ * @param {string} dirPath
+ * @param {{ prefix?: string, suffix?: string }} options
+ * @param {string[]} [extensions]
+ */
+function renameFileAddPrefixSuffix(dirPath, { prefix = '', suffix = '' }, extensions = []) {
+  renameFileBatch(
+    dirPath,
+    (filename) => {
+      const ext = path_browserify.extname(filename);
+      const name = path_browserify.basename(filename, ext);
+      return `${prefix}${name}${suffix}${ext}`;
+    },
+    extensions,
+  );
+}
 
-  /**
-   * Get metrics about a group's activity.
-   * @param {string} groupId
-   * @returns {{
-   *   totalHits: number,
-   *   lastHit: number|null,
-   *   timeSinceLastHit: number|null,
-   *   averageHitSpacing: number|null
-   * }}
-   */
-  getMetrics(groupId) {
-    const history = this.groupData.get(groupId);
-
-    if (!Array.isArray(history) || history.length === 0) {
-      return {
-        totalHits: 0,
-        lastHit: null,
-        timeSinceLastHit: null,
-        averageHitSpacing: null,
+/**
+ * Normalizes all filenames to lowercase (or uppercase).
+ * @param {string} dirPath
+ * @param {'lower' | 'upper' | 'title'} mode
+ * @param {string[]} [extensions]
+ * @param {boolean} [normalizeExt=false] - Whether to apply case change to file extensions too.
+ * @throws {Error} If mode is invalid.
+ */
+function renameFileNormalizeCase(
+  dirPath,
+  mode = 'lower',
+  extensions = [],
+  normalizeExt = false,
+) {
+  if (typeof mode !== 'string' || !['lower', 'upper', 'title'].includes(mode))
+    throw new Error(`Invalid mode "${mode}". Must be 'lower', 'upper' or 'title'.`);
+  renameFileBatch(
+    dirPath,
+    (filename) => {
+      /**
+       * @param {string} text
+       * @returns {string}
+       */
+      const changeToMode = (text) => {
+        if (mode === 'lower') return text.toLowerCase();
+        else if (mode === 'upper') return text.toUpperCase();
+        else if (mode === 'title') return toTitleCase(text);
+        else return text;
       };
-    }
 
-    const totalHits = history.length;
-    const lastHit = history[totalHits - 1];
-    const timeSinceLastHit = Date.now() - lastHit;
-    const averageHitSpacing = this._calculateAverageSpacing(history);
-
-    return {
-      totalHits,
-      lastHit,
-      timeSinceLastHit,
-      averageHitSpacing,
-    };
-  }
-
-  /**
-   * Destroy the rate limiter, stopping cleanup and clearing data
-   */
-  destroy() {
-    if (this.#cleanupTimer) clearInterval(this.#cleanupTimer);
-    this._cleanup();
-    this.groupData.clear();
-    this.lastSeen.clear();
-    this.userToGroup.clear();
-    this.groupTTL.clear();
-    this.groupFlags.clear();
-  }
+      const rawExt = path_browserify.extname(filename);
+      const ext = normalizeExt ? changeToMode(rawExt) : rawExt;
+      const name = changeToMode(path_browserify.basename(filename, rawExt));
+      return `${name}${ext}`;
+    },
+    extensions,
+  );
 }
 
-/* harmony default export */ const libs_TinyRateLimiter = (TinyRateLimiter);
-
-;// ./src/v1/index.mjs
+/**
+ * Pads numbers in filenames (e.g., "img1.jpg" -> "img001.jpg").
+ * @param {string} dirPath
+ * @param {number} totalDigits
+ * @param {string[]} [extensions]
+ */
+function renameFilePadNumbers(dirPath, totalDigits = 3, extensions = []) {
+  renameFileBatch(
+    dirPath,
+    (filename) => {
+      return filename.replace(/\d+/, (match) => match.padStart(totalDigits, '0'));
+    },
+    extensions,
+  );
+}
 
+;// ./src/v1/basics/index.mjs
 
 
 
@@ -4348,6 +4712,6 @@ class TinyRateLimiter {
 
 })();
 
-window.TinyEssentials = __webpack_exports__;
+window.TinyBasicsEs = __webpack_exports__;
 /******/ })()
 ;