@k37z3r/jbase 2.0.0

package/dist/index.mjs

@@ -0,0 +1,2118 @@
+/**
+ * @k37z3r/jbase - A modern micro-framework for the web: jBase offers the familiar syntax of classic DOM libraries, but without their baggage. Fully typed, modular, and optimized for modern browser engines.
+ * @version 2.0.0
+ * @homepage https://github.com/k37z3r/jBase-2.0
+ * @author Sven Minio (https://github.com/k37z3r/jBase-2.0)
+ * @license GPL-3.0-or-later
+ * @copyright 2026 Sven Minio (https://github.com/k37z3r/jBase-2.0)
+ */
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core.ts
+var jBase = class extends Array {
+  selectorSource = "";
+  /**
+   * * 🇬🇧: Initializes a new jBase instance. Analyzes the provided selector and populates the internal array with found or created DOM elements.
+   * * 🇩🇪: Initialisiert eine neue jBase-Instanz. Analysiert den übergebenen Selektor und füllt das interne Array mit den gefundenen oder erstellten DOM-Elementen.
+   * @param selector
+   * * 🇬🇧: The input selector (CSS selector, HTML string, DOM element, or collection).
+   * * 🇩🇪: Der Eingabe-Selektor (CSS-Selektor, HTML-String, DOM-Element oder Sammlung).
+   */
+  constructor(selector) {
+    super();
+    if (typeof document === "undefined") {
+      return;
+    }
+    this.selectorSource = typeof selector === "string" ? selector : "<DOM Object/Array>";
+    if (!selector)
+      return;
+    if (selector instanceof HTMLElement || selector === document || selector === window || selector instanceof Element) {
+      this.push(selector);
+    } else if (typeof selector === "string") {
+      const trimmed = selector.trim();
+      if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
+        const tempDiv = document.createElement("div");
+        tempDiv.innerHTML = trimmed;
+        this.push(...Array.from(tempDiv.children));
+      } else if (trimmed.startsWith("#") && !trimmed.includes(" ") && !trimmed.includes(".")) {
+        const el = document.getElementById(trimmed.slice(1));
+        if (el)
+          this.push(el);
+      } else {
+        this.push(...Array.from(document.querySelectorAll(selector)));
+      }
+    } else if (selector instanceof NodeList || Array.isArray(selector)) {
+      this.push(...Array.from(selector));
+    }
+  }
+  /**
+   * * 🇬🇧: Custom serializer for JSON.stringify. Prevents circular references and huge outputs by returning a simplified preview.
+   * * 🇩🇪: Benutzerdefinierte Serialisierung für JSON.stringify. Verhindert Zirkelbezüge und riesige Ausgaben durch Rückgabe einer vereinfachten Vorschau.
+   * @returns
+   * * 🇬🇧: A simplified object representation for debugging.
+   * * 🇩🇪: Eine vereinfachte Objektrepräsentation für das Debugging.
+   */
+  toJSON() {
+    return {
+      meta: "jBase Wrapper",
+      query: this.selectorSource,
+      count: this.length,
+      preview: this.slice(0, 10).map((el) => {
+        if (el instanceof Element)
+          return el.tagName.toLowerCase();
+        return typeof el;
+      })
+    };
+  }
+};
+
+// src/modules/css/classes.ts
+var classes_exports = {};
+__export(classes_exports, {
+  addClass: () => addClass,
+  hasClass: () => hasClass,
+  removeClass: () => removeClass,
+  toggleClass: () => toggleClass
+});
+function addClass(...classNames) {
+  this.forEach((el) => {
+    if (el instanceof Element) el.classList.add(...classNames);
+  });
+  return this;
+}
+function removeClass(...classNames) {
+  this.forEach((el) => {
+    if (el instanceof Element) el.classList.remove(...classNames);
+  });
+  return this;
+}
+function toggleClass(className) {
+  this.forEach((el) => {
+    if (el instanceof Element) el.classList.toggle(className);
+  });
+  return this;
+}
+function hasClass(className) {
+  return this.some((el) => {
+    return el instanceof Element && el.classList.contains(className);
+  });
+}
+
+// src/modules/css/styles.ts
+var styles_exports = {};
+__export(styles_exports, {
+  css: () => css
+});
+function css(property, value) {
+  if (value === void 0) {
+    const el = this[0];
+    if (el instanceof HTMLElement || el instanceof SVGElement) {
+      return window.getComputedStyle(el)[property];
+    }
+    return "";
+  }
+  this.forEach((el) => {
+    if (el instanceof HTMLElement || el instanceof SVGElement) {
+      el.style[property] = value;
+    }
+  });
+  return this;
+}
+
+// src/modules/css/index.ts
+var cssMethods = {
+  ...classes_exports,
+  ...styles_exports
+};
+
+// src/modules/events/binding.ts
+var binding_exports = {};
+__export(binding_exports, {
+  off: () => off,
+  on: () => on
+});
+function on(event, handler) {
+  this.forEach((el) => {
+    el.addEventListener(event, handler);
+  });
+  return this;
+}
+function off(event, handler) {
+  this.forEach((el) => {
+    el.removeEventListener(event, handler);
+  });
+  return this;
+}
+
+// src/modules/events/mouse.ts
+var mouse_exports = {};
+__export(mouse_exports, {
+  click: () => click,
+  dblclick: () => dblclick,
+  mousedown: () => mousedown,
+  mouseenter: () => mouseenter,
+  mouseleave: () => mouseleave,
+  mousemove: () => mousemove,
+  mouseout: () => mouseout,
+  mouseover: () => mouseover,
+  mouseup: () => mouseup
+});
+function click(handler) {
+  if (handler) {
+    return this.on("click", handler);
+  } else {
+    this.forEach((el) => {
+      if (el instanceof HTMLElement) el.click();
+    });
+    return this;
+  }
+}
+function mousemove(handler) {
+  return this.on("mousemove", handler);
+}
+function mouseleave(handler) {
+  return this.on("mouseleave", handler);
+}
+function mouseenter(handler) {
+  return this.on("mouseenter", handler);
+}
+function mousedown(handler) {
+  return this.on("mousedown", handler);
+}
+function mouseup(handler) {
+  return this.on("mouseup", handler);
+}
+function dblclick(handler) {
+  if (handler) {
+    return this.on("dblclick", handler);
+  } else {
+    this.forEach((el) => {
+      if (el instanceof HTMLElement) {
+        el.dispatchEvent(new MouseEvent("dblclick", {
+          bubbles: true,
+          cancelable: true,
+          view: window
+        }));
+      }
+    });
+    return this;
+  }
+}
+function mouseout(handler) {
+  return this.on("mouseout", handler);
+}
+function mouseover(handler) {
+  return this.on("mouseover", handler);
+}
+
+// src/modules/events/lifecycle.ts
+var lifecycle_exports = {};
+__export(lifecycle_exports, {
+  ready: () => ready
+});
+function ready(handler) {
+  if (document.readyState === "complete" || document.readyState === "interactive") {
+    handler();
+  } else {
+    this.on("DOMContentLoaded", handler);
+  }
+  return this;
+}
+
+// src/modules/events/keyboard.ts
+var keyboard_exports = {};
+__export(keyboard_exports, {
+  keydown: () => keydown,
+  keypress: () => keypress,
+  keyup: () => keyup,
+  pressedKey: () => pressedKey
+});
+function keydown(handler) {
+  return this.on("keydown", handler);
+}
+function keyup(handler) {
+  return this.on("keyup", handler);
+}
+function keypress(handler) {
+  return this.on("keypress", handler);
+}
+function pressedKey(targetKey, handler) {
+  return this.on("keydown", (e) => {
+    const event = e;
+    if (event.key.toLowerCase() === targetKey.toLowerCase()) {
+      handler(event);
+    }
+  });
+}
+
+// src/modules/events/form.ts
+var form_exports = {};
+__export(form_exports, {
+  blur: () => blur,
+  change: () => change,
+  focus: () => focus,
+  input: () => input,
+  submit: () => submit
+});
+function submit(handler) {
+  return this.on("submit", handler);
+}
+function change(handler) {
+  return this.on("change", handler);
+}
+function input(handler) {
+  return this.on("input", handler);
+}
+function focus(handler) {
+  if (handler) {
+    return this.on("focus", handler);
+  } else {
+    this.forEach((el) => {
+      if (el instanceof HTMLElement) el.focus();
+    });
+    return this;
+  }
+}
+function blur(handler) {
+  if (handler) {
+    return this.on("blur", handler);
+  } else {
+    this.forEach((el) => {
+      if (el instanceof HTMLElement) el.blur();
+    });
+    return this;
+  }
+}
+
+// src/modules/events/touch.ts
+var touch_exports = {};
+__export(touch_exports, {
+  touchcancel: () => touchcancel,
+  touchend: () => touchend,
+  touchmove: () => touchmove,
+  touchstart: () => touchstart
+});
+function touchstart(handler) {
+  return this.on("touchstart", handler);
+}
+function touchend(handler) {
+  return this.on("touchend", handler);
+}
+function touchmove(handler) {
+  return this.on("touchmove", handler);
+}
+function touchcancel(handler) {
+  return this.on("touchcancel", handler);
+}
+
+// src/modules/events/index.ts
+var eventMethods = {
+  ...binding_exports,
+  ...mouse_exports,
+  ...lifecycle_exports,
+  ...keyboard_exports,
+  ...form_exports,
+  ...touch_exports
+};
+
+// src/modules/dom/attributes.ts
+var attributes_exports = {};
+__export(attributes_exports, {
+  attr: () => attr,
+  val: () => val
+});
+function attr(name, value) {
+  if (value === void 0) {
+    const el = this[0];
+    return el instanceof Element ? el.getAttribute(name) : null;
+  }
+  this.forEach((el) => {
+    if (el instanceof Element) el.setAttribute(name, value);
+  });
+  return this;
+}
+function val(value) {
+  if (value === void 0) {
+    const el = this[0];
+    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+      return el.value;
+    }
+    return "";
+  }
+  this.forEach((el) => {
+    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+      el.value = value;
+    }
+  });
+  return this;
+}
+
+// src/modules/dom/content.ts
+var content_exports = {};
+__export(content_exports, {
+  html: () => html,
+  text: () => text
+});
+function html(content) {
+  if (content === void 0) {
+    const el = this[0];
+    return el instanceof Element ? el.innerHTML : "";
+  }
+  this.forEach((el) => {
+    if (el instanceof Element) el.innerHTML = content;
+  });
+  return this;
+}
+function text(content) {
+  if (content === void 0) {
+    const el = this[0];
+    return el instanceof Node ? el.textContent || "" : "";
+  }
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      el.textContent = content;
+    }
+  });
+  return this;
+}
+
+// src/modules/dom/manipulation.ts
+var manipulation_exports = {};
+__export(manipulation_exports, {
+  after: () => after,
+  append: () => append,
+  appendTo: () => appendTo,
+  before: () => before,
+  empty: () => empty,
+  insertAfter: () => insertAfter,
+  insertBefore: () => insertBefore,
+  prepend: () => prepend,
+  prependTo: () => prependTo,
+  remove: () => remove,
+  replaceWith: () => replaceWith,
+  replaceWithClone: () => replaceWithClone,
+  unwrap: () => unwrap,
+  wrap: () => wrap
+});
+function parseHTML(html2) {
+  const tmp = document.createElement("div");
+  tmp.innerHTML = html2.trim();
+  return tmp.firstElementChild;
+}
+function normalizeToFragment(content) {
+  const fragment = document.createDocumentFragment();
+  const add2 = (item) => {
+    if (typeof item === "string") {
+      const temp = document.createElement("div");
+      temp.innerHTML = item.trim();
+      while (temp.firstChild) {
+        fragment.appendChild(temp.firstChild);
+      }
+    } else if (item instanceof Node) {
+      fragment.appendChild(item);
+    } else if (item instanceof jBase || Array.isArray(item) || item instanceof NodeList) {
+      Array.from(item).forEach((child) => add2(child));
+    }
+  };
+  add2(content);
+  return fragment;
+}
+function remove() {
+  this.forEach((el) => {
+    if (el instanceof Element) el.remove();
+  });
+  return this;
+}
+function empty() {
+  this.forEach((el) => {
+    if (el instanceof Element) el.innerHTML = "";
+  });
+  return this;
+}
+function replaceWithClone() {
+  const newElements = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      const clone = el.cloneNode(true);
+      el.replaceWith(clone);
+      newElements.push(clone);
+    }
+  });
+  return new this.constructor(newElements);
+}
+function append(content) {
+  const fragment = normalizeToFragment(content);
+  this.forEach((el, i) => {
+    if (el instanceof Element) {
+      const contentToInsert = i < this.length - 1 ? fragment.cloneNode(true) : fragment;
+      el.appendChild(contentToInsert);
+    }
+  });
+  return this;
+}
+function prepend(content) {
+  const fragment = normalizeToFragment(content);
+  this.forEach((el, i) => {
+    if (el instanceof Element) {
+      const contentToInsert = i < this.length - 1 ? fragment.cloneNode(true) : fragment;
+      el.prepend(contentToInsert);
+    }
+  });
+  return this;
+}
+function before(content) {
+  const fragment = normalizeToFragment(content);
+  this.forEach((el, i) => {
+    if (el instanceof Element) {
+      const contentToInsert = i < this.length - 1 ? fragment.cloneNode(true) : fragment;
+      el.before(contentToInsert);
+    }
+  });
+  return this;
+}
+function after(content) {
+  const fragment = normalizeToFragment(content);
+  this.forEach((el, i) => {
+    if (el instanceof Element) {
+      const contentToInsert = i < this.length - 1 ? fragment.cloneNode(true) : fragment;
+      el.after(contentToInsert);
+    }
+  });
+  return this;
+}
+function replaceWith(content) {
+  const fragment = normalizeToFragment(content);
+  this.forEach((el, i) => {
+    if (el instanceof Element) {
+      const contentToInsert = i < this.length - 1 ? fragment.cloneNode(true) : fragment;
+      el.replaceWith(contentToInsert);
+    }
+  });
+  return this;
+}
+function appendTo(target) {
+  const parent2 = typeof target === "string" ? document.querySelector(target) : target;
+  if (parent2 instanceof Element) {
+    const fragment = document.createDocumentFragment();
+    this.forEach((el) => {
+      if (el instanceof Node) fragment.appendChild(el);
+    });
+    parent2.appendChild(fragment);
+  }
+  return this;
+}
+function prependTo(target) {
+  const parent2 = typeof target === "string" ? document.querySelector(target) : target;
+  if (parent2 instanceof Element) {
+    const fragment = document.createDocumentFragment();
+    this.forEach((el) => {
+      if (el instanceof Node) fragment.appendChild(el);
+    });
+    parent2.prepend(fragment);
+  }
+  return this;
+}
+function insertBefore(target) {
+  const targetEl = typeof target === "string" ? document.querySelector(target) : target;
+  if (targetEl instanceof Element) {
+    const fragment = document.createDocumentFragment();
+    this.forEach((el) => {
+      if (el instanceof Node) fragment.appendChild(el);
+    });
+    targetEl.before(fragment);
+  }
+  return this;
+}
+function insertAfter(target) {
+  const targetEl = typeof target === "string" ? document.querySelector(target) : target;
+  if (targetEl instanceof Element) {
+    const fragment = document.createDocumentFragment();
+    this.forEach((el) => {
+      if (el instanceof Node) fragment.appendChild(el);
+    });
+    targetEl.after(fragment);
+  }
+  return this;
+}
+function wrap(wrapperHtml) {
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      const wrapper = parseHTML(wrapperHtml);
+      if (el.parentNode) {
+        el.parentNode.insertBefore(wrapper, el);
+      }
+      wrapper.appendChild(el);
+    }
+  });
+  return this;
+}
+function unwrap() {
+  this.forEach((el) => {
+    if (el instanceof Element && el.parentElement) {
+      const parent2 = el.parentElement;
+      const fragment = document.createDocumentFragment();
+      while (parent2.firstChild) {
+        fragment.appendChild(parent2.firstChild);
+      }
+      parent2.replaceWith(fragment);
+    }
+  });
+  return this;
+}
+
+// src/modules/dom/traversal.ts
+var traversal_exports = {};
+__export(traversal_exports, {
+  children: () => children,
+  closest: () => closest,
+  descendants: () => descendants,
+  descendantsUntil: () => descendantsUntil,
+  eq: () => eq,
+  filterBy: () => filterBy,
+  findAll: () => findAll,
+  first: () => first,
+  last: () => last,
+  next: () => next,
+  nextAll: () => nextAll,
+  nextSibling: () => nextSibling,
+  nextUntil: () => nextUntil,
+  not: () => not,
+  parent: () => parent,
+  parents: () => parents,
+  parentsUntil: () => parentsUntil,
+  prev: () => prev,
+  prevAll: () => prevAll,
+  prevSibling: () => prevSibling,
+  prevUntil: () => prevUntil,
+  sibling: () => sibling,
+  siblings: () => siblings
+});
+function closest(selector) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      const match = el.closest(selector);
+      if (match) {
+        found.push(match);
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function parent() {
+  const parents2 = [];
+  this.forEach((el) => {
+    if (el instanceof Element && el.parentElement) {
+      parents2.push(el.parentElement);
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(parents2)]);
+}
+function children(selector) {
+  let allChildren = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      const kids = Array.from(el.children);
+      allChildren = allChildren.concat(kids);
+    }
+  });
+  if (selector) {
+    allChildren = allChildren.filter((child) => child.matches(selector));
+  }
+  const Construction = this.constructor;
+  return new Construction(allChildren);
+}
+function findAll(selector) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element || el instanceof Document) {
+      const matches = el.querySelectorAll(selector);
+      matches.forEach((m) => found.push(m));
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function descendants() {
+  return this.findAll("*");
+}
+function parents(selector) {
+  const ancestors = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      let curr = el.parentElement;
+      while (curr) {
+        if (!selector || curr.matches(selector)) {
+          ancestors.push(curr);
+        }
+        curr = curr.parentElement;
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(ancestors)]);
+}
+function parentsUntil(selector, filter) {
+  const ancestors = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      let curr = el.parentElement;
+      while (curr && !curr.matches(selector)) {
+        if (!filter || curr.matches(filter)) {
+          ancestors.push(curr);
+        }
+        curr = curr.parentElement;
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(ancestors)]);
+}
+function descendantsUntil(untilSelector, filter) {
+  const found = [];
+  const traverse = (parent2) => {
+    const kids = parent2.children;
+    for (let i = 0; i < kids.length; i++) {
+      const child = kids[i];
+      if (child.matches(untilSelector)) {
+        continue;
+      }
+      if (!filter || child.matches(filter)) {
+        found.push(child);
+      }
+      traverse(child);
+    }
+  };
+  this.forEach((el) => {
+    if (el instanceof Element) traverse(el);
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function next(selector) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element && el.nextElementSibling) {
+      const nextEl = el.nextElementSibling;
+      if (!selector || nextEl.matches(selector)) {
+        found.push(nextEl);
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function prev(selector) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element && el.previousElementSibling) {
+      const prevEl = el.previousElementSibling;
+      if (!selector || prevEl.matches(selector)) {
+        found.push(prevEl);
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function nextSibling(selector) {
+  return this.next(selector);
+}
+function prevSibling(selector) {
+  return this.prev(selector);
+}
+function sibling(selector) {
+  return this.next(selector);
+}
+function nextAll(selector) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      let curr = el.nextElementSibling;
+      while (curr) {
+        if (!selector || curr.matches(selector)) {
+          found.push(curr);
+        }
+        curr = curr.nextElementSibling;
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function prevAll(selector) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      let curr = el.previousElementSibling;
+      while (curr) {
+        if (!selector || curr.matches(selector)) {
+          found.push(curr);
+        }
+        curr = curr.previousElementSibling;
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function siblings(selector) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element && el.parentElement) {
+      const children2 = Array.from(el.parentElement.children);
+      children2.forEach((child) => {
+        if (child !== el) {
+          if (!selector || child.matches(selector)) {
+            found.push(child);
+          }
+        }
+      });
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function nextUntil(untilSelector, filter) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      let curr = el.nextElementSibling;
+      while (curr && !curr.matches(untilSelector)) {
+        if (!filter || curr.matches(filter)) {
+          found.push(curr);
+        }
+        curr = curr.nextElementSibling;
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function prevUntil(untilSelector, filter) {
+  const found = [];
+  this.forEach((el) => {
+    if (el instanceof Element) {
+      let curr = el.previousElementSibling;
+      while (curr && !curr.matches(untilSelector)) {
+        if (!filter || curr.matches(filter)) {
+          found.push(curr);
+        }
+        curr = curr.previousElementSibling;
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction([...new Set(found)]);
+}
+function eq(index) {
+  const len = this.length;
+  const idx = index < 0 ? len + index : index;
+  const el = this[idx];
+  const Construction = this.constructor;
+  return new Construction(el ? [el] : []);
+}
+function first() {
+  return this.eq(0);
+}
+function last() {
+  return this.eq(-1);
+}
+function filterBy(selectorOrFn) {
+  const found = [];
+  this.forEach((el, index) => {
+    if (el instanceof Element) {
+      if (typeof selectorOrFn === "string") {
+        if (el.matches(selectorOrFn)) {
+          found.push(el);
+        }
+      } else if (typeof selectorOrFn === "function") {
+        if (selectorOrFn.call(el, index, el)) {
+          found.push(el);
+        }
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction(found);
+}
+function not(selectorOrFn) {
+  const found = [];
+  this.forEach((el, index) => {
+    if (el instanceof Element) {
+      if (typeof selectorOrFn === "string") {
+        if (!el.matches(selectorOrFn)) {
+          found.push(el);
+        }
+      } else if (typeof selectorOrFn === "function") {
+        if (!selectorOrFn.call(el, index, el)) {
+          found.push(el);
+        }
+      }
+    }
+  });
+  const Construction = this.constructor;
+  return new Construction(found);
+}
+
+// src/modules/dom/states.ts
+var states_exports = {};
+__export(states_exports, {
+  checked: () => checked,
+  disabled: () => disabled,
+  selected: () => selected
+});
+function checked(state) {
+  if (state === void 0) {
+    const el = this[0];
+    return el instanceof HTMLInputElement ? el.checked : false;
+  }
+  this.forEach((el) => {
+    if (el instanceof HTMLInputElement)
+      el.checked = state;
+  });
+  return this;
+}
+function selected(state) {
+  if (state === void 0) {
+    const el = this[0];
+    return el instanceof HTMLOptionElement ? el.selected : false;
+  }
+  this.forEach((el) => {
+    if (el instanceof HTMLOptionElement)
+      el.selected = state;
+  });
+  return this;
+}
+function disabled(state) {
+  if (state === void 0) {
+    const el = this[0];
+    return el instanceof HTMLElement && "disabled" in el ? el.disabled : false;
+  }
+  this.forEach((el) => {
+    if (el instanceof HTMLElement && "disabled" in el) {
+      el.disabled = state;
+      if (state)
+        el.classList.add("disabled");
+      else
+        el.classList.remove("disabled");
+    }
+  });
+  return this;
+}
+
+// src/modules/dom/index.ts
+var domMethods = {
+  ...attributes_exports,
+  ...content_exports,
+  ...manipulation_exports,
+  ...traversal_exports,
+  ...states_exports
+};
+
+// src/modules/effects/slide.ts
+var slide_exports = {};
+__export(slide_exports, {
+  slideIn: () => slideIn,
+  slideOut: () => slideOut,
+  slideToggle: () => slideToggle
+});
+function slideIn(options = {}) {
+  const { duration = 300 } = options;
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      el.style.willChange = "transform";
+      el.style.transition = `transform ${duration}ms cubic-bezier(0.4, 0.0, 0.2, 1)`;
+      requestAnimationFrame(() => {
+        el.style.transform = "translateX(0%)";
+      });
+      el.setAttribute("data-slide-state", "open");
+    }
+  });
+  return this;
+}
+function slideOut(options = {}) {
+  const { direction = "left", duration = 300 } = options;
+  const translateValue = direction === "left" ? "-100%" : "100%";
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      el.style.willChange = "transform";
+      el.style.transition = `transform ${duration}ms cubic-bezier(0.4, 0.0, 0.2, 1)`;
+      requestAnimationFrame(() => {
+        el.style.transform = `translateX(${translateValue})`;
+      });
+      el.setAttribute("data-slide-state", "closed");
+    }
+  });
+  return this;
+}
+function slideToggle(options = {}) {
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      const state = el.getAttribute("data-slide-state");
+      const currentTransform = el.style.transform;
+      if (state === "open" || currentTransform === "translateX(0%)" || window.getComputedStyle(el).display !== "none") {
+        const wrapper = new this.constructor(el);
+        wrapper.slideOut(options);
+      } else {
+        const wrapper = new this.constructor(el);
+        wrapper.slideIn(options);
+      }
+    }
+  });
+  return this;
+}
+
+// src/modules/effects/vertical.ts
+var vertical_exports = {};
+__export(vertical_exports, {
+  slideDown: () => slideDown,
+  slideToggleBox: () => slideToggleBox,
+  slideUp: () => slideUp
+});
+function slideDown(options = {}) {
+  const { duration = 300, displayType = "block" } = options;
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      if (window.getComputedStyle(el).display !== "none") return;
+      el.style.display = displayType;
+      const height = el.scrollHeight;
+      el.style.height = "0px";
+      el.style.overflow = "hidden";
+      el.style.transition = `height ${duration}ms ease-in-out`;
+      void el.offsetHeight;
+      el.style.height = height + "px";
+      setTimeout(() => {
+        el.style.height = "auto";
+        el.style.overflow = "visible";
+        el.style.transition = "";
+      }, duration);
+    }
+  });
+  return this;
+}
+function slideUp(options = {}) {
+  const { duration = 300 } = options;
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      el.style.height = el.scrollHeight + "px";
+      el.style.overflow = "hidden";
+      el.style.transition = `height ${duration}ms ease-in-out`;
+      void el.offsetHeight;
+      el.style.height = "0px";
+      setTimeout(() => {
+        el.style.display = "none";
+        el.style.height = "";
+        el.style.overflow = "";
+        el.style.transition = "";
+      }, duration);
+    }
+  });
+  return this;
+}
+function slideToggleBox(options = {}) {
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      const display = window.getComputedStyle(el).display;
+      const wrapper = new this.constructor(el);
+      if (display === "none") {
+        wrapper.slideDown(options);
+      } else {
+        wrapper.slideUp(options);
+      }
+    }
+  });
+  return this;
+}
+
+// src/modules/effects/fade.ts
+var fade_exports = {};
+__export(fade_exports, {
+  fadeIn: () => fadeIn,
+  fadeOut: () => fadeOut,
+  fadeToggle: () => fadeToggle
+});
+function fadeIn(options = {}) {
+  const { duration = 300, displayType = "block" } = options;
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      el.style.opacity = "0";
+      el.style.display = displayType;
+      el.style.transition = `opacity ${duration}ms ease-in-out`;
+      void el.offsetHeight;
+      requestAnimationFrame(() => {
+        el.style.opacity = "1";
+      });
+      setTimeout(() => {
+        el.style.transition = "";
+      }, duration);
+    }
+  });
+  return this;
+}
+function fadeOut(options = {}) {
+  const { duration = 300 } = options;
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      el.style.opacity = "1";
+      el.style.transition = `opacity ${duration}ms ease-in-out`;
+      void el.offsetHeight;
+      requestAnimationFrame(() => {
+        el.style.opacity = "0";
+      });
+      setTimeout(() => {
+        el.style.display = "none";
+        el.style.transition = "";
+      }, duration);
+    }
+  });
+  return this;
+}
+function fadeToggle(options = {}) {
+  this.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      const display = window.getComputedStyle(el).display;
+      const wrapper = new this.constructor(el);
+      if (display === "none") {
+        wrapper.fadeIn(options);
+      } else {
+        wrapper.fadeOut(options);
+      }
+    }
+  });
+  return this;
+}
+
+// src/modules/effects/index.ts
+var effectMethods = {
+  ...slide_exports,
+  ...vertical_exports,
+  ...fade_exports
+};
+
+// src/utils.ts
+function throttle(func, limit) {
+  let inThrottle;
+  return function(...args) {
+    const context = this;
+    if (!inThrottle) {
+      func.apply(context, args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+function debounce(func, delay) {
+  let timer;
+  return function(...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => func.apply(this, args), delay);
+  };
+}
+
+// src/modules/http/get.ts
+var get_exports = {};
+__export(get_exports, {
+  get: () => get,
+  getText: () => getText
+});
+async function get(url) {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP Error: ${response.status}`);
+  }
+  return await response.json();
+}
+async function getText(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP Error: ${response.status}`);
+  }
+  return await response.text();
+}
+
+// src/modules/http/post.ts
+var post_exports = {};
+__export(post_exports, {
+  post: () => post
+});
+async function post(url, body = {}) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (response.status === 204) {
+    const text2 = await response.text();
+    return text2 ? JSON.parse(text2) : {};
+  }
+  if (!response.ok) {
+    throw new Error(`HTTP Error: ${response.status}`);
+  }
+  return await response.json();
+}
+
+// src/modules/http/index.ts
+var http = {
+  ...get_exports,
+  ...post_exports
+};
+
+// src/modules/data/arrays.ts
+var arrays_exports = {};
+__export(arrays_exports, {
+  add: () => add,
+  chunk: () => chunk,
+  find: () => find,
+  mergeArray: () => mergeArray,
+  remove: () => remove2
+});
+
+// src/modules/data/types.ts
+function checkMatch(value, query, mode) {
+  const valStr = String(value).toLowerCase();
+  const queryStr = String(query).toLowerCase();
+  switch (mode) {
+    case "exact":
+      return valStr === queryStr;
+    case "startsWith":
+      return valStr.startsWith(queryStr);
+    case "endsWith":
+      return valStr.endsWith(queryStr);
+    case "contains":
+      return valStr.includes(queryStr);
+    default:
+      return false;
+  }
+}
+
+// src/modules/data/arrays.ts
+function chunk(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+function mergeArray(...arrays) {
+  return [].concat(...arrays);
+}
+function add(array, item, index = array.length) {
+  const copy = [...array];
+  const idx = index < 0 ? array.length + index + 1 : index;
+  copy.splice(idx, 0, item);
+  return copy;
+}
+var remove2 = {
+  /**
+   * * 🇬🇧: Removes an element at a specific index.
+   * * 🇩🇪: Entfernt ein Element an einem spezifischen Index.
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   * @param index
+   * * 🇬🇧: The index (negative values allowed).
+   * * 🇩🇪: Der Index (negativ möglich).
+   */
+  at(array, index) {
+    const copy = [...array];
+    const idx = index < 0 ? array.length + index : index;
+    if (idx >= 0 && idx < copy.length) {
+      copy.splice(idx, 1);
+    }
+    return copy;
+  },
+  /**
+   * * 🇬🇧: Removes the first element.
+   * * 🇩🇪: Entfernt das erste Element.
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   */
+  first(array) {
+    return array.slice(1);
+  },
+  /**
+   * * 🇬🇧: Removes the last element.
+   * * 🇩🇪: Entfernt das letzte Element.
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   */
+  last(array) {
+    return array.slice(0, -1);
+  },
+  /**
+   * * 🇬🇧: Removes all elements matching a query condition.
+   * * 🇩🇪: Entfernt alle Elemente, die einer Suchbedingung entsprechen.
+   * @example
+   * remove.byMatch(users, 'Admin', 'exact', 'role')
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param key
+   * * 🇬🇧: (Optional) The object key if it is an array of objects.
+   * * 🇩🇪: (Optional) Der Objektschlüssel, falls es ein Array von Objekten ist.
+   */
+  byMatch(array, query, mode = "exact", key) {
+    return array.filter((item) => {
+      const val2 = key ? item[key] : item;
+      return !checkMatch(val2, query, mode);
+    });
+  }
+};
+var find = {
+  /**
+   * * 🇬🇧: Finds the index of the first match.
+   * * 🇩🇪: Findet den Index des ersten Treffers.
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param key
+   * * 🇬🇧: (Optional) The object key if it is an array of objects.
+   * * 🇩🇪: (Optional) Der Objektschlüssel, falls es ein Array von Objekten ist.
+   * @returns
+   * * 🇬🇧: Index or -1.
+   * * 🇩🇪: Index oder -1.
+   */
+  at(array, query, mode = "exact", key) {
+    return array.findIndex((item) => {
+      const val2 = key ? item[key] : item;
+      return checkMatch(val2, query, mode);
+    });
+  },
+  /**
+   * * 🇬🇧: Returns all elements matching the condition (Filter).
+   * * 🇩🇪: Gibt alle Elemente zurück, die der Bedingung entsprechen (Filter).
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param key
+   * * 🇬🇧: (Optional) The object key if it is an array of objects.
+   * * 🇩🇪: (Optional) Der Objektschlüssel, falls es ein Array von Objekten ist.
+   * @returns
+   * * 🇬🇧: All matching elements or -1.
+   * * 🇩🇪: Alle passenden Elemente oder -1.
+   */
+  all(array, query, mode = "exact", key) {
+    return array.filter((item) => {
+      const val2 = key ? item[key] : item;
+      return checkMatch(val2, query, mode);
+    });
+  },
+  /**
+   * * 🇬🇧: Returns the first matching element (or undefined).
+   * * 🇩🇪: Gibt das erste gefundene Element zurück (oder undefined).
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param key
+   * * 🇬🇧: (Optional) The object key if it is an array of objects.
+   * * 🇩🇪: (Optional) Der Objektschlüssel, falls es ein Array von Objekten ist.
+   * @returns
+   * * 🇬🇧: Index or -1.
+   * * 🇩🇪: Index oder -1.
+   */
+  first(array, query, mode = "exact", key) {
+    return array.find((item) => {
+      const val2 = key ? item[key] : item;
+      return checkMatch(val2, query, mode);
+    });
+  },
+  /**
+   * * 🇬🇧: Returns the last matching element (or undefined).
+   * * 🇩🇪: Gibt das letzte gefundene Element zurück (oder undefined).
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param key
+   * * 🇬🇧: (Optional) The object key if it is an array of objects.
+   * * 🇩🇪: (Optional) Der Objektschlüssel, falls es ein Array von Objekten ist.
+   * @returns
+   * * 🇬🇧: Index or -1.
+   * * 🇩🇪: Index oder -1.
+   */
+  last(array, query, mode = "exact", key) {
+    return [...array].reverse().find((item) => {
+      const val2 = key ? item[key] : item;
+      return checkMatch(val2, query, mode);
+    });
+  },
+  /**
+   * * 🇬🇧: Removes all elements matching a query condition.
+   * * 🇩🇪: Entfernt alle Elemente, die einer Suchbedingung entsprechen.
+   * @example
+   * find.byMatch(users, 'Admin', 'exact', 'role')
+   * @param array
+   * * 🇬🇧: The array.
+   * * 🇩🇪: Das Array.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param key
+   * * 🇬🇧: (Optional) The object key if it is an array of objects.
+   * * 🇩🇪: (Optional) Der Objektschlüssel, falls es ein Array von Objekten ist.
+   * @returns
+   * * 🇬🇧: Index or -1.
+   * * 🇩🇪: Index oder -1.
+   */
+  byMatch(array, query, mode = "exact", key) {
+    return array.findIndex((item) => {
+      const val2 = key ? item[key] : item;
+      return checkMatch(val2, query, mode);
+    });
+  }
+};
+
+// src/modules/data/objects.ts
+var objects_exports = {};
+__export(objects_exports, {
+  find: () => find2,
+  get: () => get2,
+  mergeObjects: () => mergeObjects,
+  omit: () => omit,
+  pick: () => pick,
+  set: () => set
+});
+function mergeObjects(target, ...sources) {
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (key === "__proto__" || key === "constructor") continue;
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        mergeObjects(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return mergeObjects(target, ...sources);
+}
+function pick(obj, keys) {
+  const ret = {};
+  keys.forEach((key) => {
+    if (key in obj) ret[key] = obj[key];
+  });
+  return ret;
+}
+function omit(obj, keys) {
+  const ret = { ...obj };
+  keys.forEach((key) => {
+    delete ret[key];
+  });
+  return ret;
+}
+function get2(obj, path) {
+  return path.split(".").reduce((acc, part) => acc && acc[part], obj);
+}
+function set(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!current[part]) current[part] = {};
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+var find2 = {
+  /**
+   * * 🇬🇧: Returns the n-th entry of an object as a [key, value] pair. Supports negative indices.
+   * * 🇩🇪: Gibt den n-ten Eintrag eines Objekts als [Key, Value]-Paar zurück. Unterstützt negative Indizes.
+   * @example find.at({ a: 1, b: 2 }, 1) // => ['b', 2]
+   * @param obj
+   * * 🇬🇧: The object to search.
+   * * 🇩🇪: Das zu durchsuchende Objekt.
+   * @param index
+   * * 🇬🇧: The index (0-based, negative counts from the back).
+   * * 🇩🇪: Der Index (0-basiert, negativ zählt von hinten).
+   * @returns
+   * * 🇬🇧: A [key, value] tuple or undefined.
+   * * 🇩🇪: Ein [Key, Value]-Paar oder undefined.
+   */
+  at(obj, index) {
+    const entries = Object.entries(obj);
+    const idx = index < 0 ? entries.length + index : index;
+    return entries[idx];
+  },
+  /**
+   * * 🇬🇧: Finds the first entry where the key or value matches the query.
+   * * 🇩🇪: Findet den ersten Eintrag, bei dem der Schlüssel oder Wert dem Suchbegriff entspricht.
+   * @example find.first(config, 'admin', 'exact', 'key')
+   * @param obj
+   * * 🇬🇧: The object to search.
+   * * 🇩🇪: Das zu durchsuchende Objekt.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param searchBy
+   * * 🇬🇧: Whether to search by 'key' or 'value'.
+   * * 🇩🇪: Ob nach 'key' oder 'value' gesucht werden soll.
+   * @returns
+   * * 🇬🇧: The first matching [key, value] pair or undefined.
+   * * 🇩🇪: Das erste gefundene [key, value] Paar oder undefined.
+   */
+  first(obj, query, mode = "exact", searchBy = "key") {
+    const entries = Object.entries(obj);
+    return entries.find(([key, val2]) => {
+      const target = searchBy === "key" ? key : val2;
+      return checkMatch(target, query, mode);
+    });
+  },
+  /**
+   * * 🇬🇧: Finds the last entry where the key or value matches the query.
+   * * 🇩🇪: Findet den letzten Eintrag, bei dem der Schlüssel oder Wert dem Suchbegriff entspricht.
+   * @example find.last(config, '.php', 'endsWith', 'key')
+   * @param obj
+   * * 🇬🇧: The object to search.
+   * * 🇩🇪: Das zu durchsuchende Objekt.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @param searchBy
+   * * 🇬🇧: Whether to search by 'key' or 'value'.
+   * * 🇩🇪: Ob nach 'key' oder 'value' gesucht werden soll.
+   * @returns
+   * * 🇬🇧: The last matching [key, value] pair or undefined.
+   * * 🇩🇪: Das letzte gefundene [key, value] Paar oder undefined.
+   */
+  last(obj, query, mode = "exact", searchBy = "key") {
+    const entries = Object.entries(obj);
+    return [...entries].reverse().find(([key, val2]) => {
+      const target = searchBy === "key" ? key : val2;
+      return checkMatch(target, query, mode);
+    });
+  },
+  /**
+   * * 🇬🇧: Finds all keys matching the query.
+   * * 🇩🇪: Findet alle Schlüssel (Keys), die auf den Suchbegriff passen.
+   * @example find.key(config, 'api_', 'startsWith')
+   * @param obj
+   * * 🇬🇧: The object to search.
+   * * 🇩🇪: Das zu durchsuchende Objekt.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @returns
+   * * 🇬🇧: An array of matching keys.
+   * * 🇩🇪: Ein Array mit den passenden Schlüsseln.
+   */
+  key(obj, query, mode = "exact") {
+    return Object.keys(obj).filter((key) => checkMatch(key, query, mode));
+  },
+  /**
+   * * 🇬🇧: Finds all values matching the query.
+   * * 🇩🇪: Findet alle Werte (Values), die auf den Suchbegriff passen.
+   * @param obj
+   * * 🇬🇧: The object to search.
+   * * 🇩🇪: Das zu durchsuchende Objekt.
+   * @param query
+   * * 🇬🇧: The search query.
+   * * 🇩🇪: Der Suchbegriff.
+   * @param mode
+   * * 🇬🇧: The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
+   * * 🇩🇪: Der Vergleichsmodus ('exact', 'contains', 'startsWith', 'endsWith').
+   * @returns
+   * * 🇬🇧: An array of matching values.
+   * * 🇩🇪: Ein Array mit den passenden Werten.
+   */
+  value(obj, query, mode = "exact") {
+    return Object.values(obj).filter((val2) => checkMatch(val2, query, mode));
+  }
+};
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+
+// src/modules/data/index.ts
+var data = {
+  arr: arrays_exports,
+  obj: objects_exports
+};
+
+// src/index.ts
+Object.assign(jBase.prototype, cssMethods);
+Object.assign(jBase.prototype, eventMethods);
+Object.assign(jBase.prototype, domMethods);
+Object.assign(jBase.prototype, effectMethods);
+var init = (selector) => new jBase(selector);
+var $ = init;
+var jB = init;
+var _jB = init;
+var __jB = init;
+var _jBase = init;
+var __jBase = init;
+var jBase2 = init;
+export {
+  $,
+  jBase as JBaseClass,
+  __jB,
+  __jBase,
+  _jB,
+  _jBase,
+  data,
+  debounce,
+  http,
+  jB,
+  jBase2 as jBase,
+  throttle
+};
+/**
+ * @file src/core.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Core
+ * @description
+ * * 🇬🇧: The main jBase class. Handles the selection engine, initialization, and plugin architecture.
+ * * 🇩🇪: Die Haupt-jBase-Klasse. Behandelt die Selektions-Engine, Initialisierung und Plugin-Architektur.
+ */
+/**
+ * @file src/modules/css/classes.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category CSS
+ * @description
+ * * 🇬🇧: Methods for manipulating CSS classes (add, remove, toggle, has).
+ * * 🇩🇪: Methoden zur Manipulation von CSS-Klassen (add, remove, toggle, has).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/css/styles.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category CSS
+ * @description
+ * * 🇬🇧: Methods for getting and setting inline CSS styles.
+ * * 🇩🇪: Methoden zum Lesen und Setzen von Inline-CSS-Styles.
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/css/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category CSS
+ * @description
+ * * 🇬🇧: Central entry point for CSS operations. Aggregates class and style manipulation methods.
+ * * 🇩🇪: Zentraler Einstiegspunkt für CSS-Operationen. Aggregiert Methoden zur Klassen- und Style-Manipulation.
+ * @requires ./classes
+ * * 🇬🇧: Class manipulation methods (addClass, removeClass, etc.).
+ * * 🇩🇪: Methoden zur Klassen-Manipulation (addClass, removeClass, etc.).
+ * @requires ./styles
+ * * 🇬🇧: Style manipulation methods (css).
+ * * 🇩🇪: Methoden zur Style-Manipulation (css).
+ */
+/**
+ * @file src/modules/events/binding.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Core event binding methods (on, off, trigger). Handles event registration and removal.
+ * * 🇩🇪: Kern-Methoden für Event-Binding (on, off, trigger). Behandelt die Registrierung und Entfernung von Events.
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/events/mouse.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling mouse events (click, dblclick, hover, mouseenter, mouseleave).
+ * * 🇩🇪: Methoden zur Behandlung von Maus-Events (click, dblclick, hover, mouseenter, mouseleave).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/events/lifecycle.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling DOM lifecycle events (e.g., ready).
+ * * 🇩🇪: Methoden zur Behandlung von DOM-Lebenszyklus-Events (z.B. ready).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/events/keyboard.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling keyboard events (keydown, keyup, keypress).
+ * * 🇩🇪: Methoden zur Behandlung von Tastatur-Events (keydown, keyup, keypress).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/events/form.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling form events (submit, change, focus, blur, input).
+ * * 🇩🇪: Methoden zur Behandlung von Formular-Events (submit, change, focus, blur, input).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/events/touch.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling touch events (touchstart, touchend, touchmove).
+ * * 🇩🇪: Methoden zur Behandlung von Touch-Events (touchstart, touchend, touchmove).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/events/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Central entry point for event handling. Aggregates binding, mouse, lifecycle, keyboard, form, and touch events.
+ * * 🇩🇪: Zentraler Einstiegspunkt für Event-Handling. Aggregiert Binding-, Maus-, Lebenszyklus-, Tastatur-, Formular- und Touch-Events.
+ * @requires ./binding
+ * * 🇬🇧: General event binding (on, off).
+ * * 🇩🇪: Generelle Event-Bindung (on, off).
+ * @requires ./mouse
+ * * 🇬🇧: Mouse interaction events (click, hover, etc.).
+ * * 🇩🇪: Maus-Interaktions-Events (click, hover, etc.).
+ * @requires ./lifecycle
+ * * 🇬🇧: DOM lifecycle events (ready).
+ * * 🇩🇪: DOM-Lebenszyklus-Events (ready).
+ * @requires ./keyboard
+ * * 🇬🇧: Keyboard interaction events (keydown, keyup).
+ * * 🇩🇪: Tastatur-Interaktions-Events (keydown, keyup).
+ * @requires ./form
+ * * 🇬🇧: Form handling events (submit, change, input).
+ * * 🇩🇪: Formular-Verarbeitungs-Events (submit, change, input).
+ * @requires ./touch
+ * * 🇬🇧: Touch interaction events.
+ * * 🇩🇪: Touch-Interaktions-Events.
+ */
+/**
+ * @file src/modules/dom/attributes.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category DOM
+ * @description
+ * * 🇬🇧: Methods for getting and setting HTML attributes and properties (attr, data, val).
+ * * 🇩🇪: Methoden zum Lesen und Setzen von HTML-Attributen und Eigenschaften (attr, data, val).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/dom/content.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category DOM
+ * @description
+ * * 🇬🇧: Methods for getting and setting element content (html, text, empty, replaceWith).
+ * * 🇩🇪: Methoden zum Lesen und Setzen von Elementinhalten (html, text, empty, replaceWith).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/dom/manipulation.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category DOM
+ * @description
+ * * 🇬🇧: Methods for inserting, moving, and removing elements (append, prepend, remove).
+ * * 🇩🇪: Methoden zum Einfügen, Verschieben und Entfernen von Elementen (append, prepend, remove).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/dom/traversal.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category DOM
+ * @description
+ * * 🇬🇧: Methods for navigating the DOM tree (find, parent, children, siblings).
+ * * 🇩🇪: Methoden zur Navigation im DOM-Baum (find, parent, children, siblings).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/dom/states.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category DOM
+ * @description
+ * * 🇬🇧: Methods for checking element states (e.g., visibility, checked, disabled).
+ * * 🇩🇪: Methoden zur Prüfung von Element-Zuständen (z.B. Sichtbarkeit, checked, disabled).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/dom/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category DOM
+ * @description
+ * * 🇬🇧: Central entry point for DOM operations. Aggregates methods for attributes, content, manipulation, traversal, and states.
+ * * 🇩🇪: Zentraler Einstiegspunkt für DOM-Operationen. Aggregiert Methoden für Attribute, Inhalt, Manipulation, Traversierung und Status.
+ * @requires ./attributes
+ * * 🇬🇧: Attribute and value manipulation.
+ * * 🇩🇪: Attribut- und Wert-Manipulation.
+ * @requires ./content
+ * * 🇬🇧: Content handling (html, text).
+ * * 🇩🇪: Inhalts-Steuerung (html, text).
+ * @requires ./manipulation
+ * * 🇬🇧: DOM manipulation (append, remove, etc.).
+ * * 🇩🇪: DOM-Manipulation (append, remove, etc.).
+ * @requires ./traversal
+ * * 🇬🇧: Tree traversal (find, parent, children).
+ * * 🇩🇪: Baum-Durchquerung (find, parent, children).
+ * @requires ./states
+ * * 🇬🇧: State checks (checked, disabled).
+ * * 🇩🇪: Status-Prüfungen (checked, disabled).
+ */
+/**
+ * @file src/modules/effects/slide.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Effects
+ * @description
+ * * 🇬🇧: Methods for horizontal sliding effects (slideIn, slideOut, slideToggle).
+ * * 🇩🇪: Methoden für horizontale Slide-Effekte (slideIn, slideOut, slideToggle).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/effects/vertical.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Effects
+ * @description
+ * * 🇬🇧: Methods for vertical sliding effects (slideDown, slideUp, slideToggle).
+ * * 🇩🇪: Methoden für vertikale Slide-Effekte (slideDown, slideUp, slideToggle).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/effects/fade.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Effects
+ * @description
+ * * 🇬🇧: Methods for fading elements in and out (fadeIn, fadeOut, fadeToggle).
+ * * 🇩🇪: Methoden zum Ein- und Ausblenden von Elementen (fadeIn, fadeOut, fadeToggle).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/effects/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Effects
+ * @description
+ * * 🇬🇧: Central entry point for visual effects. Aggregates slide, fade, and vertical animation modules.
+ * * 🇩🇪: Zentraler Einstiegspunkt für visuelle Effekte. Aggregiert Module für Slide-, Fade- und vertikale Animationen.
+ * @requires ./slide
+ * * 🇬🇧: Horizontal slide effects (slideIn, slideOut).
+ * * 🇩🇪: Horizontale Slide-Effekte (slideIn, slideOut).
+ * @requires ./vertical
+ * * 🇬🇧: Vertical slide effects / Accordion (slideDown, slideUp).
+ * * 🇩🇪: Vertikale Slide-Effekte / Akkordeon (slideDown, slideUp).
+ * @requires ./fade
+ * * 🇬🇧: Opacity fade effects (fadeIn, fadeOut).
+ * * 🇩🇪: Opazitäts-Fade-Effekte (fadeIn, fadeOut).
+ */
+/**
+ * @file src/utils.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Utilities
+ * @description
+ * * 🇬🇧: General utility functions and helpers (e.g., debounce, throttle, type checks).
+ * * 🇩🇪: Allgemeine Hilfsfunktionen und Helfer (z.B. debounce, throttle, Typ-Prüfungen).
+ */
+/**
+ * @file src/modules/http/get.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category HTTP
+ * @description
+ * * 🇬🇧: Abstraction for HTTP GET requests.
+ * * 🇩🇪: Abstraktion für HTTP GET-Anfragen.
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/http/post.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category HTTP
+ * * @description
+ * * 🇬🇧: Abstraction for HTTP POST requests.
+ * * 🇩🇪: Abstraktion für HTTP POST-Anfragen.
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+/**
+ * @file src/modules/http/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category HTTP
+ * @description
+ * * 🇬🇧: Central entry point for HTTP requests. Aggregates GET and POST methods.
+ * * 🇩🇪: Zentraler Einstiegspunkt für HTTP-Anfragen. Aggregiert GET- und POST-Methoden.
+ * @requires ./get
+ * * 🇬🇧: HTTP GET methods (get, getText).
+ * * 🇩🇪: HTTP GET-Methoden (get, getText).
+ * @requires ./post
+ * * 🇬🇧: HTTP POST methods.
+ * * 🇩🇪: HTTP POST-Methoden.
+ */
+/**
+ * @file src/modules/data/types.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Data
+ * @description
+ * * 🇬🇧: Type definitions and validation helpers for data structures.
+ * * 🇩🇪: Typ-Definitionen und Validierungs-Hilfsmittel für Datenstrukturen.
+ */
+/**
+ * @file src/modules/data/arrays.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Data
+ * @description
+ * * 🇬🇧: Utility functions for array manipulation and data processing.
+ * * 🇩🇪: Hilfsfunktionen für Array-Manipulation und Datenverarbeitung.
+ * @requires ./types
+ * * 🇬🇧: Depends on match logic and types.
+ * * 🇩🇪: Hängt von Match-Logik und Typen ab.
+ */
+/**
+ * @file src/modules/data/objects.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Data
+ * @description
+ * * 🇬🇧: Utility functions for object manipulation (e.g., deep merging, extension).
+ * * 🇩🇪: Hilfsfunktionen für Objekt-Manipulation (z.B. Deep Merge, Erweiterung).
+ * @requires ./types
+ * * 🇬🇧: Depends on match logic and types.
+ * * 🇩🇪: Hängt von Match-Logik und Typen ab.
+ */
+/**
+ * @file src/modules/data/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Data
+ * @description
+ * * 🇬🇧: Central entry point for data manipulation modules. Aggregates array and object utilities.
+ * * 🇩🇪: Zentraler Einstiegspunkt für Datenmanipulations-Module. Aggregiert Array- und Objekt-Hilfsmethoden.
+ * @requires ./arrays
+ * * 🇬🇧: Array manipulation methods.
+ * * 🇩🇪: Methoden zur Array-Manipulation.
+ * @requires ./objects
+ * * 🇬🇧: Object manipulation methods.
+ * * 🇩🇪: Methoden zur Objekt-Manipulation.
+ */
+/**
+ * @file src/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Entry Point
+ * @description
+ * * 🇬🇧: Main library entry point. Aggregates Core, Types, Utils, and all functional modules into a single export.
+ * * 🇩🇪: Haupt-Einstiegspunkt der Bibliothek. Aggregiert Core, Types, Utils und alle funktionalen Module in einen einzigen Export.
+ * @requires ./core
+ * * 🇬🇧: Core class logic and inheritance.
+ * * 🇩🇪: Kern-Klassenlogik und Vererbung.
+ * @requires ./types
+ * * 🇬🇧: TypeScript type definitions and interfaces.
+ * * 🇩🇪: TypeScript Typ-Definitionen und Interfaces.
+ * @requires ./utils
+ * * 🇬🇧: Helper functions (throttle, debounce).
+ * * 🇩🇪: Hilfsfunktionen (throttle, debounce).
+ * @requires ./modules/css
+ * * 🇬🇧: Style manipulation methods.
+ * * 🇩🇪: Style-Manipulations-Methoden.
+ * @requires ./modules/events
+ * * 🇬🇧: Event handling logic.
+ * * 🇩🇪: Event-Handling-Logik.
+ * @requires ./modules/dom
+ * * 🇬🇧: DOM traversal and manipulation.
+ * * 🇩🇪: DOM-Traversierung und -Manipulation.
+ * @requires ./modules/effects
+ * * 🇬🇧: Visual effects and animations.
+ * * 🇩🇪: Visuelle Effekte und Animationen.
+ * @requires ./modules/http
+ * * 🇬🇧: HTTP client for AJAX requests.
+ * * 🇩🇪: HTTP-Client für AJAX-Anfragen.
+ * @requires ./modules/data
+ * * 🇬🇧: Data structure utilities.
+ * * 🇩🇪: Datenstruktur-Utilities.
+ */