jBase-2/dist/index.mjs

/**
 * @k37z3r/jbase - Ditch the legacy bloat. jBase is a blazing-fast, SSR-ready micro-framework combining an elegant DOM chaining API with powerful, immutable data utilities. Fully typed, modular, and built for modern web & Node.js environments.
 * @version 2.4.0
 * @homepage https://github.com/k37z3r/jBase-2
 * @author Sven Minio (https://github.com/k37z3r/jBase-2)
 * @license GPL-3.0-or-later
 * @copyright 2026 Sven Minio (https://github.com/k37z3r/jBase-2)
 */
var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// 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);
  };
}
function isBrowser() {
  return typeof window !== "undefined" && typeof window.requestAnimationFrame !== "undefined";
}
function each(collection, callback) {
  const isArrayLike = Array.isArray(collection) || collection && typeof collection === "object" && "length" in collection && typeof collection.length === "number";
  if (isArrayLike) {
    const arr = collection;
    for (let i = 0, len = arr.length; i < len; i++) {
      if (callback.call(arr[i], i, arr[i]) === false) {
        break;
      }
    }
  } else {
    const obj = collection;
    for (const key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        if (callback.call(obj[key], key, obj[key]) === false) {
          break;
        }
      }
    }
  }
  return collection;
}
function sanitizeDangerousAttributes(htmlStr) {
  let cleanStr = htmlStr.replace(/on\w+\s*=\s*(['"])(?:(?!\1).)*\1/gi, "");
  cleanStr = cleanStr.replace(/(href|action)\s*=\s*(['"])\s*javascript\s*:[\s\S]*?\2/gi, "");
  return cleanStr;
}

// src/core.ts
var jBase = class extends Array {
  /**
   * * The original selector string or input type used to create this instance.
   */
  selectorSource = "";
  /**
   * * The document context this instance is bound to (supports SSR via jsdom).
   */
  doc;
  /**
   * * Initializes a new jBase instance. Analyzes the provided selector and populates the internal array with found or created DOM elements.
   * @param selector The input selector (CSS selector, HTML string, DOM element, or collection).
   * @param context An optional specific Document or Window context (essential for SSR).
   */
  constructor(selector, context) {
    super();
    if (context instanceof Document) {
      this.doc = context;
    } else if (context && context.document) {
      this.doc = context.document;
    } else {
      this.doc = typeof document !== "undefined" ? document : null;
    }
    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 = this.doc.createElement("div");
        tempDiv.innerHTML = sanitizeDangerousAttributes(trimmed);
        this.push(...Array.from(tempDiv.children));
      } else if (trimmed.startsWith("#") && !trimmed.includes(" ") && !trimmed.includes(".")) {
        const el = this.doc.getElementById(trimmed.slice(1));
        if (el)
          this.push(el);
      } else if (trimmed.startsWith(".") && !trimmed.includes(" ") && !/[:\[#]/.test(trimmed)) {
        const els = this.doc.getElementsByClassName(trimmed.slice(1));
        for (let i = 0; i < els.length; i++) {
          this.push(els[i]);
        }
      } else if (/^[a-zA-Z0-9]+$/.test(trimmed)) {
        const els = this.doc.getElementsByTagName(trimmed);
        for (let i = 0; i < els.length; i++) {
          this.push(els[i]);
        }
      } else {
        try {
          this.push(...Array.from(this.doc.querySelectorAll(selector)));
        } catch (e) {
          console.warn(`jBase: Invalid selector "${selector}"`, e);
        }
      }
    } 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.
   * @example toJson() => { meta: 'jBase Wrapper', query: '#myId', count: 1, preview: ['div'] }
   * @returns A simplified object representation for 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;
      })
    };
  }
  /**
   * * High-performance iteration over matched elements.
   * * Returning 'false' in the callback breaks the loop early.
   * @example each((el, index) => { console.log(el); if (index === 5) return false; }) => Logs the first 6 matched elements to the console.
   * @param callback The function to execute for each element. Context (`this`) is set to the current element.
   * @returns The current jBase instance for chaining.
   */
  each(callback) {
    for (let i = 0, len = this.length; i < len; i++) {
      if (callback.call(this[i], this[i], i) === false) {
        break;
      }
    }
    return this;
  }
};

// src/modules/css/classes.ts
var classes_exports = {};
__export(classes_exports, {
  addClass: () => addClass,
  hasClass: () => hasClass,
  removeClass: () => removeClass,
  toggleClass: () => toggleClass
});
function addClass(...classNames) {
  this.each(function(el) {
    if (el instanceof Element) el.classList.add(...classNames);
  });
  return this;
}
function removeClass(...classNames) {
  this.each(function(el) {
    if (el instanceof Element) el.classList.remove(...classNames);
  });
  return this;
}
function toggleClass(className) {
  this.each(function(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 (typeof property === "object" && property !== null) {
    this.each(function(el) {
      if (el instanceof HTMLElement || el instanceof SVGElement) {
        for (const key in property) {
          if (Object.prototype.hasOwnProperty.call(property, key)) {
            if (key.includes("-")) {
              el.style.setProperty(key, String(property[key]));
            } else {
              el.style[key] = property[key];
            }
          }
        }
      }
    });
    return this;
  }
  if (typeof property === "string") {
    if (value === void 0) {
      const el = this[0];
      if (el instanceof HTMLElement || el instanceof SVGElement) {
        const doc = el.ownerDocument;
        const win = doc ? doc.defaultView : null;
        if (win) {
          return win.getComputedStyle(el).getPropertyValue(property) || win.getComputedStyle(el)[property] || "";
        } else {
          return el.style[property] || "";
        }
      }
      return "";
    }
    this.each(function(el) {
      if (el instanceof HTMLElement || el instanceof SVGElement) {
        if (property.includes("-")) {
          el.style.setProperty(property, String(value));
        } else {
          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,
  once: () => once,
  trigger: () => trigger
});
var JB_EVENTS = "__jb_events";
function on(events, selectorOrDataOrHandler, dataOrHandler, handlerOrUndefined) {
  let selector;
  let data2;
  let handler;
  if (typeof selectorOrDataOrHandler === "string") {
    selector = selectorOrDataOrHandler;
    if (typeof dataOrHandler === "function") {
      handler = dataOrHandler;
    } else {
      data2 = dataOrHandler;
      handler = handlerOrUndefined;
    }
  } else if (typeof selectorOrDataOrHandler === "function") {
    handler = selectorOrDataOrHandler;
  } else {
    data2 = selectorOrDataOrHandler;
    handler = dataOrHandler;
  }
  if (!handler) return this;
  const eventTypes = events.split(" ");
  this.each(function(el) {
    if (!(el instanceof EventTarget)) return;
    const registry = el[JB_EVENTS] || (el[JB_EVENTS] = []);
    each(eventTypes, function(_index, eventType) {
      const wrappedHandler = function(e) {
        let targetContext = el;
        if (selector) {
          const target = e.target instanceof Element ? e.target : e.target?.parentElement;
          const match = target instanceof Element && target.closest ? target.closest(selector) : null;
          if (!match || !el.contains(match)) {
            return;
          }
          targetContext = match;
        }
        if (data2 !== void 0) {
          e.data = data2;
        }
        handler.call(targetContext, e);
      };
      registry.push({
        type: eventType,
        original: handler,
        wrapped: wrappedHandler,
        selector
      });
      el.addEventListener(eventType, wrappedHandler);
    });
  });
  return this;
}
function off(events, selectorOrHandler, handlerOrUndefined) {
  let selector;
  let handler;
  if (typeof selectorOrHandler === "string") {
    selector = selectorOrHandler;
    handler = handlerOrUndefined;
  } else if (typeof selectorOrHandler === "function") {
    handler = selectorOrHandler;
  }
  const eventTypes = events.split(" ");
  this.each(function(el) {
    if (!(el instanceof EventTarget)) return;
    const registry = el[JB_EVENTS];
    if (!registry) return;
    each(eventTypes, function(_index, eventType) {
      for (let i = registry.length - 1; i >= 0; i--) {
        const record = registry[i];
        const matchType = record.type === eventType;
        const matchSelector = selector ? record.selector === selector : true;
        const matchHandler = handler ? record.original === handler : true;
        if (matchType && matchSelector && matchHandler) {
          el.removeEventListener(eventType, record.wrapped);
          registry.splice(i, 1);
        }
      }
    });
  });
  return this;
}
function once(events, selectorOrDataOrHandler, dataOrHandler, handlerOrUndefined) {
  const self = this;
  const handleOnce = function(e) {
    self.off(events, selectorOrDataOrHandler, handleOnce);
    let realHandler;
    if (typeof selectorOrDataOrHandler === "function") {
      realHandler = selectorOrDataOrHandler;
    } else if (typeof dataOrHandler === "function") {
      realHandler = dataOrHandler;
    } else {
      realHandler = handlerOrUndefined;
    }
    return realHandler.apply(this, arguments);
  };
  if (typeof selectorOrDataOrHandler === "string") {
    if (typeof dataOrHandler === "function") {
      return this.on(events, selectorOrDataOrHandler, handleOnce);
    } else {
      return this.on(events, selectorOrDataOrHandler, dataOrHandler, handleOnce);
    }
  } else if (typeof selectorOrDataOrHandler === "function") {
    return this.on(events, handleOnce);
  } else {
    return this.on(events, selectorOrDataOrHandler, handleOnce);
  }
}
function trigger(eventName, data2) {
  return this.each(function(el) {
    if (!(el instanceof EventTarget)) return;
    const event = new CustomEvent(eventName, {
      bubbles: true,
      cancelable: true,
      detail: data2
    });
    el.dispatchEvent(event);
  });
}

// src/modules/events/mouse.ts
var mouse_exports = {};
__export(mouse_exports, {
  click: () => click,
  dblclick: () => dblclick,
  hover: () => hover,
  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.each(function(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.each(function(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);
}
function hover(handlerIn, handlerOut) {
  return this.mouseenter(handlerIn).mouseleave(handlerOut);
}

// src/modules/events/lifecycle.ts
var lifecycle_exports = {};
__export(lifecycle_exports, {
  ready: () => ready
});
function ready(handler) {
  const doc = window.document;
  if (doc.readyState === "complete" || doc.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.each(function(el) {
      if (el instanceof HTMLElement) el.focus();
    });
    return this;
  }
}
function blur(handler) {
  if (handler) {
    return this.on("blur", handler);
  } else {
    this.each(function(el) {
      if (el instanceof HTMLElement) el.blur();
    });
    return this;
  }
}

// src/modules/events/touch.ts
var touch_exports = {};
__export(touch_exports, {
  swipeDown: () => swipeDown,
  swipeLeft: () => swipeLeft,
  swipeRight: () => swipeRight,
  swipeUp: () => swipeUp,
  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);
}
function swipeLeft(handler) {
  return this.each(function(el) {
    if (el instanceof Element) handleSwipe.call(this, el, "left", handler);
  });
}
function swipeRight(handler) {
  return this.each(function(el) {
    if (el instanceof Element) handleSwipe.call(this, el, "right", handler);
  });
}
function swipeUp(handler) {
  return this.each(function(el) {
    if (el instanceof Element) handleSwipe.call(this, el, "up", handler);
  });
}
function swipeDown(handler) {
  return this.each(function(el) {
    if (el instanceof Element) handleSwipe.call(this, el, "down", handler);
  });
}
function handleSwipe(el, direction, handler) {
  let startX = 0, startY = 0;
  el.addEventListener("touchstart", (e) => {
    startX = e.touches[0].clientX;
    startY = e.touches[0].clientY;
  }, { passive: true });
  el.addEventListener("touchend", (e) => {
    const diffX = e.changedTouches[0].clientX - startX;
    const diffY = e.changedTouches[0].clientY - startY;
    const threshold = 50;
    if (Math.abs(diffX) > Math.abs(diffY)) {
      if (Math.abs(diffX) > threshold) {
        if (diffX > 0 && direction === "right") handler.call(el, e);
        if (diffX < 0 && direction === "left") handler.call(el, e);
      }
    } else {
      if (Math.abs(diffY) > threshold) {
        if (diffY > 0 && direction === "down") handler.call(el, e);
        if (diffY < 0 && direction === "up") handler.call(el, e);
      }
    }
  }, { passive: true });
}

// 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,
  prop: () => prop,
  removeAttr: () => removeAttr,
  val: () => val
});
function attr(name, value) {
  if (value === void 0) {
    const el = this[0];
    return el instanceof Element ? el.getAttribute(name) : null;
  }
  this.each(function(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.each(function(el) {
    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
      el.value = value;
    }
  });
  return this;
}
function removeAttr(name) {
  this.each(function(el) {
    if (el instanceof Element) el.removeAttribute(name);
  });
  return this;
}
function prop(name, value) {
  if (value === void 0) {
    const el = this[0];
    return el instanceof Element ? el[name] : void 0;
  }
  this.each(function(el) {
    if (el instanceof Element) {
      el[name] = value;
    }
  });
  return this;
}

// src/modules/dom/content.ts
var content_exports = {};
__export(content_exports, {
  html: () => html,
  load: () => load,
  text: () => text
});

// src/modules/http/get.ts
var get_exports = {};
__export(get_exports, {
  get: () => get,
  getText: () => getText
});
async function get(url, option) {
  const fetchOptions = { ...option };
  if (fetchOptions.method?.toLowerCase() === "post") {
    fetchOptions.method = "GET";
  }
  if (!fetchOptions.signal) {
    fetchOptions.signal = AbortSignal.timeout(5e3);
  }
  const response = await fetch(url, {
    ...fetchOptions
  });
  if (!response.ok) {
    throw new Error(`HTTP Error: ${response.status}`);
  }
  const text2 = await response.text();
  try {
    return text2 ? JSON.parse(text2) : {};
  } catch (e) {
    return text2;
  }
}
async function getText(url, option) {
  const fetchOptions = { ...option };
  if (fetchOptions.method?.toLowerCase() !== "get") {
    fetchOptions.method = "GET";
  }
  if (!fetchOptions.signal) {
    fetchOptions.signal = AbortSignal.timeout(5e3);
  }
  const response = await fetch(url, {
    ...fetchOptions
  });
  if (!response.ok) {
    throw new Error(`HTTP Error: ${response.status}`);
  }
  const text2 = await response.text();
  return text2;
}

// src/modules/dom/content.ts
function extractAndExecuteScripts(htmlStr, doc) {
  const tempDiv = doc.createElement("div");
  tempDiv.innerHTML = htmlStr;
  const scripts = tempDiv.querySelectorAll("script");
  scripts.forEach((oldScript) => {
    const newScript = doc.createElement("script");
    Array.from(oldScript.attributes).forEach((attr2) => {
      newScript.setAttribute(attr2.name, attr2.value);
    });
    if (oldScript.textContent) {
      newScript.textContent = oldScript.textContent;
    }
    doc.head.appendChild(newScript);
    doc.head.removeChild(newScript);
    oldScript.remove();
  });
  return tempDiv.innerHTML;
}
function html(content, options) {
  if (content === void 0) {
    const el = this[0];
    return el instanceof Element ? el.innerHTML : "";
  }
  let finalHtml = content;
  const execute = options?.executeScripts === true;
  this.each(function(el) {
    if (el instanceof Element) {
      const doc = el.ownerDocument || document;
      const processedHtml = execute ? extractAndExecuteScripts(finalHtml, doc) : sanitizeDangerousAttributes(finalHtml);
      el.innerHTML = processedHtml;
    }
  });
  return this;
}
function text(content) {
  if (content === void 0) {
    const el = this[0];
    return el instanceof Node ? el.textContent || "" : "";
  }
  this.each(function(el) {
    if (el instanceof HTMLElement) {
      el.textContent = content;
    }
  });
  return this;
}
async function load(url, options) {
  try {
    const fetchOptions = { ...options };
    delete fetchOptions.executeScripts;
    const htmlStr = await getText(url, fetchOptions);
    this.html(htmlStr, { executeScripts: options?.executeScripts });
  } catch (error) {
    console.error(`jBase .load() failed to fetch: ${url}`, error);
    throw error;
  }
  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, doc) {
  const tmp = doc.createElement("div");
  tmp.innerHTML = sanitizeDangerousAttributes(html2.trim());
  return tmp.firstElementChild;
}
function getDoc(collection) {
  if (collection.length > 0 && collection[0] instanceof Element) {
    return collection[0].ownerDocument;
  }
  return typeof document !== "undefined" ? document : null;
}
function normalizeToFragment(content, doc) {
  const fragment = doc.createDocumentFragment();
  const add4 = (item) => {
    if (typeof item === "string") {
      const temp = doc.createElement("div");
      temp.innerHTML = sanitizeDangerousAttributes(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) {
      each(item, function(_index, child) {
        add4(child);
      });
    }
  };
  add4(content);
  return fragment;
}
function remove() {
  this.each(function(el) {
    if (el instanceof Element) el.remove();
  });
  return this;
}
function empty() {
  this.each(function(el) {
    if (el instanceof Element) el.innerHTML = "";
  });
  return this;
}
function replaceWithClone() {
  const newElements = [];
  this.each(function(el) {
    if (el instanceof Element) {
      const clone = el.cloneNode(true);
      el.replaceWith(clone);
      newElements.push(clone);
    }
  });
  return new this.constructor(newElements);
}
function append(content) {
  if (typeof content === "string") {
    const safeContent = sanitizeDangerousAttributes(content);
    this.each(function(el) {
      if (el instanceof Element) {
        el.insertAdjacentHTML("beforeend", safeContent);
      }
    });
    return this;
  }
  const doc = getDoc(this);
  if (!doc)
    return this;
  const fragment = normalizeToFragment(content, doc);
  const len = this.length;
  this.each(function(el, i) {
    if (el instanceof Element) {
      const contentToInsert = i < len - 1 ? fragment.cloneNode(true) : fragment;
      el.appendChild(contentToInsert);
    }
  });
  return this;
}
function prepend(content) {
  if (typeof content === "string") {
    const safeContent = sanitizeDangerousAttributes(content);
    this.each(function(el) {
      if (el instanceof Element) {
        el.insertAdjacentHTML("afterbegin", safeContent);
      }
    });
    return this;
  }
  const doc = getDoc(this);
  if (!doc)
    return this;
  const fragment = normalizeToFragment(content, doc);
  const len = this.length;
  this.each(function(el, i) {
    if (el instanceof Element) {
      const contentToInsert = i < len - 1 ? fragment.cloneNode(true) : fragment;
      el.prepend(contentToInsert);
    }
  });
  return this;
}
function before(content) {
  if (typeof content === "string") {
    const safeContent = sanitizeDangerousAttributes(content);
    this.each(function(el) {
      if (el instanceof Element) {
        el.insertAdjacentHTML("beforebegin", safeContent);
      }
    });
    return this;
  }
  const doc = getDoc(this);
  if (!doc)
    return this;
  const fragment = normalizeToFragment(content, doc);
  const len = this.length;
  this.each(function(el, i) {
    if (el instanceof Element) {
      const contentToInsert = i < len - 1 ? fragment.cloneNode(true) : fragment;
      el.before(contentToInsert);
    }
  });
  return this;
}
function after(content) {
  if (typeof content === "string") {
    const safeContent = sanitizeDangerousAttributes(content);
    this.each(function(el) {
      if (el instanceof Element) {
        el.insertAdjacentHTML("afterend", safeContent);
      }
    });
    return this;
  }
  const doc = getDoc(this);
  if (!doc)
    return this;
  const fragment = normalizeToFragment(content, doc);
  const len = this.length;
  this.each(function(el, i) {
    if (el instanceof Element) {
      const contentToInsert = i < len - 1 ? fragment.cloneNode(true) : fragment;
      el.after(contentToInsert);
    }
  });
  return this;
}
function replaceWith(content) {
  const doc = getDoc(this);
  if (!doc)
    return this;
  const fragment = normalizeToFragment(content, doc);
  const len = this.length;
  this.each(function(el, i) {
    if (el instanceof Element) {
      const contentToInsert = i < len - 1 ? fragment.cloneNode(true) : fragment;
      el.replaceWith(contentToInsert);
    }
  });
  return this;
}
function appendTo(target) {
  const doc = getDoc(this);
  if (!doc)
    return this;
  const parent2 = typeof target === "string" ? doc.querySelector(target) : target;
  if (parent2 instanceof Element) {
    const fragment = doc.createDocumentFragment();
    this.each(function(el) {
      if (el instanceof Node) fragment.appendChild(el);
    });
    parent2.appendChild(fragment);
  }
  return this;
}
function prependTo(target) {
  const doc = getDoc(this);
  if (!doc)
    return this;
  const parent2 = typeof target === "string" ? doc.querySelector(target) : target;
  if (parent2 instanceof Element) {
    const fragment = doc.createDocumentFragment();
    this.each(function(el) {
      if (el instanceof Node) fragment.appendChild(el);
    });
    parent2.prepend(fragment);
  }
  return this;
}
function insertBefore(target) {
  const doc = getDoc(this);
  if (!doc)
    return this;
  const targetEl = typeof target === "string" ? doc.querySelector(target) : target;
  if (targetEl instanceof Element) {
    const fragment = doc.createDocumentFragment();
    this.each(function(el) {
      if (el instanceof Node) fragment.appendChild(el);
    });
    targetEl.before(fragment);
  }
  return this;
}
function insertAfter(target) {
  const doc = getDoc(this);
  if (!doc)
    return this;
  const targetEl = typeof target === "string" ? doc.querySelector(target) : target;
  if (targetEl instanceof Element) {
    const fragment = doc.createDocumentFragment();
    this.each(function(el) {
      if (el instanceof Node) fragment.appendChild(el);
    });
    targetEl.after(fragment);
  }
  return this;
}
function wrap(wrapperHtml) {
  const doc = getDoc(this);
  if (!doc)
    return this;
  this.each(function(el) {
    if (el instanceof Element) {
      const wrapper = parseHTML(wrapperHtml, doc);
      if (el.parentNode) {
        el.parentNode.insertBefore(wrapper, el);
      }
      wrapper.appendChild(el);
    }
  });
  return this;
}
function unwrap() {
  const doc = getDoc(this);
  if (!doc) return this;
  const parents2 = /* @__PURE__ */ new Set();
  this.each(function(el) {
    if (el instanceof Element && el.parentElement) {
      parents2.add(el.parentElement);
    }
  });
  each(Array.from(parents2), function(_index, parent2) {
    const fragment = doc.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.each(function(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.each(function(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.each(function(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.each(function(el) {
    if (el instanceof Element || el instanceof Document) {
      const matches = el.querySelectorAll(selector);
      each(matches, function(_index, 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.each(function(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.each(function(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.each(function(el) {
    if (el instanceof Element) traverse(el);
  });
  const Construction = this.constructor;
  return new Construction([...new Set(found)]);
}
function next(selector) {
  const found = [];
  this.each(function(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.each(function(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.each(function(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.each(function(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.each(function(el) {
    if (el instanceof Element && el.parentElement) {
      const children2 = Array.from(el.parentElement.children);
      each(children2, function(_index, 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.each(function(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.each(function(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.each(function(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.each(function(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, {
  check: () => check,
  checked: () => checked,
  disable: () => disable,
  disabled: () => disabled,
  enable: () => enable,
  select: () => select,
  selected: () => selected,
  uncheck: () => uncheck
});
function checked(state) {
  if (state === void 0) {
    const el = this[0];
    return el instanceof HTMLInputElement ? el.checked : false;
  }
  this.each(function(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.each(function(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.each(function(el) {
    if (el instanceof HTMLElement && "disabled" in el) {
      el.disabled = state;
      if (state)
        el.classList.add("disabled");
      else
        el.classList.remove("disabled");
    }
  });
  return this;
}
function check() {
  return checked.call(this, true);
}
function uncheck() {
  return checked.call(this, false);
}
function select() {
  return selected.call(this, true);
}
function disable() {
  return disabled.call(this, true);
}
function enable() {
  return disabled.call(this, false);
}

// 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 = {}) {
  if (!isBrowser())
    return this;
  const { duration = 300 } = options;
  this.each(function(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 = {}) {
  if (!isBrowser())
    return this;
  const { direction = "left", duration = 300 } = options;
  const translateValue = direction === "left" ? "-100%" : "100%";
  this.each(function(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 = {}) {
  if (!isBrowser())
    return this;
  this.each(function(el) {
    if (el instanceof HTMLElement) {
      const state = el.getAttribute("data-slide-state");
      const currentTransform = el.style.transform;
      if (state === "open" || currentTransform === "translateX(0%)") {
        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 = {}) {
  if (!isBrowser())
    return this;
  const { duration = 300, displayType = "block" } = options;
  this.each(function(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 = {}) {
  if (!isBrowser())
    return this;
  const { duration = 300 } = options;
  this.each(function(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 = {}) {
  if (!isBrowser())
    return this;
  this.each(function(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,
  hide: () => hide,
  show: () => show,
  toggle: () => toggle
});
function fadeIn(options = {}) {
  if (!isBrowser()) return this;
  const duration = typeof options === "number" ? options : options.duration || 300;
  const displayType = typeof options === "object" && options.displayType ? options.displayType : "block";
  this.each(function(el) {
    if (el instanceof HTMLElement) {
      if (el._jbaseFadeTimer) {
        clearTimeout(el._jbaseFadeTimer);
      }
      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";
      });
      el._jbaseFadeTimer = setTimeout(() => {
        el.style.transition = "";
        delete el._jbaseFadeTimer;
      }, duration);
    }
  });
  return this;
}
function fadeOut(options = {}) {
  if (!isBrowser()) return this;
  const duration = typeof options === "number" ? options : options.duration || 300;
  this.each(function(el) {
    if (el instanceof HTMLElement) {
      if (el._jbaseFadeTimer) {
        clearTimeout(el._jbaseFadeTimer);
      }
      el.style.opacity = "1";
      el.style.transition = `opacity ${duration}ms ease-in-out`;
      void el.offsetHeight;
      requestAnimationFrame(() => {
        el.style.opacity = "0";
      });
      el._jbaseFadeTimer = setTimeout(() => {
        el.style.display = "none";
        el.style.transition = "";
        delete el._jbaseFadeTimer;
      }, duration);
    }
  });
  return this;
}
function fadeToggle(options = {}) {
  if (!isBrowser()) return this;
  this.each((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;
}
var show = fadeIn;
var hide = fadeOut;
var toggle = fadeToggle;

// src/modules/effects/index.ts
var effectMethods = {
  ...slide_exports,
  ...vertical_exports,
  ...fade_exports
};

// src/modules/http/post.ts
var post_exports = {};
__export(post_exports, {
  post: () => post
});
async function post(url, body = {}, option) {
  const fetchOptions = { ...option };
  if (fetchOptions.method?.toLowerCase() !== "post") {
    fetchOptions.method = "post";
  }
  if (!fetchOptions.signal) {
    fetchOptions.signal = AbortSignal.timeout(5e3);
  }
  const response = await fetch(url, {
    ...fetchOptions,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(body)
  });
  if (response.status === 204) {
    const text3 = await response.text();
    return text3 ? JSON.parse(text3) : {};
  }
  if (!response.ok) {
    throw new Error(`HTTP Error: ${response.status}`);
  }
  const text2 = await response.text();
  try {
    return text2 ? JSON.parse(text2) : {};
  } catch (e) {
    return text2;
  }
}

// src/modules/http/upload.ts
var upload_exports = {};
__export(upload_exports, {
  upload: () => upload
});
async function upload(url, data2, onProgress) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open("POST", url);
    if (onProgress) {
      xhr.upload.onprogress = (event) => {
        if (event.lengthComputable) {
          const percentage = Math.round(event.loaded / event.total * 100);
          onProgress(percentage, event.loaded, event.total);
        }
      };
    }
    xhr.onload = () => {
      if (xhr.status >= 200 && xhr.status < 300) {
        const text2 = xhr.responseText;
        try {
          resolve(text2 ? JSON.parse(text2) : {});
        } catch (e) {
          resolve(text2);
        }
      } else {
        reject(new Error(`HTTP Error: ${xhr.status}`));
      }
    };
    xhr.onerror = () => {
      reject(new Error("Network Error during upload"));
    };
    let payload;
    if (data2 instanceof File) {
      payload = new FormData();
      payload.append("file", data2);
    } else {
      payload = data2;
    }
    xhr.send(payload);
  });
}

// src/modules/http/index.ts
var http = {
  ...get_exports,
  ...post_exports,
  ...upload_exports
};

// src/modules/data/arrays.ts
var arrays_exports = {};
__export(arrays_exports, {
  add: () => add,
  chunk: () => chunk,
  clear: () => clear,
  empty: () => empty2,
  find: () => find,
  get: () => get2,
  merge: () => merge,
  mergeArray: () => mergeArray,
  omit: () => omit,
  pick: () => pick,
  remove: () => remove2,
  set: () => set
});
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);
}
var merge = mergeArray;
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;
}
function clear(array) {
  return [];
}
var empty2 = clear;
function pick(array, indices) {
  return array.filter((_, index) => indices.includes(index));
}
function omit(array, indices) {
  return array.filter((_, index) => !indices.includes(index));
}
function get2(array, path) {
  return path.split(".").reduce((acc, part) => acc && acc[part], array);
}
function set(array, path, value) {
  const parts = path.split(".");
  let current = array;
  for (let i = 0; i < parts.length - 1; i++) {
    const part = parts[i];
    if (!current[part]) {
      current[part] = isNaN(Number(parts[i + 1])) ? {} : [];
    }
    current = current[part];
  }
  current[parts[parts.length - 1]] = value;
}
var remove2 = {
  /**
   * * Removes an element at a specific index.
   * @example remove.at([1, 2, 3, 4], -2) => [1, 2, 4]
   * @template T The type of the items in the array.
   * @param array The array.
   * @param index The index (negative values allowed).
   * @returns A new array with the element removed.
   */
  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.
   * @example remove.first([1, 2, 3]) => [2, 3]
   * @template T The type of the items in the array.
   * @param array The array.
   */
  first(array) {
    return array.slice(1);
  },
  /**
   * * Removes the last element.
   * @example remove.last([1, 2, 3]) => [1, 2]
   * @template T The type of the items in the array.
   * @param array The array.
   */
  last(array) {
    return array.slice(0, -1);
  },
  /**
   * * Removes all elements matching a query condition.
   * @example remove.byMatch(users, 'Admin', 'exact', 'role')
   * @template T The type of the items in the array.
   * @param array The array.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param key (Optional) The object key if it is an array of objects.
   */
  byMatch(array, query, mode = "exact", key) {
    const queryStr = String(query).toLowerCase();
    return array.filter((item) => {
      const val2 = key ? item[key] : item;
      const valStr = String(val2).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;
      }
    });
  },
  /**
   * * Removes the element at a specific index.
   * * Mirrors object.remove.byKey.
   * @example remove.byKey(['a', 'b', 'c'], 1) => ['a', 'c']
   * @template T The type of the items in the array.
   * @param array The source array.
   * @param index The index (key) to remove.
   * @returns A new array without the specified index.
   */
  byKey(array, index) {
    return this.at(array, index);
  },
  /**
   * * Removes all elements that match a specific value exactly (Strict Equality).
   * * Mirrors object.remove.byValue.
   * @example remove.byValue([1, 2, 1, 3], 1) => [2, 3]
   * @template T The type of the items in the array.
   * @param array The source array.
   * @param value The value to remove.
   * @returns A new array without the matching values.
   */
  byValue(array, value) {
    return array.filter((item) => item !== value);
  },
  /**
   * * ALIAS for clear. Removes all elements.
   * @param array The source array.
   * @returns A new, empty array.
   */
  all(array) {
    return clear(array);
  }
};
var find = {
  /**
   * * Finds the index of the first match.
   * @example find.at(['apple', 'banana', 'cherry'], 'an', 'contains') => 1
   * @template T The type of the items in the array.
   * @param array The array.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param key (Optional) The object key if it is an array of objects.
   * @returns Index or -1.
   */
  at(array, query, mode = "exact", key) {
    const queryStr = String(query).toLowerCase();
    return array.findIndex((item) => {
      const val2 = key ? item[key] : item;
      const valStr = String(val2).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;
      }
    });
  },
  /**
   * * Returns all elements matching the condition (Filter).
   * @example find.all(['apple', 'banana', 'cherry'], 'a', 'contains') => ['apple', 'banana']
   * @template T The type of the items in the array.
   * @param array The array.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param key (Optional) The object key if it is an array of objects.
   * @returns All matching elements or -1.
   */
  all(array, query, mode = "exact", key) {
    const queryStr = String(query).toLowerCase();
    return array.filter((item) => {
      const val2 = key ? item[key] : item;
      const valStr = String(val2).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;
      }
    });
  },
  /**
   * * Returns the first matching element (or undefined).
   * @example find.first(['apple', 'banana', 'cherry'], 'a', 'contains') => 'apple'
   * @template T The type of the items in the array.
   * @param array The array.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param key (Optional) The object key if it is an array of objects.
   * @returns Index or -1.
   */
  first(array, query, mode = "exact", key) {
    const queryStr = String(query).toLowerCase();
    return array.find((item) => {
      const val2 = key ? item[key] : item;
      const valStr = String(val2).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;
      }
    });
  },
  /**
   * * Returns the last matching element (or undefined).
   * @example find.last(['apple', 'banana', 'cherry'], 'a', 'contains') => 'banana'
   * @template T The type of the items in the array.
   * @param array The array.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param key (Optional) The object key if it is an array of objects.
   * @returns Index or -1.
   */
  last(array, query, mode = "exact", key) {
    const queryStr = String(query).toLowerCase();
    return [...array].reverse().find((item) => {
      const val2 = key ? item[key] : item;
      const valStr = String(val2).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;
      }
    });
  },
  /**
   * * Finds all indices (keys) matching the query.
   * * Mirrors object.find.key(). For arrays, keys are the indices.
   * @param array The array to search.
   * @param query The search query.
   * @param mode The comparison mode.
   * @returns An array of matching indices as strings.
   */
  key(array, query, mode = "exact") {
    const queryStr = String(query).toLowerCase();
    return Object.keys(array).filter((indexKey) => {
      const valStr = String(indexKey).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;
      }
    });
  },
  /**
   * * Finds all values matching the query.
   * * Mirrors object.find.value(). Identical to find.all() for flat arrays.
   * @param array The array to search.
   * @param query The search query.
   * @param mode The comparison mode.
   * @returns An array of matching values.
   */
  value(array, query, mode = "exact") {
    return this.all(array, query, mode);
  },
  /**
   * * Finds the key of the first match based on the query condition.
   * @example find.byMatch(users, 'Admin', 'exact', 'role') => 0
   * @template T The type of the items in the array.
   * @param array The array.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param key (Optional) The object key if it is an array of objects.
   * @returns Index or -1.
   */
  byMatch(array, query, mode = "exact", key) {
    const queryStr = String(query).toLowerCase();
    return array.findIndex((item) => {
      const val2 = key ? item[key] : item;
      const valStr = String(val2).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/objects.ts
var objects_exports = {};
__export(objects_exports, {
  add: () => add2,
  chunk: () => chunk2,
  clear: () => clear2,
  empty: () => empty3,
  find: () => find2,
  get: () => get3,
  merge: () => merge2,
  mergeObjects: () => mergeObjects,
  omit: () => omit2,
  pick: () => pick2,
  remove: () => remove3,
  set: () => set2
});
function isObject(item) {
  return item && typeof item === "object" && !Array.isArray(item);
}
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]) target[key] = {};
        mergeObjects(target[key], source[key]);
      } else {
        target[key] = source[key];
      }
    }
  }
  return mergeObjects(target, ...sources);
}
var merge2 = mergeObjects;
function chunk2(obj, size) {
  const entries = Object.entries(obj);
  const chunks = [];
  for (let i = 0; i < entries.length; i += size) {
    const slice = entries.slice(i, i + size);
    chunks.push(Object.fromEntries(slice));
  }
  return chunks;
}
function add2(obj, key, value, index = Object.keys(obj).length) {
  const entries = Object.entries(obj);
  const idx = index < 0 ? entries.length + index + 1 : index;
  entries.splice(idx, 0, [key, value]);
  return Object.fromEntries(entries);
}
function clear2(obj) {
  return {};
}
var empty3 = clear2;
function pick2(obj, keys) {
  const ret = {};
  each(keys, function(_index, key) {
    if (key in obj) ret[key] = obj[key];
  });
  return ret;
}
function omit2(obj, keys) {
  const ret = { ...obj };
  each(keys, function(_index, key) {
    delete ret[key];
  });
  return ret;
}
function get3(obj, path) {
  return path.split(".").reduce((acc, part) => acc && acc[part], obj);
}
function set2(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 remove3 = {
  /**
   * * Removes an entry at a specific index.
   * @example remove.at({a: 1, b: 2, c: 3}, -1) => {a: 1, b: 2}
   * @param obj The source object.
   * @param index The index (negative values allowed).
   * @returns A new object with the element removed.
   */
  at(obj, index) {
    const entries = Object.entries(obj);
    const idx = index < 0 ? entries.length + index : index;
    if (idx >= 0 && idx < entries.length) {
      entries.splice(idx, 1);
    }
    return Object.fromEntries(entries);
  },
  /**
   * * Removes the first entry from the object.
   * @param obj The source object.
   * @returns A new object without the first entry.
   */
  first(obj) {
    const entries = Object.entries(obj).slice(1);
    return Object.fromEntries(entries);
  },
  /**
   * * Removes the last entry from the object.
   * @param obj The source object.
   * @returns A new object without the last entry.
   */
  last(obj) {
    const entries = Object.entries(obj).slice(0, -1);
    return Object.fromEntries(entries);
  },
  /**
   * * Removes all entries matching a query condition.
   * @example remove.byMatch(config, 'hidden', 'exact', 'key')
   * @param obj The source object.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param searchBy Whether to search by 'key' or 'value' (default: 'key').
   * @returns A new object without the matching elements.
   */
  byMatch(obj, query, mode = "exact", searchBy = "key") {
    const queryStr = String(query).toLowerCase();
    const filteredEntries = Object.entries(obj).filter(([key, val2]) => {
      const target = searchBy === "key" ? key : val2;
      const valStr = String(target).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 true;
      }
    });
    return Object.fromEntries(filteredEntries);
  },
  /**
   * * Removes all entries that have a specific key.
   * @example remove.byKey({ a: 1, b: 2, c: 3 }, 'b') => { a: 1, c: 3 }
   * @param obj The source object.
   * @param key The key to remove.
   * @returns A new object without the specified key.
   */
  byKey(obj, key) {
    const ret = { ...obj };
    delete ret[key];
    return ret;
  },
  /**
   * * Removes all entries that match a specific value exactly (Strict Equality).
   * @example remove.byValue({ a: 1, b: 2, c: 1 }, 1) => { b: 2 }
   * @param obj The source object.
   * @param value The value to remove.
   * @returns A new object without the matching values.
   */
  byValue(obj, value) {
    const filteredEntries = Object.entries(obj).filter(([_key, val2]) => val2 !== value);
    return Object.fromEntries(filteredEntries);
  },
  /**
   * * ALIAS for clear. Removes all entries.
   * @param obj The source object.
   * @returns A new, empty object.
   */
  all(obj) {
    return clear2(obj);
  }
};
var find2 = {
  /**
   * * Returns the n-th entry of an object as a [key, value] pair. Supports negative indices.
   * @example find.at({ a: 1, b: 2 }, 1) => ['b', 2]
   * @param obj The object to search.
   * @param index The index (0-based, negative counts from the back).
   * @returns A [key, value] tuple or undefined.
   */
  at(obj, index) {
    const entries = Object.entries(obj);
    const idx = index < 0 ? entries.length + index : index;
    return entries[idx];
  },
  /**
   * * Returns a NEW OBJECT containing ALL elements matching the condition.
   * * Mirrors array.find.all() but returns a partial object.
   * @example find.all({a: 1, b: 2, c: 1}, 1, 'exact', 'value') => {a: 1, c: 1}
   * @param obj The object to search.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param searchBy Whether to search by 'key' or 'value' (default: 'key').
   * @returns A new object with only the matching elements.
   */
  all(obj, query, mode = "exact", searchBy = "key") {
    const queryStr = String(query).toLowerCase();
    const filteredEntries = Object.entries(obj).filter(([key, val2]) => {
      const target = searchBy === "key" ? key : val2;
      const valStr = String(target).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;
      }
    });
    return Object.fromEntries(filteredEntries);
  },
  /**
   * * Finds the first entry where the key or value matches the query.
   * @example find.first(config, 'admin', 'exact', 'key')
   * @param obj The object to search.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param searchBy Whether to search by 'key' or 'value'.
   * @returns The first matching [key, value] pair or undefined.
   */
  first(obj, query, mode = "exact", searchBy = "key") {
    const entries = Object.entries(obj);
    const queryStr = String(query).toLowerCase();
    return entries.find(([key, val2]) => {
      const target = searchBy === "key" ? key : val2;
      const valStr = String(target).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;
      }
    });
  },
  /**
   * * Finds the last entry where the key or value matches the query.
   * @example find.last(config, '.php', 'endsWith', 'key')
   * @param obj The object to search.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param searchBy Whether to search by 'key' or 'value'.
   * @returns The last matching [key, value] pair or undefined.
   */
  last(obj, query, mode = "exact", searchBy = "key") {
    const entries = Object.entries(obj);
    const queryStr = String(query).toLowerCase();
    return [...entries].reverse().find(([key, val2]) => {
      const target = searchBy === "key" ? key : val2;
      const valStr = String(target).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;
      }
    });
  },
  /**
   * * Finds all keys matching the query.
   * @example find.key(config, 'api_', 'startsWith')
   * @param obj The object to search.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @returns An array of matching keys.
   */
  key(obj, query, mode = "exact") {
    const queryStr = String(query).toLowerCase();
    return Object.keys(obj).filter((key) => {
      const valStr = String(key).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;
      }
    });
  },
  /**
   * * Finds all values matching the query.
   * @example find.value(config, 'enabled', 'exact')
   * @param obj The object to search.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @returns An array of matching values.
   */
  value(obj, query, mode = "exact") {
    const queryStr = String(query).toLowerCase();
    return Object.values(obj).filter((val2) => {
      const valStr = String(val2).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;
      }
    });
  },
  /**
   * * Finds the key of the first match based on the query condition.
   * * Mirrors array.find.byMatch(). For objects, it returns the key instead of a numeric index.
   * @example find.byMatch(config, 'admin', 'exact', 'value') => 'role'
   * @param obj The object to search.
   * @param query The search query.
   * @param mode The comparison mode ('exact', 'contains', 'startsWith', 'endsWith').
   * @param searchBy Whether to search by 'key' or 'value' (default: 'key').
   * @returns The matched key as a string, or undefined if no match is found.
   */
  byMatch(obj, query, mode = "exact", searchBy = "key") {
    const queryStr = String(query).toLowerCase();
    const entries = Object.entries(obj);
    const found = entries.find(([key, val2]) => {
      const target = searchBy === "key" ? key : val2;
      const valStr = String(target).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;
      }
    });
    return found ? found[0] : void 0;
  }
};

// src/modules/data/index.ts
function chunk3(data2, size) {
  return Array.isArray(data2) ? chunk(data2, size) : chunk2(data2, size);
}
function merge3(data2, ...args) {
  return Array.isArray(data2) ? merge(data2, ...args) : merge2(data2, ...args);
}
function add3(data2, arg1, arg2, arg3) {
  return Array.isArray(data2) ? add(data2, arg1, arg2) : add2(data2, arg1, arg2, arg3);
}
function clear3(data2) {
  return Array.isArray(data2) ? clear(data2) : clear2(data2);
}
function pick3(data2, keysOrIndices) {
  return Array.isArray(data2) ? pick(data2, keysOrIndices) : pick2(data2, keysOrIndices);
}
function omit3(data2, keysOrIndices) {
  return Array.isArray(data2) ? omit(data2, keysOrIndices) : omit2(data2, keysOrIndices);
}
function get4(data2, path) {
  return Array.isArray(data2) ? get2(data2, path) : get3(data2, path);
}
function set3(data2, path, value) {
  return Array.isArray(data2) ? set(data2, path, value) : set2(data2, path, value);
}
function removeAt(data2, index) {
  return Array.isArray(data2) ? remove2.at(data2, index) : remove3.at(data2, index);
}
function removeFirst(data2) {
  return Array.isArray(data2) ? remove2.first(data2) : remove3.first(data2);
}
function removeLast(data2) {
  return Array.isArray(data2) ? remove2.last(data2) : remove3.last(data2);
}
function removeByMatch(data2, query, mode, keyOrSearchBy) {
  return Array.isArray(data2) ? remove2.byMatch(data2, query, mode, keyOrSearchBy) : remove3.byMatch(data2, query, mode, keyOrSearchBy);
}
function removeByKey(data2, keyOrIndex) {
  return Array.isArray(data2) ? remove2.byKey(data2, keyOrIndex) : remove3.byKey(data2, keyOrIndex);
}
function removeByValue(data2, value) {
  return Array.isArray(data2) ? remove2.byValue(data2, value) : remove3.byValue(data2, value);
}
function findAt(data2, arg1, arg2, arg3) {
  return Array.isArray(data2) ? find.at(data2, arg1, arg2, arg3) : find2.at(data2, arg1);
}
function findAll2(data2, query, mode, keyOrSearchBy) {
  return Array.isArray(data2) ? find.all(data2, query, mode, keyOrSearchBy) : find2.all(data2, query, mode, keyOrSearchBy);
}
function findFirst(data2, query, mode, keyOrSearchBy) {
  return Array.isArray(data2) ? find.first(data2, query, mode, keyOrSearchBy) : find2.first(data2, query, mode, keyOrSearchBy);
}
function findLast(data2, query, mode, keyOrSearchBy) {
  return Array.isArray(data2) ? find.last(data2, query, mode, keyOrSearchBy) : find2.last(data2, query, mode, keyOrSearchBy);
}
function findKey(data2, query, mode) {
  return Array.isArray(data2) ? find.key(data2, query, mode) : find2.key(data2, query, mode);
}
function findValue(data2, query, mode) {
  return Array.isArray(data2) ? find.value(data2, query, mode) : find2.value(data2, query, mode);
}
function findByMatch(data2, query, mode, keyOrSearchBy) {
  return Array.isArray(data2) ? find.byMatch(data2, query, mode, keyOrSearchBy) : find2.byMatch(data2, query, mode, keyOrSearchBy);
}
var data = {
  arr: arrays_exports,
  obj: objects_exports,
  chunk: chunk3,
  merge: merge3,
  add: add3,
  clear: clear3,
  empty: clear3,
  pick: pick3,
  omit: omit3,
  get: get4,
  set: set3,
  remove: {
    at: removeAt,
    first: removeFirst,
    last: removeLast,
    byKey: removeByKey,
    byValue: removeByValue,
    byMatch: removeByMatch,
    all: clear3
  },
  find: {
    at: findAt,
    all: findAll2,
    first: findFirst,
    last: findLast,
    key: findKey,
    value: findValue,
    byMatch: findByMatch
  }
};

// src/index.ts
Object.assign(jBase.prototype, cssMethods);
Object.assign(jBase.prototype, eventMethods);
Object.assign(jBase.prototype, domMethods);
Object.assign(jBase.prototype, effectMethods);
var initFn = (selector) => {
  return new jBase(selector);
};
var init = Object.assign(initFn, {
  http,
  data,
  each,
  throttle,
  debounce,
  fn: jBase.prototype
});
var bind = (window2) => {
  const doc = window2.document;
  const boundInit = (selector) => new jBase(selector, doc);
  Object.assign(boundInit, {
    fn: jBase.prototype,
    http,
    data,
    each,
    throttle,
    debounce
  });
  return boundInit;
};
var $ = init;
var jB = init;
var _jB = init;
var __jB = init;
var _jBase = init;
var __jBase = init;
var jBase2 = init;
var __ = init;
export {
  $,
  jBase as JBaseClass,
  __,
  __jB,
  __jBase,
  _jB,
  _jBase,
  bind,
  data,
  debounce,
  each,
  http,
  jB,
  jBase2 as jBase,
  throttle
};
/**
 * @file src/utils.ts
 * @version 2.2.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).
 */
/**
 * @file src/core.ts
 * @version 2.2.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.
 * @requires ./types
 * * Type definitions for the core class and its methods.
 */
/**
 * @file src/modules/css/classes.ts
 * @version 2.0.3
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/css/styles.ts
 * @version 2.0.4
 * @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.
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/css/index.ts
 * @version 2.0.3
 * @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.
 * @requires ./classes
 * * Class manipulation methods (addClass, removeClass, etc.).
 * @requires ./styles
 * * Style manipulation methods (css).
 */
/**
 * @file src/modules/events/binding.ts
 * @version 2.1.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.
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 * @requires ../../utils
 * * Uses utility functions for iteration and environment checks.
 */
/**
 * @file src/modules/events/mouse.ts
 * @version 2.1.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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/events/lifecycle.ts
 * @version 2.0.3
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/events/keyboard.ts
 * @version 2.0.3
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/events/form.ts
 * @version 2.0.3
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/events/touch.ts
 * @version 2.1.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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/events/index.ts
 * @version 2.0.2
 * @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.
 * @requires ./binding
 * * General event binding (on, off).
 * @requires ./mouse
 * * Mouse interaction events (click, hover, etc.).
 * @requires ./lifecycle
 * * DOM lifecycle events (ready).
 * @requires ./keyboard
 * * Keyboard interaction events (keydown, keyup).
 * @requires ./form
 * * Form handling events (submit, change, input).
 * @requires ./touch
 * * Touch interaction events.
 */
/**
 * @file src/modules/dom/attributes.ts
 * @version 2.1.1
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/http/get.ts
 * @version 2.0.6
 * @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.
 */
/**
 * @file src/modules/dom/content.ts
 * @version 2.1.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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/dom/manipulation.ts
 * @version 2.0.4
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 * @requires src/utils
 * * Depends on utility functions (e.g., each).
 */
/**
 * @file src/modules/dom/traversal.ts
 * @version 2.0.3
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 * @requires ../../utils
 * * Utility functions (e.g., `each` for iteration).
 */
/**
 * @file src/modules/dom/states.ts
 * @version 2.1.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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 */
/**
 * @file src/modules/dom/index.ts
 * @version 2.0.3
 * @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.
 * @requires ./attributes
 * * Attribute and value manipulation.
 * @requires ./content
 * * Content handling (html, text).
 * @requires ./manipulation
 * * DOM manipulation (append, remove, etc.).
 * @requires ./traversal
 * * Tree traversal (find, parent, children).
 * @requires ./states
 * * State checks (checked, disabled).
 */
/**
 * @file src/modules/effects/slide.ts
 * @version 2.0.3
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 * @requires ../../utils
 * * Uses utility functions for environment checks.
 * @requires ./types
 * * Type definitions for slide options.
 */
/**
 * @file src/modules/effects/vertical.ts
 * @version 2.0.3
 * @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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 * @requires ../../utils
 * * Utility function to check for browser environment.
 * @requires ./types
 * * Type definitions for effect options.
 */
/**
 * @file src/modules/effects/fade.ts
 * @version 2.1.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).
 * @requires ../../core
 * * Depends on the core jBase class for type definitions.
 * @requires ../../utils
 * * Uses utility functions for environment checks.
 * @requires ./types
 * * Type definitions for fade options.
 */
/**
 * @file src/modules/effects/index.ts
 * @version 2.0.3
 * @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.
 * @requires ./slide
 * * Horizontal slide effects (slideIn, slideOut).
 * @requires ./vertical
 * * Vertical slide effects / Accordion (slideDown, slideUp).
 * @requires ./fade
 * * Opacity fade effects (fadeIn, fadeOut).
 */
/**
 * @file src/modules/http/post.ts
 * @version 2.0.5
 * @since 2.0.2
 * @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.
 */
/**
 * @file src/modules/http/upload.ts
 * @version 2.0.0
 * @since 2.3.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.
 */
/**
 * @file src/modules/http/index.ts
 * @version 2.1.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.
 * @requires ./get
 * * HTTP GET methods (get, getText).
 * @requires ./post
 * * HTTP POST methods.
 * @requires ./upload
 * * HTTP file upload method with progress tracking.
 */
/**
 * @file src/modules/data/arrays.ts
 * @version 2.1.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.
 * @requires ./types
 * * Depends on types.
 */
/**
 * @file src/modules/data/objects.ts
 * @version 2.1.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).
 * @requires ./types
 * * Depends on types.
 * @requires src/utils
 * * Depends on utility functions (e.g., each).
 */
/**
 * @file src/modules/data/index.ts
 * @version 2.1.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. 
 * * Features a dynamic, overloaded API router that automatically delegates 
 * * to array or object utilities based on the input type.
 * @requires ./arrays
 * * Array manipulation methods.
 * @requires ./objects
 * * Object manipulation methods.
 */
/**
 * @file src/index.ts
 * @version 2.3.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.
 * @requires ./core
 * * Core class logic and inheritance.
 * @requires ./types
 * * TypeScript type definitions and interfaces.
 * @requires ./utils
 * * Helper functions (throttle, debounce).
 * @requires ./modules/css
 * * Style manipulation methods.
 * @requires ./modules/events
 * * Event handling logic.
 * @requires ./modules/dom
 * * DOM traversal and manipulation.
 * @requires ./modules/effects
 * * Visual effects and animations.
 * @requires ./modules/http
 * * HTTP client for AJAX requests.
 * @requires ./modules/data
 * * Data structure utilities.
 */
//# sourceMappingURL=index.mjs.map