@bquery/bquery 1.0.0

package/dist/core.es.mjs

@@ -0,0 +1,1015 @@
+import { sanitize as u } from "./security.es.mjs";
+const a = (r) => Array.isArray(r) ? r : [r], s = (r, e) => {
+  for (const t of r)
+    e(t);
+};
+class o {
+  /**
+   * Creates a new BQueryElement wrapper.
+   * @param element - The DOM element to wrap
+   */
+  constructor(e) {
+    this.element = e;
+  }
+  /**
+   * Exposes the raw DOM element when direct access is needed.
+   * Use sparingly; prefer the wrapper methods for consistency.
+   */
+  get raw() {
+    return this.element;
+  }
+  /**
+   * Exposes the underlying DOM element.
+   * Provided for spec compatibility and read-only access.
+   */
+  get node() {
+    return this.element;
+  }
+  /** Add one or more classes. */
+  addClass(...e) {
+    return this.element.classList.add(...e), this;
+  }
+  /** Remove one or more classes. */
+  removeClass(...e) {
+    return this.element.classList.remove(...e), this;
+  }
+  /** Toggle a class by name. */
+  toggleClass(e, t) {
+    return this.element.classList.toggle(e, t), this;
+  }
+  /** Get or set an attribute. */
+  attr(e, t) {
+    return t === void 0 ? this.element.getAttribute(e) ?? "" : (this.element.setAttribute(e, t), 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, (i) => `-${i.toLowerCase()}`);
+    return t === void 0 ? this.element.getAttribute(`data-${n}`) ?? "" : (this.element.setAttribute(`data-${n}`, t), this);
+  }
+  /** Get or set text content. */
+  text(e) {
+    return e === void 0 ? this.element.textContent ?? "" : (this.element.textContent = e, this);
+  }
+  /** Set HTML content using a sanitized string. */
+  /**
+   * Sets sanitized HTML content on the element.
+   * Uses the security module to sanitize input and prevent XSS attacks.
+   *
+   * @param value - The HTML string to set (will be sanitized)
+   * @returns The instance for method chaining
+   *
+   * @example
+   * ```ts
+   * $('#content').html('<strong>Hello</strong>');
+   * ```
+   */
+  html(e) {
+    return this.element.innerHTML = u(e), this;
+  }
+  /**
+   * Sets HTML content without sanitization.
+   * Use only when you trust the HTML source completely.
+   *
+   * @param value - The raw HTML string to set
+   * @returns The instance for method chaining
+   *
+   * @warning This method bypasses XSS protection. Use with caution.
+   */
+  htmlUnsafe(e) {
+    return this.element.innerHTML = e, this;
+  }
+  /**
+   * Gets or sets CSS styles on the element.
+   *
+   * @param property - A CSS property name or an object of property-value pairs
+   * @param value - The value when setting a single property
+   * @returns The instance for method chaining
+   *
+   * @example
+   * ```ts
+   * // Single property
+   * $('#box').css('color', 'red');
+   *
+   * // Multiple properties
+   * $('#box').css({ color: 'red', 'font-size': '16px' });
+   * ```
+   */
+  css(e, t) {
+    if (typeof e == "string")
+      return t !== void 0 && this.element.style.setProperty(e, t), this;
+    for (const [n, i] of Object.entries(e))
+      this.element.style.setProperty(n, i);
+    return this;
+  }
+  /**
+   * Appends HTML or elements to the end of the element.
+   *
+   * @param content - HTML string or element(s) to append
+   * @returns The instance for method chaining
+   */
+  append(e) {
+    return this.insertContent(e, "beforeend"), this;
+  }
+  /**
+   * Prepends HTML or elements to the beginning of the element.
+   *
+   * @param content - HTML string or element(s) to prepend
+   * @returns The instance for method chaining
+   */
+  prepend(e) {
+    return this.insertContent(e, "afterbegin"), this;
+  }
+  /**
+   * Inserts content before this element.
+   *
+   * @param content - HTML string or element(s) to insert
+   * @returns The instance for method chaining
+   */
+  before(e) {
+    return this.insertContent(e, "beforebegin"), this;
+  }
+  /**
+   * Inserts content after this element.
+   *
+   * @param content - HTML string or element(s) to insert
+   * @returns The instance for method chaining
+   */
+  after(e) {
+    return this.insertContent(e, "afterend"), this;
+  }
+  /**
+   * Removes the element from the DOM.
+   *
+   * @returns The instance for method chaining (though element is now detached)
+   */
+  remove() {
+    return this.element.remove(), this;
+  }
+  /**
+   * Clears all child nodes from the element.
+   *
+   * @returns The instance for method chaining
+   */
+  empty() {
+    return this.element.innerHTML = "", this;
+  }
+  /**
+   * Clones the element, optionally with all descendants.
+   *
+   * @param deep - If true, clone all descendants (default: true)
+   * @returns A new BQueryElement wrapping the cloned element
+   */
+  clone(e = !0) {
+    return new o(this.element.cloneNode(e));
+  }
+  /**
+   * Finds all descendant elements matching the selector.
+   *
+   * @param selector - CSS selector to match
+   * @returns Array of matching elements
+   */
+  find(e) {
+    return Array.from(this.element.querySelectorAll(e));
+  }
+  /**
+   * Finds the first descendant element matching the selector.
+   *
+   * @param selector - CSS selector to match
+   * @returns The first matching element or null
+   */
+  findOne(e) {
+    return this.element.querySelector(e);
+  }
+  /**
+   * Finds the closest ancestor matching the selector.
+   *
+   * @param selector - CSS selector to match
+   * @returns The matching ancestor or null
+   */
+  closest(e) {
+    return this.element.closest(e);
+  }
+  /**
+   * Gets the parent element.
+   *
+   * @returns The parent element or null
+   */
+  parent() {
+    return this.element.parentElement;
+  }
+  /**
+   * Gets all child elements.
+   *
+   * @returns Array of child elements
+   */
+  children() {
+    return Array.from(this.element.children);
+  }
+  /**
+   * Gets all sibling elements.
+   *
+   * @returns Array of sibling elements (excluding this element)
+   */
+  siblings() {
+    const e = this.element.parentElement;
+    return e ? Array.from(e.children).filter((t) => t !== this.element) : [];
+  }
+  /**
+   * Gets the next sibling element.
+   *
+   * @returns The next sibling element or null
+   */
+  next() {
+    return this.element.nextElementSibling;
+  }
+  /**
+   * Gets the previous sibling element.
+   *
+   * @returns The previous sibling element or null
+   */
+  prev() {
+    return this.element.previousElementSibling;
+  }
+  /**
+   * Adds an event listener.
+   *
+   * @param event - Event type to listen for
+   * @param handler - Event handler function
+   * @returns The instance for method chaining
+   */
+  on(e, t) {
+    return this.element.addEventListener(e, t), this;
+  }
+  /**
+   * Adds a one-time event listener that removes itself after firing.
+   *
+   * @param event - Event type to listen for
+   * @param handler - Event handler function
+   * @returns The instance for method chaining
+   */
+  once(e, t) {
+    return this.element.addEventListener(e, t, { once: !0 }), this;
+  }
+  /**
+   * Removes an event listener.
+   *
+   * @param event - Event type
+   * @param handler - The handler to remove
+   * @returns The instance for method chaining
+   */
+  off(e, t) {
+    return this.element.removeEventListener(e, t), this;
+  }
+  /**
+   * Triggers a custom event on the element.
+   *
+   * @param event - Event type to trigger
+   * @param detail - Optional detail data to include with the event
+   * @returns The instance for method chaining
+   */
+  trigger(e, t) {
+    return this.element.dispatchEvent(new CustomEvent(e, { detail: t, bubbles: !0, cancelable: !0 })), this;
+  }
+  /**
+   * Checks if the element matches a CSS selector.
+   *
+   * @param selector - CSS selector to match against
+   * @returns True if the element matches the selector
+   */
+  matches(e) {
+    return this.element.matches(e);
+  }
+  /**
+   * Checks if the element has a specific class.
+   *
+   * @param className - Class name to check
+   * @returns True if the element has the class
+   */
+  hasClass(e) {
+    return this.element.classList.contains(e);
+  }
+  /**
+   * Shows the element by removing the hidden attribute and setting display.
+   *
+   * @param display - Optional display value (default: '')
+   * @returns The instance for method chaining
+   */
+  show(e = "") {
+    return this.element.removeAttribute("hidden"), this.element.style.display = e, this;
+  }
+  /**
+   * Hides the element by setting display to 'none'.
+   *
+   * @returns The instance for method chaining
+   */
+  hide() {
+    return this.element.style.display = "none", this;
+  }
+  /**
+   * Toggles the visibility of the element.
+   *
+   * @param force - Optional force show (true) or hide (false)
+   * @returns The instance for method chaining
+   */
+  toggle(e) {
+    const t = this.element.style.display === "none";
+    return e ?? t ? this.show() : this.hide();
+  }
+  /**
+   * Focuses the element.
+   *
+   * @returns The instance for method chaining
+   */
+  focus() {
+    return this.element.focus(), this;
+  }
+  /**
+   * Blurs (unfocuses) the element.
+   *
+   * @returns The instance for method chaining
+   */
+  blur() {
+    return this.element.blur(), this;
+  }
+  /**
+   * Gets or sets the value of form elements.
+   *
+   * @param newValue - Optional value to set
+   * @returns The current value when getting, or the instance when setting
+   */
+  val(e) {
+    const t = this.element;
+    return e === void 0 ? t.value ?? "" : (t.value = e, this);
+  }
+  /**
+   * Gets the bounding client rectangle of the element.
+   *
+   * @returns The element's bounding rectangle
+   */
+  rect() {
+    return this.element.getBoundingClientRect();
+  }
+  /**
+   * Gets the offset dimensions (width, height, top, left).
+   *
+   * @returns Object with offset dimensions
+   */
+  offset() {
+    const e = this.element;
+    return {
+      width: e.offsetWidth,
+      height: e.offsetHeight,
+      top: e.offsetTop,
+      left: e.offsetLeft
+    };
+  }
+  /**
+   * Internal method to insert content at a specified position.
+   * @internal
+   */
+  insertContent(e, t) {
+    if (typeof e == "string") {
+      this.element.insertAdjacentHTML(t, u(e));
+      return;
+    }
+    const n = a(e);
+    s(n, (i) => {
+      this.element.insertAdjacentElement(t, i);
+    });
+  }
+}
+class l {
+  /**
+   * Creates a new collection wrapper.
+   * @param elements - Array of DOM elements to wrap
+   */
+  constructor(e) {
+    this.elements = e;
+  }
+  /**
+   * Gets the number of elements in the collection.
+   */
+  get length() {
+    return this.elements.length;
+  }
+  /**
+   * Gets the first element in the collection, if any.
+   * @internal
+   */
+  first() {
+    return this.elements[0];
+  }
+  /**
+   * Gets a single element as a BQueryElement wrapper.
+   *
+   * @param index - Zero-based index of the element
+   * @returns BQueryElement wrapper or undefined if out of range
+   */
+  eq(e) {
+    const t = this.elements[e];
+    return t ? new o(t) : void 0;
+  }
+  /**
+   * Gets the first element as a BQueryElement wrapper.
+   *
+   * @returns BQueryElement wrapper or undefined if empty
+   */
+  firstEl() {
+    return this.eq(0);
+  }
+  /**
+   * Gets the last element as a BQueryElement wrapper.
+   *
+   * @returns BQueryElement wrapper or undefined if empty
+   */
+  lastEl() {
+    return this.eq(this.elements.length - 1);
+  }
+  /**
+   * Iterates over each element in the collection.
+   *
+   * @param callback - Function to call for each wrapped element
+   * @returns The instance for method chaining
+   */
+  each(e) {
+    return this.elements.forEach((t, n) => {
+      e(new o(t), n);
+    }), this;
+  }
+  /**
+   * Maps each element to a new value.
+   *
+   * @param callback - Function to transform each element
+   * @returns Array of transformed values
+   */
+  map(e) {
+    return this.elements.map(e);
+  }
+  /**
+   * Filters elements based on a predicate.
+   *
+   * @param predicate - Function to test each element
+   * @returns New BQueryCollection with matching elements
+   */
+  filter(e) {
+    return new l(this.elements.filter(e));
+  }
+  /**
+   * Reduces the collection to a single value.
+   *
+   * @param callback - Reducer function
+   * @param initialValue - Initial accumulator value
+   * @returns Accumulated result
+   */
+  reduce(e, t) {
+    return this.elements.reduce(e, t);
+  }
+  /**
+   * Converts the collection to an array of BQueryElement wrappers.
+   *
+   * @returns Array of BQueryElement instances
+   */
+  toArray() {
+    return this.elements.map((e) => new o(e));
+  }
+  /** Add one or more classes to all elements. */
+  addClass(...e) {
+    return s(this.elements, (t) => t.classList.add(...e)), this;
+  }
+  /** Remove one or more classes from all elements. */
+  removeClass(...e) {
+    return s(this.elements, (t) => t.classList.remove(...e)), this;
+  }
+  /** Toggle a class on all elements. */
+  toggleClass(e, t) {
+    return s(this.elements, (n) => n.classList.toggle(e, t)), this;
+  }
+  /**
+   * Sets an attribute on all elements or gets from first.
+   *
+   * @param name - Attribute name
+   * @param value - Value to set (optional)
+   * @returns Attribute value when getting, instance when setting
+   */
+  attr(e, t) {
+    return t === void 0 ? this.first()?.getAttribute(e) ?? "" : (s(this.elements, (n) => n.setAttribute(e, t)), this);
+  }
+  /**
+   * Removes an attribute from all elements.
+   *
+   * @param name - Attribute name to remove
+   * @returns The instance for method chaining
+   */
+  removeAttr(e) {
+    return s(this.elements, (t) => t.removeAttribute(e)), this;
+  }
+  /**
+   * Sets text content on all elements or gets from first.
+   *
+   * @param value - Text to set (optional)
+   * @returns Text content when getting, instance when setting
+   */
+  text(e) {
+    return e === void 0 ? this.first()?.textContent ?? "" : (s(this.elements, (t) => {
+      t.textContent = e;
+    }), this);
+  }
+  /**
+   * Sets sanitized HTML on all elements or gets from first.
+   *
+   * @param value - HTML to set (optional, will be sanitized)
+   * @returns HTML content when getting, instance when setting
+   */
+  html(e) {
+    if (e === void 0)
+      return this.first()?.innerHTML ?? "";
+    const t = u(e);
+    return s(this.elements, (n) => {
+      n.innerHTML = t;
+    }), this;
+  }
+  /**
+   * Sets HTML on all elements without sanitization.
+   *
+   * @param value - Raw HTML to set
+   * @returns The instance for method chaining
+   * @warning Bypasses XSS protection
+   */
+  htmlUnsafe(e) {
+    return s(this.elements, (t) => {
+      t.innerHTML = e;
+    }), this;
+  }
+  /**
+   * Applies CSS styles to all elements.
+   *
+   * @param property - Property name or object of properties
+   * @param value - Value when setting single property
+   * @returns The instance for method chaining
+   */
+  css(e, t) {
+    return typeof e == "string" ? (t !== void 0 && s(this.elements, (n) => {
+      n.style.setProperty(e, t);
+    }), this) : (s(this.elements, (n) => {
+      for (const [i, m] of Object.entries(e))
+        n.style.setProperty(i, m);
+    }), this);
+  }
+  /**
+   * Shows all elements.
+   *
+   * @param display - Optional display value (default: '')
+   * @returns The instance for method chaining
+   */
+  show(e = "") {
+    return s(this.elements, (t) => {
+      t.removeAttribute("hidden"), t.style.display = e;
+    }), this;
+  }
+  /**
+   * Hides all elements.
+   *
+   * @returns The instance for method chaining
+   */
+  hide() {
+    return s(this.elements, (e) => {
+      e.style.display = "none";
+    }), this;
+  }
+  /**
+   * Adds an event listener to all elements.
+   *
+   * @param event - Event type
+   * @param handler - Event handler
+   * @returns The instance for method chaining
+   */
+  on(e, t) {
+    return s(this.elements, (n) => n.addEventListener(e, t)), this;
+  }
+  /**
+   * Adds a one-time event listener to all elements.
+   *
+   * @param event - Event type
+   * @param handler - Event handler
+   * @returns The instance for method chaining
+   */
+  once(e, t) {
+    return s(this.elements, (n) => n.addEventListener(e, t, { once: !0 })), this;
+  }
+  /**
+   * Removes an event listener from all elements.
+   *
+   * @param event - Event type
+   * @param handler - The handler to remove
+   * @returns The instance for method chaining
+   */
+  off(e, t) {
+    return s(this.elements, (n) => n.removeEventListener(e, t)), this;
+  }
+  /**
+   * Triggers a custom event on all elements.
+   *
+   * @param event - Event type
+   * @param detail - Optional event detail
+   * @returns The instance for method chaining
+   */
+  trigger(e, t) {
+    return s(this.elements, (n) => {
+      n.dispatchEvent(new CustomEvent(e, { detail: t, bubbles: !0, cancelable: !0 }));
+    }), this;
+  }
+  /**
+   * Removes all elements from the DOM.
+   *
+   * @returns The instance for method chaining
+   */
+  remove() {
+    return s(this.elements, (e) => e.remove()), this;
+  }
+  /**
+   * Clears all child nodes from all elements.
+   *
+   * @returns The instance for method chaining
+   */
+  empty() {
+    return s(this.elements, (e) => {
+      e.innerHTML = "";
+    }), this;
+  }
+}
+const f = (r) => {
+  if (typeof r != "string")
+    return new o(r);
+  const e = document.querySelector(r);
+  if (!e)
+    throw new Error(`bQuery: element not found for selector "${r}"`);
+  return new o(e);
+}, d = (r) => Array.isArray(r) ? new l(r) : r instanceof NodeList ? new l(Array.from(r)) : new l(Array.from(document.querySelectorAll(r))), h = {
+  /**
+   * 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 } }
+   * ```
+   */
+  merge(...r) {
+    const e = {};
+    for (const t of r)
+      for (const [n, i] of Object.entries(t))
+        h.isPlainObject(i) && h.isPlainObject(e[n]) ? e[n] = h.merge(
+          e[n],
+          i
+        ) : e[n] = i;
+    return e;
+  },
+  /**
+   * 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 i = Date.now();
+      i - t >= e && (t = i, 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());
+  }
+};
+export {
+  f as $,
+  d as $$,
+  l as BQueryCollection,
+  o as BQueryElement,
+  h as utils
+};
+//# sourceMappingURL=core.es.mjs.map