@splendidlabz/utils 1.5.0-beta.6 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @splendidlabz/utils
 
+## 1.5.1
+
+### Patch Changes
+
+- - Utils: Added getFocusableElements as alias of Focusables
+  - Styles: Adjusted `grid-with-breakout` children classes and CSS properties. Wrote docs for it.
+
+## 1.5.0
+
+### Minor Changes
+
+- 859a2b0: Add utilities for SSE
+- acf9faf: Improve sort function
+- 8b17adc: Ready for next release
+- 5fe7c51: - Just bumping
+  - Fix bug with `mix` erroring when a `null` or `undefined` source is passed to it. `mix` now ignores `null` and `undefined`.
+  - Adds `toDegrees`
+  - Adds `toRadians`
+  - Adds `getCSSValue` and `setCSSValue`. They're aliases for `getCSSVar` and `setCSSVar` but they're more descriptive for standard properties.
+  - Renamed `hasLabel` to `checkForAccessibleName`
+  - Add `getParentElement` to get the parent element of a DOM node. If it encounters an `ASTRO-ISLAND` and `ASTRO-SLOT`, it goes one level up.
+
+### Patch Changes
+
+- df4f2d6: Simplified Markdown — so utils now contain a markdown function
+- Include typescript checks!
+- bb06596: Updates
+
 ## 1.5.0-beta.6
 
 ### Minor Changes

package/dist/dom/accessibility.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Checks if an element has an accessible name through label or aria-labelledby
+ * @param {string} [label] - The label text
+ * @param {string} [labelledBy] - The aria-labelledby value
+ * @returns {boolean} True if the element has an accessible name
+ */
+export function hasAccessibleName(label?: string, labelledBy?: string): boolean;
+/**
+ * Checks if an element has an accessible name and logs a warning/error if it doesn't
+ * @param {Object} [options] - Options for checking accessible name
+ * @param {string} [options.name] - The name of the element being checked
+ * @param {string} [options.ariaLabel] - The aria-label value
+ * @param {string} [options.ariaLabelledBy] - The aria-labelledby value
+ * @param {'warn'|'error'} [options.severity='warn'] - Severity level for the message
+ * @returns {boolean} True if the element has an accessible name
+ */
+export function checkForAccessibleName({ name, ariaLabel, ariaLabelledBy, severity, }?: {
+    name?: string;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    severity?: "warn" | "error";
+}): boolean;
+/**
+ * Checks if an ARIA popup value is valid
+ * @param {string} value - The ARIA popup value to check
+ * @returns {boolean} True if the value is invalid
+ */
+export function isInvalidAriaPopup(value: string): boolean;

package/dist/dom/actions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./masonry.js";
+export * from "./prefer-horizontal-scroll.js";
+export * from "./sticky.js";

package/dist/dom/actions/masonry.d.ts

@@ -0,0 +1,3 @@
+export function masonry(node: any): Promise<{
+    destroy(): void;
+}>;

package/dist/dom/actions/prefer-horizontal-scroll.d.ts

@@ -0,0 +1,3 @@
+export function preferHorizontalScroll(node: any, props?: {}): {
+    destroy(): void;
+};

package/dist/dom/actions/sticky.d.ts

@@ -0,0 +1,3 @@
+export function sticky(node: any, props?: {}): {
+    destroy(): void;
+};

package/dist/dom/bounding-box.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Advanced boundingClientRect that contains information vertical and horizontal centers.
+ * @param {HTMLElement} element - The element to get the bounding box for
+ * @param {Object} [options] - Options for the bounding box calculation
+ * @param {boolean} [options.containsPadding=true] - Whether to include padding in the calculations
+ * @returns {Object} The bounding box object with additional center coordinates
+ * @property {number} x - The x coordinate
+ * @property {number} y - The y coordinate
+ * @property {number} width - The width
+ * @property {number} height - The height
+ * @property {number} top - The top coordinate
+ * @property {number} right - The right coordinate
+ * @property {number} bottom - The bottom coordinate
+ * @property {number} left - The left coordinate
+ * @property {number} xCenter - The horizontal center coordinate
+ * @property {number} yCenter - The vertical center coordinate
+ */
+export function boundingBox(element: HTMLElement, { containsPadding }?: {
+    containsPadding?: boolean;
+}): any;
+/**
+ * Gets the bounding box of an element relative to its ancestor
+ * @param {Object} params - Parameters for the calculation
+ * @param {HTMLElement} params.element - The element to get the bounding box for
+ * @param {HTMLElement} [params.ancestorElement] - The ancestor element to calculate position relative to. Defaults to parent element
+ * @returns {Object} The relative bounding box with center coordinates
+ * @property {number} top - Distance from ancestor's top
+ * @property {number} right - Distance from ancestor's right
+ * @property {number} bottom - Distance from ancestor's bottom
+ * @property {number} left - Distance from ancestor's left
+ * @property {number} width - The width
+ * @property {number} height - The height
+ * @property {number} xCenter - The horizontal center coordinate relative to ancestor
+ * @property {number} yCenter - The vertical center coordinate relative to ancestor
+ */
+export function boundingBoxRelativeToAncestor({ element, ancestorElement }: {
+    element: HTMLElement;
+    ancestorElement?: HTMLElement;
+}): any;

package/dist/dom/clipboard.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copies rich text from an element to the clipboard
+ * @param HTMLElement element - Element to copy
+ */
+export function copyRichText(element: any): void;

package/dist/dom/cookie.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gets a cookie by name
+ * Thanks to https://stackoverflow.com/a/21125098
+ * @param {string} name Cookie name
+ * @returns string Cookie value
+ */
+export function getCookie(name: string): string;
+export namespace cookies {
+    function get(name: any): string;
+    function set(name: any, value: any, days: any): void;
+}

package/dist/dom/css-vars.d.ts

@@ -0,0 +1,4 @@
+export function getCSSValue(element: any, prop: any): string;
+export function setCSSValue(element: any, prop: any, value: any): void;
+export function getCSSVar(element: any, prop: any): string;
+export function setCSSVar(element: any, prop: any, value: any): void;

package/dist/dom/events.d.ts

@@ -0,0 +1,18 @@
+export function addListeners(listeners: any): void;
+export function removeListeners(listeners: any): void;
+export function dispatchEvent(node: any, eventName: any, detail: any, options?: {}): void;
+export function updateEvent(event: any, updates: any): CustomEvent<any>;
+export function createListeners(listeners: any): {
+    readonly list: any;
+    add({ node, event, handler }: {
+        node: any;
+        event: any;
+        handler: any;
+    }): void;
+    remove({ node, event, handler }: {
+        node: any;
+        event: any;
+        handler: any;
+    }): void;
+    clear(): void;
+};

package/dist/dom/focusable.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @typedef {Object} Focusables
+ * @property {number} length - Number of keyboard focusable elements
+ * @property {Array} all - All focusable elements that are visible and enabled
+ * @property {Array} keyboard - Elements that can be focused via keyboard (tabIndex > -1)
+ * @property {Array} keyboardOnly - Alias for keyboard focusable elements
+ * @property {HTMLElement|null} first - First keyboard focusable element
+ * @property {HTMLElement|null} last - Last keyboard focusable element
+ * @property {function(number): HTMLElement|null} next - Get next focusable element after the given index
+ * @property {function(number): HTMLElement|null} prev - Get previous focusable element before the given index
+ */
+/**
+ * Gets all focusable elements within a container and provides methods to navigate between them.
+ * This is useful for implementing keyboard navigation, focus trapping, and accessibility features.
+ *
+ * @param {HTMLElement} [container=document.body] - The container element to search within. Only elements inside this container will be included.
+ * @returns {Focusables} Object containing focusable elements and navigation methods
+ * @example
+ * // Get focusable elements in a modal
+ * const modal = document.querySelector('.modal')
+ * const focusable = getFocusableElements(modal)
+ *
+ * // Get all focusable elements in document
+ * const allFocusable = getFocusableElements()
+ *
+ * // Focus the first element when modal opens
+ * focusable.first?.focus()
+ *
+ * // Handle tab key to trap focus
+ * modal.addEventListener('keydown', e => {
+ *   if (e.key === 'Tab') {
+ *     e.preventDefault()
+ *     const currentIndex = focusable.keyboard.indexOf(document.activeElement)
+ *     const nextElement = e.shiftKey
+ *       ? focusable.prev(currentIndex)
+ *       : focusable.next(currentIndex)
+ *     nextElement?.focus()
+ *   }
+ * })
+ */
+export function getFocusableElements(container?: HTMLElement): Focusables;
+export function Focusable(container?: HTMLElement): Focusables;
+export type Focusables = {
+    /**
+     * - Number of keyboard focusable elements
+     */
+    length: number;
+    /**
+     * - All focusable elements that are visible and enabled
+     */
+    all: any[];
+    /**
+     * - Elements that can be focused via keyboard (tabIndex > -1)
+     */
+    keyboard: any[];
+    /**
+     * - Alias for keyboard focusable elements
+     */
+    keyboardOnly: any[];
+    /**
+     * - First keyboard focusable element
+     */
+    first: HTMLElement | null;
+    /**
+     * - Last keyboard focusable element
+     */
+    last: HTMLElement | null;
+    /**
+     * - Get next focusable element after the given index
+     */
+    next: (arg0: number) => HTMLElement | null;
+    /**
+     * - Get previous focusable element before the given index
+     */
+    prev: (arg0: number) => HTMLElement | null;
+};

package/dist/dom/font-size.d.ts

@@ -0,0 +1,5 @@
+export function getUnit(value: any): any;
+export function em(element?: HTMLElement, multiple?: number): number;
+export function rem(multiple?: number): number;
+export function lh(element?: HTMLElement, multiple?: number): number;
+export function toPx(value: any, element?: any): number;

package/dist/dom/get-element.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Gets the type of a DOM node
+ * @param {Node|NodeList|Array} node - The node to check
+ * @returns {'element'|'nodelist'|'array'|undefined} The type of the node
+ */
+export function getNodeType(node: Node | NodeList | any[]): "element" | "nodelist" | "array" | undefined;
+/**
+ * Gets an element from a selector or returns the element if it's already an Element
+ * @param {string|Element} selector - CSS selector or Element
+ * @returns {Element|undefined} The matching element or undefined if not found
+ *
+ * @example
+ * // Get element by selector
+ * const button = getElement('.button')
+ *
+ * // Pass through Element
+ * const element = document.querySelector('.button')
+ * const sameElement = getElement(element) // Returns element directly
+ */
+export function getElement(selector: string | Element): Element | undefined;
+/**
+ * Gets all child elements of a node, handling Astro slots
+ * @param {Element} node - The parent node
+ * @returns {Element[]} Array of child elements
+ *
+ * @example
+ * // Get children of a div
+ * const children = getChildrenElements(div)
+ *
+ * // Works with Astro slots
+ * const slotChildren = getChildrenElements(astroSlot)
+ */
+export function getChildrenElements(node: Element): Element[];
+/**
+ * Gets the parent element, skipping Astro-specific nodes
+ * @param {Element} element - The element to get the parent of
+ * @returns {Element|null} The parent element, or null if no parent exists
+ *
+ * @example
+ * // Get parent, skipping Astro slots
+ * const parent = getParentElement(element)
+ */
+export function getParentElement(element: Element): Element | null;
+/**
+ * Gets all sibling elements of an element (excluding the element itself)
+ * @param {Element} element - The element to get siblings of
+ * @returns {Element[]} Array of sibling elements
+ *
+ * @example
+ * // Get all siblings of an element
+ * const siblings = getSiblingElements(element)
+ */
+export function getSiblingElements(element: Element): Element[];
+/**
+ * Gets the index of an element among its siblings
+ * @param {Element} element - The element to get the index of
+ * @returns {number} The index of the element (0-based)
+ *
+ * @example
+ * // Get position of element among siblings
+ * const index = getSelfIndex(element)
+ */
+export function getSelfIndex(element: Element): number;
+/**
+ * Checks if an element is an ancestor of another element
+ * @param {Element} ancestor - The potential ancestor element
+ * @param {Element} element - The element to check
+ * @param {Object} [options] - Options for the search
+ * @param {number} [options.searchLevels=0] - Number of levels to search up, 0 for unlimited
+ * @returns {boolean} True if ancestor is an ancestor of element
+ *
+ * @example
+ * // Check if div is an ancestor of button
+ * const isParent = isAncestor(div, button)
+ *
+ * // Check if div is an ancestor within 2 levels
+ * const isCloseAncestor = isAncestor(div, button, { searchLevels: 2 })
+ */
+export function isAncestor(ancestor: Element, element: Element, { searchLevels }?: {
+    searchLevels?: number;
+}): boolean;
+/**
+ * Gets ancestor elements with their siblings, optionally limiting the search depth.
+ * Useful for finding the nearest ancestor that has siblings.
+ *
+ * @param {Element} element - The element to start searching from
+ * @param {Object} [options] - Options for the search
+ * @param {number|boolean} [options.limit=false] - Number of levels to search up, or false for unlimited
+ * @returns {Element[]|null} Array of sibling elements, or null if none found
+ *
+ * @example
+ * // Get siblings of nearest ancestor that has siblings
+ * const ancestorSiblings = getAncestorWithSiblings(element)
+ *
+ * // Search up to 2 levels
+ * const limitedSiblings = getAncestorWithSiblings(element, { limit: 2 })
+ */
+export function getAncestorWithSiblings(element: Element, { limit }?: {
+    limit?: number | boolean;
+}): Element[] | null;

package/dist/dom/hash.d.ts

@@ -0,0 +1 @@
+export function sha256Hash(string: any): Promise<string>;

package/dist/dom/index.d.ts

@@ -0,0 +1,22 @@
+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 "./trap-focus.js";
+export * from "./ui/index.js";

package/dist/dom/keyboard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Event is Tab (without shift)
+ * @param {KeyboardEvent} event - The keyboard event object
+ * @returns {boolean}
+ */
+export function isTab(event: KeyboardEvent): boolean;
+/**
+ * Event is shift + Tab
+ * @param {KeyboardEvent} event - The keyboard event object
+ * @returns {boolean}
+ */
+export function isShiftTab(event: KeyboardEvent): boolean;
+/**
+ * Matches both Tab and Shift+Tab
+ * @param {string} key - The keyboard key to check
+ * @returns {boolean} Whether the key is Tab
+ */
+export function isTabKey(key: string): boolean;
+/**
+ * Event is an arrow key
+ * @param {string} key - The keyboard key to check
+ * @returns {boolean} Whether the key is an arrow key (Up, Down, Left, Right)
+ */
+export function isArrowKey(key: string): boolean;
+/**
+ * Event is Escape key
+ * @param {string} key - The keyboard key to check
+ * @returns {boolean} Whether the key is Escape
+ */
+export function isEscapeKey(key: string): boolean;

package/dist/dom/local-store.d.ts

@@ -0,0 +1,29 @@
+export namespace 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
+     */
+    function get(key: string): any;
+    /**
+     * 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
+     */
+    function set(key: string, value: any): void;
+    /**
+     * Stores multiple key-value pairs in localStorage
+     * @param {Object|Map} data - An object or Map containing key-value pairs to store
+     */
+    function setMultiple(data: any | Map<any, any>): void;
+    /**
+     * Removes a value from localStorage
+     * @param {string} key - The key to remove from localStorage
+     */
+    function remove(key: string): void;
+    /**
+     * Removes multiple keys from localStorage
+     * @param {string[]} keys - Array of keys to remove from localStorage
+     */
+    function removeMultiple(keys: string[]): void;
+}

package/dist/dom/media.d.ts

@@ -0,0 +1,3 @@
+export function imagesLoaded(node: any): Promise<any[]>;
+export function videosLoaded(node: any): Promise<any[]>;
+export function mediaLoaded(node: any): Promise<[any[], any[]]>;

package/dist/dom/observers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./intersection-observer.js";
+export * from "./mutation-observer.js";
+export * from "./resize-observer.js";

package/dist/dom/observers/intersection-observer.d.ts

@@ -0,0 +1,8 @@
+export function intersectionObserver(target: any, options?: {}): {
+    observer: IntersectionObserver;
+    observe(target: any): void;
+    unobserve(target: any): void;
+    takeRecords(): IntersectionObserverEntry[];
+    disconnect(): void;
+    destroy(): void;
+};

package/dist/dom/observers/mutation-observer.d.ts

@@ -0,0 +1,7 @@
+export function mutationObserver(target: any, options: any): {
+    observer: MutationObserver;
+    observe(target: any): void;
+    takeRecords(): MutationRecord[];
+    disconnect(): void;
+    destroy(): void;
+};

package/dist/dom/observers/observer.d.ts

@@ -0,0 +1 @@
+export function useObserverMethodOnTarget(target: any, observer: any, method?: string, options?: any): void;

package/dist/dom/observers/resize-observer.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Creates and manages a ResizeObserver instance to monitor size changes of a target element.
+ *
+ * @param {Element|Window|NodeList|Element[]} target - The element(s) to observe.
+ *   - If window is provided, document.body will be observed instead.
+ *   - If NodeList or Array of elements is provided, all elements will be observed.
+ * @param {Object} options - Configuration options for the resize observer
+ * @param {boolean} [options.observe=true] - Whether to start observing immediately. If false, the observer won't be created.
+ * @param {Function} [options.callback] - Optional callback function that will be called when resize changes are detected.
+ *                                          If not provided, a 'resize-obs' event will be dispatched on the target.
+ * @param {Object} [options.observerOptions] - Additional options to pass to ResizeObserver.observe()
+ *
+ * @returns {Object} An object with methods to control the observer:
+ *   - observe(target, options): Start observing a new target element
+ *   - unobserve(target): Stop observing a target element
+ *   - disconnect(): Disconnect the observer and stop all observations
+ *   - destroy(): Alias for disconnect()
+ *
+ * @example
+ * // Basic usage with callback
+ * resizeObserver(element, {
+ *   callback: ({ entry, entries, observer }) => {
+ *     console.log('Element resized:', entry.contentRect);
+ *   }
+ * });
+ *
+ * @example
+ * // Usage with event listener
+ * resizeObserver(element);
+ * element.addEventListener('resize-obs', ({ detail }) => {
+ *   console.log('Element resized:', detail.entry.contentRect);
+ * });
+ */
+export function resizeObserver(target: Element | Window | NodeList | Element[], options: {
+    observe?: boolean;
+    callback?: Function;
+    observerOptions?: any;
+}): any;

package/dist/dom/pkce.d.ts

@@ -0,0 +1,6 @@
+export function PKCE(): Promise<{
+    state: string;
+    code_verifier: string;
+    code_challenge: string;
+    code_challenge_method: string;
+}>;

package/dist/dom/query-params.d.ts

@@ -0,0 +1,4 @@
+export namespace queryParams {
+    function get(key: any): string;
+    function stringify(params: any): string;
+}

package/dist/dom/random-string.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates a random string.
+ * Ensures first character is a letter so it can be used in HTML ids and classes
+ * This can actually be used everywhere, not just in the browser.
+ */
+export function randomString(length: any): string;
+export function uuid(): `${string}-${string}-${string}-${string}-${string}`;

package/dist/dom/sanitize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sanitizes values using DOMPurify
+ * @param {*} value - Value to sanitize (string, array, or object)
+ * @param {Object} [options={}] - DOMPurify options
+ * @returns {*} Sanitized value
+ * @throws {Error} If input is a string but DOMPurify fails
+ */
+export function sanitize(value: any, options?: any): any;

package/dist/dom/session-store.d.ts

@@ -0,0 +1,5 @@
+export namespace sessionStore {
+    function get(key: any): any;
+    function set(key: any, value: any): void;
+    function remove(key: any): void;
+}

package/dist/dom/trap-focus.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Traps focus within a set of focusable elements, creating a circular tab order
+ * @param {Object} params
+ * @param {KeyboardEvent} params.event - The keyboard event to handle
+ * @param {import('./focusable.js').Focusables} params.focusables - Object containing focusable elements
+ */
+export function trapFocus({ event, focusables }: {
+    event: KeyboardEvent;
+    focusables: import("./focusable.js").Focusables;
+}): void;
+/**
+ * Manages focus behavior when tabbing through content, with options to control focus on exit
+ * @param {Object} params
+ * @param {KeyboardEvent} params.event - The keyboard event to handle
+ * @param {HTMLElement} params.triggerNode - Element that triggered the focus trap
+ * @param {HTMLElement} params.contentNode - Container element that holds focusable content
+ * @param {import('./focusable.js').Focusables} params.focusables - Object containing focusable elements
+ * @param {'next'|'trigger'} [params.tabOutFocus='next'] - Where to focus when tabbing out: 'next' element or back to trigger
+ * @param {Function} [params.onLeave=()=>{}] - Callback when focus leaves content, receives 'forward' or 'back' direction
+ */
+export function manageFocus({ event, triggerNode, contentNode, focusables, tabOutFocus, onLeave, }: {
+    event: KeyboardEvent;
+    triggerNode: HTMLElement;
+    contentNode: HTMLElement;
+    focusables: import("./focusable.js").Focusables;
+    tabOutFocus?: "next" | "trigger";
+    onLeave?: Function;
+}): void;

package/dist/dom/ui/aria-current.d.ts

@@ -0,0 +1,5 @@
+export function markActiveAnchorIn(container: any, anchorType?: string): any;
+export function goToElement(element: any, { scrollBehaviour, scrollMargin }?: {
+    scrollBehaviour?: string;
+    scrollMargin?: string;
+}): void;

package/dist/dom/ui/inconsistent-button-fix.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Fixes inconsistent button focus behavior across browsers.
+ *
+ * In some browsers (like Firefox), clicking a button doesn't focus it.
+ * This function ensures buttons are focused when clicked, making behavior consistent.
+ *
+ * @see {@link https://zellwk.com/blog/inconsistent-button-behavior/|Source}
+ * @example
+ * // Add the fix to your app
+ * inconsistentButtonFix()
+ */
+export function inconsistentButtonFix(): void;

package/dist/dom/ui/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./aria-current.js";
+export * from "./inconsistent-button-fix.js";
+export * from "./scroll-container.js";
+export * from "./traverse-and-scramble.js";

package/dist/dom/ui/scroll-container.d.ts

@@ -0,0 +1 @@
+export function findScrollContainer(element: any, direction?: string): any;

package/dist/dom/ui/traverse-and-scramble.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Traverses a DOM node and scrambles its text content, excluding specified elements.
+ * Useful for creating placeholder/loading states or privacy features.
+ *
+ * @param {Element|ChildNode} node - The root element or node to start traversal from
+ * @param {Object} [options] - Options for traversal
+ * @param {string[]} [options.excludes=[]] - Array of CSS selectors to exclude from scrambling
+ * @example
+ * // Scramble all text in a container
+ * traverseAndScramble(document.querySelector('.container'))
+ *
+ * // Scramble text but exclude certain elements
+ * traverseAndScramble(document.body, {
+ *   excludes: ['.no-scramble', '[data-no-scramble]']
+ * })
+ */
+export function traverseAndScramble(node: Element | ChildNode, { excludes }?: {
+    excludes?: string[];
+}): void;

package/dist/lib/arrays/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./item-position.js";
+export * from "./join.js";
+export * from "./shuffle.js";
+export * from "./sort.js";
+export * from "./unique.js";

package/dist/lib/arrays/item-position.d.ts

@@ -0,0 +1,14 @@
+export function last(array: any, index: any): boolean;
+/**
+ * Checks if the given index is the last item in the array
+ * @param {Array} array - The array to check
+ * @param {number} index - The index to check
+ * @returns {boolean} True if the index is the last item, false otherwise
+ */
+export function isLastItem(array: any[], index: number): boolean;
+/**
+ * Returns the last item in the array
+ * @param {Array} array - The array to get the last item from
+ * @returns {*} The last item in the array
+ */
+export function lastArrayItem(array: any[]): any;