tiny-essentials 1.11.0 → 1.12.0

package/dist/v1/TinyEssentials.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,32 +2879,71 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   ColorSafeStringify: () => (/* reexport */ libs_ColorSafeStringify),
+  TinyDragDropDetector: () => (/* reexport */ libs_TinyDragDropDetector),
+  TinyDragger: () => (/* reexport */ libs_TinyDragger),
   TinyLevelUp: () => (/* reexport */ userLevel),
   TinyNotifyCenter: () => (/* reexport */ libs_TinyNotifyCenter),
   TinyPromiseQueue: () => (/* reexport */ libs_TinyPromiseQueue),
   TinyRateLimiter: () => (/* reexport */ libs_TinyRateLimiter),
   TinyToastNotify: () => (/* reexport */ libs_TinyToastNotify),
   addAiMarkerShortcut: () => (/* reexport */ addAiMarkerShortcut),
+  areHtmlElsColliding: () => (/* reexport */ areHtmlElsColliding),
   arraySortPositions: () => (/* reexport */ arraySortPositions),
   asyncReplace: () => (/* reexport */ asyncReplace),
+  backupFile: () => (/* reexport */ backupFile),
   checkObj: () => (/* reexport */ checkObj),
+  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/replaceAsync.mjs
@@ -3090,6 +3865,132 @@ extendObjType([
   ],
 ]);
 
+;// ./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.
@@ -4751,6 +5652,38 @@ class TinyNotifyCenter {
   get count() {
     return this.#count;
   }
+
+  /**
+   * Destroys the notification center instance, removing all event listeners,
+   * clearing notifications, and optionally removing DOM elements.
+   *
+   * Call this when the notification center is no longer needed to prevent memory leaks.
+   *
+   * @returns {void}
+   */
+  destroy() {
+    // Remove event listeners
+    this.#button?.removeEventListener('click', this.toggle);
+    this.#center?.querySelector('.close')?.removeEventListener('click', this.close);
+    this.#center?.querySelector('.clear-all')?.removeEventListener('click', this.clear);
+    this.#overlay?.removeEventListener('click', this.close);
+
+    // Clear all notifications
+    this.clear();
+
+    this.#center?.remove();
+    this.#overlay?.remove();
+    this.#button?.remove();
+
+    // Clean internal references
+    // this.#center = null;
+    // this.#list = null;
+    // this.#badge = null;
+    // this.#button = null;
+    // this.#overlay = null;
+    this.#count = 0;
+    this.#modes = new WeakMap();
+  }
 }
 
 /* harmony default export */ const libs_TinyNotifyCenter = (TinyNotifyCenter);
@@ -4802,6 +5735,8 @@ class TinyToastNotify {
   #baseDuration;
   #extraPerChar;
   #fadeOutDuration;
+
+  /** @type {HTMLElement|null} */
   #container;
 
   /**
@@ -5129,11 +6064,1857 @@ class TinyToastNotify {
 
     setTimeout(() => close(), totalTime);
   }
+
+  /**
+   * Destroys the notification container and removes all active notifications.
+   * This should be called when the notification system is no longer needed,
+   * such as when unloading a page or switching views in a single-page app.
+   *
+   * @returns {void}
+   */
+  destroy() {
+    if (!(this.#container instanceof HTMLElement)) return;
+
+    // Remove all child notifications
+    this.#container.querySelectorAll('.notify').forEach((el) => el.remove());
+
+    // Remove the container itself from the DOM
+    if (this.#container.parentNode) {
+      this.#container.parentNode.removeChild(this.#container);
+    }
+
+    // Optional: Clean internal references (safe practice)
+    this.#container = null;
+  }
 }
 
 /* harmony default export */ const libs_TinyToastNotify = (TinyToastNotify);
 
-;// ./src/v1/index.mjs
+;// ./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/libs/TinyDragDropDetector.mjs
+/**
+ * @typedef {Object} DragAndDropOptions
+ * @property {HTMLElement} [target=document.body] - The DOM element where drag listeners will be attached. Defaults to `document.body` if `fullscreen` is true or no target is provided.
+ * @property {boolean} [fullscreen=true] - If true, listeners are attached to the entire page (`document.body`). If false, the `target` must be specified.
+ * @property {string} [hoverClass="dnd-hover"] - CSS class applied to the target element while files are being dragged over it.
+ * @property {(files: FileList, event: DragEvent) => void} [onDrop] - Callback function executed when files are dropped onto the target.
+ * @property {(event: DragEvent) => void} [onEnter] - Optional callback triggered when dragging enters the target area.
+ * @property {(event: DragEvent) => void} [onLeave] - Optional callback triggered when dragging leaves the target area.
+ */
+
+/**
+ * TinyDragDropDetector
+ *
+ * A lightweight utility to detect drag-and-drop file operations on a specific DOM element or the entire page.
+ * It handles the drag lifecycle (enter, over, leave, drop) and provides hooks for developers to handle file uploads or UI changes.
+ *
+ * @class
+ */
+class TinyDragDropDetector {
+  /** @type {HTMLElement} */
+  #target;
+
+  /** @type {boolean} */
+  #fullscreen;
+
+  /** @type {string} */
+  #hoverClass;
+
+  /** @type {(files: FileList, event: DragEvent) => void} */
+  #onDropCallback;
+
+  /** @type {(event: DragEvent) => void} */
+  #onEnterCallback;
+
+  /** @type {(event: DragEvent) => void} */
+  #onLeaveCallback;
+
+  /** @type {boolean} */
+  #isDragging;
+
+  /** @type {boolean} */
+  #bound;
+
+  /**
+   * Creates a new instance of TinyDragDropDetector to handle drag-and-drop file detection.
+   *
+   * @param {DragAndDropOptions} [options={}] - Configuration options for the detector.
+   * @throws {TypeError} If `target` is not an HTMLElement.
+   * @throws {TypeError} If `fullscreen` is not a boolean.
+   * @throws {TypeError} If `hoverClass` is not a string.
+   * @throws {TypeError} If `onDrop` is defined but not a function.
+   * @throws {TypeError} If `onEnter` is defined but not a function.
+   * @throws {TypeError} If `onLeave` is defined but not a function.
+   */
+  constructor(options = {}) {
+    const {
+      target,
+      fullscreen = true,
+      hoverClass = 'dnd-hover',
+      onDrop,
+      onEnter,
+      onLeave,
+    } = options;
+
+    // Validate fullscreen
+    if (typeof fullscreen !== 'boolean')
+      throw new TypeError('The "fullscreen" option must be a boolean.');
+
+    // Validate target
+    const resolvedTarget = fullscreen ? document.body : target || document.body;
+    if (!(resolvedTarget instanceof HTMLElement))
+      throw new TypeError('The "target" option must be an instance of HTMLElement.');
+
+    // Validate hoverClass
+    if (typeof hoverClass !== 'string')
+      throw new TypeError('The "hoverClass" option must be a string.');
+
+    // Validate onDrop
+    if (typeof onDrop !== 'function')
+      throw new TypeError('The "onDrop" option must be a function.');
+
+    // Validate onEnter
+    if (typeof onEnter !== 'function')
+      throw new TypeError('The "onEnter" option must be a function.');
+
+    // Validate onLeave
+    if (typeof onLeave !== 'function')
+      throw new TypeError('The "onLeave" option must be a function.');
+
+    // Store properties
+    this.#target = resolvedTarget;
+    this.#fullscreen = fullscreen;
+    this.#hoverClass = hoverClass;
+
+    this.#onDropCallback = onDrop || (() => {});
+    this.#onEnterCallback = onEnter;
+    this.#onLeaveCallback = onLeave;
+
+    this.#isDragging = false;
+    this.#bound = false;
+
+    // Bind event handlers
+    this._handleDragEnter = this._handleDragEnter.bind(this);
+    this._handleDragOver = this._handleDragOver.bind(this);
+    this._handleDragLeave = this._handleDragLeave.bind(this);
+    this._handleDrop = this._handleDrop.bind(this);
+
+    this.#bindEvents();
+  }
+
+  /**
+   * Returns the current target DOM element where the listeners are attached.
+   * @returns {HTMLElement}
+   */
+  getTarget() {
+    return this.#target;
+  }
+
+  /**
+   * Returns the CSS class applied during drag hover.
+   * @returns {string}
+   */
+  getHoverClass() {
+    return this.#hoverClass;
+  }
+
+  /**
+   * Indicates whether the detector is operating in fullscreen mode.
+   * @returns {boolean}
+   */
+  isFullScreen() {
+    return this.#fullscreen;
+  }
+
+  /**
+   * Returns whether a drag operation is currently active over the target.
+   * @returns {boolean}
+   */
+  isDragging() {
+    return this.#isDragging;
+  }
+
+  /**
+   * Returns whether the event listeners are currently bound to the target.
+   * @returns {boolean}
+   */
+  bound() {
+    return this.#bound;
+  }
+
+  /**
+   * Binds the drag-and-drop event listeners to the target element.
+   * Automatically called on instantiation.
+   * @returns {void}
+   */
+  #bindEvents() {
+    if (this.#bound) return;
+    const target = this.getTarget();
+    target.addEventListener('dragenter', this._handleDragEnter);
+    target.addEventListener('dragover', this._handleDragOver);
+    target.addEventListener('dragleave', this._handleDragLeave);
+    target.addEventListener('drop', this._handleDrop);
+    this.#bound = true;
+  }
+
+  /**
+   * Removes all previously attached drag-and-drop event listeners from the target.
+   * @returns {void}
+   */
+  #unbindEvents() {
+    if (!this.#bound) return;
+    const target = this.getTarget();
+    target.removeEventListener('dragenter', this._handleDragEnter);
+    target.removeEventListener('dragover', this._handleDragOver);
+    target.removeEventListener('dragleave', this._handleDragLeave);
+    target.removeEventListener('drop', this._handleDrop);
+    this.#bound = false;
+  }
+
+  /**
+   * Handles the `dragenter` event.
+   * Adds the hover CSS class and triggers the `onEnter` callback if provided.
+   * @private
+   * @param {DragEvent} event - The dragenter event.
+   * @returns {void}
+   */
+  _handleDragEnter(event) {
+    event.preventDefault();
+    if (!this.#isDragging) {
+      const target = this.getTarget();
+      this.#isDragging = true;
+      target.classList.add(this.#hoverClass);
+      this.#onEnterCallback(event);
+    }
+  }
+
+  /**
+   * Handles the `dragover` event.
+   * Prevents default to allow drop and sets the drop effect.
+   * @private
+   * @param {DragEvent} event - The dragover event.
+   * @returns {void}
+   */
+  _handleDragOver(event) {
+    event.preventDefault(); // Required to allow drop
+    if (!event.dataTransfer) {
+      console.warn('[TinyDragDropDetector] [handleDragOver] DragOver event missing dataTransfer.');
+      return;
+    }
+    event.dataTransfer.dropEffect = 'copy';
+  }
+
+  /**
+   * Handles the `dragleave` event.
+   * Removes the hover class and triggers the `onLeave` callback if provided.
+   * @private
+   * @param {DragEvent} event - The dragleave event.
+   * @returns {void}
+   */
+  _handleDragLeave(event) {
+    event.preventDefault();
+    const target = this.getTarget();
+    // Check if you've completely left the area
+    // @ts-ignore
+    if (event.relatedTarget === null || !target.contains(event.relatedTarget)) {
+      this.#isDragging = false;
+      target.classList.remove(this.#hoverClass);
+      this.#onLeaveCallback(event);
+    }
+  }
+
+  /**
+   * Handles the `drop` event.
+   * Removes the hover class, resets dragging state, and triggers the `onDrop` callback.
+   * @private
+   * @param {DragEvent} event - The drop event.
+   * @returns {void}
+   */
+  _handleDrop(event) {
+    event.preventDefault();
+    if (!event.dataTransfer) {
+      console.warn('[TinyDragDropDetector] [handleDrop] DragOver event missing dataTransfer.');
+      return;
+    }
+    const target = this.getTarget();
+    this.#isDragging = false;
+    target.classList.remove(this.#hoverClass);
+    const files = event.dataTransfer.files;
+    if (files.length > 0) {
+      this.#onDropCallback(files, event);
+    }
+  }
+
+  /**
+   * Destroys the detector instance, unbinding all event listeners and cleaning up.
+   * Should be called when the detector is no longer needed to avoid memory leaks.
+   * @returns {void}
+   */
+  destroy() {
+    this.#unbindEvents();
+    const target = this.getTarget();
+    target.classList.remove(this.#hoverClass);
+  }
+}
+
+/* harmony default export */ const libs_TinyDragDropDetector = (TinyDragDropDetector);
+
+// 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/libs/TinyDragger.mjs
+
+
+
+/**
+ * @typedef {Object} VibrationPatterns
+ * @property {number[]|false} start - Pattern to vibrate on start
+ * @property {number[]|false} end - Pattern to vibrate on end
+ * @property {number[]|false} collide - Pattern to vibrate on collision
+ * @property {number[]|false} move - Pattern to vibrate while moving
+ */
+
+/**
+ * TinyDragger enables drag-and-drop functionality for a DOM element.
+ * It supports jail boundaries, optional collision detection, vibration feedback,
+ * automatic reverting, proxy dragging, and event dispatching.
+ */
+class TinyDragger {
+  #enabled = true;
+  #destroyed = false;
+
+  #offsetY = 0;
+  #offsetX = 0;
+
+  #lockInsideJail = false;
+  #revertOnDrop = false;
+  #dragging = false;
+  #collisionByMouse = false;
+  #dropInJailOnly = false;
+
+  /** @type {HTMLElement|null} */
+  #lastCollision = null;
+
+  /** @type {HTMLElement[]} */
+  #collidables = [];
+
+  /** @type {HTMLElement|null} */
+  #dragProxy = null;
+
+  /** @type {VibrationPatterns} */
+  #vibration = { start: false, end: false, collide: false, move: false };
+
+  /** @type {HTMLElement|null} */
+  #jail = null;
+
+  #target;
+
+  #dragHiddenClass = 'drag-hidden';
+  #classDragging = 'dragging';
+  #classBodyDragging = 'drag-active';
+  #classJailDragging = 'jail-drag-active';
+  #classJailDragDisabled = 'jail-drag-disabled';
+  #classDragCollision = 'dragging-collision';
+
+  /** @typedef {(event: TouchEvent) => void} TouchDragEvent */
+
+  /**
+   * @param {HTMLElement} targetElement - The element to make draggable.
+   * @param {Object} [options={}] - Configuration options.
+   * @param {HTMLElement} [options.jail] - Optional container to restrict dragging within.
+   * @param {boolean} [options.collisionByMouse=false] - Use mouse position for collision instead of element rect.
+   * @param {string} [options.classDragging='dragging'] - CSS class applied to the clone during dragging.
+   * @param {string} [options.classBodyDragging='drag-active'] - CSS class applied to <body> during dragging.
+   * @param {string} [options.classJailDragging='jail-drag-active'] - CSS class applied to jail element during drag.
+   * @param {string} [options.classJailDragDisabled='jail-drag-disabled'] - CSS class applied to jail element disabled.
+   * @param {string} [options.classDragCollision='dragging-collision'] - CSS class applied to collision element.
+   * @param {boolean} [options.lockInsideJail=false] - Restrict movement within the jail container.
+   * @param {boolean} [options.dropInJailOnly=false] - Restrict drop within the jail container.
+   * @param {VibrationPatterns|false} [options.vibration=false] - Vibration feedback configuration.
+   * @param {boolean} [options.revertOnDrop=false] - Whether to return to original position on drop.
+   * @param {string} [options.classHidden='drag-hidden'] - CSS class to hide original element during dragging.
+   * @throws {Error} If any option has an invalid type.
+   */
+  constructor(targetElement, options = {}) {
+    if (!(targetElement instanceof HTMLElement))
+      throw new Error('TinyDragger requires a valid target HTMLElement to initialize.');
+
+    this.#target = targetElement;
+
+    // === Validations ===
+    if (options.jail !== undefined && !(options.jail instanceof HTMLElement))
+      throw new Error('The "jail" option must be an HTMLElement if provided.');
+
+    if (
+      options.vibration !== undefined &&
+      options.vibration !== false &&
+      !isJsonObject(options.vibration)
+    )
+      throw new Error('The "vibration" option must be an object or false.');
+
+    /**
+     * @param {any} val
+     * @param {string} name
+     */
+    const validateBoolean = (val, name) => {
+      if (val !== undefined && typeof val !== 'boolean') {
+        throw new Error(`The "${name}" option must be a boolean.`);
+      }
+    };
+
+    /**
+     * @param {any} val
+     * @param {string} name
+     */
+    const validateString = (val, name) => {
+      if (val !== undefined && typeof val !== 'string') {
+        throw new Error(`The "${name}" option must be a string.`);
+      }
+    };
+
+    validateBoolean(options.collisionByMouse, 'collisionByMouse');
+    validateBoolean(options.lockInsideJail, 'lockInsideJail');
+    validateBoolean(options.dropInJailOnly, 'dropInJailOnly');
+    validateBoolean(options.revertOnDrop, 'revertOnDrop');
+
+    validateString(options.classDragging, 'classDragging');
+    validateString(options.classBodyDragging, 'classBodyDragging');
+    validateString(options.classJailDragging, 'classJailDragging');
+    validateString(options.classJailDragDisabled, 'classJailDragDisabled');
+    validateString(options.classDragCollision, 'classDragCollision');
+    validateString(options.classHidden, 'classHidden');
+
+    if (options.jail instanceof HTMLElement) this.#jail = options.jail;
+
+    /** @type {VibrationPatterns} */
+    const vibrationTemplate = { start: false, end: false, collide: false, move: false };
+    this.#vibration = Object.assign(
+      vibrationTemplate,
+      isJsonObject(options.vibration) ? options.vibration : {},
+    );
+
+    if (typeof options.classDragging === 'string') this.#classDragging = options.classDragging;
+    if (typeof options.classBodyDragging === 'string')
+      this.#classBodyDragging = options.classBodyDragging;
+    if (typeof options.classJailDragging === 'string')
+      this.#classJailDragging = options.classJailDragging;
+    if (typeof options.classJailDragDisabled === 'string')
+      this.#classJailDragDisabled = options.classJailDragDisabled;
+    if (typeof options.classHidden === 'string') this.#dragHiddenClass = options.classHidden;
+    if (typeof options.classDragCollision === 'string')
+      this.#classDragCollision = options.classDragCollision;
+
+    if (typeof options.collisionByMouse === 'boolean')
+      this.#collisionByMouse = options.collisionByMouse;
+    if (typeof options.revertOnDrop === 'boolean') this.#revertOnDrop = options.revertOnDrop;
+    if (typeof options.lockInsideJail === 'boolean') this.#lockInsideJail = options.lockInsideJail;
+    if (typeof options.dropInJailOnly === 'boolean') this.#dropInJailOnly = options.dropInJailOnly;
+
+    /** @private */
+    this._onMouseDown = this.#startDrag.bind(this);
+    /** @private */
+    this._onMouseMove = this.#drag.bind(this);
+    /** @private */
+    this._onMouseUp = this.#endDrag.bind(this);
+
+    /**
+     * @type {TouchDragEvent}
+     * @private
+     */
+    this._onTouchStart = (e) => this.#startDrag(e.touches[0]);
+
+    /**
+     * @type {TouchDragEvent}
+     * @private
+     */
+    this._onTouchMove = (e) => this.#drag(e.touches[0]);
+
+    /**
+     * @type {TouchDragEvent}
+     * @private
+     */
+    this._onTouchEnd = (e) => this.#endDrag(e.changedTouches[0]);
+
+    this.#target.addEventListener('mousedown', this._onMouseDown);
+    this.#target.addEventListener('touchstart', this._onTouchStart, { passive: false });
+  }
+
+  /**
+   * Enables the drag functionality.
+   */
+  enable() {
+    this.#checkDestroy();
+    if (this.#jail) this.#jail.classList.add(this.#classJailDragDisabled);
+    this.#enabled = true;
+  }
+
+  /**
+   * Disables the drag functionality.
+   */
+  disable() {
+    if (this.#jail) this.#jail.classList.remove(this.#classJailDragDisabled);
+    this.#enabled = false;
+  }
+
+  /**
+   * Adds an element to be considered for collision detection.
+   * @param {HTMLElement} element - The element to track collisions with.
+   * @throws {Error} If the element is not a valid HTMLElement.
+   */
+  addCollidable(element) {
+    this.#checkDestroy();
+    if (!(element instanceof HTMLElement))
+      throw new Error('addCollidable expects an HTMLElement as argument.');
+    if (!this.#collidables.includes(element)) this.#collidables.push(element);
+  }
+
+  /**
+   * Removes a collidable element from the tracking list.
+   * @param {HTMLElement} element - The element to remove.
+   * @throws {Error} If the element is not a valid HTMLElement.
+   */
+  removeCollidable(element) {
+    this.#checkDestroy();
+    if (!(element instanceof HTMLElement))
+      throw new Error('removeCollidable expects an HTMLElement as argument.');
+    this.#collidables = this.#collidables.filter((el) => el !== element);
+  }
+
+  /**
+   * Sets vibration patterns for drag events.
+   * @param {Object} [param0={}] - Vibration pattern configuration.
+   * @param {number[]|false} [param0.startPattern=false] - Vibration on drag start.
+   * @param {number[]|false} [param0.endPattern=false] - Vibration on drag end.
+   * @param {number[]|false} [param0.collidePattern=false] - Vibration on collision.
+   * @param {number[]|false} [param0.movePattern=false] - Vibration during movement.
+   * @throws {Error} If any pattern is not false or an array of numbers.
+   */
+  setVibrationPattern({
+    startPattern = false,
+    endPattern = false,
+    collidePattern = false,
+    movePattern = false,
+  } = {}) {
+    this.#checkDestroy();
+
+    /** @param {any} value */
+    const isValidPattern = (value) =>
+      value === false || (Array.isArray(value) && value.every((n) => typeof n === 'number'));
+
+    if (!isValidPattern(startPattern))
+      throw new Error('Invalid "startPattern": must be false or an array of numbers.');
+    if (!isValidPattern(endPattern))
+      throw new Error('Invalid "endPattern": must be false or an array of numbers.');
+    if (!isValidPattern(collidePattern))
+      throw new Error('Invalid "collidePattern": must be false or an array of numbers.');
+    if (!isValidPattern(movePattern))
+      throw new Error('Invalid "movePattern": must be false or an array of numbers.');
+
+    this.#vibration = {
+      start: startPattern,
+      end: endPattern,
+      collide: collidePattern,
+      move: movePattern,
+    };
+  }
+
+  /**
+   * Disables all vibration feedback.
+   */
+  disableVibration() {
+    this.#checkDestroy();
+    this.#vibration = { start: false, end: false, collide: false, move: false };
+  }
+
+  /**
+   * Calculates the cursor offset relative to the top-left of the target element.
+   * @param {MouseEvent|Touch} event - The mouse or touch event.
+   * @returns {{x: number, y: number}} The offset in pixels.
+   * @throws {Error} If event is not a MouseEvent or Touch with clientX/clientY.
+   */
+  getOffset(event) {
+    this.#checkDestroy();
+    if (
+      (!(event instanceof MouseEvent) && !(event instanceof Touch)) ||
+      typeof event.clientX !== 'number' ||
+      typeof event.clientY !== 'number'
+    )
+      throw new Error('getOffset expects an event with valid clientX and clientY coordinates.');
+
+    const targetRect = this.#target.getBoundingClientRect();
+    const { left: borderLeft, top: borderTop } = getHtmlElBordersWidth(this.#target);
+    return {
+      x: event.clientX - targetRect.left + borderLeft,
+      y: event.clientY - targetRect.top + borderTop,
+    };
+  }
+
+  /**
+   * Handles the start of a drag event.
+   * @param {MouseEvent|Touch} event - The initiating event.
+   */
+  #startDrag(event) {
+    if (event instanceof MouseEvent) event.preventDefault();
+    if (this.#destroyed || !this.#enabled || !this.#target.parentElement) return;
+
+    const dragProxy = this.#target.cloneNode(true);
+    if (!(dragProxy instanceof HTMLElement)) return;
+    this.#dragProxy = dragProxy;
+
+    this.#dragging = true;
+
+    const rect = this.#target.getBoundingClientRect();
+
+    Object.assign(this.#dragProxy.style, {
+      position: 'absolute',
+      pointerEvents: 'none',
+      left: `${this.#target.offsetLeft}px`,
+      top: `${this.#target.offsetTop}px`,
+      width: `${rect.width}px`,
+      height: `${rect.height}px`,
+      zIndex: 9999,
+    });
+
+    this.#target.classList.add(this.#dragHiddenClass);
+    this.#target.parentElement.appendChild(this.#dragProxy);
+
+    const { x: offsetX, y: offsetY } = this.getOffset(event);
+    this.#offsetX = offsetX;
+    this.#offsetY = offsetY;
+
+    this.#dragProxy.classList.add(this.#classDragging);
+    document.body.classList.add(this.#classBodyDragging);
+    if (this.#jail) this.#jail.classList.add(this.#classJailDragging);
+
+    document.addEventListener('mousemove', this._onMouseMove);
+    document.addEventListener('mouseup', this._onMouseUp);
+
+    document.addEventListener('touchmove', this._onTouchMove, { passive: false });
+    document.addEventListener('touchend', this._onTouchEnd);
+
+    if (navigator.vibrate && Array.isArray(this.#vibration.start)) {
+      navigator.vibrate(this.#vibration.start);
+    }
+
+    this.checkDragCollision(event);
+    this.#dispatchEvent('drag');
+  }
+
+  /**
+   * Handles dragging collision.
+   * @param {MouseEvent|Touch} event - The drag event.
+   */
+  checkDragCollision(event) {
+    const { collidedElement: collided } = this.execCollision(event);
+    if (collided && collided !== this.#lastCollision) {
+      if (navigator.vibrate && Array.isArray(this.#vibration.collide)) {
+        navigator.vibrate(this.#vibration.collide);
+      }
+      this.#lastCollision = collided;
+      if (this.#lastCollision) this.#lastCollision.classList.add(this.#classDragCollision);
+    } else if (!collided) {
+      if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
+      this.#lastCollision = null;
+    }
+  }
+
+  /**
+   * Handles dragging movement.
+   * @param {MouseEvent|Touch} event - The drag event.
+   */
+  #drag(event) {
+    if (event instanceof MouseEvent) event.preventDefault();
+    if (this.#destroyed || !this.#dragging || !this.#enabled || !this.#dragProxy) return;
+
+    const parent = this.#dragProxy.offsetParent || document.body;
+    const parentRect = parent.getBoundingClientRect();
+
+    let x = event.clientX - parentRect.left - this.#offsetX;
+    let y = event.clientY - parentRect.top - this.#offsetY;
+
+    if (this.#lockInsideJail && this.#jail) {
+      const jailRect = this.#jail.getBoundingClientRect();
+      const targetRect = this.#dragProxy.getBoundingClientRect();
+
+      const jailLeft = jailRect.left - parentRect.left;
+      const jailTop = jailRect.top - parentRect.top;
+
+      const { x: borderX, y: borderY } = getHtmlElBordersWidth(this.#jail);
+      const maxX = jailLeft + jailRect.width - targetRect.width - borderY;
+      const maxY = jailTop + jailRect.height - targetRect.height - borderX;
+
+      x = Math.max(jailLeft, Math.min(x, maxX));
+      y = Math.max(jailTop, Math.min(y, maxY));
+    }
+
+    this.#dragProxy.style.position = 'absolute';
+    this.#dragProxy.style.left = `${x}px`;
+    this.#dragProxy.style.top = `${y}px`;
+
+    if (navigator.vibrate && Array.isArray(this.#vibration.move)) {
+      navigator.vibrate(this.#vibration.move);
+    }
+
+    this.checkDragCollision(event);
+    this.#dispatchEvent('dragging');
+  }
+
+  /**
+   * Handles the collision of a drag.
+   * @param {MouseEvent|Touch} event - The release event.
+   * @returns {{ inJail: boolean; collidedElement: HTMLElement|null }}
+   */
+  execCollision(event) {
+    if (this.#destroyed || !this.#dragProxy) return { inJail: false, collidedElement: null };
+
+    let collidedElement;
+    let inJail = true;
+    const jailRect = this.#jail?.getBoundingClientRect();
+    if (this.#collisionByMouse) {
+      const x = event.clientX;
+      const y = event.clientY;
+      if (this.#dropInJailOnly && this.#jail && jailRect) {
+        inJail =
+          x >= jailRect.left && x <= jailRect.right && y >= jailRect.top && y <= jailRect.bottom;
+      }
+
+      collidedElement = inJail ? this.getCollidedElement(x, y) : null;
+    } else {
+      const targetRect = this.#dragProxy.getBoundingClientRect();
+      if (this.#dropInJailOnly && this.#jail && jailRect) {
+        inJail =
+          targetRect.left >= jailRect.left &&
+          targetRect.right <= jailRect.right &&
+          targetRect.top >= jailRect.top &&
+          targetRect.bottom <= jailRect.bottom;
+      }
+
+      collidedElement = inJail ? this.getCollidedElementByRect(targetRect) : null;
+    }
+
+    return { inJail, collidedElement };
+  }
+
+  /**
+   * Handles the end of a drag.
+   * @param {MouseEvent|Touch} event - The release event.
+   */
+  #endDrag(event) {
+    if (event instanceof MouseEvent) event.preventDefault();
+    if (this.#destroyed || !this.#dragging) return;
+
+    this.#dragging = false;
+    if (!this.#dragProxy) return;
+
+    this.#target.classList.remove(this.#classDragging);
+    document.body.classList.remove(this.#classBodyDragging);
+    if (this.#jail) this.#jail.classList.remove(this.#classJailDragging);
+
+    document.removeEventListener('mousemove', this._onMouseMove);
+    document.removeEventListener('mouseup', this._onMouseUp);
+
+    document.removeEventListener('touchmove', this._onTouchMove);
+    document.removeEventListener('touchend', this._onTouchEnd);
+    const { collidedElement } = this.execCollision(event);
+
+    if (navigator.vibrate && Array.isArray(this.#vibration.end)) {
+      navigator.vibrate(this.#vibration.end);
+    }
+
+    const newX = this.#dragProxy.style.left;
+    const newY = this.#dragProxy.style.top;
+    if (this.#dragProxy) {
+      this.#dragProxy.remove();
+      this.#dragProxy = null;
+    }
+
+    if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
+    this.#lastCollision = null;
+
+    this.#target.classList.remove(this.#dragHiddenClass);
+    if (!this.#revertOnDrop) {
+      this.#target.style.left = newX;
+      this.#target.style.top = newY;
+    }
+
+    const dropEvent = new CustomEvent('drop', {
+      detail: {
+        target: collidedElement,
+      },
+    });
+
+    this.#target.dispatchEvent(dropEvent);
+  }
+
+  /**
+   * Detects collision based on rectangle intersection.
+   * @param {DOMRect} rect - Bounding rectangle of the dragged proxy.
+   * @returns {HTMLElement|null} The collided element or null.
+   * @throws {Error} If rect is not a DOMRect with valid numeric properties.
+   */
+  getCollidedElementByRect(rect) {
+    this.#checkDestroy();
+    if (
+      !(rect instanceof DOMRect) ||
+      typeof rect.left !== 'number' ||
+      typeof rect.right !== 'number' ||
+      typeof rect.top !== 'number' ||
+      typeof rect.bottom !== 'number'
+    )
+      throw new Error('getCollidedElementByRect expects a valid DOMRect object.');
+
+    return (
+      this.#collidables.find((el) => {
+        const elRect = el.getBoundingClientRect();
+        return !(
+          rect.right < elRect.left ||
+          rect.left > elRect.right ||
+          rect.bottom < elRect.top ||
+          rect.top > elRect.bottom
+        );
+      }) || null
+    );
+  }
+
+  /**
+   * Detects collision with a point using element bounding rectangles.
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {HTMLElement|null} The collided element or null.
+   */
+  getCollidedElement(x, y) {
+    this.#checkDestroy();
+    if (typeof x !== 'number' || typeof y !== 'number')
+      throw new Error('getCollidedElement expects numeric x and y coordinates.');
+
+    return (
+      this.#collidables.find((el) => {
+        const rect = el.getBoundingClientRect();
+        return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+      }) || null
+    );
+  }
+
+  /**
+   * Dispatches a custom event from the target element.
+   * @param {string} type - The event name.
+   */
+  #dispatchEvent(type) {
+    const event = new CustomEvent(type);
+    this.#target.dispatchEvent(event);
+  }
+
+  /**
+   * Gets whether dragging is currently active.
+   * @returns {boolean}
+   */
+  getDragging() {
+    return this.#dragging;
+  }
+
+  /**
+   * Gets whether movement is restricted inside the jail container.
+   * @returns {boolean}
+   */
+  getLockInsideJail() {
+    return this.#lockInsideJail;
+  }
+
+  /**
+   * Sets whether movement is restricted inside the jail container.
+   * @param {boolean} value
+   */
+  setLockInsideJail(value) {
+    if (typeof value !== 'boolean') throw new Error('lockInsideJail must be a boolean.');
+    this.#lockInsideJail = value;
+  }
+
+  /**
+   * Gets whether the element should revert to original position on drop.
+   * @returns {boolean}
+   */
+  getRevertOnDrop() {
+    return this.#revertOnDrop;
+  }
+
+  /**
+   * Sets whether the element should revert to original position on drop.
+   * @param {boolean} value
+   */
+  setRevertOnDrop(value) {
+    if (typeof value !== 'boolean') throw new Error('revertOnDrop must be a boolean.');
+    this.#revertOnDrop = value;
+  }
+
+  /**
+   * Gets whether collision detection uses mouse position.
+   * @returns {boolean}
+   */
+  getCollisionByMouse() {
+    return this.#collisionByMouse;
+  }
+
+  /**
+   * Sets whether collision detection uses mouse position.
+   * @param {boolean} value
+   */
+  setCollisionByMouse(value) {
+    if (typeof value !== 'boolean') throw new Error('collisionByMouse must be a boolean.');
+    this.#collisionByMouse = value;
+  }
+
+  /**
+   * Gets whether dropping is restricted inside the jail container.
+   * @returns {boolean}
+   */
+  getDropInJailOnly() {
+    return this.#dropInJailOnly;
+  }
+
+  /**
+   * Sets whether dropping is restricted inside the jail container.
+   * @param {boolean} value
+   */
+  setDropInJailOnly(value) {
+    if (typeof value !== 'boolean') throw new Error('dropInJailOnly must be a boolean.');
+    this.#dropInJailOnly = value;
+  }
+
+  /**
+   * Returns the original target element being dragged.
+   * @returns {HTMLElement}
+   */
+  getTarget() {
+    return this.#target;
+  }
+
+  /**
+   * Returns the current jail container (if any).
+   * @returns {HTMLElement|null}
+   */
+  getJail() {
+    return this.#jail;
+  }
+
+  /**
+   * Returns the current proxy element being dragged (if any).
+   * @returns {HTMLElement|null}
+   */
+  getDragProxy() {
+    return this.#dragProxy;
+  }
+
+  /**
+   * Returns the last collided element (if any).
+   * @returns {HTMLElement|null}
+   */
+  getLastCollision() {
+    return this.#lastCollision;
+  }
+
+  /**
+   * Returns all registered collidable elements.
+   * @returns {HTMLElement[]}
+   */
+  getCollidables() {
+    return [...this.#collidables];
+  }
+
+  /**
+   * Returns the CSS class used to hide the target during drag.
+   * @returns {string}
+   */
+  getDragHiddenClass() {
+    return this.#dragHiddenClass;
+  }
+
+  /**
+   * Returns the CSS class applied to the clone during dragging.
+   * @returns {string}
+   */
+  getClassDragging() {
+    return this.#classDragging;
+  }
+
+  /**
+   * Returns the CSS class applied to <body> during dragging.
+   * @returns {string}
+   */
+  getClassBodyDragging() {
+    return this.#classBodyDragging;
+  }
+
+  /**
+   * Returns the CSS class applied to the jail during dragging.
+   * @returns {string}
+   */
+  getClassJailDragging() {
+    return this.#classJailDragging;
+  }
+
+  /**
+   * Returns the CSS class applied to the jail when dragging is disabled.
+   * @returns {string}
+   */
+  getClassJailDragDisabled() {
+    return this.#classJailDragDisabled;
+  }
+
+  /**
+   * Returns the CSS class applied to a collided element.
+   * @returns {string}
+   */
+  getClassDragCollision() {
+    return this.#classDragCollision;
+  }
+
+  /**
+   * Returns the full vibration configuration.
+   * @returns {VibrationPatterns}
+   */
+  getVibrations() {
+    return { ...this.#vibration };
+  }
+
+  /**
+   * Returns the vibration pattern for drag start.
+   * @returns {number[]|boolean}
+   */
+  getStartVibration() {
+    return this.#vibration.start;
+  }
+
+  /**
+   * Returns the vibration pattern for drag end.
+   * @returns {number[]|boolean}
+   */
+  getEndVibration() {
+    return this.#vibration.end;
+  }
+
+  /**
+   * Returns the vibration pattern for collisions.
+   * @returns {number[]|boolean}
+   */
+  getCollideVibration() {
+    return this.#vibration.collide;
+  }
+
+  /**
+   * Returns the vibration pattern during movement.
+   * @returns {number[]|boolean}
+   */
+  getMoveVibration() {
+    return this.#vibration.move;
+  }
+
+  /**
+   * Returns whether the dragger is currently enabled.
+   * @returns {boolean}
+   */
+  isEnabled() {
+    return this.#enabled;
+  }
+
+  /**
+   * Internal method to verify if the instance has been destroyed.
+   * Throws an error if any operation is attempted after destruction.
+   */
+  #checkDestroy() {
+    if (this.#destroyed)
+      throw new Error('This TinyDragger instance has been destroyed and can no longer be used.');
+  }
+
+  /**
+   * Completely disables drag-and-drop and cleans up all event listeners.
+   * Does NOT remove the original HTML element.
+   */
+  destroy() {
+    if (this.#destroyed) return;
+    this.disable();
+
+    this.#target.removeEventListener('mousedown', this._onMouseDown);
+    this.#target.removeEventListener('touchstart', this._onTouchStart);
+
+    document.removeEventListener('mousemove', this._onMouseMove);
+    document.removeEventListener('mouseup', this._onMouseUp);
+
+    document.removeEventListener('touchmove', this._onTouchMove);
+    document.removeEventListener('touchend', this._onTouchEnd);
+
+    if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
+    if (this.#dragProxy) {
+      this.#dragProxy.remove();
+      this.#dragProxy = null;
+    }
+
+    this.#collidables = [];
+    this.#dragging = false;
+    this.#lastCollision = null;
+
+    this.#target.classList.remove(this.#dragHiddenClass, this.#classDragging);
+    document.body.classList.remove(this.#classBodyDragging);
+    if (this.#jail)
+      this.#jail.classList.remove(this.#classJailDragging, this.#classJailDragDisabled);
+
+    this.#destroyed = true;
+  }
+}
+
+/* harmony default export */ const libs_TinyDragger = (TinyDragger);
+
+;// ./src/v1/index.mjs
+
+
+
+
+