@bquery/bquery 1.2.0 → 1.3.0

package/dist/core.es.mjs

@@ -1,9 +1,23 @@
-import { sanitize as f } from "./security.es.mjs";
-const p = (r) => Array.isArray(r) ? r : [r], o = (r, e) => {
-  for (const t of r)
+import { s as f } from "./sanitize-1FBEPAFH.js";
+const g = (n) => Array.isArray(n) ? n : [n], o = (n, e) => {
+  for (const t of n)
     e(t);
+}, p = (n) => f(n), w = (n, e) => {
+  n.innerHTML = f(e);
+}, y = (n) => {
+  const e = document.createElement("template");
+  return e.innerHTML = f(n), e.content.firstElementChild ?? document.createElement("div");
+}, b = (n, e, t) => {
+  if (typeof e == "string") {
+    n.insertAdjacentHTML(t, f(e));
+    return;
+  }
+  const r = g(e), i = t === "afterbegin" || t === "afterend" ? r.slice().reverse() : r;
+  o(i, (l) => {
+    n.insertAdjacentElement(t, l);
+  });
 };
-class a {
+class h {
   /**
    * Creates a new BQueryElement wrapper.
    * @param element - The DOM element to wrap
@@ -41,14 +55,23 @@ class a {
   attr(e, t) {
     return t === void 0 ? this.element.getAttribute(e) ?? "" : (this.element.setAttribute(e, t), this);
   }
+  /** Remove an attribute. */
+  removeAttr(e) {
+    return this.element.removeAttribute(e), this;
+  }
+  /** Toggle an attribute on/off. */
+  toggleAttr(e, t) {
+    const r = this.element.hasAttribute(e);
+    return t ?? !r ? this.element.setAttribute(e, "") : this.element.removeAttribute(e), this;
+  }
   /** Get or set a property. */
   prop(e, t) {
     return t === void 0 ? this.element[e] : (this.element[e] = t, this);
   }
   /** Read or write data attributes in camelCase. */
   data(e, t) {
-    const n = e.replace(/[A-Z]/g, (s) => `-${s.toLowerCase()}`);
-    return t === void 0 ? this.element.getAttribute(`data-${n}`) ?? "" : (this.element.setAttribute(`data-${n}`, t), this);
+    const r = e.replace(/[A-Z]/g, (s) => `-${s.toLowerCase()}`);
+    return t === void 0 ? this.element.getAttribute(`data-${r}`) ?? "" : (this.element.setAttribute(`data-${r}`, t), this);
   }
   /** Get or set text content. */
   text(e) {
@@ -68,7 +91,7 @@ class a {
    * ```
    */
   html(e) {
-    return this.element.innerHTML = f(e), this;
+    return w(this.element, e), this;
   }
   /**
    * Sets HTML content without sanitization.
@@ -101,8 +124,8 @@ class a {
   css(e, t) {
     if (typeof e == "string")
       return t !== void 0 && this.element.style.setProperty(e, t), this;
-    for (const [n, s] of Object.entries(e))
-      this.element.style.setProperty(n, s);
+    for (const [r, s] of Object.entries(e))
+      this.element.style.setProperty(r, s);
     return this;
   }
   /**
@@ -161,6 +184,10 @@ class a {
    * Removes the parent element, keeping this element in its place.
    * Essentially the opposite of wrap().
    *
+   * **Important**: This method only moves the current element out of its parent
+   * before removing the parent. Any sibling elements will be removed along with
+   * the parent. For unwrapping multiple siblings, use a collection: `$$(siblings).unwrap()`.
+   *
    * @returns The instance for method chaining
    *
    * @example
@@ -186,13 +213,8 @@ class a {
    * ```
    */
   replaceWith(e) {
-    let t;
-    if (typeof e == "string") {
-      const n = document.createElement("template");
-      n.innerHTML = f(e), t = n.content.firstElementChild ?? document.createElement("div");
-    } else
-      t = e;
-    return this.element.replaceWith(t), new a(t);
+    const t = typeof e == "string" ? y(e) : e;
+    return this.element.replaceWith(t), new h(t);
   }
   /**
    * Scrolls the element into view with configurable behavior.
@@ -232,7 +254,7 @@ class a {
    * @returns A new BQueryElement wrapping the cloned element
    */
   clone(e = !0) {
-    return new a(this.element.cloneNode(e));
+    return new h(this.element.cloneNode(e));
   }
   /**
    * Finds all descendant elements matching the selector.
@@ -363,12 +385,12 @@ class a {
    * $('#list').undelegate('click', '.item', handler);
    * ```
    */
-  delegate(e, t, n) {
+  delegate(e, t, r) {
     const s = `${e}:${t}`, i = (l) => {
-      const h = l.target.closest(t);
-      h && this.element.contains(h) && n(l, h);
+      const u = l.target.closest(t);
+      u && this.element.contains(u) && r(l, u);
     };
-    return this.delegatedHandlers.has(s) || this.delegatedHandlers.set(s, /* @__PURE__ */ new Map()), this.delegatedHandlers.get(s).set(n, i), this.element.addEventListener(e, i), this;
+    return this.delegatedHandlers.has(s) || this.delegatedHandlers.set(s, /* @__PURE__ */ new Map()), this.delegatedHandlers.get(s).set(r, i), this.element.addEventListener(e, i), this;
   }
   /**
    * Removes a delegated event listener previously added with `delegate()`.
@@ -387,11 +409,11 @@ class a {
    * $('#list').undelegate('click', '.item', handler);
    * ```
    */
-  undelegate(e, t, n) {
+  undelegate(e, t, r) {
     const s = `${e}:${t}`, i = this.delegatedHandlers.get(s);
     if (i) {
-      const l = i.get(n);
-      l && (this.element.removeEventListener(e, l), i.delete(n), i.size === 0 && this.delegatedHandlers.delete(s));
+      const l = i.get(r);
+      l && (this.element.removeEventListener(e, l), i.delete(r), i.size === 0 && this.delegatedHandlers.delete(s));
     }
     return this;
   }
@@ -483,8 +505,8 @@ class a {
     const e = this.element;
     if (e.tagName.toLowerCase() !== "form")
       return {};
-    const t = {}, n = new FormData(e);
-    for (const [s, i] of n.entries())
+    const t = {}, r = new FormData(e);
+    for (const [s, i] of r.entries())
       if (typeof i == "string")
         if (s in t) {
           const l = t[s];
@@ -508,10 +530,10 @@ class a {
     const e = this.element;
     if (e.tagName.toLowerCase() !== "form")
       return "";
-    const t = new FormData(e), n = new URLSearchParams();
+    const t = new FormData(e), r = new URLSearchParams();
     for (const [s, i] of t.entries())
-      typeof i == "string" && n.append(s, i);
-    return n.toString();
+      typeof i == "string" && r.append(s, i);
+    return r.toString();
   }
   /**
    * Gets the bounding client rectangle of the element.
@@ -540,17 +562,10 @@ class a {
    * @internal
    */
   insertContent(e, t) {
-    if (typeof e == "string") {
-      this.element.insertAdjacentHTML(t, f(e));
-      return;
-    }
-    const n = p(e);
-    o(n, (s) => {
-      this.element.insertAdjacentElement(t, s);
-    });
+    b(this.element, e, t);
   }
 }
-class m {
+class c {
   /**
    * Creates a new collection wrapper.
    * @param elements - Array of DOM elements to wrap
@@ -579,7 +594,7 @@ class m {
    */
   eq(e) {
     const t = this.elements[e];
-    return t ? new a(t) : void 0;
+    return t ? new h(t) : void 0;
   }
   /**
    * Gets the first element as a BQueryElement wrapper.
@@ -604,8 +619,8 @@ class m {
    * @returns The instance for method chaining
    */
   each(e) {
-    return this.elements.forEach((t, n) => {
-      e(new a(t), n);
+    return this.elements.forEach((t, r) => {
+      e(new h(t), r);
     }), this;
   }
   /**
@@ -624,7 +639,7 @@ class m {
    * @returns New BQueryCollection with matching elements
    */
   filter(e) {
-    return new m(this.elements.filter(e));
+    return new c(this.elements.filter(e));
   }
   /**
    * Reduces the collection to a single value.
@@ -642,7 +657,7 @@ class m {
    * @returns Array of BQueryElement instances
    */
   toArray() {
-    return this.elements.map((e) => new a(e));
+    return this.elements.map((e) => new h(e));
   }
   /** Add one or more classes to all elements. */
   addClass(...e) {
@@ -654,7 +669,7 @@ class m {
   }
   /** Toggle a class on all elements. */
   toggleClass(e, t) {
-    return o(this.elements, (n) => n.classList.toggle(e, t)), this;
+    return o(this.elements, (r) => r.classList.toggle(e, t)), this;
   }
   /**
    * Sets an attribute on all elements or gets from first.
@@ -664,7 +679,7 @@ class m {
    * @returns Attribute value when getting, instance when setting
    */
   attr(e, t) {
-    return t === void 0 ? this.first()?.getAttribute(e) ?? "" : (o(this.elements, (n) => n.setAttribute(e, t)), this);
+    return t === void 0 ? this.first()?.getAttribute(e) ?? "" : (o(this.elements, (r) => r.setAttribute(e, t)), this);
   }
   /**
    * Removes an attribute from all elements.
@@ -675,6 +690,13 @@ class m {
   removeAttr(e) {
     return o(this.elements, (t) => t.removeAttribute(e)), this;
   }
+  /** Toggle an attribute on all elements. */
+  toggleAttr(e, t) {
+    return o(this.elements, (r) => {
+      const s = r.hasAttribute(e);
+      t ?? !s ? r.setAttribute(e, "") : r.removeAttribute(e);
+    }), this;
+  }
   /**
    * Sets text content on all elements or gets from first.
    *
@@ -695,9 +717,9 @@ class m {
   html(e) {
     if (e === void 0)
       return this.first()?.innerHTML ?? "";
-    const t = f(e);
-    return o(this.elements, (n) => {
-      n.innerHTML = t;
+    const t = p(e);
+    return o(this.elements, (r) => {
+      r.innerHTML = t;
     }), this;
   }
   /**
@@ -712,6 +734,22 @@ class m {
       t.innerHTML = e;
     }), this;
   }
+  /** Append content to all elements. */
+  append(e) {
+    return this.insertAll(e, "beforeend"), this;
+  }
+  /** Prepend content to all elements. */
+  prepend(e) {
+    return this.insertAll(e, "afterbegin"), this;
+  }
+  /** Insert content before all elements. */
+  before(e) {
+    return this.insertAll(e, "beforebegin"), this;
+  }
+  /** Insert content after all elements. */
+  after(e) {
+    return this.insertAll(e, "afterend"), this;
+  }
   /**
    * Applies CSS styles to all elements.
    *
@@ -720,13 +758,59 @@ class m {
    * @returns The instance for method chaining
    */
   css(e, t) {
-    return typeof e == "string" ? (t !== void 0 && o(this.elements, (n) => {
-      n.style.setProperty(e, t);
-    }), this) : (o(this.elements, (n) => {
+    return typeof e == "string" ? (t !== void 0 && o(this.elements, (r) => {
+      r.style.setProperty(e, t);
+    }), this) : (o(this.elements, (r) => {
       for (const [s, i] of Object.entries(e))
-        n.style.setProperty(s, i);
+        r.style.setProperty(s, i);
     }), this);
   }
+  /** Wrap each element with a wrapper element or tag. */
+  wrap(e) {
+    return this.elements.forEach((t, r) => {
+      const s = typeof e == "string" ? document.createElement(e) : r === 0 ? e : e.cloneNode(!0);
+      t.parentNode?.insertBefore(s, t), s.appendChild(t);
+    }), this;
+  }
+  /**
+   * Remove the parent element of each element, keeping the elements in place.
+   *
+   * **Important**: This method unwraps ALL children of each parent element,
+   * not just the elements in the collection. If you call `unwrap()` on a
+   * collection containing only some children of a parent, all siblings will
+   * also be unwrapped. This behavior is consistent with jQuery's `.unwrap()`.
+   *
+   * @returns The collection for chaining
+   *
+   * @example
+   * ```ts
+   * // HTML: <div><section><span>A</span><span>B</span></section></div>
+   * const spans = $$('span');
+   * spans.unwrap(); // Removes <section>, both spans move to <div>
+   * // Result: <div><span>A</span><span>B</span></div>
+   * ```
+   */
+  unwrap() {
+    const e = /* @__PURE__ */ new Set();
+    for (const t of this.elements)
+      t.parentElement && e.add(t.parentElement);
+    return e.forEach((t) => {
+      const r = t.parentNode;
+      if (r) {
+        for (; t.firstChild; )
+          r.insertBefore(t.firstChild, t);
+        t.remove();
+      }
+    }), this;
+  }
+  /** Replace each element with provided content. */
+  replaceWith(e) {
+    const t = [];
+    return this.elements.forEach((r, s) => {
+      const i = typeof e == "string" ? y(e) : s === 0 ? e : e.cloneNode(!0);
+      r.replaceWith(i), t.push(i);
+    }), new c(t);
+  }
   /**
    * Shows all elements.
    *
@@ -756,7 +840,7 @@ class m {
    * @returns The instance for method chaining
    */
   on(e, t) {
-    return o(this.elements, (n) => n.addEventListener(e, t)), this;
+    return o(this.elements, (r) => r.addEventListener(e, t)), this;
   }
   /**
    * Adds a one-time event listener to all elements.
@@ -766,7 +850,7 @@ class m {
    * @returns The instance for method chaining
    */
   once(e, t) {
-    return o(this.elements, (n) => n.addEventListener(e, t, { once: !0 })), this;
+    return o(this.elements, (r) => r.addEventListener(e, t, { once: !0 })), this;
   }
   /**
    * Removes an event listener from all elements.
@@ -776,7 +860,7 @@ class m {
    * @returns The instance for method chaining
    */
   off(e, t) {
-    return o(this.elements, (n) => n.removeEventListener(e, t)), this;
+    return o(this.elements, (r) => r.removeEventListener(e, t)), this;
   }
   /**
    * Triggers a custom event on all elements.
@@ -786,8 +870,8 @@ class m {
    * @returns The instance for method chaining
    */
   trigger(e, t) {
-    return o(this.elements, (n) => {
-      n.dispatchEvent(new CustomEvent(e, { detail: t, bubbles: !0, cancelable: !0 }));
+    return o(this.elements, (r) => {
+      r.dispatchEvent(new CustomEvent(e, { detail: t, bubbles: !0, cancelable: !0 }));
     }), this;
   }
   /**
@@ -810,16 +894,16 @@ class m {
    * $$('.container').undelegate('click', '.item', handler);
    * ```
    */
-  delegate(e, t, n) {
+  delegate(e, t, r) {
     const s = `${e}:${t}`;
     return o(this.elements, (i) => {
-      const l = (u) => {
-        const d = u.target.closest(t);
-        d && i.contains(d) && n(u, d);
+      const l = (a) => {
+        const m = a.target.closest(t);
+        m && i.contains(m) && r(a, m);
       };
       this.delegatedHandlers.has(i) || this.delegatedHandlers.set(i, /* @__PURE__ */ new Map());
-      const h = this.delegatedHandlers.get(i);
-      h.has(s) || h.set(s, /* @__PURE__ */ new Map()), h.get(s).set(n, l), i.addEventListener(e, l);
+      const u = this.delegatedHandlers.get(i);
+      u.has(s) || u.set(s, /* @__PURE__ */ new Map()), u.get(s).set(r, l), i.addEventListener(e, l);
     }), this;
   }
   /**
@@ -839,15 +923,15 @@ class m {
    * $$('.container').undelegate('click', '.item', handler);
    * ```
    */
-  undelegate(e, t, n) {
+  undelegate(e, t, r) {
     const s = `${e}:${t}`;
     return o(this.elements, (i) => {
       const l = this.delegatedHandlers.get(i);
       if (!l) return;
-      const h = l.get(s);
-      if (!h) return;
-      const u = h.get(n);
-      u && (i.removeEventListener(e, u), h.delete(n), h.size === 0 && l.delete(s), l.size === 0 && this.delegatedHandlers.delete(i));
+      const u = l.get(s);
+      if (!u) return;
+      const a = u.get(r);
+      a && (i.removeEventListener(e, a), u.delete(r), u.size === 0 && l.delete(s), l.size === 0 && this.delegatedHandlers.delete(i));
     }), this;
   }
   /**
@@ -868,391 +952,270 @@ class m {
       e.innerHTML = "";
     }), this;
   }
+  /** @internal */
+  insertAll(e, t) {
+    if (typeof e == "string") {
+      const s = p(e);
+      o(this.elements, (i) => {
+        i.insertAdjacentHTML(t, s);
+      });
+      return;
+    }
+    const r = g(e);
+    this.elements.forEach((s, i) => {
+      const l = i === 0 ? r : r.map((u) => u.cloneNode(!0));
+      b(s, l, t);
+    });
+  }
 }
-const y = (r) => {
-  if (typeof r != "string")
-    return new a(r);
-  const e = document.querySelector(r);
+const oe = (n) => {
+  if (typeof n != "string")
+    return new h(n);
+  const e = document.querySelector(n);
   if (!e)
-    throw new Error(`bQuery: element not found for selector "${r}"`);
-  return new a(e);
-}, b = (r) => Array.isArray(r) ? new m(r) : r instanceof NodeList ? new m(Array.from(r)) : new m(Array.from(document.querySelectorAll(r))), c = {
-  /**
-   * Creates a deep clone using structuredClone if available, otherwise fallback to JSON.
-   *
-   * @template T - The type of value being cloned
-   * @param value - The value to clone
-   * @returns A deep copy of the value
-   *
-   * @example
-   * ```ts
-   * const original = { nested: { value: 1 } };
-   * const copy = utils.clone(original);
-   * copy.nested.value = 2;
-   * console.log(original.nested.value); // 1
-   * ```
-   */
-  clone(r) {
-    return typeof structuredClone == "function" ? structuredClone(r) : JSON.parse(JSON.stringify(r));
-  },
-  /**
-   * Deep-merges plain objects into a new object.
-   * Later sources override earlier ones for primitive values.
-   * Objects are recursively merged.
-   *
-   * @template T - The type of the merged object
-   * @param sources - Objects to merge
-   * @returns A new object with all sources merged
-   *
-   * @example
-   * ```ts
-   * const result = utils.merge(
-   *   { a: 1, nested: { x: 1 } },
-   *   { b: 2, nested: { y: 2 } }
-   * );
-   * // Result: { a: 1, b: 2, nested: { x: 1, y: 2 } }
-   * ```
-   *
-   * @security This method is protected against prototype pollution attacks.
-   * Keys like `__proto__`, `constructor`, and `prototype` are ignored.
-   */
-  merge(...r) {
-    const e = {};
-    for (const t of r)
-      for (const [n, s] of Object.entries(t))
-        c.isPrototypePollutionKey(n) || (c.isPlainObject(s) && c.isPlainObject(e[n]) ? e[n] = c.merge(
-          e[n],
-          s
-        ) : e[n] = s);
+    throw new Error(`bQuery: element not found for selector "${n}"`);
+  return new h(e);
+}, le = (n) => Array.isArray(n) ? new c(n) : n instanceof NodeList ? new c(Array.from(n)) : new c(Array.from(document.querySelectorAll(n)));
+function E(n) {
+  return n == null ? [] : Array.isArray(n) ? n : [n];
+}
+function C(n) {
+  return Array.from(new Set(n));
+}
+function L(n, e) {
+  if (e <= 0) return [];
+  const t = [];
+  for (let r = 0; r < n.length; r += e)
+    t.push(n.slice(r, r + e));
+  return t;
+}
+function H(n) {
+  return n.filter(Boolean);
+}
+function v(n) {
+  const e = [];
+  for (const t of n)
+    Array.isArray(t) ? e.push(...t) : e.push(t);
+  return e;
+}
+function N(n, e) {
+  let t;
+  return (...r) => {
+    t && clearTimeout(t), t = setTimeout(() => n(...r), e);
+  };
+}
+function $(n, e) {
+  let t = 0;
+  return (...r) => {
+    const s = Date.now();
+    s - t >= e && (t = s, n(...r));
+  };
+}
+function M(n) {
+  let e = !1, t;
+  return (...r) => (e || (t = n(...r), e = !0), t);
+}
+function S() {
+}
+function j(n = "bQuery") {
+  return `${n}_${Math.random().toString(36).slice(2, 9)}`;
+}
+function O(n) {
+  return new Promise((e) => setTimeout(e, n));
+}
+function T(n, e) {
+  try {
+    return JSON.parse(n);
+  } catch {
     return e;
-  },
-  /**
-   * Checks if a key could cause prototype pollution.
-   * These keys are dangerous when used in object merging operations.
-   *
-   * @param key - The key to check
-   * @returns True if the key is a prototype pollution vector
-   *
-   * @internal
-   */
-  isPrototypePollutionKey(r) {
-    return r === "__proto__" || r === "constructor" || r === "prototype";
-  },
-  /**
-   * Creates a debounced function that delays execution until after
-   * the specified delay has elapsed since the last call.
-   *
-   * @template TArgs - The argument types of the function
-   * @param fn - The function to debounce
-   * @param delayMs - Delay in milliseconds
-   * @returns A debounced version of the function
-   *
-   * @example
-   * ```ts
-   * const search = utils.debounce((query: string) => {
-   *   console.log('Searching:', query);
-   * }, 300);
-   *
-   * search('h');
-   * search('he');
-   * search('hello'); // Only this call executes after 300ms
-   * ```
-   */
-  debounce(r, e) {
-    let t;
-    return (...n) => {
-      t && clearTimeout(t), t = setTimeout(() => r(...n), e);
-    };
-  },
-  /**
-   * Creates a throttled function that runs at most once per interval.
-   *
-   * @template TArgs - The argument types of the function
-   * @param fn - The function to throttle
-   * @param intervalMs - Minimum interval between calls in milliseconds
-   * @returns A throttled version of the function
-   *
-   * @example
-   * ```ts
-   * const handleScroll = utils.throttle(() => {
-   *   console.log('Scroll position:', window.scrollY);
-   * }, 100);
-   *
-   * window.addEventListener('scroll', handleScroll);
-   * ```
-   */
-  throttle(r, e) {
-    let t = 0;
-    return (...n) => {
-      const s = Date.now();
-      s - t >= e && (t = s, r(...n));
-    };
-  },
-  /**
-   * Creates a stable unique ID for DOM usage.
-   *
-   * @param prefix - Optional prefix for the ID (default: 'bQuery')
-   * @returns A unique identifier string
-   *
-   * @example
-   * ```ts
-   * const id = utils.uid('modal'); // 'modal_x7k2m9p'
-   * ```
-   */
-  uid(r = "bQuery") {
-    return `${r}_${Math.random().toString(36).slice(2, 9)}`;
-  },
-  /**
-   * Checks if a value is a DOM Element.
-   *
-   * @param value - The value to check
-   * @returns True if the value is an Element
-   */
-  isElement(r) {
-    return r instanceof Element;
-  },
-  /**
-   * Checks if a value is a BQueryCollection-like object.
-   *
-   * @param value - The value to check
-   * @returns True if the value has an elements array property
-   */
-  isCollection(r) {
-    return !!(r && typeof r == "object" && "elements" in r);
-  },
-  /**
-   * Checks for emptiness across common value types.
-   *
-   * @param value - The value to check
-   * @returns True if the value is empty (null, undefined, empty string, empty array, or empty object)
-   *
-   * @example
-   * ```ts
-   * utils.isEmpty('');       // true
-   * utils.isEmpty([]);       // true
-   * utils.isEmpty({});       // true
-   * utils.isEmpty(null);     // true
-   * utils.isEmpty('hello');  // false
-   * utils.isEmpty([1, 2]);   // false
-   * ```
-   */
-  isEmpty(r) {
-    return r == null ? !0 : typeof r == "string" ? r.trim().length === 0 : Array.isArray(r) ? r.length === 0 : typeof r == "object" ? Object.keys(r).length === 0 : !1;
-  },
-  /**
-   * Checks if a value is a plain object (not null, array, or class instance).
-   *
-   * @param value - The value to check
-   * @returns True if the value is a plain object
-   */
-  isPlainObject(r) {
-    return Object.prototype.toString.call(r) === "[object Object]";
-  },
-  /**
-   * Checks if a value is a function.
-   *
-   * @param value - The value to check
-   * @returns True if the value is a function
-   */
-  isFunction(r) {
-    return typeof r == "function";
-  },
-  /**
-   * Checks if a value is a string.
-   *
-   * @param value - The value to check
-   * @returns True if the value is a string
-   */
-  isString(r) {
-    return typeof r == "string";
-  },
-  /**
-   * Checks if a value is a number (excluding NaN).
-   *
-   * @param value - The value to check
-   * @returns True if the value is a valid number
-   */
-  isNumber(r) {
-    return typeof r == "number" && !Number.isNaN(r);
-  },
-  /**
-   * Checks if a value is a boolean.
-   *
-   * @param value - The value to check
-   * @returns True if the value is a boolean
-   */
-  isBoolean(r) {
-    return typeof r == "boolean";
-  },
-  /**
-   * Checks if a value is an array.
-   *
-   * @template T - The type of array elements
-   * @param value - The value to check
-   * @returns True if the value is an array
-   */
-  isArray(r) {
-    return Array.isArray(r);
-  },
-  /**
-   * Safely parses a JSON string, returning a default value on error.
-   *
-   * @template T - The expected type of the parsed value
-   * @param json - The JSON string to parse
-   * @param fallback - The default value if parsing fails
-   * @returns The parsed value or the fallback
-   *
-   * @example
-   * ```ts
-   * utils.parseJson('{"name":"bQuery"}', {}); // { name: 'bQuery' }
-   * utils.parseJson('invalid', {}); // {}
-   * ```
-   */
-  parseJson(r, e) {
-    try {
-      return JSON.parse(r);
-    } catch {
-      return e;
-    }
-  },
-  /**
-   * Picks specified keys from an object.
-   *
-   * @template T - The object type
-   * @template K - The key type
-   * @param obj - The source object
-   * @param keys - Keys to pick
-   * @returns A new object with only the specified keys
-   *
-   * @example
-   * ```ts
-   * const user = { name: 'John', age: 30, email: 'john@example.com' };
-   * utils.pick(user, ['name', 'email']); // { name: 'John', email: 'john@example.com' }
-   * ```
-   */
-  pick(r, e) {
-    const t = {};
-    for (const n of e)
-      n in r && (t[n] = r[n]);
-    return t;
-  },
-  /**
-   * Omits specified keys from an object.
-   *
-   * @template T - The object type
-   * @template K - The key type
-   * @param obj - The source object
-   * @param keys - Keys to omit
-   * @returns A new object without the specified keys
-   *
-   * @example
-   * ```ts
-   * const user = { name: 'John', age: 30, password: 'secret' };
-   * utils.omit(user, ['password']); // { name: 'John', age: 30 }
-   * ```
-   */
-  omit(r, e) {
-    const t = { ...r };
-    for (const n of e)
-      delete t[n];
-    return t;
-  },
-  /**
-   * Delays execution for a specified number of milliseconds.
-   *
-   * @param ms - Milliseconds to delay
-   * @returns A promise that resolves after the delay
-   *
-   * @example
-   * ```ts
-   * await utils.sleep(1000); // Wait 1 second
-   * console.log('Done!');
-   * ```
-   */
-  sleep(r) {
-    return new Promise((e) => setTimeout(e, r));
-  },
-  /**
-   * Generates a random integer between min and max (inclusive).
-   *
-   * @param min - Minimum value
-   * @param max - Maximum value
-   * @returns A random integer in the range [min, max]
-   *
-   * @example
-   * ```ts
-   * const roll = utils.randomInt(1, 6); // Random dice roll
-   * ```
-   */
-  randomInt(r, e) {
-    return Math.floor(Math.random() * (e - r + 1)) + r;
-  },
-  /**
-   * Clamps a number between a minimum and maximum value.
-   *
-   * @param value - The value to clamp
-   * @param min - Minimum value
-   * @param max - Maximum value
-   * @returns The clamped value
-   *
-   * @example
-   * ```ts
-   * utils.clamp(150, 0, 100); // 100
-   * utils.clamp(-10, 0, 100); // 0
-   * utils.clamp(50, 0, 100);  // 50
-   * ```
-   */
-  clamp(r, e, t) {
-    return Math.min(Math.max(r, e), t);
-  },
-  /**
-   * Capitalizes the first letter of a string.
-   *
-   * @param str - The string to capitalize
-   * @returns The capitalized string
-   *
-   * @example
-   * ```ts
-   * utils.capitalize('hello'); // 'Hello'
-   * ```
-   */
-  capitalize(r) {
-    return r && r.charAt(0).toUpperCase() + r.slice(1);
-  },
-  /**
-   * Converts a string to kebab-case.
-   *
-   * @param str - The string to convert
-   * @returns The kebab-cased string
-   *
-   * @example
-   * ```ts
-   * utils.toKebabCase('myVariableName'); // 'my-variable-name'
-   * ```
-   */
-  toKebabCase(r) {
-    return r.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-  },
-  /**
-   * Converts a string to camelCase.
-   *
-   * @param str - The string to convert
-   * @returns The camelCased string
-   *
-   * @example
-   * ```ts
-   * utils.toCamelCase('my-variable-name'); // 'myVariableName'
-   * ```
-   */
-  toCamelCase(r) {
-    return r.replace(/[-_\s]+(.)?/g, (e, t) => t ? t.toUpperCase() : "").replace(/^[A-Z]/, (e) => e.toLowerCase());
   }
+}
+function k(n) {
+  return n == null ? !0 : typeof n == "string" ? n.trim().length === 0 : Array.isArray(n) ? n.length === 0 : typeof n == "object" ? Object.keys(n).length === 0 : !1;
+}
+function P(n, e) {
+  return Math.floor(Math.random() * (e - n + 1)) + n;
+}
+function z(n, e, t) {
+  return Math.min(Math.max(n, e), t);
+}
+function x(n, e, t, r = !0) {
+  return r ? n >= e && n <= t : n > e && n < t;
+}
+function q(n, e = 0) {
+  const t = typeof n == "number" ? n : Number(n);
+  return Number.isNaN(t) ? e : t;
+}
+function d(n) {
+  return Object.prototype.toString.call(n) === "[object Object]";
+}
+function D(n) {
+  return n === "__proto__" || n === "constructor" || n === "prototype";
+}
+function R(n) {
+  return typeof structuredClone == "function" ? structuredClone(n) : JSON.parse(JSON.stringify(n));
+}
+function A(...n) {
+  const e = {};
+  for (const t of n)
+    for (const [r, s] of Object.entries(t))
+      D(r) || (d(s) && d(e[r]) ? e[r] = A(
+        e[r],
+        s
+      ) : e[r] = s);
+  return e;
+}
+function B(n, e) {
+  const t = {};
+  for (const r of e)
+    r in n && (t[r] = n[r]);
+  return t;
+}
+function W(n, e) {
+  const t = { ...n };
+  for (const r of e)
+    delete t[r];
+  return t;
+}
+function F(n, e) {
+  return Object.prototype.hasOwnProperty.call(n, e);
+}
+function U(n) {
+  return n && n.charAt(0).toUpperCase() + n.slice(1);
+}
+function _(n) {
+  return n.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function J(n) {
+  return n.replace(/[-_\s]+(.)?/g, (e, t) => t ? t.toUpperCase() : "").replace(/^[A-Z]/, (e) => e.toLowerCase());
+}
+function I(n, e, t = "…") {
+  if (e <= 0) return "";
+  if (n.length <= e) return n;
+  const r = Math.max(0, e - t.length);
+  return `${n.slice(0, r)}${t}`;
+}
+function Z(n) {
+  return n.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^\w\s-]/g, "").trim().replace(/[\s_-]+/g, "-").toLowerCase();
+}
+function K(n) {
+  return n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function G(n) {
+  return typeof Element < "u" && n instanceof Element;
+}
+function Q(n) {
+  return !!(n && typeof n == "object" && "elements" in n);
+}
+function V(n) {
+  return typeof n == "function";
+}
+function X(n) {
+  return typeof n == "string";
+}
+function Y(n) {
+  return typeof n == "number" && !Number.isNaN(n);
+}
+function ee(n) {
+  return typeof n == "boolean";
+}
+function te(n) {
+  return Array.isArray(n);
+}
+function ne(n) {
+  return n instanceof Date;
+}
+function re(n) {
+  return !!(n && (n instanceof Promise || typeof n == "object" && "then" in n && typeof n.then == "function"));
+}
+function se(n) {
+  return typeof n == "object" && n !== null;
+}
+const ue = {
+  clone: R,
+  merge: A,
+  pick: B,
+  omit: W,
+  hasOwn: F,
+  debounce: N,
+  throttle: $,
+  once: M,
+  noop: S,
+  uid: j,
+  isElement: G,
+  isCollection: Q,
+  isEmpty: k,
+  isPlainObject: d,
+  isFunction: V,
+  isString: X,
+  isNumber: Y,
+  isBoolean: ee,
+  isArray: te,
+  isDate: ne,
+  isPromise: re,
+  isObject: se,
+  parseJson: T,
+  sleep: O,
+  randomInt: P,
+  clamp: z,
+  inRange: x,
+  toNumber: q,
+  capitalize: U,
+  toKebabCase: _,
+  toCamelCase: J,
+  truncate: I,
+  slugify: Z,
+  escapeRegExp: K,
+  ensureArray: E,
+  unique: C,
+  chunk: L,
+  compact: H,
+  flatten: v
 };
 export {
-  y as $,
-  b as $$,
-  m as BQueryCollection,
-  a as BQueryElement,
-  c as utils
+  oe as $,
+  le as $$,
+  c as BQueryCollection,
+  h as BQueryElement,
+  U as capitalize,
+  L as chunk,
+  z as clamp,
+  R as clone,
+  H as compact,
+  N as debounce,
+  E as ensureArray,
+  K as escapeRegExp,
+  v as flatten,
+  F as hasOwn,
+  x as inRange,
+  te as isArray,
+  ee as isBoolean,
+  Q as isCollection,
+  ne as isDate,
+  G as isElement,
+  k as isEmpty,
+  V as isFunction,
+  Y as isNumber,
+  se as isObject,
+  d as isPlainObject,
+  re as isPromise,
+  X as isString,
+  A as merge,
+  S as noop,
+  W as omit,
+  M as once,
+  T as parseJson,
+  B as pick,
+  P as randomInt,
+  O as sleep,
+  Z as slugify,
+  $ as throttle,
+  J as toCamelCase,
+  _ as toKebabCase,
+  q as toNumber,
+  I as truncate,
+  j as uid,
+  C as unique,
+  ue as utils
 };
 //# sourceMappingURL=core.es.mjs.map