@splendidlabz/utils 1.10.2 → 1.10.3

package/dist/esm/dom/index.js

@@ -1,1168 +1,23 @@
-// src/dom/accessibility.js
-function hasAccessibleName(label, labelledBy) {
-  if (label || labelledBy) return true;
-  return false;
-}
-function checkForAccessibleName({
-  name,
-  ariaLabel,
-  ariaLabelledBy,
-  severity = "warn"
-} = {}) {
-  if (ariaLabel || ariaLabelledBy) return true;
-  const message = `${name} is missing an accessible name. Please provide an accessible name with 'aria-label' or 'aria-labelledby'.`;
-  if (severity === "warn") console.warn(message);
-  if (severity === "error") console.error(message);
-  return false;
-}
-function isInvalidAriaPopup(value) {
-  const allowedPopoupValues = ["dialog", "menu", "listbox", "grid", "tree"];
-  if (!allowedPopoupValues.includes(value)) return true;
-  return false;
-}
-
-// src/dom/get-element.js
-var astroNodes = ["ASTRO-SLOT", "ASTRO-ISLAND"];
-function getNodeType(node) {
-  if (node instanceof Element) return "element";
-  if (node instanceof NodeList) return "nodelist";
-  if (Array.isArray(node)) return "array";
-}
-function getElement(selector) {
-  if (!selector) return;
-  if (selector instanceof Element) return selector;
-  return document.querySelector(selector);
-}
-function getChildrenElements(node) {
-  let children = node.children;
-  if (children[0]?.nodeName === "ASTRO-SLOT") children = children[0].children;
-  return Array.from(children);
-}
-function getParentElement(element) {
-  const parent = element.parentElement;
-  if (astroNodes.includes(parent.nodeName)) return getParentElement(parent);
-  return parent;
-}
-function getSiblingElements(element) {
-  return Array.from(element.parentElement.children).filter(
-    (child) => child !== element
-  );
-}
-function getSelfIndex(element) {
-  return Array.from(element.parentElement.children).indexOf(element);
-}
-function isAncestor(ancestor, element, { searchLevels = 0 } = {}) {
-  if (ancestor === element) return true;
-  let parent = element.parentElement;
-  if (searchLevels === 0) {
-    while (parent) {
-      if (ancestor === parent) return true;
-      parent = parent.parentElement;
-    }
-  } else {
-    for (let i = 0; i < searchLevels; i++) {
-      if (ancestor === parent) return true;
-      parent = parent.parentElement;
-    }
-  }
-  return false;
-}
-function getAncestorWithSiblings(element, { limit = false } = {}) {
-  const ancestor = element.parentElement;
-  const siblings = getSiblingElements(ancestor);
-  if (siblings.length) return siblings;
-  if (!ancestor) return null;
-  if (limit === false) return getAncestorWithSiblings(ancestor);
-  if (typeof limit === "number" && limit > 0) {
-    return getAncestorWithSiblings(ancestor, { limit: limit - 1 });
-  }
-  if (limit === 0) return null;
-}
-
-// src/dom/media.js
-async function imagesLoaded(node) {
-  const images = Array.from(node.querySelectorAll("img"));
-  const promises = images.map((img) => {
-    return new Promise((resolve, reject) => {
-      if (img.complete) return resolve();
-      img.onload = resolve;
-      img.onerror = (e) => {
-        reject("Image failed to load");
-      };
-    });
-  });
-  return Promise.all(promises);
-}
-async function videosLoaded(node) {
-  const videos = Array.from(node.querySelectorAll("video"));
-  const promises = videos.map((video) => {
-    return new Promise((resolve, reject) => {
-      if (video.readyState === 4) return resolve();
-      video.onloadedmetadata = resolve;
-      video.onerror = reject;
-    });
-  });
-  return Promise.all(promises);
-}
-async function mediaLoaded(node) {
-  return Promise.all([imagesLoaded(node), videosLoaded(node)]);
-}
-
-// src/dom/events.js
-function addListeners(listeners) {
-  listeners.forEach(({ node, event, handler }) => {
-    node.addEventListener(event, handler);
-  });
-}
-function removeListeners(listeners) {
-  listeners.forEach(({ node, event, handler }) => {
-    node.removeEventListener(event, handler);
-  });
-}
-function dispatchEvent(node, eventName, detail, options = {}) {
-  node.dispatchEvent(
-    new CustomEvent(eventName, {
-      ...options,
-      detail
-    })
-  );
-}
-function updateEvent(event, updates) {
-  const { type, ...rest } = event;
-  return new CustomEvent(event.type, {
-    ...rest,
-    ...updates
-  });
-}
-
-// src/dom/observers/observer.js
-function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
-  const targetType = getNodeType(target);
-  if (targetType === "element") observer[method](target, options);
-  if (targetType === "nodelist") {
-    const elements = Array.from(target);
-    elements.forEach((element) => observer[method](element, options));
-  }
-  if (targetType === "array") {
-    target.forEach((element) => observer[method](element, options));
-  }
-}
-
-// src/dom/observers/resize-observer.js
-function resizeObserver(target, options) {
-  const { callback, ...opts } = options;
-  const observer = new ResizeObserver(observerFn);
-  if (target === window || target === document)
-    target = document.documentElement;
-  useObserverMethodOnTarget(target, observer, "observe", opts);
-  function observerFn(entries) {
-    for (const entry of entries) {
-      if (callback) callback({ entry, entries, observer });
-      else
-        dispatchEvent(entry.target, "resize-obs", { entry, entries, observer });
-    }
-  }
-  return {
-    observe(target2) {
-      useObserverMethodOnTarget(target2, observer, "observe", options);
-    },
-    unobserve(target2) {
-      useObserverMethodOnTarget(target2, observer, "unobserve");
-    },
-    disconnect: (_) => observer.disconnect(),
-    destroy: (_) => observer.disconnect()
-  };
-}
-
-// src/dom/actions/masonry.js
-async function masonry(node) {
-  if (nativeMasonrySupport(node)) return;
-  const colGap = parseFloat(getComputedStyle(node).columnGap);
-  const items = getChildrenElements(node);
-  node.style.setProperty("row-gap", "1px", "important");
-  node.style.gridAutoRows = "0px";
-  try {
-    await mediaLoaded(node);
-  } catch (e) {
-  }
-  layout({ colGap, items });
-  const obs = resizeObserver(node, {
-    async callback(opts) {
-      layout({ colGap, items });
-    }
-  });
-  async function layout({ colGap: colGap2, items: items2 }) {
-    items2.forEach((item) => {
-      const ib = item.getBoundingClientRect();
-      item.style.gridRowEnd = `span ${Math.round(ib.height + colGap2)}`;
-    });
-  }
-  return {
-    destroy() {
-      obs.disconnect();
-    }
-  };
-}
-function nativeMasonrySupport(node) {
-  return getComputedStyle(node).gridTemplateRows === "masonry";
-}
-
-// src/lib/objects/omit-empty.js
-function omitEmpty(obj, shallow = false) {
-  if (typeof obj !== "object" || obj === null) return obj;
-  if (obj instanceof Date) return obj;
-  const result = Array.isArray(obj) ? [] : {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === null || value === void 0 || value === "" || typeof value === "object" && !(value instanceof Date) && Object.keys(value).length === 0) {
-      continue;
-    }
-    result[key] = shallow ? value : omitEmpty(value);
-  }
-  return result;
-}
-
-// src/dom/css-vars.js
-function getCSSValue(element, prop) {
-  return getCSSVar(element, prop);
-}
-function setCSSValue(element, prop, value) {
-  setCSSVar(element, prop, value);
-}
-function getCSSVar(element, prop) {
-  element = getElement(element);
-  return getComputedStyle(element).getPropertyValue(prop);
-}
-function setCSSVar(element, prop, value) {
-  element = getElement(element);
-  element.style.setProperty(prop, value);
-}
-
-// src/dom/actions/prefer-horizontal-scroll.js
-var DEFAULT_OPTIONS = {
-  scrollSnapDelay: 1e3
-};
-function preferHorizontalScroll(node, props = {}) {
-  if (!node.classList.contains("scrollable-prefer-horizontal")) return;
-  const state = {
-    origSnapType: null,
-    currentSnapType: null,
-    snapTimeoutID: null
-  };
-  const options = {
-    ...DEFAULT_OPTIONS,
-    ...omitEmpty({
-      scrollSnapDelay: getCSSVar(node, "--scroll-snap-delay")
-    }),
-    ...omitEmpty(props)
-  };
-  const listeners = [
-    {
-      event: "wheel",
-      node,
-      handler: handleWheel
-    },
-    {
-      event: "pointerenter",
-      node,
-      handler: handlePointerEnter
-    },
-    {
-      event: "pointerleave",
-      node,
-      handler: handlePointerLeave
-    }
-  ];
-  addListeners(listeners);
-  function handleWheel(event) {
-    const direction = event.deltaY > 0 ? "down" : "up";
-    const updatedDelta = event.deltaY;
-    if (isTrackpad(event)) return false;
-    setCSSVar(node, "--snap-type", "none");
-    const scrolledAmount = node.scrollLeft;
-    const scrollWidth = node.scrollWidth;
-    const clientWidth = node.clientWidth;
-    const scrollableAmount = scrollWidth - clientWidth;
-    if (direction === "down" && scrolledAmount < scrollableAmount) {
-      node.scrollLeft += updatedDelta;
-      event.preventDefault();
-    }
-    if (direction === "up" && scrolledAmount > 0) {
-      node.scrollLeft += updatedDelta;
-      event.preventDefault();
-    }
-    const { snapTimeoutID } = state;
-    if (snapTimeoutID) clearTimeout(snapTimeoutID);
-    state.snapTimeoutID = setTimeout((_) => {
-      restoreHijackedState(node, state);
-    }, options.scrollSnapDelay);
-  }
-  function handlePointerEnter(event) {
-    state.origSnapType = getCSSVar(node, "--snap-type") || "proximity";
-  }
-  function handlePointerLeave(event) {
-    restoreHijackedState(node, state);
-  }
-  return {
-    destroy() {
-      removeListeners(listeners);
-    }
-  };
-}
-function restoreHijackedState(node, state) {
-  const scrollLeft = node.scrollLeft;
-  setCSSVar(node, "--snap-type", state.origSnapType);
-  const finalScrollLeft = node.scrollLeft;
-  setCSSVar(node, "--snap-type", "none");
-  node.scrollTo({ left: scrollLeft, behavior: "instant" });
-  node.scrollTo({ left: finalScrollLeft, behavior: "smooth" });
-  setTimeout((_) => {
-    setCSSVar(node, "--snap-type", state.origSnapType);
-  }, 250);
-}
-function isTrackpad(event) {
-  if (event.wheelDeltaY === event.deltaY * -3) return true;
-}
-
-// src/dom/bounding-box.js
-function boundingBox(element, { containsPadding = true } = {}) {
-  const box = element.getBoundingClientRect();
-  const ret = {};
-  for (const prop in box) ret[prop] = box[prop];
-  if (!containsPadding) {
-    const style = getComputedStyle(element);
-    const paddingTop = parseFloat(style.paddingTop);
-    const paddingRight = parseFloat(style.paddingRight);
-    const paddingBottom = parseFloat(style.paddingBottom);
-    const paddingLeft = parseFloat(style.paddingLeft);
-    ret.x = ret.x + paddingLeft;
-    ret.y = ret.y + paddingTop;
-    ret.width = ret.width - paddingLeft - paddingRight;
-    ret.height = ret.height - paddingTop - paddingBottom;
-    ret.top = ret.top + paddingTop;
-    ret.bottom = ret.bottom - paddingBottom;
-    ret.right = ret.right - paddingRight;
-    ret.left = ret.left + paddingLeft;
-  }
-  ret.xCenter = (ret.left + ret.right) / 2;
-  ret.yCenter = (ret.top + ret.bottom) / 2;
-  return ret;
-}
-function boundingBoxRelativeToAncestor({ element, ancestorElement }) {
-  ancestorElement = ancestorElement || element.parentElement;
-  const box = boundingBox(element);
-  const ancestorBox = boundingBox(ancestorElement, {
-    containsPadding: false
-  });
-  return {
-    top: box.top - ancestorBox.top,
-    right: box.right - ancestorBox.right,
-    bottom: box.bottom - ancestorBox.bottom,
-    left: box.left - ancestorBox.left,
-    width: box.width,
-    height: box.height,
-    xCenter: (box.left + box.right) / 2 - ancestorBox.left,
-    yCenter: (box.top + box.bottom) / 2 - ancestorBox.top
-  };
-}
-
-// src/dom/ui/scroll-container.js
-function findScrollContainer(element, direction = "both") {
-  if (!element) return;
-  let parent = element.parentElement;
-  while (parent) {
-    const { overflow, overflowX, overflowY } = getComputedStyle(parent);
-    if (direction === "both") {
-      if (overflow.includes("auto") || overflow.includes("scroll"))
-        return parent;
-    }
-    if (direction === "horizontal") {
-      if (overflowX === "auto" || overflowX === "scroll") return parent;
-    }
-    if (direction === "vertical") {
-      if (overflowY === "auto" || overflowY === "scroll") return parent;
-    }
-    parent = parent.parentElement;
-  }
-  return document.documentElement;
-}
-
-// src/dom/actions/sticky.js
-function sticky(node, props = {}) {
-  const scrollContainer = findScrollContainer(node);
-  let stickyTBLR = getComputedTBLR(node);
-  const obs = resizeObserver(node, {
-    callback: ({ entry }) => {
-      stickyTBLR = getComputedTBLR(node);
-      isSticking();
-      scrollContainer === document.documentElement ? window.addEventListener("scroll", scrollEventListener) : scrollContainer.addEventListener("scroll", scrollEventListener);
-    }
-  });
-  function scrollEventListener(event) {
-    isSticking();
-  }
-  function isSticking() {
-    const { top, bottom, left, right } = stickyTBLR;
-    const relativeRect = boundingBoxRelativeToAncestor({
-      element: node,
-      ancestorElement: scrollContainer
-    });
-    if (!isNaN(top)) {
-      if (relativeRect.top - top <= 1) {
-        node.classList.add("sticking");
-      } else {
-        node.classList.remove("sticking");
-      }
-    }
-    if (!isNaN(bottom)) {
-      if (relativeRect.bottom + bottom >= -1) {
-        node.classList.add("sticking");
-      } else {
-        node.classList.remove("sticking");
-      }
-    }
-    if (!isNaN(left)) {
-      if (relativeRect.left - left <= 1) {
-        node.classList.add("sticking");
-      } else {
-        node.classList.remove("sticking");
-      }
-    }
-    if (!isNaN(right)) {
-      if (relativeRect.right + right >= -1) {
-        node.classList.add("sticking");
-      } else {
-        node.classList.remove("sticking");
-      }
-    }
-  }
-  return {
-    destroy() {
-      obs.disconnect();
-      scrollContainer.removeEventListener("scroll", scrollEventListener);
-    }
-  };
-}
-function getComputedTBLR(element) {
-  const style = getComputedStyle(element);
-  return {
-    top: parseFloat(style.top),
-    bottom: parseFloat(style.bottom),
-    left: parseFloat(style.left),
-    right: parseFloat(style.right)
-  };
-}
-
-// src/dom/clipboard.js
-function copyRichText(element) {
-  const range = document.createRange();
-  range.selectNode(element);
-  const selection = window.getSelection();
-  selection.removeAllRanges();
-  selection.addRange(range);
-  document.execCommand("copy");
-  selection.removeAllRanges();
-}
-
-// src/dom/cookie.js
-var cookies = {
-  get(name) {
-    return getCookie(name);
-  },
-  set(name, value, days) {
-    setCookie(name, value, days);
-  }
-};
-function getCookie(name) {
-  const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
-  if (!match) return null;
-  const decoded = decodeURIComponent(match[2]);
-  try {
-    return JSON.parse(decoded);
-  } catch (e) {
-    return decoded;
-  }
-}
-function setCookie(name, value, days) {
-  let expires = "";
-  if (days) {
-    const date = /* @__PURE__ */ new Date();
-    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1e3);
-    expires = "; expires=" + date.toUTCString();
-  }
-  document.cookie = name + "=" + (value || "") + expires + "; path=/";
-}
-
-// src/dom/focusable.js
-function getFocusableElements(container = document.body) {
-  return {
-    /**
-     * Gets the number of keyboard focusable elements.
-     * This is useful for checking if there are any focusable elements
-     * before attempting to focus them.
-     * 
-     * @returns {number} The number of keyboard focusable elements
-     */
-    get length() {
-      return this.keyboard.length;
-    },
-    /**
-     * Gets all focusable elements within the container that are visible and enabled.
-     * This includes elements that can be focused via mouse or programmatically,
-     * but may not be keyboard focusable.
-     * 
-     * Elements are considered focusable if they:
-     * - Are not disabled
-     * - Are not hidden
-     * - Are not display:none
-     * 
-     * @returns {HTMLElement[]} Array of focusable elements that are visible and enabled
-     */
-    get all() {
-      const elements = Array.from(
-        container.querySelectorAll(
-          `a, 
-            button, 
-            input, 
-            textarea, 
-            select, 
-            details, 
-            iframe, 
-            embed, 
-            object, 
-            summary, 
-            dialog, 
-            audio[controls], 
-            video[controls], 
-            [contenteditable], 
-            [tabindex]
-          `
-        )
-      );
-      return elements.filter((el) => {
-        if (el.hasAttribute("disabled")) return false;
-        if (el.hasAttribute("hidden")) return false;
-        if (window.getComputedStyle(el).display === "none") return false;
-        return true;
-      });
-    },
-    /**
-     * Gets elements that can be focused via keyboard (tabIndex > -1).
-     * These are the elements that will be focused when using the Tab key.
-     * 
-     * @returns {HTMLElement[]} Array of keyboard focusable elements
-     */
-    get keyboard() {
-      return this.all.filter((el) => el instanceof HTMLElement && el.tabIndex > -1);
-    },
-    /**
-     * Alias for keyboard focusable elements.
-     * This is provided for semantic clarity in certain contexts.
-     * 
-     * @returns {HTMLElement[]} Array of keyboard focusable elements
-     */
-    get keyboardOnly() {
-      return this.keyboard;
-    },
-    /**
-     * Gets the first keyboard focusable element.
-     * This is useful for setting initial focus when opening a modal or dialog.
-     * 
-     * @returns {HTMLElement|null} The first focusable element or null if none exist
-     */
-    get first() {
-      return this.keyboard[0] || null;
-    },
-    /**
-     * Gets the last keyboard focusable element.
-     * This is useful for focus trapping when using Shift+Tab.
-     * 
-     * @returns {HTMLElement|null} The last focusable element or null if none exist
-     */
-    get last() {
-      return this.keyboard[this.length - 1] || null;
-    },
-    /**
-     * Gets the next focusable element after the given index.
-     * This is useful for implementing custom tab order or focus management.
-     * 
-     * @param {number} index - The current element's index in the keyboard focusable array
-     * @returns {HTMLElement|null} The next focusable element or null if none exists
-     */
-    next(index) {
-      return this.keyboard[index + 1] || null;
-    },
-    /**
-     * Gets the previous focusable element before the given index.
-     * This is useful for implementing custom tab order or focus management.
-     * 
-     * @param {number} index - The current element's index in the keyboard focusable array
-     * @returns {HTMLElement|null} The previous focusable element or null if none exists
-     */
-    prev(index) {
-      return this.keyboard[index - 1] || null;
-    }
-  };
-}
-function Focusable(container = document.body) {
-  return getFocusableElements(container);
-}
-
-// src/lib/numbers/index.js
-function splitUnit(string) {
-  if (typeof string === "number") return [string, null];
-  const regex = /(-?\d*\.?\d+)\s*([a-z]+)/i;
-  const match = string.match(regex);
-  if (match) return [parseFloat(match[1]), match[2]];
-  return [parseFloat(string), null];
-}
-
-// src/dom/font-size.js
-function getUnit(value) {
-  const [, unit] = splitUnit(value);
-  return unit;
-}
-function rem(multiple = 1) {
-  const value = parseFloat(getComputedStyle(document.body)["font-size"]);
-  return Math.round(value * multiple);
-}
-function em(element = document.body, multiple = 1) {
-  const value = parseFloat(getComputedStyle(element)["font-size"]);
-  return Math.round(value * multiple);
-}
-function rlh(multiple = 1) {
-  const lineHeight = parseFloat(getComputedStyle(document.body)["line-height"]);
-  return Math.round(lineHeight * multiple);
-}
-function lh(element = document.body, multiple = 1) {
-  const lineHeight = getComputedStyle(element)["line-height"];
-  const value = parseFloat(lineHeight);
-  return Math.round(value * multiple);
-}
-function toPx(value, element = null) {
-  const [numeric, unit] = splitUnit(value);
-  let finalValue = 0;
-  if (unit === "rem") finalValue = rem(numeric);
-  if (unit === "em") finalValue = em(element, numeric);
-  if (unit === "lh") finalValue = lh(element, numeric);
-  if (unit === "px") finalValue = numeric;
-  if (!unit) finalValue = numeric;
-  return finalValue;
-}
-
-// src/dom/hash.js
-async function sha256Hash(string) {
-  const utf8 = new TextEncoder().encode(string);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", utf8);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((bytes) => bytes.toString(16).padStart(2, "0")).join("");
-  return hashHex;
-}
-
-// src/dom/keyboard.js
-function isTab(event) {
-  return !event.shiftKey && event.key === "Tab";
-}
-function isShiftTab(event) {
-  return event.shiftKey && event.key === "Tab";
-}
-function isTabKey(key) {
-  return key === "Tab";
-}
-function isArrowKey(key) {
-  return ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(key);
-}
-function isEscapeKey(key) {
-  return key === "Escape";
-}
-
-// src/dom/local-store.js
-var localStore = {
-  /**
-   * Retrieves a value from localStorage
-   * @param {string} key - The key to retrieve from localStorage
-   * @returns {any} The stored value. Returns parsed JSON if the value was stored as JSON. Returns the original string if not JSON, or undefined if key doesn't exist
-   */
-  get(key) {
-    const value = localStorage.getItem(key);
-    if (!value) return;
-    try {
-      return JSON.parse(value);
-    } catch (error) {
-      return value;
-    }
-  },
-  /**
-   * Stores a value in localStorage
-   * @param {string} key - The key to store the value under
-   * @param {any} value - The value to store. Objects will be stringified to JSON
-   */
-  set(key, value) {
-    if (typeof value === "string") {
-      localStorage.setItem(key, value);
-    } else {
-      localStorage.setItem(key, JSON.stringify(value));
-    }
-  },
-  /**
-   * Stores multiple key-value pairs in localStorage
-   * @param {Object|Map} data - An object or Map containing key-value pairs to store
-   */
-  setMultiple(data) {
-    for (const [key, value] of Object.entries(data)) {
-      this.set(key, value);
-    }
-  },
-  /**
-   * Removes a value from localStorage
-   * @param {string} key - The key to remove from localStorage
-   */
-  remove(key) {
-    localStorage.removeItem(key);
-  },
-  /**
-   * Removes multiple keys from localStorage
-   * @param {string[]} keys - Array of keys to remove from localStorage
-   */
-  removeMultiple(keys) {
-    keys.forEach((key) => this.remove(key));
-  }
-};
-
-// src/dom/observers/intersection-observer.js
-function intersectionObserver(target, options = {}) {
-  const { callback, ...opts } = options;
-  const observer = new IntersectionObserver(observerFn, opts);
-  useObserverMethodOnTarget(target, observer, "observe");
-  function observerFn(entries) {
-    for (const entry of entries) {
-      if (callback) callback({ entry, entries, observer });
-      else dispatchEvent(target, "intersect", { entry, entries, observer });
-    }
-  }
-  return {
-    observer,
-    observe(target2) {
-      useObserverMethodOnTarget(target2, observer, "observe", options);
-    },
-    unobserve(target2) {
-      useObserverMethodOnTarget(target2, observer, "unobserve");
-    },
-    takeRecords() {
-      return observer.takeRecords();
-    },
-    disconnect() {
-      const records = observer.takeRecords();
-      observer.disconnect();
-      if (records.length > 0) observerFn(records);
-    },
-    destroy() {
-      observer.disconnect();
-    }
-  };
-}
-
-// src/dom/observers/mutation-observer.js
-var defaultOptions = {
-  attributes: false,
-  childList: false,
-  subtree: false
-};
-function mutationObserver(target, options) {
-  options = { ...defaultOptions, ...options };
-  const { callback, ...opts } = options;
-  const observer = new MutationObserver(observerFn);
-  if (target === window) target = document.body;
-  useObserverMethodOnTarget(target, observer, "observe", opts);
-  function observerFn(entries) {
-    for (const entry of entries) {
-      if (callback) callback({ entry, entries, observer });
-      else dispatchEvent(target, "mutate", { entry, entries, observer });
-    }
-  }
-  return {
-    observer,
-    observe(target2) {
-      useObserverMethodOnTarget(target2, observer, "observe", options);
-    },
-    takeRecords() {
-      return observer.takeRecords();
-    },
-    disconnect() {
-      const records = observer.takeRecords();
-      observer.disconnect();
-      if (records.length > 0) observerFn(records);
-    },
-    destroy() {
-      observer.disconnect();
-    }
-  };
-}
-
-// src/dom/observers/scroll-observer.js
-var defaultOptions2 = {
-  threshold: 0,
-  // Float between 0 to 1.
-  tolerance: 0.1,
-  // Float between 0 to 1. Tolerance for event firing
-  once: false
-  // Only fire threshold callback once
-};
-function getScrollElement(node) {
-  if (node === document || node === window || node === document.documentElement) {
-    return document.documentElement;
-  }
-  return (
-    /** @type {Element} */
-    node
-  );
-}
-function scrollObserver(node, options = {}) {
-  const { callback, onScrollDown, onScrollUp, onEnterThreshold, ...userOpts } = options;
-  const opts = { ...defaultOptions2, ...userOpts };
-  const { threshold, tolerance, once } = opts;
-  let prevScrollDirection = null;
-  let prevScrollTop = 0;
-  let prevScrollPercent = 0;
-  let thresholdFired = false;
-  let rafId = null;
-  const isDocumentScroll = node === document || node === window || node === document.documentElement;
-  const scrollElement = getScrollElement(node);
-  const eventTarget = isDocumentScroll ? window : node;
-  let cachedScrollHeight = 0;
-  let cachedClientHeight = 0;
-  updateCache();
-  const cacheObserver = resizeObserver(scrollElement, {
-    callback: updateCache
-  });
-  eventTarget.addEventListener("scroll", throttledObserve, { passive: true });
-  function throttledObserve() {
-    rafId = requestAnimationFrame(observe);
-  }
-  function updateCache() {
-    cachedScrollHeight = scrollElement.scrollHeight;
-    cachedClientHeight = scrollElement.clientHeight;
-  }
-  function observe() {
-    const scrollTop = scrollElement.scrollTop;
-    if (Math.abs(scrollTop - prevScrollTop) < 1) return;
-    const scrollDirection = scrollTop > prevScrollTop ? "down" : "up";
-    const maxScroll = Math.max(1, cachedScrollHeight - cachedClientHeight);
-    const scrollPercent = Math.min(1, Math.max(0, scrollTop / maxScroll));
-    const thresholdMin = threshold - tolerance / 2;
-    const thresholdMax = threshold + tolerance / 2;
-    const wasInThreshold = prevScrollPercent >= thresholdMin && prevScrollPercent <= thresholdMax;
-    const isInThreshold = scrollPercent >= thresholdMin && scrollPercent <= thresholdMax;
-    const hasEnteredThreshold = !wasInThreshold && isInThreshold && (!once || !thresholdFired);
-    if (hasEnteredThreshold && once) {
-      thresholdFired = true;
-    }
-    const callbackData = {
-      scrollTop,
-      scrollDirection,
-      scrollPercent,
-      directionChanged: scrollDirection !== prevScrollDirection,
-      hasEnteredThreshold,
-      isInThreshold
-    };
-    if (typeof callback === "function") {
-      callback(callbackData);
-    }
-    if (scrollDirection !== prevScrollDirection) {
-      if (scrollDirection === "down" && typeof onScrollDown === "function") {
-        onScrollDown(callbackData);
-      }
-      if (scrollDirection === "up" && typeof onScrollUp === "function") {
-        onScrollUp(callbackData);
-      }
-    }
-    if (hasEnteredThreshold && typeof onEnterThreshold === "function") {
-      onEnterThreshold(callbackData);
-    }
-    prevScrollTop = scrollTop;
-    prevScrollPercent = scrollPercent;
-    prevScrollDirection = scrollDirection;
-  }
-  return {
-    destroy() {
-      eventTarget.removeEventListener("scroll", throttledObserve);
-      if (rafId) cancelAnimationFrame(rafId);
-      cacheObserver.destroy();
-    }
-  };
-}
-
-// src/dom/random-string.js
-function randomString(length = 10) {
-  const firstLetter = String.fromCharCode(65 + Math.floor(Math.random() * 26));
-  const others = Math.random().toString(36).substring(2, 2 + length - 1);
-  return firstLetter + others;
-}
-function uuid() {
-  return crypto.randomUUID();
-}
-
-// src/dom/pkce.js
-async function PKCE() {
-  const codeVerifier = await randomString();
-  const codeChallenge = await getCodeChallenge(codeVerifier);
-  return {
-    state: await randomString(),
-    code_verifier: codeVerifier,
-    code_challenge: codeChallenge,
-    code_challenge_method: "S256"
-  };
-}
-async function getCodeChallenge(verifier) {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(verifier);
-  const hashed = await window.crypto.subtle.digest("SHA-256", data);
-  return window.btoa(String.fromCharCode.apply(null, new Uint8Array(hashed))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-// src/dom/query-params.js
-var queryParams = {
-  get(key) {
-    const searchParams = new URLSearchParams(location.search);
-    return searchParams.get(key);
-  },
-  stringify(params) {
-    const searchParams = new URLSearchParams(location.search);
-    return searchParams.toString();
-  }
-};
-
-// src/dom/sanitize.js
-import DOMPurify from "dompurify";
-
-// src/lib/form/sanitize.js
-function sanitize(value, options = {}) {
-  const { sanitizer, ...rest } = options;
-  if (!sanitizer) throw new Error("sanitizer function is required");
-  if (typeof value === "string") return sanitizer(value, rest);
-  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest });
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, val]) => [
-        key,
-        sanitize(val, { sanitizer, ...rest })
-      ])
-    );
-  }
-  return value;
-}
-function sanitizeArray(arr, { sanitizer, ...rest }) {
-  if (!sanitizer) throw new Error("sanitizer function is required");
-  return arr.map((item) => sanitize(item, { sanitizer, ...rest }));
-}
-
-// src/dom/sanitize.js
-function sanitize2(value, options = {}) {
-  return sanitize(value, { sanitizer: DOMPurify.sanitize, ...options });
-}
-
-// src/dom/session-store.js
-var sessionStore = {
-  get(key) {
-    const value = sessionStorage.getItem(key);
-    if (!value) return;
-    try {
-      return JSON.parse(value);
-    } catch (error) {
-      return value;
-    }
-  },
-  set(key, value) {
-    if (typeof value === "string") {
-      sessionStorage.setItem(key, value);
-    } else {
-      sessionStorage.setItem(key, JSON.stringify(value));
-    }
-  },
-  remove(key) {
-    sessionStorage.removeItem(key);
-  }
-};
-
-// src/dom/spam-prevention.js
-function preventSpam(form, { honeypotField = "hp", honeypotDuration = 2e3 } = {}) {
-  const startTime = Date.now();
-  let hasInteraction = false;
-  function checkForInteraction() {
-    hasInteraction = true;
-  }
-  const events = ["keydown", "mousemove", "touchstart", "click"];
-  events.forEach((event) => {
-    form.addEventListener(event, checkForInteraction, { once: true });
-  });
-  form.containsSpam = function() {
-    const fillTime = Date.now() - startTime;
-    const isTooFast = fillTime < honeypotDuration;
-    const honeypotInput = form.querySelector(`[name="${honeypotField}"]`);
-    const hasHoneypotValue = honeypotInput?.value?.trim();
-    const noInteraction = !hasInteraction;
-    events.forEach(
-      (event) => form.removeEventListener(event, checkForInteraction)
-    );
-    return isTooFast || !!hasHoneypotValue || noInteraction;
-  };
-}
-
-// src/dom/trap-focus.js
-function trapFocus({ event, focusables }) {
-  if (event.key !== "Tab") return;
-  if (isTab(event) && document.activeElement === focusables.last) {
-    event.preventDefault();
-    focusables.first.focus();
-  }
-  if (isShiftTab(event) && document.activeElement === focusables.first) {
-    event.preventDefault();
-    focusables.last.focus();
-  }
-}
-function manageFocus({
-  event,
-  triggerNode,
-  contentNode,
-  focusables,
-  tabOutFocus = "next",
-  // 'trigger'
-  onLeave = function() {
-  }
-}) {
-  const activeEl = document.activeElement;
-  if (activeEl === contentNode && isShiftTab(event)) return backFocus();
-  if (activeEl === contentNode && focusables.length === 0 && isTab(event))
-    return nextFocus();
-  if (activeEl === focusables.last && isTab(event)) return nextFocus();
-  if (activeEl === focusables.first && isShiftTab(event)) return backFocus();
-  function backFocus() {
-    event.preventDefault();
-    triggerNode.focus();
-    onLeave("back");
-  }
-  function nextFocus() {
-    if (tabOutFocus === "trigger") triggerNode.focus();
-    if (tabOutFocus === "next") {
-      event.preventDefault();
-      const DOMFocusables = getFocusableElements().keyboard;
-      const index = DOMFocusables.findIndex((e) => e === triggerNode);
-      const next = DOMFocusables[index + 1];
-      if (next) next.focus();
-      else triggerNode.focus();
-    }
-    onLeave("forward");
-  }
-}
-
-// src/dom/ui/aria-current.js
-function markActiveAnchorIn(container, anchorType = "page") {
-  if (!container) return;
-  const { pathname } = window.location;
-  const element = container.querySelector(`[href="${pathname}"]`);
-  if (!element) return;
-  element.setAttribute("aria-current", "page");
-  return element;
-}
-function scrollToElement(element, { scrollBehaviour = "instant", scrollMargin = "3rem" } = {}) {
-  if (!element) return;
-  element.style.scrollMarginTop = scrollMargin;
-  element.scrollIntoView({ behavior: scrollBehaviour });
-}
-
-// src/dom/ui/inconsistent-button-fix.js
-function inconsistentButtonFix() {
-  document.addEventListener("click", (event) => {
-    if (event.target instanceof HTMLButtonElement) {
-      event.target.focus();
-    }
-  });
-}
-
-// src/dom/ui/traverse-and-scramble.js
-function traverseAndScramble(node, { excludes = [] } = {}) {
-  if (node instanceof Element && excludes.some((selector) => node.matches(selector))) {
-    return;
-  }
-  node.childNodes.forEach((child) => {
-    if (child.nodeType === 3) {
-      child.nodeValue = scrambleText(child.nodeValue);
-    } else if (child.nodeType === 1 && child instanceof Element) {
-      traverseAndScramble(child, { excludes });
-    }
-  });
-}
-function scrambleText(text) {
-  return text.split("").map((char) => {
-    if (/^[A-Za-z0-9]$/.test(char)) {
-      const randomCharCode = Math.random() < 26 / 36 ? Math.floor(Math.random() * 26) + (char === char.toUpperCase() ? 65 : 97) : Math.floor(Math.random() * 10) + 48;
-      return String.fromCharCode(randomCharCode);
-    } else {
-      return char;
-    }
-  }).join("");
-}
-export {
-  Focusable,
-  PKCE,
-  addListeners,
-  boundingBox,
-  boundingBoxRelativeToAncestor,
-  checkForAccessibleName,
-  cookies,
-  copyRichText,
-  dispatchEvent,
-  em,
-  findScrollContainer,
-  getAncestorWithSiblings,
-  getCSSValue,
-  getCSSVar,
-  getChildrenElements,
-  getCookie,
-  getElement,
-  getFocusableElements,
-  getNodeType,
-  getParentElement,
-  getSelfIndex,
-  getSiblingElements,
-  getUnit,
-  hasAccessibleName,
-  imagesLoaded,
-  inconsistentButtonFix,
-  intersectionObserver,
-  isAncestor,
-  isArrowKey,
-  isEscapeKey,
-  isInvalidAriaPopup,
-  isShiftTab,
-  isTab,
-  isTabKey,
-  lh,
-  localStore,
-  manageFocus,
-  markActiveAnchorIn,
-  masonry,
-  mediaLoaded,
-  mutationObserver,
-  preferHorizontalScroll,
-  preventSpam,
-  queryParams,
-  randomString,
-  rem,
-  removeListeners,
-  resizeObserver,
-  rlh,
-  sanitize2 as sanitize,
-  scrollObserver,
-  scrollToElement,
-  sessionStore,
-  setCSSValue,
-  setCSSVar,
-  sha256Hash,
-  sticky,
-  toPx,
-  trapFocus,
-  traverseAndScramble,
-  updateEvent,
-  uuid,
-  videosLoaded
-};
+export * from "./accessibility.js";
+export * from "./actions/index.js";
+export * from "./bounding-box.js";
+export * from "./clipboard.js";
+export * from "./cookie.js";
+export * from "./css-vars.js";
+export * from "./events.js";
+export * from "./focusable.js";
+export * from "./font-size.js";
+export * from "./get-element.js";
+export * from "./hash.js";
+export * from "./keyboard.js";
+export * from "./local-store.js";
+export * from "./media.js";
+export * from "./observers/index.js";
+export * from "./pkce.js";
+export * from "./query-params.js";
+export * from "./random-string.js";
+export * from "./sanitize.js";
+export * from "./session-store.js";
+export * from "./spam-prevention.js";
+export * from "./trap-focus.js";
+export * from "./ui/index.js";