tiny-essentials 1.11.0 → 1.12.0

package/dist/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;
+
+
 /***/ })
 
 /******/ 	});
@@ -2143,25 +2879,62 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   addAiMarkerShortcut: () => (/* reexport */ addAiMarkerShortcut),
+  areHtmlElsColliding: () => (/* reexport */ areHtmlElsColliding),
   arraySortPositions: () => (/* reexport */ arraySortPositions),
   asyncReplace: () => (/* reexport */ asyncReplace),
+  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
@@ -2831,6 +3604,385 @@ extendObjType([
   ],
 ]);
 
+;// ./src/v1/basics/html.mjs
+
+
+/**
+ * Checks if two DOM elements are colliding on the screen.
+ *
+ * @param {Element} elem1 - First DOM element.
+ * @param {Element} elem2 - Second DOM element.
+ * @returns {boolean} - Returns true if the elements are colliding.
+ */
+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
+  );
+}
+
+/**
+ * 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 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);
+  });
+}
+
+/**
+ * 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 {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.
+ */
+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.');
+
+  if (typeof method !== 'string' || !method.trim())
+    throw new Error('Invalid method: must be a non-empty string.');
+
+  if (!signal) {
+    if (
+      typeof timeout !== 'number' ||
+      !Number.isFinite(timeout) ||
+      Number.isNaN(timeout) ||
+      timeout < 0
+    )
+      throw new Error('Invalid timeout: must be a positive number.');
+
+    if (
+      typeof retries !== 'number' ||
+      !Number.isFinite(retries) ||
+      Number.isNaN(retries) ||
+      retries < 0
+    )
+      throw new Error('Invalid retries: must be a positive number.');
+  }
+
+  const attempts = signal ? 1 : retries + 1;
+  /** @type {Error|null} */
+  let lastError = null;
+
+  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;
+
+    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)));
+    }
+  }
+
+  throw new Error(
+    `Failed to fetch JSON from "${url}"${lastError ? `: ${lastError.message}` : '.'}`,
+  );
+}
+
+/**
+ * @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.
@@ -3047,6 +4199,503 @@ function KeyPressHandler() {
 export default KeyPressHandler;
 */
 
+// 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
+
+
+
+
+/*========================*
+ * JSON Operations
+ *========================*/
+
+/**
+ * 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);
+}
+
+/**
+ * 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');
+}
+
+/**
+ * Reads and parses a JSON file.
+ * Throws an error if the file content is not valid JSON.
+ * @param {string} filePath
+ * @returns {Promise<any>}
+ */
+async function readJsonFileAsync(filePath) {
+  if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+  const content = await fs.promises.readFile(filePath, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Saves an object as JSON to a file.
+ * Automatically creates the directory if it does not exist.
+ * @param {string} filePath
+ * @param {any} data
+ * @param {number} [spaces=2]
+ * @returns {Promise<void>}
+ */
+function writeJsonFileAsync(filePath, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  return fs.promises.writeFile(filePath, json, 'utf-8');
+}
+
+/*========================*
+ * Directory Management
+ *========================*/
+
+/**
+ * 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 });
+  }
+}
+
+/**
+ * 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);
+    }
+  }
+}
+
+/*========================*
+ * File Checks
+ *========================*/
+
+/**
+ * Checks whether a file exists.
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function fileExists(filePath) {
+  return fs_ignored_.existsSync(filePath) && fs_ignored_.lstatSync(filePath).isFile();
+}
+
+/**
+ * Checks whether a directory exists.
+ * @param {string} dirPath
+ * @returns {boolean}
+ */
+function dirExists(dirPath) {
+  return fs_ignored_.existsSync(dirPath) && fs_ignored_.lstatSync(dirPath).isDirectory();
+}
+
+/**
+ * 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;
+}
+
+/*========================*
+ * File Operations
+ *========================*/
+
+/**
+ * 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);
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Copies a file to a destination.
+ * @param {string} src
+ * @param {string} dest
+ * @param {number} [mode]
+ * @returns {Promise<void>}
+ */
+function ensureCopyFileAsync(src, dest, mode) {
+  ensureDirectory(path.dirname(dest));
+  return fs.promises.copyFile(src, dest, mode);
+}
+
+/**
+ * Deletes a file (If the file exists).
+ * @param {string} filePath
+ * @returns {Promise<boolean>}
+ */
+async function tryDeleteFileAsync(filePath) {
+  if (fileExists(filePath)) {
+    await fs.promises.unlink(filePath);
+    return true;
+  }
+  return false;
+}
+
+/*========================*
+ * Text Operations
+ *========================*/
+
+/**
+ * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
+ * @param {string} filePath
+ * @param {string} content
+ * @param {fs.WriteFileOptions} [ops='utf-8']
+ */
+function writeTextFile(filePath, content, ops = 'utf-8') {
+  const dir = path_browserify.dirname(filePath);
+  ensureDirectory(dir);
+  fs_ignored_.writeFileSync(filePath, content, ops);
+}
+
+/**
+ * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
+ * @param {string} filePath
+ * @param {string} content
+ * @param {fs.WriteFileOptions} [ops='utf-8']
+ * @returns {Promise<void>}
+ */
+function writeTextFileAsync(filePath, content, ops = 'utf-8') {
+  const dir = path.dirname(filePath);
+  ensureDirectory(dir);
+  return fs.promises.writeFile(filePath, content, ops);
+}
+
+/*========================*
+ * Directory Listings
+ *========================*/
+
+/**
+ * Lists all files and dirs in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {{ files: string[]; dirs: string[] }}
+ */
+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);
+      }
+    } else {
+      results.files.push(fullPath);
+    }
+  }
+  return results;
+}
+
+/**
+ * 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;
+}
+
+/*========================*
+ * File Info
+ *========================*/
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/*========================*
+ * Backup Utilities
+ *========================*/
+
+/**
+ * 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);
+}
+
+/**
+ * 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();
+
+  if (backups.length === 0) throw new Error(`No backups found for ${filePath}`);
+
+  return path_browserify.join(dir, backups[0]);
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Restores the most recent backup of a file.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+function restoreLatestBackupAsync(filePath, ext = 'bak') {
+  const latestBackup = getLatestBackupPath(filePath, ext);
+  return ensureCopyFileAsync(latestBackup, filePath);
+}
+
+/**
+ * Creates a backup copy of a file with .bak timestamp suffix.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+async function backupFileAsync(filePath, ext = 'bak') {
+  if (!fileExists(filePath)) return;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.${ext}.${timestamp}`;
+  return ensureCopyFileAsync(filePath, backupPath);
+}
+
+/*========================*
+ * Rename Utilities
+ *========================*/
+
+/**
+ * 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}`);
+  }
+
+  const files = listFiles(dirPath).files;
+  let index = 0;
+
+  for (const file of files) {
+    const ext = path_browserify.extname(file);
+    if (extensions.length && !extensions.includes(ext)) continue;
+
+    const originalName = path_browserify.basename(file);
+    const newName = renameFn(originalName, index++);
+    const newPath = path_browserify.join(dirPath, newName);
+
+    if (originalName === newName) continue;
+
+    fs_ignored_.renameSync(file, newPath);
+  }
+}
+
+/**
+ * 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,
+  );
+}
+
+/**
+ * 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,
+  );
+}
+
+/**
+ * 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 rawExt = path_browserify.extname(filename);
+      const ext = normalizeExt ? changeToMode(rawExt) : rawExt;
+      const name = changeToMode(path_browserify.basename(filename, rawExt));
+      return `${name}${ext}`;
+    },
+    extensions,
+  );
+}
+
+/**
+ * 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
 
 
@@ -3058,6 +4707,9 @@ export default KeyPressHandler;
 
 
 
+
+
+
 })();
 
 window.TinyBasicsEs = __webpack_exports__;