@splendidlabz/utils 1.11.3 → 1.11.5

package/dist/cjs/dom/index.cjs

@@ -0,0 +1,1267 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/index.js
+var dom_exports = {};
+__export(dom_exports, {
+  Focusable: () => Focusable,
+  PKCE: () => PKCE,
+  addListeners: () => addListeners,
+  boundingBox: () => boundingBox,
+  boundingBoxRelativeToAncestor: () => boundingBoxRelativeToAncestor,
+  checkForAccessibleName: () => checkForAccessibleName,
+  cookies: () => cookies,
+  copyRichText: () => copyRichText,
+  dispatchEvent: () => dispatchEvent,
+  em: () => em,
+  findScrollContainer: () => findScrollContainer,
+  getAncestorWithSiblings: () => getAncestorWithSiblings,
+  getCSSValue: () => getCSSValue,
+  getCSSVar: () => getCSSVar,
+  getChildrenElements: () => getChildrenElements,
+  getCookie: () => getCookie,
+  getElement: () => getElement,
+  getFocusableElements: () => getFocusableElements,
+  getNodeType: () => getNodeType,
+  getParentElement: () => getParentElement,
+  getSelfIndex: () => getSelfIndex,
+  getSiblingElements: () => getSiblingElements,
+  getUnit: () => getUnit,
+  hasAccessibleName: () => hasAccessibleName,
+  imagesLoaded: () => imagesLoaded,
+  inconsistentButtonFix: () => inconsistentButtonFix,
+  intersectionObserver: () => intersectionObserver,
+  isAncestor: () => isAncestor,
+  isArrowKey: () => isArrowKey,
+  isEscapeKey: () => isEscapeKey,
+  isInvalidAriaPopup: () => isInvalidAriaPopup,
+  isShiftTab: () => isShiftTab,
+  isTab: () => isTab,
+  isTabKey: () => isTabKey,
+  lh: () => lh,
+  localStore: () => localStore,
+  manageFocus: () => manageFocus,
+  markActiveAnchorIn: () => markActiveAnchorIn,
+  masonry: () => masonry,
+  mediaLoaded: () => mediaLoaded,
+  mutationObserver: () => mutationObserver,
+  preferHorizontalScroll: () => preferHorizontalScroll,
+  preventSpam: () => preventSpam,
+  queryParams: () => queryParams,
+  randomString: () => randomString,
+  rem: () => rem,
+  removeListeners: () => removeListeners,
+  resizeObserver: () => resizeObserver,
+  rlh: () => rlh,
+  sanitize: () => sanitize2,
+  scrollObserver: () => scrollObserver,
+  scrollToElement: () => scrollToElement,
+  sessionStore: () => sessionStore,
+  setCSSValue: () => setCSSValue,
+  setCSSVar: () => setCSSVar,
+  sha256Hash: () => sha256Hash,
+  sticky: () => sticky,
+  toPx: () => toPx,
+  trapFocus: () => trapFocus,
+  traverseAndScramble: () => traverseAndScramble,
+  updateEvent: () => updateEvent,
+  uuid: () => uuid,
+  videosLoaded: () => videosLoaded
+});
+module.exports = __toCommonJS(dom_exports);
+
+// 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";
+  node.updateMasonryLayout = (_) => layout({ colGap, items });
+  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
+var import_dompurify = __toESM(require("dompurify"), 1);
+
+// 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: import_dompurify.default.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("");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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,
+  sanitize,
+  scrollObserver,
+  scrollToElement,
+  sessionStore,
+  setCSSValue,
+  setCSSVar,
+  sha256Hash,
+  sticky,
+  toPx,
+  trapFocus,
+  traverseAndScramble,
+  updateEvent,
+  uuid,
+  videosLoaded
+});