tiny-essentials 1.12.0 → 1.12.2

package/dist/v1/TinyUploadClicker.js

@@ -1,7 +1,7 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 41:
+/***/ 133:
 /***/ (() => {
 
 /* (ignored) */
@@ -1924,6 +1924,13 @@ var hexSliceLookupTable = (function () {
 })()
 
 
+/***/ }),
+
+/***/ 370:
+/***/ (() => {
+
+/* (ignored) */
+
 /***/ }),
 
 /***/ 526:
@@ -3683,10 +3690,10 @@ const getHtmlElPadding = (el) => {
 };
 
 // EXTERNAL MODULE: fs (ignored)
-var fs_ignored_ = __webpack_require__(41);
+var fs_ignored_ = __webpack_require__(133);
 // EXTERNAL MODULE: ./node_modules/path-browserify/index.js
 var path_browserify = __webpack_require__(975);
-;// ./src/v1/basics/fileManager.mjs
+;// ./src/v1/fileManager/normalFuncs.mjs
 
 
 
@@ -3702,8 +3709,8 @@ var path_browserify = __webpack_require__(975);
  * @returns {any}
  */
 function readJsonFile(filePath) {
-  if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-  const content = fs.readFileSync(filePath, 'utf-8');
+  if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+  const content = readFileSync(filePath, 'utf-8');
   return JSON.parse(content);
 }
 
@@ -3716,32 +3723,7 @@ function readJsonFile(filePath) {
  */
 function writeJsonFile(filePath, data, spaces = 2) {
   const json = JSON.stringify(data, null, spaces);
-  fs.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');
+  writeFileSync(filePath, json, 'utf-8');
 }
 
 /*========================*
@@ -3752,9 +3734,9 @@ function writeJsonFileAsync(filePath, data, spaces = 2) {
  * Ensures that the directory exists, creating it recursively if needed.
  * @param {string} dirPath
  */
-function ensureDirectory(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
+function normalFuncs_ensureDirectory(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
   }
 }
 
@@ -3763,15 +3745,15 @@ function ensureDirectory(dirPath) {
  * @param {string} dirPath
  */
 function clearDirectory(dirPath) {
-  if (!fs.existsSync(dirPath)) return;
-  const files = fs.readdirSync(dirPath);
+  if (!existsSync(dirPath)) return;
+  const files = readdirSync(dirPath);
   for (const file of files) {
-    const fullPath = path.join(dirPath, file);
-    const stat = fs.lstatSync(fullPath);
-    if (stat.isDirectory()) {
-      fs.rmSync(fullPath, { recursive: true, force: true });
+    const fullPath = join(dirPath, file);
+    const statData = lstatSync(fullPath);
+    if (statData.isDirectory()) {
+      rmSync(fullPath, { recursive: true, force: true });
     } else {
-      fs.unlinkSync(fullPath);
+      unlinkSync(fullPath);
     }
   }
 }
@@ -3785,8 +3767,8 @@ function clearDirectory(dirPath) {
  * @param {string} filePath
  * @returns {boolean}
  */
-function fileExists(filePath) {
-  return fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
+function normalFuncs_fileExists(filePath) {
+  return existsSync(filePath) && lstatSync(filePath).isFile();
 }
 
 /**
@@ -3794,8 +3776,8 @@ function fileExists(filePath) {
  * @param {string} dirPath
  * @returns {boolean}
  */
-function dirExists(dirPath) {
-  return fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
+function normalFuncs_dirExists(dirPath) {
+  return existsSync(dirPath) && lstatSync(dirPath).isDirectory();
 }
 
 /**
@@ -3804,7 +3786,7 @@ function dirExists(dirPath) {
  * @returns {boolean}
  */
 function isDirEmpty(dirPath) {
-  return fs.existsSync(dirPath) && fs.readdirSync(dirPath).length === 0;
+  return readdirSync(dirPath).length === 0;
 }
 
 /*========================*
@@ -3818,8 +3800,8 @@ function isDirEmpty(dirPath) {
  * @param {number} [mode]
  */
 function ensureCopyFile(src, dest, mode) {
-  ensureDirectory(path.dirname(dest));
-  fs.copyFileSync(src, dest, mode);
+  normalFuncs_ensureDirectory(dirname(dest));
+  copyFileSync(src, dest, mode);
 }
 
 /**
@@ -3828,33 +3810,8 @@ function ensureCopyFile(src, dest, mode) {
  * @returns {boolean}
  */
 function tryDeleteFile(filePath) {
-  if (fileExists(filePath)) {
-    fs.unlinkSync(filePath);
-    return true;
-  }
-  return false;
-}
-
-/**
- * Copies a file to a destination.
- * @param {string} src
- * @param {string} dest
- * @param {number} [mode]
- * @returns {Promise<void>}
- */
-function ensureCopyFileAsync(src, dest, mode) {
-  ensureDirectory(path.dirname(dest));
-  return fs.promises.copyFile(src, dest, mode);
-}
-
-/**
- * Deletes a file (If the file exists).
- * @param {string} filePath
- * @returns {Promise<boolean>}
- */
-async function tryDeleteFileAsync(filePath) {
-  if (fileExists(filePath)) {
-    await fs.promises.unlink(filePath);
+  if (normalFuncs_fileExists(filePath)) {
+    unlinkSync(filePath);
     return true;
   }
   return false;
@@ -3868,25 +3825,12 @@ async function tryDeleteFileAsync(filePath) {
  * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
  * @param {string} filePath
  * @param {string} content
- * @param {fs.WriteFileOptions} [ops='utf-8']
+ * @param {import('fs').WriteFileOptions} [ops='utf-8']
  */
 function writeTextFile(filePath, content, ops = 'utf-8') {
-  const dir = path.dirname(filePath);
-  ensureDirectory(dir);
-  fs.writeFileSync(filePath, content, ops);
-}
-
-/**
- * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
- * @param {string} filePath
- * @param {string} content
- * @param {fs.WriteFileOptions} [ops='utf-8']
- * @returns {Promise<void>}
- */
-function writeTextFileAsync(filePath, content, ops = 'utf-8') {
-  const dir = path.dirname(filePath);
-  ensureDirectory(dir);
-  return fs.promises.writeFile(filePath, content, ops);
+  const dir = dirname(filePath);
+  normalFuncs_ensureDirectory(dir);
+  writeFileSync(filePath, content, ops);
 }
 
 /*========================*
@@ -3902,13 +3846,13 @@ function writeTextFileAsync(filePath, content, ops = 'utf-8') {
 function listFiles(dirPath, recursive = false) {
   /** @type {{ files: string[]; dirs: string[] }} */
   const results = { files: [], dirs: [] };
-  if (!dirExists(dirPath)) return results;
+  if (!normalFuncs_dirExists(dirPath)) return results;
 
-  const entries = fs.readdirSync(dirPath);
+  const entries = readdirSync(dirPath);
   for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry);
-    const stat = fs.lstatSync(fullPath);
-    if (stat.isDirectory()) {
+    const fullPath = join(dirPath, entry);
+    const statData = lstatSync(fullPath);
+    if (statData.isDirectory()) {
       results.dirs.push(fullPath);
       if (recursive) {
         const results2 = listFiles(fullPath, true);
@@ -3931,13 +3875,13 @@ function listFiles(dirPath, recursive = false) {
 function listDirs(dirPath, recursive = false) {
   /** @type {string[]} */
   const results = [];
-  if (!dirExists(dirPath)) return results;
+  if (!normalFuncs_dirExists(dirPath)) return results;
 
-  const entries = fs.readdirSync(dirPath);
+  const entries = readdirSync(dirPath);
   for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry);
-    const stat = fs.lstatSync(fullPath);
-    if (stat.isDirectory()) {
+    const fullPath = join(dirPath, entry);
+    const statData = lstatSync(fullPath);
+    if (statData.isDirectory()) {
       results.push(fullPath);
       if (recursive) {
         results.push(...listDirs(fullPath, true));
@@ -3957,8 +3901,8 @@ function listDirs(dirPath, recursive = false) {
  * @returns {number}
  */
 function fileSize(filePath) {
-  if (!fileExists(filePath)) return 0;
-  const stats = fs.statSync(filePath);
+  if (!normalFuncs_fileExists(filePath)) return 0;
+  const stats = statSync(filePath);
   return stats.size;
 }
 
@@ -3986,7 +3930,7 @@ function dirSize(dirPath) {
  * @param {string} [ext='bak']
  */
 function backupFile(filePath, ext = 'bak') {
-  if (!fileExists(filePath)) return;
+  if (!normalFuncs_fileExists(filePath)) return;
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
   const backupPath = `${filePath}.${ext}.${timestamp}`;
   ensureCopyFile(filePath, backupPath);
@@ -3998,18 +3942,17 @@ function backupFile(filePath, ext = 'bak') {
  * @param {string} [ext='bak']
  * @returns {string} Full path to the most recent backup
  */
-function getLatestBackupPath(filePath, ext = 'bak') {
-  const dir = path.dirname(filePath);
-  const baseName = path.basename(filePath);
-  const backups = fs
-    .readdirSync(dir)
+function normalFuncs_getLatestBackupPath(filePath, ext = 'bak') {
+  const dir = dirname(filePath);
+  const baseName = basename(filePath);
+  const backups = readdirSync(dir)
     .filter((name) => name.startsWith(`${baseName}.${ext}.`))
     .sort()
     .reverse();
 
   if (backups.length === 0) throw new Error(`No backups found for ${filePath}`);
 
-  return path.join(dir, backups[0]);
+  return join(dir, backups[0]);
 }
 
 /**
@@ -4018,34 +3961,10 @@ function getLatestBackupPath(filePath, ext = 'bak') {
  * @param {string} [ext='bak']
  */
 function restoreLatestBackup(filePath, ext = 'bak') {
-  const latestBackup = getLatestBackupPath(filePath, ext);
+  const latestBackup = normalFuncs_getLatestBackupPath(filePath, ext);
   ensureCopyFile(latestBackup, filePath);
 }
 
-/**
- * Restores the most recent backup of a file.
- * @param {string} filePath
- * @param {string} [ext='bak']
- * @returns {Promise<void>}
- */
-function restoreLatestBackupAsync(filePath, ext = 'bak') {
-  const latestBackup = getLatestBackupPath(filePath, ext);
-  return ensureCopyFileAsync(latestBackup, filePath);
-}
-
-/**
- * Creates a backup copy of a file with .bak timestamp suffix.
- * @param {string} filePath
- * @param {string} [ext='bak']
- * @returns {Promise<void>}
- */
-async function backupFileAsync(filePath, ext = 'bak') {
-  if (!fileExists(filePath)) return;
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const backupPath = `${filePath}.${ext}.${timestamp}`;
-  return ensureCopyFileAsync(filePath, backupPath);
-}
-
 /*========================*
  * Rename Utilities
  *========================*/
@@ -4064,7 +3983,7 @@ function renameFileBatch(dirPath, renameFn, extensions = []) {
   if (typeof dirPath !== 'string') throw new TypeError('dirPath must be a string');
   if (typeof renameFn !== 'function') throw new TypeError('renameFn must be a function');
   if (!Array.isArray(extensions)) throw new TypeError('extensions must be an array of strings');
-  if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory())
+  if (!existsSync(dirPath) || !statSync(dirPath).isDirectory())
     throw new Error(`Directory not found or invalid: ${dirPath}`);
   for (const ext of extensions) {
     if (typeof ext !== 'string' || !ext.startsWith('.'))
@@ -4075,16 +3994,16 @@ function renameFileBatch(dirPath, renameFn, extensions = []) {
   let index = 0;
 
   for (const file of files) {
-    const ext = path.extname(file);
+    const ext = extname(file);
     if (extensions.length && !extensions.includes(ext)) continue;
 
-    const originalName = path.basename(file);
+    const originalName = basename(file);
     const newName = renameFn(originalName, index++);
-    const newPath = path.join(dirPath, newName);
+    const newPath = join(dirPath, newName);
 
     if (originalName === newName) continue;
 
-    fs.renameSync(file, newPath);
+    renameSync(file, newPath);
   }
 }
 
@@ -4099,8 +4018,8 @@ function renameFileRegex(dirPath, pattern, replacement, extensions = []) {
   renameFileBatch(
     dirPath,
     (filename) => {
-      const ext = path.extname(filename);
-      const name = path.basename(filename, ext).replace(pattern, replacement);
+      const ext = extname(filename);
+      const name = basename(filename, ext).replace(pattern, replacement);
       return `${name}${ext}`;
     },
     extensions,
@@ -4117,8 +4036,8 @@ function renameFileAddPrefixSuffix(dirPath, { prefix = '', suffix = '' }, extens
   renameFileBatch(
     dirPath,
     (filename) => {
-      const ext = path.extname(filename);
-      const name = path.basename(filename, ext);
+      const ext = extname(filename);
+      const name = basename(filename, ext);
       return `${prefix}${name}${suffix}${ext}`;
     },
     extensions,
@@ -4155,9 +4074,9 @@ function renameFileNormalizeCase(
         else return text;
       };
 
-      const rawExt = path.extname(filename);
+      const rawExt = extname(filename);
       const ext = normalizeExt ? changeToMode(rawExt) : rawExt;
-      const name = changeToMode(path.basename(filename, rawExt));
+      const name = changeToMode(basename(filename, rawExt));
       return `${name}${ext}`;
     },
     extensions,
@@ -4180,6 +4099,266 @@ function renameFilePadNumbers(dirPath, totalDigits = 3, extensions = []) {
   );
 }
 
+// EXTERNAL MODULE: fs/promises (ignored)
+var promises_ignored_ = __webpack_require__(370);
+;// ./src/v1/fileManager/asyncFuncs.mjs
+
+
+
+
+
+/*========================*
+ * JSON Operations
+ *========================*/
+
+/**
+ * Reads and parses a JSON file.
+ * Throws an error if the file content is not valid JSON.
+ * @param {string} filePath
+ * @returns {Promise<any>}
+ */
+async function readJsonFileAsync(filePath) {
+  if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+  const content = await readFile(filePath, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Saves an object as JSON to a file.
+ * Automatically creates the directory if it does not exist.
+ * @param {string} filePath
+ * @param {any} data
+ * @param {number} [spaces=2]
+ * @returns {Promise<void>}
+ */
+function writeJsonFileAsync(filePath, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  return writeFile(filePath, json, 'utf-8');
+}
+
+/*========================*
+ * Directory Management
+ *========================*/
+
+/**
+ * Clears all contents inside a directory but keeps the directory.
+ * @param {string} dirPath
+ */
+async function clearDirectoryAsync(dirPath) {
+  if (!existsSync(dirPath)) return;
+  const files = await readdir(dirPath);
+
+  /** @type {Record<string, import('fs').Stats>} */
+  const dataList = {};
+  const promises = [];
+
+  for (const file of files) {
+    const fullPath = join(dirPath, file);
+    const lsResult = lstat(fullPath);
+
+    lsResult.then((statData) => {
+      dataList[fullPath] = statData;
+      return statData;
+    });
+    promises.push(lsResult);
+  }
+
+  await Promise.all(promises);
+  const promises2 = [];
+  for (const fullPath in dataList) {
+    const statData = dataList[fullPath];
+    if (statData.isDirectory()) {
+      promises2.push(rm(fullPath, { recursive: true, force: true }));
+    } else {
+      promises2.push(unlink(fullPath));
+    }
+  }
+
+  await Promise.all(promises2);
+}
+
+/*========================*
+ * File Checks
+ *========================*/
+
+/**
+ * Checks whether a directory is empty.
+ * @param {string} dirPath
+ * @returns {Promise<boolean>}
+ */
+async function isDirEmptyAsync(dirPath) {
+  const data = await readdir(dirPath);
+  return data.length === 0;
+}
+
+/*========================*
+ * File Operations
+ *========================*/
+
+/**
+ * Copies a file to a destination.
+ * @param {string} src
+ * @param {string} dest
+ * @param {number} [mode]
+ * @returns {Promise<void>}
+ */
+function ensureCopyFileAsync(src, dest, mode) {
+  ensureDirectory(dirname(dest));
+  return copyFile(src, dest, mode);
+}
+
+/**
+ * Deletes a file (If the file exists).
+ * @param {string} filePath
+ * @returns {Promise<boolean>}
+ */
+async function tryDeleteFileAsync(filePath) {
+  if (fileExists(filePath)) {
+    await unlink(filePath);
+    return true;
+  }
+  return false;
+}
+
+/*========================*
+ * Text Operations
+ *========================*/
+
+/**
+ * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
+ * @param {string} filePath
+ * @param {string} content
+ * @param {import('fs').WriteFileOptions} [ops='utf-8']
+ * @returns {Promise<void>}
+ */
+function writeTextFileAsync(filePath, content, ops = 'utf-8') {
+  const dir = dirname(filePath);
+  ensureDirectory(dir);
+  return writeFile(filePath, content, ops);
+}
+
+/*========================*
+ * Directory Listings
+ *========================*/
+
+/**
+ * Lists all files and dirs in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {Promise<{ files: string[]; dirs: string[] }>}
+ */
+async function listFilesAsync(dirPath, recursive = false) {
+  /** @type {{ files: string[]; dirs: string[] }} */
+  const results = { files: [], dirs: [] };
+  if (!dirExists(dirPath)) return results;
+
+  const entries = await readdir(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const statData = await lstat(fullPath);
+    if (statData.isDirectory()) {
+      results.dirs.push(fullPath);
+      if (recursive) {
+        const results2 = await listFilesAsync(fullPath, true);
+        results.files.push(...results2.files);
+        results.dirs.push(...results2.dirs);
+      }
+    } else {
+      results.files.push(fullPath);
+    }
+  }
+  return results;
+}
+
+/**
+ * Lists all directories in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {Promise<string[]>}
+ */
+async function listDirsAsync(dirPath, recursive = false) {
+  /** @type {string[]} */
+  const results = [];
+  if (!dirExists(dirPath)) return results;
+
+  const entries = await readdir(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const statData = await lstat(fullPath);
+    if (statData.isDirectory()) {
+      results.push(fullPath);
+      if (recursive) {
+        results.push(...(await listDirsAsync(fullPath, true)));
+      }
+    }
+  }
+  return results;
+}
+
+/*========================*
+ * File Info
+ *========================*/
+
+/**
+ * Returns the size of a file in bytes.
+ * @param {string} filePath
+ * @returns {Promise<number>}
+ */
+async function fileSizeAsync(filePath) {
+  if (!fileExists(filePath)) return 0;
+  const stats = await stat(filePath);
+  return stats.size;
+}
+
+/**
+ * Returns the total size of a directory in bytes.
+ * @param {string} dirPath
+ * @returns {Promise<number>}
+ */
+async function dirSizeAsync(dirPath) {
+  let total = 0;
+  const { files } = await listFilesAsync(dirPath, true);
+  const promises = [];
+  for (const file of files) {
+    const result = fileSizeAsync(file);
+    result.then((item) => {
+      total += item;
+      return item;
+    });
+    promises.push(result);
+  }
+  await Promise.all(promises);
+  return total;
+}
+
+/*========================*
+ * Backup Utilities
+ *========================*/
+
+/**
+ * Restores the most recent backup of a file.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+function restoreLatestBackupAsync(filePath, ext = 'bak') {
+  const latestBackup = getLatestBackupPath(filePath, ext);
+  return ensureCopyFileAsync(latestBackup, filePath);
+}
+
+/**
+ * Creates a backup copy of a file with .bak timestamp suffix.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+async function backupFileAsync(filePath, ext = 'bak') {
+  if (!fileExists(filePath)) return;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.${ext}.${timestamp}`;
+  return ensureCopyFileAsync(filePath, backupPath);
+}
+
 ;// ./src/v1/libs/TinyDragger.mjs
 
 
@@ -4204,6 +4383,7 @@ class TinyDragger {
   #offsetY = 0;
   #offsetX = 0;
 
+  #multiCollision = false;
   #lockInsideJail = false;
   #revertOnDrop = false;
   #dragging = false;
@@ -4248,6 +4428,7 @@ class TinyDragger {
    * @param {string} [options.classDragCollision='dragging-collision'] - CSS class applied to collision element.
    * @param {boolean} [options.lockInsideJail=false] - Restrict movement within the jail container.
    * @param {boolean} [options.dropInJailOnly=false] - Restrict drop within the jail container.
+   * @param {boolean} [options.multiCollision=false] - Enables returning multiple collided elements.
    * @param {VibrationPatterns|false} [options.vibration=false] - Vibration feedback configuration.
    * @param {boolean} [options.revertOnDrop=false] - Whether to return to original position on drop.
    * @param {string} [options.classHidden='drag-hidden'] - CSS class to hide original element during dragging.
@@ -4294,6 +4475,7 @@ class TinyDragger {
     validateBoolean(options.lockInsideJail, 'lockInsideJail');
     validateBoolean(options.dropInJailOnly, 'dropInJailOnly');
     validateBoolean(options.revertOnDrop, 'revertOnDrop');
+    validateBoolean(options.multiCollision, 'multiCollision');
 
     validateString(options.classDragging, 'classDragging');
     validateString(options.classBodyDragging, 'classBodyDragging');
@@ -4327,6 +4509,7 @@ class TinyDragger {
     if (typeof options.revertOnDrop === 'boolean') this.#revertOnDrop = options.revertOnDrop;
     if (typeof options.lockInsideJail === 'boolean') this.#lockInsideJail = options.lockInsideJail;
     if (typeof options.dropInJailOnly === 'boolean') this.#dropInJailOnly = options.dropInJailOnly;
+    if (typeof options.multiCollision === 'boolean') this.#multiCollision = options.multiCollision;
 
     /** @private */
     this._onMouseDown = this.#startDrag.bind(this);
@@ -4518,22 +4701,67 @@ class TinyDragger {
     this.#dispatchEvent('drag');
   }
 
+  /** @type {HTMLElement[]} */
+  #collisionsMarked = [];
+
+  /**
+   * Marks an element as currently collided by adding the collision CSS class.
+   * The element is stored in an internal list for easy removal later.
+   *
+   * @param {HTMLElement|null} el - The element to mark as collided.
+   */
+  #addCollision(el) {
+    if (!el) return;
+    el.classList.add(this.#classDragCollision);
+    this.#collisionsMarked.push(el);
+  }
+
+  /**
+   * Removes the collision CSS class from all previously marked elements.
+   * Also clears the last single collision element, if set.
+   *
+   */
+  #removeCollision() {
+    while (this.#collisionsMarked.length > 0) {
+      const el = this.#collisionsMarked.shift();
+      if (el) el.classList.remove(this.#classDragCollision);
+    }
+    if (!this.#lastCollision) return;
+    this.#lastCollision.classList.remove(this.#classDragCollision);
+  }
+
   /**
    * Handles dragging collision.
    * @param {MouseEvent|Touch} event - The drag event.
    */
   checkDragCollision(event) {
-    const { collidedElement: collided } = this.execCollision(event);
-    if (collided && collided !== this.#lastCollision) {
-      if (navigator.vibrate && Array.isArray(this.#vibration.collide)) {
-        navigator.vibrate(this.#vibration.collide);
+    const { collidedElements } = this.execCollision(event);
+    const first = collidedElements[0] || null;
+
+    // Removes old marking if necessary
+    if (this.#lastCollision && !collidedElements.includes(this.#lastCollision)) {
+      this.#removeCollision();
+    }
+
+    // Adds Marking for All Colluded
+    collidedElements.forEach((el) => this.#addCollision(el));
+
+    // Removes markings from who no longer collided
+    this.#collidables.forEach((el) => {
+      if (!collidedElements.includes(el)) {
+        el.classList.remove(this.#classDragCollision);
       }
-      this.#lastCollision = collided;
-      if (this.#lastCollision) this.#lastCollision.classList.add(this.#classDragCollision);
-    } else if (!collided) {
-      if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
-      this.#lastCollision = null;
+    });
+
+    if (
+      navigator.vibrate &&
+      Array.isArray(this.#vibration.collide) &&
+      collidedElements.length > 0
+    ) {
+      navigator.vibrate(this.#vibration.collide);
     }
+
+    this.#lastCollision = first;
   }
 
   /**
@@ -4580,37 +4808,48 @@ class TinyDragger {
   /**
    * Handles the collision of a drag.
    * @param {MouseEvent|Touch} event - The release event.
-   * @returns {{ inJail: boolean; collidedElement: HTMLElement|null }}
+   * @returns {{ inJail: boolean; collidedElements: (HTMLElement | null)[] }}
    */
   execCollision(event) {
-    if (this.#destroyed || !this.#dragProxy) return { inJail: false, collidedElement: null };
+    if (this.#destroyed || !this.#dragProxy) return { inJail: false, collidedElements: [] };
 
-    let collidedElement;
+    let collidedElements = [];
     let inJail = true;
     const jailRect = this.#jail?.getBoundingClientRect();
+
     if (this.#collisionByMouse) {
       const x = event.clientX;
       const y = event.clientY;
+
       if (this.#dropInJailOnly && this.#jail && jailRect) {
         inJail =
           x >= jailRect.left && x <= jailRect.right && y >= jailRect.top && y <= jailRect.bottom;
       }
 
-      collidedElement = inJail ? this.getCollidedElement(x, y) : null;
+      collidedElements = inJail
+        ? this.#multiCollision
+          ? this.getAllCollidedElements(x, y)
+          : [this.getCollidedElement(x, y)].filter(Boolean)
+        : [];
     } else {
-      const targetRect = this.#dragProxy.getBoundingClientRect();
+      const rect = this.#dragProxy.getBoundingClientRect();
+
       if (this.#dropInJailOnly && this.#jail && jailRect) {
         inJail =
-          targetRect.left >= jailRect.left &&
-          targetRect.right <= jailRect.right &&
-          targetRect.top >= jailRect.top &&
-          targetRect.bottom <= jailRect.bottom;
+          rect.left >= jailRect.left &&
+          rect.right <= jailRect.right &&
+          rect.top >= jailRect.top &&
+          rect.bottom <= jailRect.bottom;
       }
 
-      collidedElement = inJail ? this.getCollidedElementByRect(targetRect) : null;
+      collidedElements = inJail
+        ? this.#multiCollision
+          ? this.getAllCollidedElementsByRect(rect)
+          : [this.getCollidedElementByRect(rect)].filter(Boolean)
+        : [];
     }
 
-    return { inJail, collidedElement };
+    return { inJail, collidedElements };
   }
 
   /**
@@ -4633,7 +4872,7 @@ class TinyDragger {
 
     document.removeEventListener('touchmove', this._onTouchMove);
     document.removeEventListener('touchend', this._onTouchEnd);
-    const { collidedElement } = this.execCollision(event);
+    const { collidedElements } = this.execCollision(event);
 
     if (navigator.vibrate && Array.isArray(this.#vibration.end)) {
       navigator.vibrate(this.#vibration.end);
@@ -4646,7 +4885,7 @@ class TinyDragger {
       this.#dragProxy = null;
     }
 
-    if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
+    if (this.#lastCollision) this.#removeCollision();
     this.#lastCollision = null;
 
     this.#target.classList.remove(this.#dragHiddenClass);
@@ -4657,13 +4896,50 @@ class TinyDragger {
 
     const dropEvent = new CustomEvent('drop', {
       detail: {
-        target: collidedElement,
+        targets: collidedElements,
+        first: collidedElements[0] || null,
       },
     });
-
     this.#target.dispatchEvent(dropEvent);
   }
 
+  /**
+   * Checks if the provided element intersects with the given bounding rectangle.
+   *
+   * @param {HTMLElement} el - The element to test for collision.
+   * @param {DOMRect} rect - The bounding rectangle to check against.
+   * @returns {boolean} True if the element intersects with the rectangle.
+   */
+  #getCollidedElementByRect(el, rect) {
+    const elRect = el.getBoundingClientRect();
+    return !(
+      rect.right < elRect.left ||
+      rect.left > elRect.right ||
+      rect.bottom < elRect.top ||
+      rect.top > elRect.bottom
+    );
+  }
+
+  /**
+   * Returns all elements currently colliding with the given rectangle.
+   *
+   * @param {DOMRect} rect - Bounding rectangle of the dragged proxy.
+   * @returns {HTMLElement[]} A list of all collided elements.
+   * @throws {Error} If the input is not a valid DOMRect with numeric bounds.
+   */
+  getAllCollidedElementsByRect(rect) {
+    this.#checkDestroy();
+    if (
+      !(rect instanceof DOMRect) ||
+      typeof rect.left !== 'number' ||
+      typeof rect.right !== 'number' ||
+      typeof rect.top !== 'number' ||
+      typeof rect.bottom !== 'number'
+    )
+      throw new Error('getCollidedElementByRect expects a valid DOMRect object.');
+    return this.#collidables.filter((el) => this.#getCollidedElementByRect(el, rect));
+  }
+
   /**
    * Detects collision based on rectangle intersection.
    * @param {DOMRect} rect - Bounding rectangle of the dragged proxy.
@@ -4680,18 +4956,32 @@ class TinyDragger {
       typeof rect.bottom !== 'number'
     )
       throw new Error('getCollidedElementByRect expects a valid DOMRect object.');
+    return this.#collidables.find((el) => this.#getCollidedElementByRect(el, rect)) || null;
+  }
 
-    return (
-      this.#collidables.find((el) => {
-        const elRect = el.getBoundingClientRect();
-        return !(
-          rect.right < elRect.left ||
-          rect.left > elRect.right ||
-          rect.bottom < elRect.top ||
-          rect.top > elRect.bottom
-        );
-      }) || null
-    );
+  /**
+   * Checks whether a given (x, y) coordinate is inside the bounding rectangle of an element.
+   *
+   * @param {HTMLElement} el - The element to test for collision.
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {boolean} True if the point is within the element's bounds.
+   */
+  #getCollidedElement(el, x, y) {
+    const rect = el.getBoundingClientRect();
+    return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+  }
+
+  /**
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {HTMLElement[]} The collided element or null.
+   */
+  getAllCollidedElements(x, y) {
+    this.#checkDestroy();
+    if (typeof x !== 'number' || typeof y !== 'number')
+      throw new Error('getCollidedElement expects numeric x and y coordinates.');
+    return this.#collidables.filter((el) => this.#getCollidedElement(el, x, y));
   }
 
   /**
@@ -4704,13 +4994,7 @@ class TinyDragger {
     this.#checkDestroy();
     if (typeof x !== 'number' || typeof y !== 'number')
       throw new Error('getCollidedElement expects numeric x and y coordinates.');
-
-    return (
-      this.#collidables.find((el) => {
-        const rect = el.getBoundingClientRect();
-        return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
-      }) || null
-    );
+    return this.#collidables.find((el) => this.#getCollidedElement(el, x, y)) || null;
   }
 
   /**
@@ -4960,7 +5244,7 @@ class TinyDragger {
     document.removeEventListener('touchmove', this._onTouchMove);
     document.removeEventListener('touchend', this._onTouchEnd);
 
-    if (this.#lastCollision) this.#lastCollision.classList.remove(this.#classDragCollision);
+    if (this.#lastCollision) this.#removeCollision();
     if (this.#dragProxy) {
       this.#dragProxy.remove();
       this.#dragProxy = null;
@@ -4998,6 +5282,10 @@ class TinyDragger {
 
 
 
+
+
+
+