@splendidlabz/utils 1.11.2 → 1.11.4

package/dist/cjs/dom/sanitize.cjs

@@ -25,15 +25,39 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/sanitize.js
 var sanitize_exports = {};
 __export(sanitize_exports, {
-  sanitize: () => sanitize
+  sanitize: () => sanitize2
 });
 module.exports = __toCommonJS(sanitize_exports);
 var import_dompurify = __toESM(require("dompurify"), 1);
-var import_sanitize = require("../lib/form/sanitize.js");
+
+// src/lib/form/sanitize.js
 function sanitize(value, options = {}) {
-  return (0, import_sanitize.sanitize)(value, { sanitizer: import_dompurify.default.sanitize, ...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 });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/dom/session-store.cjs

@@ -15,12 +15,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/session-store.js
 var session_store_exports = {};
 __export(session_store_exports, {
   sessionStore: () => sessionStore
 });
 module.exports = __toCommonJS(session_store_exports);
-const sessionStore = {
+var sessionStore = {
   get(key) {
     const value = sessionStorage.getItem(key);
     if (!value) return;

package/dist/cjs/dom/spam-prevention.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/spam-prevention.js
 var spam_prevention_exports = {};
 __export(spam_prevention_exports, {
   preventSpam: () => preventSpam

package/dist/cjs/dom/trap-focus.cjs

@@ -15,21 +15,143 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/trap-focus.js
 var trap_focus_exports = {};
 __export(trap_focus_exports, {
   manageFocus: () => manageFocus,
   trapFocus: () => trapFocus
 });
 module.exports = __toCommonJS(trap_focus_exports);
-var import_focusable = require("./focusable.js");
-var import_keyboard = require("./keyboard.js");
+
+// 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;
+    }
+  };
+}
+
+// src/dom/keyboard.js
+function isTab(event) {
+  return !event.shiftKey && event.key === "Tab";
+}
+function isShiftTab(event) {
+  return event.shiftKey && event.key === "Tab";
+}
+
+// src/dom/trap-focus.js
 function trapFocus({ event, focusables }) {
   if (event.key !== "Tab") return;
-  if ((0, import_keyboard.isTab)(event) && document.activeElement === focusables.last) {
+  if (isTab(event) && document.activeElement === focusables.last) {
     event.preventDefault();
     focusables.first.focus();
   }
-  if ((0, import_keyboard.isShiftTab)(event) && document.activeElement === focusables.first) {
+  if (isShiftTab(event) && document.activeElement === focusables.first) {
     event.preventDefault();
     focusables.last.focus();
   }
@@ -45,11 +167,11 @@ function manageFocus({
   }
 }) {
   const activeEl = document.activeElement;
-  if (activeEl === contentNode && (0, import_keyboard.isShiftTab)(event)) return backFocus();
-  if (activeEl === contentNode && focusables.length === 0 && (0, import_keyboard.isTab)(event))
+  if (activeEl === contentNode && isShiftTab(event)) return backFocus();
+  if (activeEl === contentNode && focusables.length === 0 && isTab(event))
     return nextFocus();
-  if (activeEl === focusables.last && (0, import_keyboard.isTab)(event)) return nextFocus();
-  if (activeEl === focusables.first && (0, import_keyboard.isShiftTab)(event)) return backFocus();
+  if (activeEl === focusables.last && isTab(event)) return nextFocus();
+  if (activeEl === focusables.first && isShiftTab(event)) return backFocus();
   function backFocus() {
     event.preventDefault();
     triggerNode.focus();
@@ -59,7 +181,7 @@ function manageFocus({
     if (tabOutFocus === "trigger") triggerNode.focus();
     if (tabOutFocus === "next") {
       event.preventDefault();
-      const DOMFocusables = (0, import_focusable.getFocusableElements)().keyboard;
+      const DOMFocusables = getFocusableElements().keyboard;
       const index = DOMFocusables.findIndex((e) => e === triggerNode);
       const next = DOMFocusables[index + 1];
       if (next) next.focus();

package/dist/cjs/dom/ui/aria-current.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/ui/aria-current.js
 var aria_current_exports = {};
 __export(aria_current_exports, {
   markActiveAnchorIn: () => markActiveAnchorIn,

package/dist/cjs/dom/ui/inconsistent-button-fix.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/ui/inconsistent-button-fix.js
 var inconsistent_button_fix_exports = {};
 __export(inconsistent_button_fix_exports, {
   inconsistentButtonFix: () => inconsistentButtonFix

package/dist/cjs/dom/ui/index.cjs

@@ -2,6 +2,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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))
@@ -10,18 +14,92 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/ui/index.js
 var ui_exports = {};
+__export(ui_exports, {
+  findScrollContainer: () => findScrollContainer,
+  inconsistentButtonFix: () => inconsistentButtonFix,
+  markActiveAnchorIn: () => markActiveAnchorIn,
+  scrollToElement: () => scrollToElement,
+  traverseAndScramble: () => traverseAndScramble
+});
 module.exports = __toCommonJS(ui_exports);
-__reExport(ui_exports, require("./aria-current.js"), module.exports);
-__reExport(ui_exports, require("./inconsistent-button-fix.js"), module.exports);
-__reExport(ui_exports, require("./scroll-container.js"), module.exports);
-__reExport(ui_exports, require("./traverse-and-scramble.js"), module.exports);
+
+// 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/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/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 = {
-  ...require("./aria-current.js"),
-  ...require("./inconsistent-button-fix.js"),
-  ...require("./scroll-container.js"),
-  ...require("./traverse-and-scramble.js")
+  findScrollContainer,
+  inconsistentButtonFix,
+  markActiveAnchorIn,
+  scrollToElement,
+  traverseAndScramble
 });

package/dist/cjs/dom/ui/scroll-container.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/ui/scroll-container.js
 var scroll_container_exports = {};
 __export(scroll_container_exports, {
   findScrollContainer: () => findScrollContainer

package/dist/cjs/dom/ui/traverse-and-scramble.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/ui/traverse-and-scramble.js
 var traverse_and_scramble_exports = {};
 __export(traverse_and_scramble_exports, {
   traverseAndScramble: () => traverseAndScramble

package/dist/cjs/lib/arrays/index.cjs

@@ -2,6 +2,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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))
@@ -10,22 +14,126 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/arrays/index.js
 var arrays_exports = {};
+__export(arrays_exports, {
+  isLastItem: () => isLastItem,
+  joinWithConjunction: () => joinWithConjunction,
+  last: () => last,
+  lastArrayItem: () => lastArrayItem,
+  shuffle: () => shuffle,
+  sort: () => sort,
+  splitArray: () => splitArray,
+  uniqueArray: () => uniqueArray
+});
 module.exports = __toCommonJS(arrays_exports);
-__reExport(arrays_exports, require("./item-position.js"), module.exports);
-__reExport(arrays_exports, require("./join.js"), module.exports);
-__reExport(arrays_exports, require("./shuffle.js"), module.exports);
-__reExport(arrays_exports, require("./sort.js"), module.exports);
-__reExport(arrays_exports, require("./split-array.js"), module.exports);
-__reExport(arrays_exports, require("./unique.js"), module.exports);
+
+// src/lib/arrays/item-position.js
+function last(array, index) {
+  console.warn("last is deprecated. Use isLastItem instead.");
+  return index === array.length - 1;
+}
+function isLastItem(array, index) {
+  return index === array.length - 1;
+}
+function lastArrayItem(array) {
+  return array[array.length - 1];
+}
+
+// src/lib/arrays/join.js
+function joinWithConjunction(array, { conjunction = "and" } = {}) {
+  if (!array?.length) return "";
+  if (array.length === 1) return array[0];
+  if (array.length === 2) return `${array[0]} ${conjunction} ${array[1]}`;
+  const lastItem = lastArrayItem(array);
+  const rest = array.slice(0, -1);
+  return `${rest.join(", ")} ${conjunction} ${lastItem}`;
+}
+
+// src/lib/arrays/shuffle.js
+function shuffle(array) {
+  const clone = array.slice();
+  let currentIndex = array.length;
+  let temporaryValue;
+  let randomIndex;
+  while (currentIndex !== 0) {
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex -= 1;
+    temporaryValue = clone[currentIndex];
+    clone[currentIndex] = clone[randomIndex];
+    clone[randomIndex] = temporaryValue;
+  }
+  return clone;
+}
+
+// src/lib/objects/nested-property.js
+function getNestedValue(object, path) {
+  return path.split(".").reduce((acc, part) => acc?.[part], object);
+}
+
+// src/lib/arrays/sort.js
+function sort(array, { props = null, reverse = false } = {}) {
+  const clone = array.slice();
+  if (props === null) {
+    return clone.sort((a, b) => {
+      const comparison = compareValues(a, b);
+      return reverse ? -comparison : comparison;
+    });
+  }
+  const properties = Array.isArray(props) ? props : [props];
+  return clone.sort((a, b) => {
+    for (const property of properties) {
+      const aValue = getNestedValue(a, property);
+      const bValue = getNestedValue(b, property);
+      if (aValue === bValue) continue;
+      if (aValue == null) return 1;
+      if (bValue == null) return -1;
+      const comparison = compareValues(aValue, bValue);
+      return reverse ? -comparison : comparison;
+    }
+    return 0;
+  });
+}
+function compareValues(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+  const aDate = new Date(a);
+  const bDate = new Date(b);
+  const aTime = aDate.getTime();
+  const bTime = bDate.getTime();
+  if (!isNaN(aTime) && !isNaN(bTime)) return aTime - bTime;
+  return String(a).localeCompare(String(b));
+}
+
+// src/lib/arrays/split-array.js
+function splitArray(array, predicate) {
+  const ret = {
+    picked: [],
+    omitted: []
+  };
+  array.forEach((item, index, arr) => {
+    if (predicate(item, index, arr)) ret.picked.push(item);
+    else ret.omitted.push(item);
+  });
+  ret.p = ret.picked;
+  ret.o = ret.omitted;
+  return ret;
+}
+
+// src/lib/arrays/unique.js
+function uniqueArray(array) {
+  return Array.from(new Set(array));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./item-position.js"),
-  ...require("./join.js"),
-  ...require("./shuffle.js"),
-  ...require("./sort.js"),
-  ...require("./split-array.js"),
-  ...require("./unique.js")
+  isLastItem,
+  joinWithConjunction,
+  last,
+  lastArrayItem,
+  shuffle,
+  sort,
+  splitArray,
+  uniqueArray
 });

package/dist/cjs/lib/arrays/item-position.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/arrays/item-position.js
 var item_position_exports = {};
 __export(item_position_exports, {
   isLastItem: () => isLastItem,

package/dist/cjs/lib/arrays/join.cjs

@@ -15,17 +15,25 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/arrays/join.js
 var join_exports = {};
 __export(join_exports, {
   joinWithConjunction: () => joinWithConjunction
 });
 module.exports = __toCommonJS(join_exports);
-var import_item_position = require("./item-position.js");
+
+// src/lib/arrays/item-position.js
+function lastArrayItem(array) {
+  return array[array.length - 1];
+}
+
+// src/lib/arrays/join.js
 function joinWithConjunction(array, { conjunction = "and" } = {}) {
   if (!array?.length) return "";
   if (array.length === 1) return array[0];
   if (array.length === 2) return `${array[0]} ${conjunction} ${array[1]}`;
-  const lastItem = (0, import_item_position.lastArrayItem)(array);
+  const lastItem = lastArrayItem(array);
   const rest = array.slice(0, -1);
   return `${rest.join(", ")} ${conjunction} ${lastItem}`;
 }

package/dist/cjs/lib/arrays/shuffle.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/arrays/shuffle.js
 var shuffle_exports = {};
 __export(shuffle_exports, {
   shuffle: () => shuffle

package/dist/cjs/lib/arrays/sort.cjs

@@ -15,12 +15,20 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/arrays/sort.js
 var sort_exports = {};
 __export(sort_exports, {
   sort: () => sort
 });
 module.exports = __toCommonJS(sort_exports);
-var import_nested_property = require("../objects/nested-property.js");
+
+// src/lib/objects/nested-property.js
+function getNestedValue(object, path) {
+  return path.split(".").reduce((acc, part) => acc?.[part], object);
+}
+
+// src/lib/arrays/sort.js
 function sort(array, { props = null, reverse = false } = {}) {
   const clone = array.slice();
   if (props === null) {
@@ -32,8 +40,8 @@ function sort(array, { props = null, reverse = false } = {}) {
   const properties = Array.isArray(props) ? props : [props];
   return clone.sort((a, b) => {
     for (const property of properties) {
-      const aValue = (0, import_nested_property.getNestedValue)(a, property);
-      const bValue = (0, import_nested_property.getNestedValue)(b, property);
+      const aValue = getNestedValue(a, property);
+      const bValue = getNestedValue(b, property);
       if (aValue === bValue) continue;
       if (aValue == null) return 1;
       if (bValue == null) return -1;

package/dist/cjs/lib/arrays/split-array.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/arrays/split-array.js
 var split_array_exports = {};
 __export(split_array_exports, {
   splitArray: () => splitArray

package/dist/cjs/lib/arrays/unique.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/arrays/unique.js
 var unique_exports = {};
 __export(unique_exports, {
   uniqueArray: () => uniqueArray