@react-hive/honey-utils 2.3.1 → 3.0.0

package/dist/index.dev.cjs

@@ -383,12 +383,17 @@ const findAsync = async (array, predicate) => {
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   FOCUSABLE_HTML_TAGS: () => (/* binding */ FOCUSABLE_HTML_TAGS),
 /* harmony export */   cloneBlob: () => (/* binding */ cloneBlob),
-/* harmony export */   convertBlobToFile: () => (/* binding */ convertBlobToFile),
 /* harmony export */   getDOMRectIntersectionRatio: () => (/* binding */ getDOMRectIntersectionRatio),
 /* harmony export */   getElementOffsetRect: () => (/* binding */ getElementOffsetRect),
+/* harmony export */   getFocusableHtmlElements: () => (/* binding */ getFocusableHtmlElements),
+/* harmony export */   isAnchorHtmlElement: () => (/* binding */ isAnchorHtmlElement),
+/* harmony export */   isContentEditableHtmlElement: () => (/* binding */ isContentEditableHtmlElement),
+/* harmony export */   isHtmlElementFocusable: () => (/* binding */ isHtmlElementFocusable),
 /* harmony export */   parse2DMatrix: () => (/* binding */ parse2DMatrix)
 /* harmony export */ });
+const FOCUSABLE_HTML_TAGS = ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON', 'A'];
 /**
  * Extracts transformation values (translate, scale, skew) from the 2D transformation matrix of a given HTML element.
  *
@@ -438,28 +443,6 @@ const parse2DMatrix = (element) => {
  * @returns A new Blob with the same content and type as the original.
  */
 const cloneBlob = (blob) => new Blob([blob], { type: blob.type });
-/**
- * Converts a `Blob` object into a `File` object with the specified name.
- *
- * This is useful when you receive a `Blob` (e.g., from canvas, fetch, or file manipulation)
- * and need to convert it into a `File` to upload via `FormData` or file inputs.
- *
- * @param blob - The `Blob` to convert.
- * @param fileName - The desired name for the resulting file (including extension).
- *
- * @returns A `File` instance with the same content and MIME type as the input `Blob`.
- *
- * @example
- * ```ts
- * const blob = new Blob(['Hello world'], { type: 'text/plain' });
- * const file = convertBlobToFile(blob, 'hello.txt');
- *
- * console.log(file instanceof File); // true
- * ```
- */
-const convertBlobToFile = (blob, fileName) => new File([blob], fileName, {
-    type: blob.type,
-});
 /**
  * Calculates the intersection ratio between two DOM rectangles.
  *
@@ -488,6 +471,166 @@ const getDOMRectIntersectionRatio = (sourceRect, targetRect) => {
  * @returns A `DOMRect` representing the element’s offset position and size.
  */
 const getElementOffsetRect = (element) => new DOMRect(element.offsetLeft, element.offsetTop, element.clientWidth, element.clientHeight);
+/**
+ * Determines whether the given HTMLElement is an HTMLAnchorElement.
+ *
+ * Acts as a type guard so that TypeScript narrows `element` to
+ * `HTMLAnchorElement` when the function returns `true`.
+ *
+ * An element qualifies as an anchor by having a tag name of `"A"`.
+ *
+ * @param element - The element to test.
+ *
+ * @returns Whether the element is an anchor element.
+ */
+const isAnchorHtmlElement = (element) => element.tagName === 'A';
+/**
+ * Checks whether an element is explicitly marked as contenteditable.
+ *
+ * Browsers treat elements with `contenteditable="true"` as focusable,
+ * even if they are not normally keyboard-focusable.
+ *
+ * @param element - The element to inspect.
+ *
+ * @returns True if `contenteditable="true"` is set.
+ */
+const isContentEditableHtmlElement = (element) => element.getAttribute('contenteditable') === 'true';
+/**
+ * Determines whether an HTMLElement is focusable under standard browser rules.
+ *
+ * The function checks a combination of factors:
+ * - The element must be rendered (not `display: none` or `visibility: hidden`).
+ * - Disabled form controls are never focusable.
+ * - Elements with `tabindex="-1"` are intentionally removed from the focus order.
+ * - Certain native HTML elements are inherently focusable (e.g. inputs, buttons, anchors with `href`).
+ * - Elements with `contenteditable="true"` are treated as focusable.
+ * - Any element with a valid `tabindex` (not null) is considered focusable.
+ *
+ * This logic approximates how browsers and the accessibility tree
+ * determine real-world focusability—not just tabindex presence.
+ *
+ * @param element - The element to test. `null` or `undefined` will return `false`.
+ *
+ * @returns Whether the element is focusable.
+ */
+const isHtmlElementFocusable = (element) => {
+    if (!element) {
+        return false;
+    }
+    // Hidden or not rendered
+    const style = window.getComputedStyle(element);
+    if (style.visibility === 'hidden' || style.display === 'none') {
+        return false;
+    }
+    if ('disabled' in element && element.disabled) {
+        return false;
+    }
+    // Explicitly removed from tab order
+    const tabIndex = element.getAttribute('tabindex');
+    if (tabIndex === '-1') {
+        return false;
+    }
+    if (FOCUSABLE_HTML_TAGS.includes(element.tagName)) {
+        if (isAnchorHtmlElement(element)) {
+            return element.href !== '';
+        }
+        return true;
+    }
+    if (isContentEditableHtmlElement(element)) {
+        return true;
+    }
+    return tabIndex !== null;
+};
+/**
+ * Collects all focusable descendant elements within a container.
+ *
+ * The function queries *all* elements under the container and filters them
+ * using `isHtmlElementFocusable`, producing a reliable list of elements
+ * that can receive keyboard focus in real-world browser conditions.
+ *
+ * @param container - The root container whose focusable children will be found.
+ *
+ * @returns An array of focusable HTMLElements in DOM order.
+ */
+const getFocusableHtmlElements = (container) => Array.from(container.querySelectorAll('*')).filter(isHtmlElementFocusable);
+
+
+/***/ }),
+
+/***/ "./src/file.ts":
+/*!*********************!*\
+  !*** ./src/file.ts ***!
+  \*********************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   blobToFile: () => (/* binding */ blobToFile),
+/* harmony export */   fileListToFiles: () => (/* binding */ fileListToFiles),
+/* harmony export */   parseFileName: () => (/* binding */ parseFileName)
+/* harmony export */ });
+/**
+ * Splits a file name into its base name and extension.
+ *
+ * Special cases:
+ * - Files without a dot return `[fileName, ""]`
+ * - Hidden files like `.gitignore` return `[".gitignore", ""]`
+ * - Names ending with a trailing dot (e.g., `"file."`) return `["file.", ""]`
+ * - Multi-dot names (e.g., `"archive.tar.gz"`) split on the last dot
+ *
+ * @param fileName - The full file name to parse.
+ *
+ * @returns A tuple where:
+ *  - index 0 is the base name
+ *  - index 1 is the file extension (lowercased), or an empty string if none exists
+ */
+const parseFileName = (fileName) => {
+    const lastDotIndex = fileName.lastIndexOf('.');
+    // No dot or leading dot with no extension (e.g., ".gitignore")
+    if (lastDotIndex <= 0 || lastDotIndex === fileName.length - 1) {
+        return [fileName, ''];
+    }
+    return [fileName.slice(0, lastDotIndex), fileName.slice(lastDotIndex + 1).toLowerCase()];
+};
+/**
+ * Converts a `FileList` object to an array of `File` objects.
+ *
+ * @param fileList - The `FileList` object to convert.
+ *
+ * @returns An array of `File` objects.
+ */
+const fileListToFiles = (fileList) => {
+    if (!fileList) {
+        return [];
+    }
+    const files = [];
+    for (let i = 0; i < fileList.length; i++) {
+        files.push(fileList[i]);
+    }
+    return files;
+};
+/**
+ * Converts a `Blob` object into a `File` object with the specified name.
+ *
+ * This is useful when you receive a `Blob` (e.g., from canvas, fetch, or file manipulation)
+ * and need to convert it into a `File` to upload via `FormData` or file inputs.
+ *
+ * @param blob - The `Blob` to convert.
+ * @param fileName - The desired name for the resulting file (including extension).
+ *
+ * @returns A `File` instance with the same content and MIME type as the input `Blob`.
+ *
+ * @example
+ * ```ts
+ * const blob = new Blob(['Hello world'], { type: 'text/plain' });
+ * const file = blobToFile(blob, 'hello.txt');
+ *
+ * console.log(file instanceof File); // true
+ * ```
+ */
+const blobToFile = (blob, fileName) => new File([blob], fileName, {
+    type: blob.type,
+});
 
 
 /***/ }),
@@ -950,6 +1093,7 @@ const calculatePercentage = (value, percentage) => {
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   camelToDashCase: () => (/* binding */ camelToDashCase),
+/* harmony export */   camelToWords: () => (/* binding */ camelToWords),
 /* harmony export */   hashString: () => (/* binding */ hashString),
 /* harmony export */   splitStringIntoWords: () => (/* binding */ splitStringIntoWords),
 /* harmony export */   toKebabCase: () => (/* binding */ toKebabCase)
@@ -1001,6 +1145,25 @@ const camelToDashCase = (input) => {
     const restProcessed = restOfString.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
     return firstCharProcessed + restProcessed;
 };
+/**
+ * Splits a camelCase or PascalCase string into separate words with spaces.
+ *
+ * This function inserts spaces between lowercase and uppercase letters,
+ * making camelCase or PascalCase strings more human-readable without
+ * altering their original capitalization.
+ *
+ * @param input - The camelCase or PascalCase string to split into words.
+ *
+ * @returns The string with spaces inserted between words.
+ *
+ * @example
+ * ```ts
+ * camelToWords('helloWorld'); // → 'hello World'
+ * camelToWords('HelloWorld'); // → 'Hello World'
+ * camelToWords('userIDNumber'); // → 'user ID Number'
+ * ```
+ */
+const camelToWords = (input) => input.replace(/([a-z0-9])([A-Z])/g, '$1 $2');
 /**
  * Splits a string into an array of filtered from redundant spaces words.
  *
@@ -1108,35 +1271,42 @@ var __webpack_exports__ = {};
   \**********************/
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   FOCUSABLE_HTML_TAGS: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.FOCUSABLE_HTML_TAGS),
 /* harmony export */   assert: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.assert),
+/* harmony export */   blobToFile: () => (/* reexport safe */ _file__WEBPACK_IMPORTED_MODULE_7__.blobToFile),
 /* harmony export */   calculateEuclideanDistance: () => (/* reexport safe */ _math__WEBPACK_IMPORTED_MODULE_5__.calculateEuclideanDistance),
 /* harmony export */   calculateMovingSpeed: () => (/* reexport safe */ _math__WEBPACK_IMPORTED_MODULE_5__.calculateMovingSpeed),
 /* harmony export */   calculatePercentage: () => (/* reexport safe */ _math__WEBPACK_IMPORTED_MODULE_5__.calculatePercentage),
 /* harmony export */   camelToDashCase: () => (/* reexport safe */ _string__WEBPACK_IMPORTED_MODULE_1__.camelToDashCase),
+/* harmony export */   camelToWords: () => (/* reexport safe */ _string__WEBPACK_IMPORTED_MODULE_1__.camelToWords),
 /* harmony export */   chunk: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_2__.chunk),
 /* harmony export */   cloneBlob: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.cloneBlob),
 /* harmony export */   compact: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_2__.compact),
 /* harmony export */   compose: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_2__.compose),
-/* harmony export */   convertBlobToFile: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.convertBlobToFile),
 /* harmony export */   delay: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_3__.delay),
 /* harmony export */   difference: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_2__.difference),
 /* harmony export */   everyAsync: () => (/* reexport safe */ _async__WEBPACK_IMPORTED_MODULE_0__.everyAsync),
+/* harmony export */   fileListToFiles: () => (/* reexport safe */ _file__WEBPACK_IMPORTED_MODULE_7__.fileListToFiles),
 /* harmony export */   filterParallel: () => (/* reexport safe */ _async__WEBPACK_IMPORTED_MODULE_0__.filterParallel),
 /* harmony export */   filterSequential: () => (/* reexport safe */ _async__WEBPACK_IMPORTED_MODULE_0__.filterSequential),
 /* harmony export */   findAsync: () => (/* reexport safe */ _async__WEBPACK_IMPORTED_MODULE_0__.findAsync),
 /* harmony export */   getDOMRectIntersectionRatio: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.getDOMRectIntersectionRatio),
 /* harmony export */   getElementOffsetRect: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.getElementOffsetRect),
+/* harmony export */   getFocusableHtmlElements: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.getFocusableHtmlElements),
 /* harmony export */   hashString: () => (/* reexport safe */ _string__WEBPACK_IMPORTED_MODULE_1__.hashString),
 /* harmony export */   intersection: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_2__.intersection),
 /* harmony export */   invokeIfFunction: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_3__.invokeIfFunction),
+/* harmony export */   isAnchorHtmlElement: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.isAnchorHtmlElement),
 /* harmony export */   isArray: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isArray),
 /* harmony export */   isBool: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isBool),
+/* harmony export */   isContentEditableHtmlElement: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.isContentEditableHtmlElement),
 /* harmony export */   isDate: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isDate),
 /* harmony export */   isDefined: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isDefined),
 /* harmony export */   isEmptyArray: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isEmptyArray),
 /* harmony export */   isEmptyObject: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isEmptyObject),
 /* harmony export */   isFiniteNumber: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isFiniteNumber),
 /* harmony export */   isFunction: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isFunction),
+/* harmony export */   isHtmlElementFocusable: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.isHtmlElementFocusable),
 /* harmony export */   isInteger: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isInteger),
 /* harmony export */   isMap: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isMap),
 /* harmony export */   isNil: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_4__.isNil),
@@ -1154,6 +1324,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   noop: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_3__.noop),
 /* harmony export */   not: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_3__.not),
 /* harmony export */   parse2DMatrix: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_6__.parse2DMatrix),
+/* harmony export */   parseFileName: () => (/* reexport safe */ _file__WEBPACK_IMPORTED_MODULE_7__.parseFileName),
 /* harmony export */   pipe: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_2__.pipe),
 /* harmony export */   reduceAsync: () => (/* reexport safe */ _async__WEBPACK_IMPORTED_MODULE_0__.reduceAsync),
 /* harmony export */   retry: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_3__.retry),
@@ -1172,6 +1343,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _guards__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./guards */ "./src/guards.ts");
 /* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./math */ "./src/math.ts");
 /* harmony import */ var _dom__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./dom */ "./src/dom.ts");
+/* harmony import */ var _file__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./file */ "./src/file.ts");
+
 
 
 

package/dist/index.dev.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.dev.cjs","mappings":"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","sources":["webpack://@react-hive/honey-utils/./src/array.ts","webpack://@react-hive/honey-utils/./src/async.ts","webpack://@react-hive/honey-utils/./src/dom.ts","webpack://@react-hive/honey-utils/./src/function.ts","webpack://@react-hive/honey-utils/./src/guards.ts","webpack://@react-hive/honey-utils/./src/math.ts","webpack://@react-hive/honey-utils/./src/string.ts","webpack://@react-hive/honey-utils/webpack/bootstrap","webpack://@react-hive/honey-utils/webpack/runtime/define property getters","webpack://@react-hive/honey-utils/webpack/runtime/hasOwnProperty shorthand","webpack://@react-hive/honey-utils/webpack/runtime/make namespace object","webpack://@react-hive/honey-utils/./src/index.ts"],"sourcesContent":["import { assert } from './guards';\n\n/**\n * Represents all falsy values.\n */\ntype Falsy = false | null | undefined | 0 | '';\n\n/**\n * Removes all falsy values from an array.\n *\n * Falsy values include: `false`, `0`, `''` (empty string), `null`, `undefined`, and `NaN`.\n *\n * Useful for cleaning up arrays with optional, nullable, or conditionally included items.\n *\n * @template T - The type of the truthy items.\n *\n * @param array - An array possibly containing falsy values.\n *\n * @returns A new array containing only truthy values of type `T`.\n *\n * @example\n * ```ts\n * compact([0, 1, false, 2, '', 3, null, undefined, NaN]); // [1, 2, 3]\n * ```\n */\nexport const compact = <T>(array: (T | Falsy)[]): T[] => array.filter(Boolean) as T[];\n\n/**\n * Returns a new array with duplicate values removed.\n *\n * Uses Set for efficient duplicate removal while preserving the original order.\n *\n * @template T - The type of the items in the array.\n *\n * @param array - The input array that may contain duplicate values.\n *\n * @returns A new array with only unique values, maintaining the original order.\n *\n * @example\n * ```ts\n * unique([1, 2, 2, 3, 1, 4]); // [1, 2, 3, 4]\n * unique(['a', 'b', 'a', 'c']); // ['a', 'b', 'c']\n * ```\n */\nexport const unique = <T>(array: T[]): T[] => [...new Set(array)];\n\n/**\n * Splits an array into chunks of the specified size.\n *\n * Useful for pagination, batch processing, or creating grid layouts.\n *\n * @template T - The type of the items in the array.\n *\n * @param array - The input array to be chunked.\n * @param size - The size of each chunk. Must be greater than 0.\n *\n * @returns An array of chunks, where each chunk is an array of the specified size\n *          (except possibly the last chunk, which may be smaller).\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * chunk(['a', 'b', 'c', 'd'], 3); // [['a', 'b', 'c'], ['d']]\n * ```\n */\nexport const chunk = <T>(array: T[], size: number): T[][] => {\n  assert(size > 0, 'Chunk size must be greater than 0');\n\n  return Array.from({ length: Math.ceil(array.length / size) }, (_, index) =>\n    array.slice(index * size, (index + 1) * size),\n  );\n};\n\n/**\n * Returns an array containing elements that exist in all provided arrays.\n *\n * @template T - The type of the items in the arrays.\n *\n * @param arrays - Two or more arrays to find common elements from.\n *\n * @returns A new array containing only the elements that exist in all input arrays.\n *\n * @example\n * ```ts\n * intersection([1, 2, 3], [2, 3, 4]); // [2, 3]\n * intersection(['a', 'b', 'c'], ['b', 'c', 'd'], ['b', 'e']); // ['b']\n * ```\n */\nexport const intersection = <T>(...arrays: T[][]): T[] => {\n  if (arrays.length === 0) {\n    return [];\n  }\n\n  if (arrays.length === 1) {\n    return [...arrays[0]];\n  }\n\n  const [first, ...rest] = arrays;\n  const uniqueFirst = unique(first);\n\n  return uniqueFirst.filter(item => rest.every(array => array.includes(item)));\n};\n\n/**\n * Returns elements from the first array that don't exist in the second array.\n *\n * @template T - The type of the items in the arrays.\n *\n * @param array - The source array.\n * @param exclude - The array containing elements to exclude.\n *\n * @returns A new array with elements from the first array that don't exist in the second array.\n *\n * @example\n * ```ts\n * difference([1, 2, 3, 4], [2, 4]); // [1, 3]\n * difference(['a', 'b', 'c'], ['b']); // ['a', 'c']\n * ```\n */\nexport const difference = <T>(array: T[], exclude: T[]): T[] =>\n  array.filter(item => !exclude.includes(item));\n\ntype PipeFn = (arg: unknown) => unknown;\n\ntype Pipe = {\n  <A, B>(fn1: (a: A) => B): (a: A) => B;\n  <A, B, C>(fn1: (a: A) => B, fn2: (b: B) => C): (a: A) => C;\n  <A, B, C, D>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): (a: A) => D;\n  <A, B, C, D, E>(\n    fn1: (a: A) => B,\n    fn2: (b: B) => C,\n    fn3: (c: C) => D,\n    fn4: (d: D) => E,\n  ): (a: A) => E;\n  <A, B, C, D, E, F>(\n    fn1: (a: A) => B,\n    fn2: (b: B) => C,\n    fn3: (c: C) => D,\n    fn4: (d: D) => E,\n    fn5: (e: E) => F,\n  ): (a: A) => F;\n  (...fns: PipeFn[]): (arg: unknown) => unknown;\n};\n\n/**\n * Composes multiple unary functions into a single function, applying them from left to right.\n *\n * Useful for building a data processing pipeline where the output of one function becomes the input of the next.\n *\n * Types are inferred up to 5 chained functions for full type safety. Beyond that, it falls back to the unknown.\n *\n * @param fns - A list of unary functions to compose.\n *\n * @returns A new function that applies all functions from left to right.\n *\n * @example\n * ```ts\n * const add = (x: number) => x + 1;\n * const double = (x: number) => x * 2;\n * const toStr = (x: number) => `Result: ${x}`;\n *\n * const result = pipe(add, double, toStr)(2);\n * // => 'Result: 6'\n * ```\n */\nexport const pipe: Pipe =\n  (...fns: PipeFn[]) =>\n  (arg: unknown) =>\n    fns.reduce((prev, fn) => fn(prev), arg);\n\ntype ComposeFn = (arg: unknown) => unknown;\n\ntype Compose = {\n  <A, R>(fn1: (a: A) => R): (a: A) => R;\n  <A, B, R>(fn1: (b: B) => R, fn2: (a: A) => B): (a: A) => R;\n  <A, B, C, R>(fn1: (c: C) => R, fn2: (b: B) => C, fn3: (a: A) => B): (a: A) => R;\n  <A, B, C, D, R>(\n    fn1: (d: D) => R,\n    fn2: (c: C) => D,\n    fn3: (b: B) => C,\n    fn4: (a: A) => B,\n  ): (a: A) => R;\n  <A, B, C, D, E, R>(\n    fn1: (e: E) => R,\n    fn2: (d: D) => E,\n    fn3: (c: C) => D,\n    fn4: (b: B) => C,\n    fn5: (a: A) => B,\n  ): (a: A) => R;\n  (...fns: ComposeFn[]): (arg: unknown) => unknown;\n};\n\n/**\n * Composes multiple unary functions into a single function, applying them from **right to left**.\n *\n * Often used for building functional pipelines where the innermost function runs first.\n * Types are inferred up to 5 chained functions for full type safety.\n *\n * @param fns - A list of unary functions to compose.\n *\n * @returns A new function that applies all functions from right to left.\n *\n * @example\n * ```ts\n * const add = (x: number) => x + 1;\n * const double = (x: number) => x * 2;\n * const toStr = (x: number) => `Result: ${x}`;\n *\n * const result = compose(toStr, double, add)(2);\n * // => 'Result: 6'\n * ```\n */\nexport const compose: Compose =\n  (...fns: ComposeFn[]) =>\n  (arg: unknown) =>\n    fns.reduceRight((prev, fn) => fn(prev), arg);\n","import { compact } from './array';\n\n/**\n * Asynchronously iterates over an array and executes an async function on each item sequentially,\n * collecting the results.\n *\n * Useful when order or timing matters (e.g., rate limits, UI updates, animations).\n *\n * @param array - The array of items to iterate over.\n * @param fn - An async function to execute for each item. Must return a value.\n *\n * @returns A promise that resolves with an array of results from each function call.\n *\n * @example\n * ```ts\n * const results = await runSequential([1, 2, 3], async (item) => {\n *   await delay(100);\n *\n *   return item * 2;\n * });\n *\n * console.log(results); // [2, 4, 6]\n * ```\n */\nexport const runSequential = async <Item, Result>(\n  array: Item[],\n  fn: (item: Item, index: number, array: Item[]) => Promise<Result>,\n): Promise<Result[]> => {\n  const results: Result[] = [];\n\n  for (let i = 0; i < array.length; i++) {\n    results.push(await fn(array[i], i, array));\n  }\n\n  return results;\n};\n\n/**\n * Executes an asynchronous operation on each element of an array and waits for all promises to resolve.\n *\n * @param array - The array of items to operate on.\n * @param fn - The asynchronous operation to perform on each item.\n *\n * @returns A promise that resolves with an array of results after all operations are completed.\n *\n * @example\n * ```ts\n * const results = await runParallel([1, 2, 3], async (item) => {\n *   await delay(100);\n *\n *   return item * 2;\n * });\n *\n * console.log(results); // [2, 4, 6]\n * ```\n */\nexport const runParallel = async <Item, Result>(\n  array: Item[],\n  fn: (item: Item, index: number, array: Item[]) => Promise<Result>,\n): Promise<Result[]> => Promise.all(array.map(fn));\n\n/**\n * Asynchronously filters an array using a predicate function, executing **sequentially**.\n *\n * Useful for rate-limited or stateful async operations where execution order matters.\n *\n * @template Item - The type of the items in the input array.\n *\n * @param array - The array of items to filter.\n * @param predicate - An async function that returns a `boolean` indicating whether to keep each item.\n *\n * @returns A promise that resolves to a new array containing only the items for which the predicate returned `true`.\n *\n * @example\n * ```ts\n * // Sequentially filter even numbers with delay\n * const result = await filterSequential([1, 2, 3, 4], async (num) => {\n *   await delay(100);\n *\n *   return num % 2 === 0;\n * });\n *\n * console.log(result); // [2, 4]\n * ```\n */\nexport const filterSequential = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<Item[]> => {\n  const results: Item[] = [];\n\n  for (let i = 0; i < array.length; i++) {\n    const item = array[i];\n\n    if (await predicate(item, i, array)) {\n      results.push(item);\n    }\n  }\n\n  return results;\n};\n\n/**\n * Asynchronously filters an array based on a provided async predicate function.\n *\n * Each item is passed to the `predicate` function in parallel, and only the items\n * for which the predicate resolves to `true` are included in the final result.\n *\n * Useful for filtering based on asynchronous conditions such as API calls,\n * file system access, or any other delayed operations.\n *\n * @template Item - The type of the items in the input array.\n *\n * @param array - The array of items to filter.\n * @param predicate - An async function that returns a boolean indicating whether to keep each item.\n *\n * @returns A promise that resolves to a new array containing only the items for which the predicate returned `true`.\n *\n * @example\n * ```ts\n * // Filter numbers that are even after a simulated delay\n * const result = await filterParallel([1, 2, 3, 4], async (num) => {\n *   await delay(100);\n *\n *   return num % 2 === 0;\n * });\n *\n * console.log(result); // [2, 4]\n * ```\n */\nexport const filterParallel = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<Item[]> => {\n  const results = await runParallel(array, async (item, index, array) =>\n    (await predicate(item, index, array)) ? item : false,\n  );\n\n  return compact(results);\n};\n\n/**\n * Asynchronously checks if at least one element in the array satisfies the async condition.\n *\n * @param array - The array of items to check.\n * @param predicate - An async function that returns a boolean.\n *\n * @returns A promise that resolves to true if any item passes the condition.\n */\nexport const someAsync = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<boolean> => {\n  for (let i = 0; i < array.length; i++) {\n    if (await predicate(array[i], i, array)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Asynchronously checks if all elements in the array satisfy the async condition.\n *\n * @param array - The array of items to check.\n * @param predicate - An async function that returns a boolean.\n *\n * @returns A promise that resolves to true if all items pass the condition.\n */\nexport const everyAsync = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<boolean> => {\n  for (let i = 0; i < array.length; i++) {\n    if (!(await predicate(array[i], i, array))) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Asynchronously reduces an array to a single accumulated value.\n *\n * @template Item - The type of items in the array.\n * @template Accumulator - The type of the accumulated result.\n *\n * @param array - The array to reduce.\n * @param fn - The async reducer function that processes each item and returns the updated accumulator.\n * @param initialValue - The initial accumulator value.\n *\n * @returns A promise that resolves to the final accumulated result.\n */\nexport const reduceAsync = async <Item, Accumulator>(\n  array: Item[],\n  fn: (accumulator: Accumulator, item: Item, index: number, array: Item[]) => Promise<Accumulator>,\n  initialValue: Accumulator,\n): Promise<Accumulator> => {\n  let accumulator = initialValue;\n\n  for (let i = 0; i < array.length; i++) {\n    accumulator = await fn(accumulator, array[i], i, array);\n  }\n\n  return accumulator;\n};\n\n/**\n * Asynchronously finds the first element that satisfies the async condition.\n *\n * @param array - The array of items to search.\n * @param predicate - An async function that returns a boolean.\n *\n * @returns A promise that resolves to the found item or null if none match.\n */\nexport const findAsync = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<Item | null> => {\n  for (let i = 0; i < array.length; i++) {\n    if (await predicate(array[i], i, array)) {\n      return array[i];\n    }\n  }\n\n  return null;\n};\n","interface HTMLElementTransformationValues {\n  translateX: number;\n  translateY: number;\n  scaleX: number;\n  scaleY: number;\n  skewX: number;\n  skewY: number;\n}\n\n/**\n * Extracts transformation values (translate, scale, skew) from the 2D transformation matrix of a given HTML element.\n *\n * Only works with 2D transforms (i.e., `matrix(a, b, c, d, e, f)`).\n *\n * @param element - The element with a CSS transform applied.\n * @returns An object with parsed transformation values.\n *\n * @example\n * ```ts\n * const values = parse2DMatrix(myElement);\n * console.log(values.translateX);\n * console.log(values.scaleX);\n * ```\n */\nexport const parse2DMatrix = (element: HTMLElement): HTMLElementTransformationValues => {\n  const computedStyles = window.getComputedStyle(element);\n  const transformValue = computedStyles.getPropertyValue('transform');\n\n  const matrixMatch = transformValue.match(/^matrix\\((.+)\\)$/);\n  if (!matrixMatch) {\n    return {\n      translateX: 0,\n      translateY: 0,\n      scaleX: 1,\n      scaleY: 1,\n      skewX: 0,\n      skewY: 0,\n    };\n  }\n\n  const [scaleX, skewY, skewX, scaleY, translateX, translateY] = matrixMatch[1]\n    .split(', ')\n    .map(parseFloat);\n\n  return {\n    translateX,\n    translateY,\n    scaleX,\n    scaleY,\n    skewX,\n    skewY,\n  };\n};\n\n/**\n * Creates a clone of a Blob object.\n *\n * @param blob - The Blob object to clone.\n *\n * @returns A new Blob with the same content and type as the original.\n */\nexport const cloneBlob = (blob: Blob): Blob => new Blob([blob], { type: blob.type });\n\n/**\n * Converts a `Blob` object into a `File` object with the specified name.\n *\n * This is useful when you receive a `Blob` (e.g., from canvas, fetch, or file manipulation)\n * and need to convert it into a `File` to upload via `FormData` or file inputs.\n *\n * @param blob - The `Blob` to convert.\n * @param fileName - The desired name for the resulting file (including extension).\n *\n * @returns A `File` instance with the same content and MIME type as the input `Blob`.\n *\n * @example\n * ```ts\n * const blob = new Blob(['Hello world'], { type: 'text/plain' });\n * const file = convertBlobToFile(blob, 'hello.txt');\n *\n * console.log(file instanceof File); // true\n * ```\n */\nexport const convertBlobToFile = (blob: Blob, fileName: string): File =>\n  new File([blob], fileName, {\n    type: blob.type,\n  });\n\n/**\n * Calculates the intersection ratio between two DOM rectangles.\n *\n * The ratio represents the proportion of the `targetRect` that is covered by `sourceRect`.\n * A value of `1` means `sourceRect` completely covers `targetRect`, and `0` means no overlap.\n *\n * @param sourceRect - The rectangle used to measure overlap against the target.\n * @param targetRect - The rectangle whose covered area is measured.\n *\n * @returns A number between `0` and `1` representing the intersection ratio.\n */\nexport const getDOMRectIntersectionRatio = (sourceRect: DOMRect, targetRect: DOMRect): number => {\n  const xOverlap = Math.max(\n    0,\n    Math.min(sourceRect.right, targetRect.right) - Math.max(sourceRect.left, targetRect.left),\n  );\n\n  const yOverlap = Math.max(\n    0,\n    Math.min(sourceRect.bottom, targetRect.bottom) - Math.max(sourceRect.top, targetRect.top),\n  );\n\n  const intersectionArea = xOverlap * yOverlap;\n  const targetArea = targetRect.width * targetRect.height;\n\n  return intersectionArea / targetArea;\n};\n\n/**\n * Returns the bounding DOMRect of an element based on offset and client dimensions.\n *\n * This utility is useful when you need a stable, layout-based rect\n * without triggering a reflow via `getBoundingClientRect()`.\n *\n * @param element - The target HTML element.\n * @returns A `DOMRect` representing the element’s offset position and size.\n */\nexport const getElementOffsetRect = (element: HTMLElement): DOMRect =>\n  new DOMRect(element.offsetLeft, element.offsetTop, element.clientWidth, element.clientHeight);\n","export const noop = () => {};\n\n/**\n * Creates a function that negates the result of the given predicate function.\n *\n * @template Args - Argument types of the predicate function.\n *\n * @param fn - A function that returns any value.\n *\n * @returns A new function that returns the negated result of the original function.\n *\n * @example\n * ```ts\n * const isEven = (n: number) => n % 2 === 0;\n * const isOdd = not(isEven);\n *\n * console.log(isOdd(2)); // false\n * console.log(isOdd(3)); // true\n * ```\n */\nexport const not =\n  <Args extends unknown[]>(fn: (...args: Args) => any): ((...args: Args) => boolean) =>\n  (...args: Args) =>\n    !fn(...args);\n\n/**\n * Invokes the given input if it is a function, passing the provided arguments.\n * Otherwise, returns the input as-is.\n *\n * @template Args - Tuple of argument types to pass to the function.\n * @template Result - Return type of the function or the value.\n *\n * @param input - A function to invoke with `args`, or a direct value of type `Result`.\n * @param args - Arguments to pass if `input` is a function.\n *\n * @returns The result of invoking the function, or the original value if it's not a function.\n */\nexport const invokeIfFunction = <Args extends unknown[], Result>(\n  input: ((...args: Args) => Result) | Result,\n  ...args: Args\n): Result => (typeof input === 'function' ? (input as (...args: Args) => Result)(...args) : input);\n\n/**\n * Creates a promise that resolves after the specified delay.\n *\n * Useful for creating artificial delays, implementing timeouts, or spacing operations.\n *\n * @param delayMs - The delay in milliseconds.\n *\n * @returns A promise that resolves after the specified delay.\n *\n * @example\n * ```ts\n * // Wait for 1 second\n * await delay(1000);\n * console.log('This logs after 1 second');\n *\n * // Use with other async operations\n * const fetchWithTimeout = async () => {\n *   const timeoutPromise = delay(5000).then(() => {\n *     throw new Error('Request timed out');\n *   });\n *\n *   return Promise.race([fetchData(), timeoutPromise]);\n * }\n * ```\n */\nexport const delay = (delayMs: number): Promise<void> =>\n  new Promise(resolve => setTimeout(resolve, delayMs));\n\n/**\n * Wraps a promise with a timeout. If the promise does not settle within the specified time,\n * it will reject with a timeout error.\n *\n * @template T - The type of the promise result.\n *\n * @param promise - The promise to wrap.\n * @param timeoutMs - Timeout duration in milliseconds.\n * @param errorMessage - Optional custom error message.\n *\n * @returns A promise that resolves or rejects with the original promise,\n *          or rejects with a timeout error if the duration is exceeded.\n *\n * @example\n * ```ts\n * // Rejects if fetch takes longer than 3 seconds\n * const response = await timeout(fetch('/api/data'), 3000);\n *\n * // With custom message\n * await timeout(fetchData(), 2000, 'Too long');\n * ```\n */\nexport const timeout = async <T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  errorMessage = 'Operation timed out',\n): Promise<T> => {\n  const timeoutId: ReturnType<typeof setTimeout> | null = null;\n\n  try {\n    return await Promise.race([\n      promise,\n      delay(timeoutMs).then(() => Promise.reject(new Error(errorMessage))),\n    ]);\n  } finally {\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n    }\n  }\n};\n\ninterface RetryOptions {\n  /**\n   * Maximum number of retry attempts before failing.\n   *\n   * @default 3\n   */\n  maxAttempts?: number;\n  /**\n   * Delay in milliseconds between retry attempts.\n   * If `backoff` is true, this is the base delay for exponential backoff.\n   *\n   * @default 300\n   */\n  delayMs?: number;\n  /**\n   * Whether to use exponential backoff for delays between attempts.\n   * When enabled, the delay is multiplied by 2 ^ (`attempt` - 1).\n   *\n   * @default true\n   */\n  backoff?: boolean;\n  /**\n   * Optional callback triggered before each retry attempt.\n   *\n   * @param attempt - The current attempt number (starting from 1).\n   * @param error - The error that caused the retry.\n   */\n  onRetry?: (attempt: number, error: unknown) => void;\n}\n\n/**\n * Wraps an asynchronous function with retry logic.\n *\n * The returned function will attempt to call the original function up to `maxAttempts` times,\n * with a delay between retries. If all attempts fail, the last encountered error is thrown.\n *\n * Useful for operations that may fail intermittently, such as network requests.\n *\n * @template Task - The type of the async function to wrap.\n * @template TaskResult - The result type of the async function.\n *\n * @param task - The async function to wrap with retry logic.\n * @param options - Configuration options for retry behavior.\n *\n * @returns A function that wraps the original function with retry support.\n *\n * @example\n * ```ts\n * async function fetchData() {\n *   const response = await fetch('/api/data');\n *\n *   if (!response.ok) {\n *    throw new Error('Network error');\n *   }\n *\n *   return await response.json();\n * }\n *\n * const fetchWithRetry = retry(fetchData, {\n *   maxAttempts: 5,\n *   delayMs: 500,\n *   onRetry: (attempt, error) => {\n *     console.warn(`Attempt ${attempt} failed:`, error);\n *   }\n * });\n *\n * fetchWithRetry()\n *   .then(data => console.log('Success:', data))\n *   .catch(error => console.error('Failed after retries:', error));\n * ```\n */\nexport const retry = <Task extends (...args: unknown[]) => Promise<TaskResult>, TaskResult>(\n  task: Task,\n  { maxAttempts = 3, delayMs = 300, backoff = true, onRetry }: RetryOptions = {},\n): ((...args: Parameters<Task>) => Promise<TaskResult>) => {\n  return async (...args: Parameters<Task>): Promise<TaskResult> => {\n    let lastError: unknown;\n\n    for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n      try {\n        return await task(...args);\n      } catch (e) {\n        lastError = e;\n\n        if (attempt < maxAttempts) {\n          onRetry?.(attempt, e);\n\n          const delayTime = backoff ? delayMs * 2 ** (attempt - 1) : delayMs;\n          await delay(delayTime);\n        }\n      }\n    }\n\n    throw lastError;\n  };\n};\n","export function assert(condition: any, message: string): asserts condition {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Checks if a value is null.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is null; otherwise, `false`.\n */\nexport const isNull = (value: unknown): value is null => value === null;\n\n/**\n * Checks if a value is null or undefined.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is `null` or `undefined`, otherwise `false`.\n */\nexport const isNil = (value: unknown): value is null | undefined =>\n  value === undefined || value === null;\n\n/**\n * Checks whether the provided value is considered \"empty\".\n *\n * A value is considered empty if it is:\n * - `null`\n * - `undefined`\n * - `''`\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is empty; otherwise, `false`.\n */\nexport const isNilOrEmptyString = (value: unknown): value is null | undefined =>\n  value === '' || isNil(value);\n\n/**\n * Checks if a value is neither `null` nor `undefined`.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is defined (not `null` or `undefined`); otherwise, `false`.\n */\nexport const isDefined = <T>(value: T): value is NonNullable<T> =>\n  value !== null && value !== undefined;\n\n/**\n * Checks if a value is a string.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a string; otherwise, `false`.\n */\nexport const isString = (value: unknown): value is string => typeof value === 'string';\n\n/**\n * Checks if a value is a number.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a number; otherwise, `false`.\n */\nexport const isNumber = (value: unknown): value is number => typeof value === 'number';\n\n/**\n * Checks if a value is a boolean.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a boolean; otherwise, `false`.\n */\nexport const isBool = (value: unknown): value is boolean => typeof value === 'boolean';\n\n/**\n * Checks if a value is an object.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an object; otherwise, `false`.\n */\nexport const isObject = (value: unknown): value is object => typeof value === 'object';\n\n/**\n * Checks if a value is an empty object (no own enumerable properties).\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an empty object; otherwise, `false`.\n */\nexport const isEmptyObject = (value: unknown): value is Record<string, never> =>\n  isObject(value) && !isNull(value) && Object.keys(value).length === 0;\n\n/**\n * Checks if a value is an array.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an array; otherwise, `false`.\n */\nexport const isArray = (value: unknown): value is unknown[] => Array.isArray(value);\n\n/**\n * Checks if a value is an empty array.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an empty array; otherwise, `false`.\n */\nexport const isEmptyArray = (value: unknown): value is [] => isArray(value) && value.length === 0;\n\n/**\n * Checks if a value is a function.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a function; otherwise, `false`.\n */\nexport const isFunction = (value: unknown) => typeof value === 'function';\n\n/**\n * Checks if a value is a Promise.\n *\n * @template T - The type of the value that the Promise resolves to.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Promise; otherwise, `false`.\n */\nexport const isPromise = <T = unknown>(value: unknown): value is Promise<T> =>\n  isFunction((value as Promise<T>)?.then);\n\n/**\n * Checks if a value is a Date object.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Date object; otherwise, `false`.\n */\nexport const isDate = (value: unknown): value is Date => value instanceof Date;\n\n/**\n * Checks if a value is a valid Date object (not Invalid Date).\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a valid Date object; otherwise, `false`.\n */\nexport const isValidDate = (value: unknown): value is Date =>\n  isDate(value) && !isNaN(value.getTime());\n\n/**\n * Checks if a value is a RegExp object.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a RegExp object; otherwise, `false`.\n */\nexport const isRegExp = (value: unknown): value is RegExp => value instanceof RegExp;\n\n/**\n * Checks if a value is a Map.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Map; otherwise, `false`.\n */\nexport const isMap = (value: unknown): value is Map<unknown, unknown> => value instanceof Map;\n\n/**\n * Checks if a value is a Set.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Set; otherwise, `false`.\n */\nexport const isSet = (value: unknown): value is Set<unknown> => value instanceof Set;\n\n/**\n * Checks if a value is a Symbol.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Symbol; otherwise, `false`.\n */\nexport const isSymbol = (value: unknown): value is symbol => typeof value === 'symbol';\n\n/**\n * Checks if a value is undefined.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is undefined; otherwise, `false`.\n */\nexport const isUndefined = (value: unknown): value is undefined => value === undefined;\n\n/**\n * Checks if a value is a finite number.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a finite number; otherwise, `false`.\n */\nexport const isFiniteNumber = (value: unknown): value is number =>\n  isNumber(value) && isFinite(value);\n\n/**\n * Checks if a value is an integer.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an integer; otherwise, `false`.\n */\nexport const isInteger = (value: unknown): value is number =>\n  isNumber(value) && Number.isInteger(value);\n","/**\n * Calculates the Euclidean distance between two points in 2D space.\n *\n * @param startX - The X coordinate of the starting point.\n * @param startY - The Y coordinate of the starting point.\n * @param endX - The X coordinate of the ending point.\n * @param endY - The Y coordinate of the ending point.\n *\n * @returns The Euclidean distance between the two points.\n */\nexport const calculateEuclideanDistance = (\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n): number => {\n  const deltaX = endX - startX;\n  const deltaY = endY - startY;\n\n  return Math.hypot(deltaX, deltaY);\n};\n\n/**\n * Calculates the moving speed.\n *\n * @param distance - The distance.\n * @param elapsedTime - The time taken to move the distance.\n *\n * @returns The calculated speed, which is the absolute value of delta divided by elapsed time.\n */\nexport const calculateMovingSpeed = (distance: number, elapsedTime: number): number =>\n  Math.abs(distance / elapsedTime);\n\n/**\n * Calculates the specified percentage of a given value.\n *\n * @param value - The value to calculate the percentage of.\n * @param percentage - The percentage to calculate.\n *\n * @returns The calculated percentage of the value.\n */\nexport const calculatePercentage = (value: number, percentage: number): number => {\n  return (value * percentage) / 100;\n};\n","/**\n * Converts a string to kebab-case format.\n *\n * This function transforms camelCase or PascalCase strings into kebab-case by inserting\n * hyphens between lowercase and uppercase letters, then converting everything to lowercase.\n *\n * @param input - The string to convert to kebab-case.\n *\n * @returns The kebab-case formatted string.\n *\n * @example\n * ```ts\n * toKebabCase('helloWorld'); // → 'hello-world'\n * toKebabCase('HelloWorld'); // → 'hello-world'\n * toKebabCase('hello123World'); // → 'hello123-world'\n * ```\n */\nexport const toKebabCase = (input: string): string =>\n  input.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();\n\n/**\n * Converts a camelCase string to dash-case format.\n *\n * This function transforms camelCase strings into dash-case by inserting\n * hyphens before uppercase letters and converting them to lowercase.\n * The function ensures that no hyphen is added at the start of the output string,\n * even if the input begins with an uppercase letter.\n *\n * @param input - The camelCase string to convert to dash-case.\n *\n * @returns The dash-case formatted string.\n *\n * @example\n * ```ts\n * camelToDashCase('helloWorld'); // → 'hello-world'\n * camelToDashCase('HelloWorld'); // → 'hello-world'\n * camelToDashCase('backgroundColor'); // → 'background-color'\n * ```\n */\nexport const camelToDashCase = (input: string): string => {\n  // First handle the first character separately to avoid adding a hyphen at the start\n  const firstChar = input.charAt(0);\n  const restOfString = input.slice(1);\n  \n  // Convert the first character to lowercase without adding a hyphen\n  const firstCharProcessed = firstChar.toLowerCase();\n  \n  // Process the rest of the string normally, adding hyphens before uppercase letters\n  const restProcessed = restOfString.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);\n  \n  return firstCharProcessed + restProcessed;\n};\n\n/**\n * Splits a string into an array of filtered from redundant spaces words.\n *\n * @param input - The input string to be split.\n *\n * @returns An array of words from the input string.\n */\nexport const splitStringIntoWords = (input: string): string[] => input.split(' ').filter(Boolean);\n\n/**\n * Generates a short, consistent hash string from an input string using a DJB2-inspired algorithm.\n *\n * This function uses a variation of the DJB2 algorithm, which is a simple yet effective hashing algorithm\n * based on bitwise XOR (`^`) and multiplication by 33. It produces a non-negative 32-bit integer,\n * which is then converted to a base-36 string (digits + lowercase letters) to produce a compact output.\n *\n * Useful for:\n * - Generating stable class names in CSS-in-JS libraries.\n * - Producing consistent cache keys.\n * - Quick and lightweight hashing needs where cryptographic security is not required.\n *\n * ⚠️ This is not cryptographically secure and should not be used for hashing passwords or sensitive data.\n *\n * @param input - The input string to hash.\n *\n * @returns A short, base-36 encoded hash string.\n *\n * @example\n * ```ts\n * const className = hashString('background-color: red;');\n * // → 'e4k1z0x'\n * ```\n */\nexport const hashString = (input: string): string => {\n  let hash = 5381;\n\n  for (let i = 0; i < input.length; i++) {\n    hash = (hash * 33) ^ input.charCodeAt(i);\n  }\n\n  return (hash >>> 0).toString(36);\n};\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export * from './async';\nexport * from './string';\nexport * from './array';\nexport * from './function';\nexport * from './guards';\nexport * from './math';\nexport * from './dom';\n"],"names":[],"sourceRoot":""}
+{"version":3,"file":"index.dev.cjs","mappings":"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","sources":["webpack://@react-hive/honey-utils/./src/array.ts","webpack://@react-hive/honey-utils/./src/async.ts","webpack://@react-hive/honey-utils/./src/dom.ts","webpack://@react-hive/honey-utils/./src/file.ts","webpack://@react-hive/honey-utils/./src/function.ts","webpack://@react-hive/honey-utils/./src/guards.ts","webpack://@react-hive/honey-utils/./src/math.ts","webpack://@react-hive/honey-utils/./src/string.ts","webpack://@react-hive/honey-utils/webpack/bootstrap","webpack://@react-hive/honey-utils/webpack/runtime/define property getters","webpack://@react-hive/honey-utils/webpack/runtime/hasOwnProperty shorthand","webpack://@react-hive/honey-utils/webpack/runtime/make namespace object","webpack://@react-hive/honey-utils/./src/index.ts"],"sourcesContent":["import { assert } from './guards';\n\n/**\n * Represents all falsy values.\n */\ntype Falsy = false | null | undefined | 0 | '';\n\n/**\n * Removes all falsy values from an array.\n *\n * Falsy values include: `false`, `0`, `''` (empty string), `null`, `undefined`, and `NaN`.\n *\n * Useful for cleaning up arrays with optional, nullable, or conditionally included items.\n *\n * @template T - The type of the truthy items.\n *\n * @param array - An array possibly containing falsy values.\n *\n * @returns A new array containing only truthy values of type `T`.\n *\n * @example\n * ```ts\n * compact([0, 1, false, 2, '', 3, null, undefined, NaN]); // [1, 2, 3]\n * ```\n */\nexport const compact = <T>(array: (T | Falsy)[]): T[] => array.filter(Boolean) as T[];\n\n/**\n * Returns a new array with duplicate values removed.\n *\n * Uses Set for efficient duplicate removal while preserving the original order.\n *\n * @template T - The type of the items in the array.\n *\n * @param array - The input array that may contain duplicate values.\n *\n * @returns A new array with only unique values, maintaining the original order.\n *\n * @example\n * ```ts\n * unique([1, 2, 2, 3, 1, 4]); // [1, 2, 3, 4]\n * unique(['a', 'b', 'a', 'c']); // ['a', 'b', 'c']\n * ```\n */\nexport const unique = <T>(array: T[]): T[] => [...new Set(array)];\n\n/**\n * Splits an array into chunks of the specified size.\n *\n * Useful for pagination, batch processing, or creating grid layouts.\n *\n * @template T - The type of the items in the array.\n *\n * @param array - The input array to be chunked.\n * @param size - The size of each chunk. Must be greater than 0.\n *\n * @returns An array of chunks, where each chunk is an array of the specified size\n *          (except possibly the last chunk, which may be smaller).\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * chunk(['a', 'b', 'c', 'd'], 3); // [['a', 'b', 'c'], ['d']]\n * ```\n */\nexport const chunk = <T>(array: T[], size: number): T[][] => {\n  assert(size > 0, 'Chunk size must be greater than 0');\n\n  return Array.from({ length: Math.ceil(array.length / size) }, (_, index) =>\n    array.slice(index * size, (index + 1) * size),\n  );\n};\n\n/**\n * Returns an array containing elements that exist in all provided arrays.\n *\n * @template T - The type of the items in the arrays.\n *\n * @param arrays - Two or more arrays to find common elements from.\n *\n * @returns A new array containing only the elements that exist in all input arrays.\n *\n * @example\n * ```ts\n * intersection([1, 2, 3], [2, 3, 4]); // [2, 3]\n * intersection(['a', 'b', 'c'], ['b', 'c', 'd'], ['b', 'e']); // ['b']\n * ```\n */\nexport const intersection = <T>(...arrays: T[][]): T[] => {\n  if (arrays.length === 0) {\n    return [];\n  }\n\n  if (arrays.length === 1) {\n    return [...arrays[0]];\n  }\n\n  const [first, ...rest] = arrays;\n  const uniqueFirst = unique(first);\n\n  return uniqueFirst.filter(item => rest.every(array => array.includes(item)));\n};\n\n/**\n * Returns elements from the first array that don't exist in the second array.\n *\n * @template T - The type of the items in the arrays.\n *\n * @param array - The source array.\n * @param exclude - The array containing elements to exclude.\n *\n * @returns A new array with elements from the first array that don't exist in the second array.\n *\n * @example\n * ```ts\n * difference([1, 2, 3, 4], [2, 4]); // [1, 3]\n * difference(['a', 'b', 'c'], ['b']); // ['a', 'c']\n * ```\n */\nexport const difference = <T>(array: T[], exclude: T[]): T[] =>\n  array.filter(item => !exclude.includes(item));\n\ntype PipeFn = (arg: unknown) => unknown;\n\ntype Pipe = {\n  <A, B>(fn1: (a: A) => B): (a: A) => B;\n  <A, B, C>(fn1: (a: A) => B, fn2: (b: B) => C): (a: A) => C;\n  <A, B, C, D>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): (a: A) => D;\n  <A, B, C, D, E>(\n    fn1: (a: A) => B,\n    fn2: (b: B) => C,\n    fn3: (c: C) => D,\n    fn4: (d: D) => E,\n  ): (a: A) => E;\n  <A, B, C, D, E, F>(\n    fn1: (a: A) => B,\n    fn2: (b: B) => C,\n    fn3: (c: C) => D,\n    fn4: (d: D) => E,\n    fn5: (e: E) => F,\n  ): (a: A) => F;\n  (...fns: PipeFn[]): (arg: unknown) => unknown;\n};\n\n/**\n * Composes multiple unary functions into a single function, applying them from left to right.\n *\n * Useful for building a data processing pipeline where the output of one function becomes the input of the next.\n *\n * Types are inferred up to 5 chained functions for full type safety. Beyond that, it falls back to the unknown.\n *\n * @param fns - A list of unary functions to compose.\n *\n * @returns A new function that applies all functions from left to right.\n *\n * @example\n * ```ts\n * const add = (x: number) => x + 1;\n * const double = (x: number) => x * 2;\n * const toStr = (x: number) => `Result: ${x}`;\n *\n * const result = pipe(add, double, toStr)(2);\n * // => 'Result: 6'\n * ```\n */\nexport const pipe: Pipe =\n  (...fns: PipeFn[]) =>\n  (arg: unknown) =>\n    fns.reduce((prev, fn) => fn(prev), arg);\n\ntype ComposeFn = (arg: unknown) => unknown;\n\ntype Compose = {\n  <A, R>(fn1: (a: A) => R): (a: A) => R;\n  <A, B, R>(fn1: (b: B) => R, fn2: (a: A) => B): (a: A) => R;\n  <A, B, C, R>(fn1: (c: C) => R, fn2: (b: B) => C, fn3: (a: A) => B): (a: A) => R;\n  <A, B, C, D, R>(\n    fn1: (d: D) => R,\n    fn2: (c: C) => D,\n    fn3: (b: B) => C,\n    fn4: (a: A) => B,\n  ): (a: A) => R;\n  <A, B, C, D, E, R>(\n    fn1: (e: E) => R,\n    fn2: (d: D) => E,\n    fn3: (c: C) => D,\n    fn4: (b: B) => C,\n    fn5: (a: A) => B,\n  ): (a: A) => R;\n  (...fns: ComposeFn[]): (arg: unknown) => unknown;\n};\n\n/**\n * Composes multiple unary functions into a single function, applying them from **right to left**.\n *\n * Often used for building functional pipelines where the innermost function runs first.\n * Types are inferred up to 5 chained functions for full type safety.\n *\n * @param fns - A list of unary functions to compose.\n *\n * @returns A new function that applies all functions from right to left.\n *\n * @example\n * ```ts\n * const add = (x: number) => x + 1;\n * const double = (x: number) => x * 2;\n * const toStr = (x: number) => `Result: ${x}`;\n *\n * const result = compose(toStr, double, add)(2);\n * // => 'Result: 6'\n * ```\n */\nexport const compose: Compose =\n  (...fns: ComposeFn[]) =>\n  (arg: unknown) =>\n    fns.reduceRight((prev, fn) => fn(prev), arg);\n","import { compact } from './array';\n\n/**\n * Asynchronously iterates over an array and executes an async function on each item sequentially,\n * collecting the results.\n *\n * Useful when order or timing matters (e.g., rate limits, UI updates, animations).\n *\n * @param array - The array of items to iterate over.\n * @param fn - An async function to execute for each item. Must return a value.\n *\n * @returns A promise that resolves with an array of results from each function call.\n *\n * @example\n * ```ts\n * const results = await runSequential([1, 2, 3], async (item) => {\n *   await delay(100);\n *\n *   return item * 2;\n * });\n *\n * console.log(results); // [2, 4, 6]\n * ```\n */\nexport const runSequential = async <Item, Result>(\n  array: Item[],\n  fn: (item: Item, index: number, array: Item[]) => Promise<Result>,\n): Promise<Result[]> => {\n  const results: Result[] = [];\n\n  for (let i = 0; i < array.length; i++) {\n    results.push(await fn(array[i], i, array));\n  }\n\n  return results;\n};\n\n/**\n * Executes an asynchronous operation on each element of an array and waits for all promises to resolve.\n *\n * @param array - The array of items to operate on.\n * @param fn - The asynchronous operation to perform on each item.\n *\n * @returns A promise that resolves with an array of results after all operations are completed.\n *\n * @example\n * ```ts\n * const results = await runParallel([1, 2, 3], async (item) => {\n *   await delay(100);\n *\n *   return item * 2;\n * });\n *\n * console.log(results); // [2, 4, 6]\n * ```\n */\nexport const runParallel = async <Item, Result>(\n  array: Item[],\n  fn: (item: Item, index: number, array: Item[]) => Promise<Result>,\n): Promise<Result[]> => Promise.all(array.map(fn));\n\n/**\n * Asynchronously filters an array using a predicate function, executing **sequentially**.\n *\n * Useful for rate-limited or stateful async operations where execution order matters.\n *\n * @template Item - The type of the items in the input array.\n *\n * @param array - The array of items to filter.\n * @param predicate - An async function that returns a `boolean` indicating whether to keep each item.\n *\n * @returns A promise that resolves to a new array containing only the items for which the predicate returned `true`.\n *\n * @example\n * ```ts\n * // Sequentially filter even numbers with delay\n * const result = await filterSequential([1, 2, 3, 4], async (num) => {\n *   await delay(100);\n *\n *   return num % 2 === 0;\n * });\n *\n * console.log(result); // [2, 4]\n * ```\n */\nexport const filterSequential = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<Item[]> => {\n  const results: Item[] = [];\n\n  for (let i = 0; i < array.length; i++) {\n    const item = array[i];\n\n    if (await predicate(item, i, array)) {\n      results.push(item);\n    }\n  }\n\n  return results;\n};\n\n/**\n * Asynchronously filters an array based on a provided async predicate function.\n *\n * Each item is passed to the `predicate` function in parallel, and only the items\n * for which the predicate resolves to `true` are included in the final result.\n *\n * Useful for filtering based on asynchronous conditions such as API calls,\n * file system access, or any other delayed operations.\n *\n * @template Item - The type of the items in the input array.\n *\n * @param array - The array of items to filter.\n * @param predicate - An async function that returns a boolean indicating whether to keep each item.\n *\n * @returns A promise that resolves to a new array containing only the items for which the predicate returned `true`.\n *\n * @example\n * ```ts\n * // Filter numbers that are even after a simulated delay\n * const result = await filterParallel([1, 2, 3, 4], async (num) => {\n *   await delay(100);\n *\n *   return num % 2 === 0;\n * });\n *\n * console.log(result); // [2, 4]\n * ```\n */\nexport const filterParallel = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<Item[]> => {\n  const results = await runParallel(array, async (item, index, array) =>\n    (await predicate(item, index, array)) ? item : false,\n  );\n\n  return compact(results);\n};\n\n/**\n * Asynchronously checks if at least one element in the array satisfies the async condition.\n *\n * @param array - The array of items to check.\n * @param predicate - An async function that returns a boolean.\n *\n * @returns A promise that resolves to true if any item passes the condition.\n */\nexport const someAsync = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<boolean> => {\n  for (let i = 0; i < array.length; i++) {\n    if (await predicate(array[i], i, array)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Asynchronously checks if all elements in the array satisfy the async condition.\n *\n * @param array - The array of items to check.\n * @param predicate - An async function that returns a boolean.\n *\n * @returns A promise that resolves to true if all items pass the condition.\n */\nexport const everyAsync = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<boolean> => {\n  for (let i = 0; i < array.length; i++) {\n    if (!(await predicate(array[i], i, array))) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Asynchronously reduces an array to a single accumulated value.\n *\n * @template Item - The type of items in the array.\n * @template Accumulator - The type of the accumulated result.\n *\n * @param array - The array to reduce.\n * @param fn - The async reducer function that processes each item and returns the updated accumulator.\n * @param initialValue - The initial accumulator value.\n *\n * @returns A promise that resolves to the final accumulated result.\n */\nexport const reduceAsync = async <Item, Accumulator>(\n  array: Item[],\n  fn: (accumulator: Accumulator, item: Item, index: number, array: Item[]) => Promise<Accumulator>,\n  initialValue: Accumulator,\n): Promise<Accumulator> => {\n  let accumulator = initialValue;\n\n  for (let i = 0; i < array.length; i++) {\n    accumulator = await fn(accumulator, array[i], i, array);\n  }\n\n  return accumulator;\n};\n\n/**\n * Asynchronously finds the first element that satisfies the async condition.\n *\n * @param array - The array of items to search.\n * @param predicate - An async function that returns a boolean.\n *\n * @returns A promise that resolves to the found item or null if none match.\n */\nexport const findAsync = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<Item | null> => {\n  for (let i = 0; i < array.length; i++) {\n    if (await predicate(array[i], i, array)) {\n      return array[i];\n    }\n  }\n\n  return null;\n};\n","export const FOCUSABLE_HTML_TAGS = ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON', 'A'];\n\ninterface HTMLElementTransformationValues {\n  translateX: number;\n  translateY: number;\n  scaleX: number;\n  scaleY: number;\n  skewX: number;\n  skewY: number;\n}\n\n/**\n * Extracts transformation values (translate, scale, skew) from the 2D transformation matrix of a given HTML element.\n *\n * Only works with 2D transforms (i.e., `matrix(a, b, c, d, e, f)`).\n *\n * @param element - The element with a CSS transform applied.\n * @returns An object with parsed transformation values.\n *\n * @example\n * ```ts\n * const values = parse2DMatrix(myElement);\n * console.log(values.translateX);\n * console.log(values.scaleX);\n * ```\n */\nexport const parse2DMatrix = (element: HTMLElement): HTMLElementTransformationValues => {\n  const computedStyles = window.getComputedStyle(element);\n  const transformValue = computedStyles.getPropertyValue('transform');\n\n  const matrixMatch = transformValue.match(/^matrix\\((.+)\\)$/);\n  if (!matrixMatch) {\n    return {\n      translateX: 0,\n      translateY: 0,\n      scaleX: 1,\n      scaleY: 1,\n      skewX: 0,\n      skewY: 0,\n    };\n  }\n\n  const [scaleX, skewY, skewX, scaleY, translateX, translateY] = matrixMatch[1]\n    .split(', ')\n    .map(parseFloat);\n\n  return {\n    translateX,\n    translateY,\n    scaleX,\n    scaleY,\n    skewX,\n    skewY,\n  };\n};\n\n/**\n * Creates a clone of a Blob object.\n *\n * @param blob - The Blob object to clone.\n *\n * @returns A new Blob with the same content and type as the original.\n */\nexport const cloneBlob = (blob: Blob): Blob => new Blob([blob], { type: blob.type });\n\n/**\n * Calculates the intersection ratio between two DOM rectangles.\n *\n * The ratio represents the proportion of the `targetRect` that is covered by `sourceRect`.\n * A value of `1` means `sourceRect` completely covers `targetRect`, and `0` means no overlap.\n *\n * @param sourceRect - The rectangle used to measure overlap against the target.\n * @param targetRect - The rectangle whose covered area is measured.\n *\n * @returns A number between `0` and `1` representing the intersection ratio.\n */\nexport const getDOMRectIntersectionRatio = (sourceRect: DOMRect, targetRect: DOMRect): number => {\n  const xOverlap = Math.max(\n    0,\n    Math.min(sourceRect.right, targetRect.right) - Math.max(sourceRect.left, targetRect.left),\n  );\n\n  const yOverlap = Math.max(\n    0,\n    Math.min(sourceRect.bottom, targetRect.bottom) - Math.max(sourceRect.top, targetRect.top),\n  );\n\n  const intersectionArea = xOverlap * yOverlap;\n  const targetArea = targetRect.width * targetRect.height;\n\n  return intersectionArea / targetArea;\n};\n\n/**\n * Returns the bounding DOMRect of an element based on offset and client dimensions.\n *\n * This utility is useful when you need a stable, layout-based rect\n * without triggering a reflow via `getBoundingClientRect()`.\n *\n * @param element - The target HTML element.\n * @returns A `DOMRect` representing the element’s offset position and size.\n */\nexport const getElementOffsetRect = (element: HTMLElement): DOMRect =>\n  new DOMRect(element.offsetLeft, element.offsetTop, element.clientWidth, element.clientHeight);\n\n/**\n * Determines whether the given HTMLElement is an HTMLAnchorElement.\n *\n * Acts as a type guard so that TypeScript narrows `element` to\n * `HTMLAnchorElement` when the function returns `true`.\n *\n * An element qualifies as an anchor by having a tag name of `\"A\"`.\n *\n * @param element - The element to test.\n *\n * @returns Whether the element is an anchor element.\n */\nexport const isAnchorHtmlElement = (element: HTMLElement): element is HTMLAnchorElement =>\n  element.tagName === 'A';\n\n/**\n * Checks whether an element is explicitly marked as contenteditable.\n *\n * Browsers treat elements with `contenteditable=\"true\"` as focusable,\n * even if they are not normally keyboard-focusable.\n *\n * @param element - The element to inspect.\n *\n * @returns True if `contenteditable=\"true\"` is set.\n */\nexport const isContentEditableHtmlElement = (element: HTMLElement) =>\n  element.getAttribute('contenteditable') === 'true';\n\n/**\n * Determines whether an HTMLElement is focusable under standard browser rules.\n *\n * The function checks a combination of factors:\n * - The element must be rendered (not `display: none` or `visibility: hidden`).\n * - Disabled form controls are never focusable.\n * - Elements with `tabindex=\"-1\"` are intentionally removed from the focus order.\n * - Certain native HTML elements are inherently focusable (e.g. inputs, buttons, anchors with `href`).\n * - Elements with `contenteditable=\"true\"` are treated as focusable.\n * - Any element with a valid `tabindex` (not null) is considered focusable.\n *\n * This logic approximates how browsers and the accessibility tree\n * determine real-world focusability—not just tabindex presence.\n *\n * @param element - The element to test. `null` or `undefined` will return `false`.\n *\n * @returns Whether the element is focusable.\n */\nexport const isHtmlElementFocusable = (element: HTMLElement | null): boolean => {\n  if (!element) {\n    return false;\n  }\n\n  // Hidden or not rendered\n  const style = window.getComputedStyle(element);\n  if (style.visibility === 'hidden' || style.display === 'none') {\n    return false;\n  }\n\n  if ('disabled' in element && element.disabled) {\n    return false;\n  }\n\n  // Explicitly removed from tab order\n  const tabIndex = element.getAttribute('tabindex');\n  if (tabIndex === '-1') {\n    return false;\n  }\n\n  if (FOCUSABLE_HTML_TAGS.includes(element.tagName)) {\n    if (isAnchorHtmlElement(element)) {\n      return element.href !== '';\n    }\n\n    return true;\n  }\n\n  if (isContentEditableHtmlElement(element)) {\n    return true;\n  }\n\n  return tabIndex !== null;\n};\n\n/**\n * Collects all focusable descendant elements within a container.\n *\n * The function queries *all* elements under the container and filters them\n * using `isHtmlElementFocusable`, producing a reliable list of elements\n * that can receive keyboard focus in real-world browser conditions.\n *\n * @param container - The root container whose focusable children will be found.\n *\n * @returns An array of focusable HTMLElements in DOM order.\n */\nexport const getFocusableHtmlElements = (container: HTMLElement): HTMLElement[] =>\n  Array.from(container.querySelectorAll<HTMLElement>('*')).filter(isHtmlElementFocusable);\n","/**\n * Splits a file name into its base name and extension.\n *\n * Special cases:\n * - Files without a dot return `[fileName, \"\"]`\n * - Hidden files like `.gitignore` return `[\".gitignore\", \"\"]`\n * - Names ending with a trailing dot (e.g., `\"file.\"`) return `[\"file.\", \"\"]`\n * - Multi-dot names (e.g., `\"archive.tar.gz\"`) split on the last dot\n *\n * @param fileName - The full file name to parse.\n *\n * @returns A tuple where:\n *  - index 0 is the base name\n *  - index 1 is the file extension (lowercased), or an empty string if none exists\n */\nexport const parseFileName = (fileName: string) => {\n  const lastDotIndex = fileName.lastIndexOf('.');\n\n  // No dot or leading dot with no extension (e.g., \".gitignore\")\n  if (lastDotIndex <= 0 || lastDotIndex === fileName.length - 1) {\n    return [fileName, ''];\n  }\n\n  return [fileName.slice(0, lastDotIndex), fileName.slice(lastDotIndex + 1).toLowerCase()];\n};\n\n/**\n * Converts a `FileList` object to an array of `File` objects.\n *\n * @param fileList - The `FileList` object to convert.\n *\n * @returns An array of `File` objects.\n */\nexport const fileListToFiles = (fileList: FileList | null): File[] => {\n  if (!fileList) {\n    return [];\n  }\n\n  const files: File[] = [];\n\n  for (let i = 0; i < fileList.length; i++) {\n    files.push(fileList[i]);\n  }\n\n  return files;\n};\n\n/**\n * Converts a `Blob` object into a `File` object with the specified name.\n *\n * This is useful when you receive a `Blob` (e.g., from canvas, fetch, or file manipulation)\n * and need to convert it into a `File` to upload via `FormData` or file inputs.\n *\n * @param blob - The `Blob` to convert.\n * @param fileName - The desired name for the resulting file (including extension).\n *\n * @returns A `File` instance with the same content and MIME type as the input `Blob`.\n *\n * @example\n * ```ts\n * const blob = new Blob(['Hello world'], { type: 'text/plain' });\n * const file = blobToFile(blob, 'hello.txt');\n *\n * console.log(file instanceof File); // true\n * ```\n */\nexport const blobToFile = (blob: Blob, fileName: string): File =>\n  new File([blob], fileName, {\n    type: blob.type,\n  });\n","export const noop = () => {};\n\n/**\n * Creates a function that negates the result of the given predicate function.\n *\n * @template Args - Argument types of the predicate function.\n *\n * @param fn - A function that returns any value.\n *\n * @returns A new function that returns the negated result of the original function.\n *\n * @example\n * ```ts\n * const isEven = (n: number) => n % 2 === 0;\n * const isOdd = not(isEven);\n *\n * console.log(isOdd(2)); // false\n * console.log(isOdd(3)); // true\n * ```\n */\nexport const not =\n  <Args extends unknown[]>(fn: (...args: Args) => any): ((...args: Args) => boolean) =>\n  (...args: Args) =>\n    !fn(...args);\n\n/**\n * Invokes the given input if it is a function, passing the provided arguments.\n * Otherwise, returns the input as-is.\n *\n * @template Args - Tuple of argument types to pass to the function.\n * @template Result - Return type of the function or the value.\n *\n * @param input - A function to invoke with `args`, or a direct value of type `Result`.\n * @param args - Arguments to pass if `input` is a function.\n *\n * @returns The result of invoking the function, or the original value if it's not a function.\n */\nexport const invokeIfFunction = <Args extends unknown[], Result>(\n  input: ((...args: Args) => Result) | Result,\n  ...args: Args\n): Result => (typeof input === 'function' ? (input as (...args: Args) => Result)(...args) : input);\n\n/**\n * Creates a promise that resolves after the specified delay.\n *\n * Useful for creating artificial delays, implementing timeouts, or spacing operations.\n *\n * @param delayMs - The delay in milliseconds.\n *\n * @returns A promise that resolves after the specified delay.\n *\n * @example\n * ```ts\n * // Wait for 1 second\n * await delay(1000);\n * console.log('This logs after 1 second');\n *\n * // Use with other async operations\n * const fetchWithTimeout = async () => {\n *   const timeoutPromise = delay(5000).then(() => {\n *     throw new Error('Request timed out');\n *   });\n *\n *   return Promise.race([fetchData(), timeoutPromise]);\n * }\n * ```\n */\nexport const delay = (delayMs: number): Promise<void> =>\n  new Promise(resolve => setTimeout(resolve, delayMs));\n\n/**\n * Wraps a promise with a timeout. If the promise does not settle within the specified time,\n * it will reject with a timeout error.\n *\n * @template T - The type of the promise result.\n *\n * @param promise - The promise to wrap.\n * @param timeoutMs - Timeout duration in milliseconds.\n * @param errorMessage - Optional custom error message.\n *\n * @returns A promise that resolves or rejects with the original promise,\n *          or rejects with a timeout error if the duration is exceeded.\n *\n * @example\n * ```ts\n * // Rejects if fetch takes longer than 3 seconds\n * const response = await timeout(fetch('/api/data'), 3000);\n *\n * // With custom message\n * await timeout(fetchData(), 2000, 'Too long');\n * ```\n */\nexport const timeout = async <T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  errorMessage = 'Operation timed out',\n): Promise<T> => {\n  const timeoutId: ReturnType<typeof setTimeout> | null = null;\n\n  try {\n    return await Promise.race([\n      promise,\n      delay(timeoutMs).then(() => Promise.reject(new Error(errorMessage))),\n    ]);\n  } finally {\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n    }\n  }\n};\n\ninterface RetryOptions {\n  /**\n   * Maximum number of retry attempts before failing.\n   *\n   * @default 3\n   */\n  maxAttempts?: number;\n  /**\n   * Delay in milliseconds between retry attempts.\n   * If `backoff` is true, this is the base delay for exponential backoff.\n   *\n   * @default 300\n   */\n  delayMs?: number;\n  /**\n   * Whether to use exponential backoff for delays between attempts.\n   * When enabled, the delay is multiplied by 2 ^ (`attempt` - 1).\n   *\n   * @default true\n   */\n  backoff?: boolean;\n  /**\n   * Optional callback triggered before each retry attempt.\n   *\n   * @param attempt - The current attempt number (starting from 1).\n   * @param error - The error that caused the retry.\n   */\n  onRetry?: (attempt: number, error: unknown) => void;\n}\n\n/**\n * Wraps an asynchronous function with retry logic.\n *\n * The returned function will attempt to call the original function up to `maxAttempts` times,\n * with a delay between retries. If all attempts fail, the last encountered error is thrown.\n *\n * Useful for operations that may fail intermittently, such as network requests.\n *\n * @template Task - The type of the async function to wrap.\n * @template TaskResult - The result type of the async function.\n *\n * @param task - The async function to wrap with retry logic.\n * @param options - Configuration options for retry behavior.\n *\n * @returns A function that wraps the original function with retry support.\n *\n * @example\n * ```ts\n * async function fetchData() {\n *   const response = await fetch('/api/data');\n *\n *   if (!response.ok) {\n *    throw new Error('Network error');\n *   }\n *\n *   return await response.json();\n * }\n *\n * const fetchWithRetry = retry(fetchData, {\n *   maxAttempts: 5,\n *   delayMs: 500,\n *   onRetry: (attempt, error) => {\n *     console.warn(`Attempt ${attempt} failed:`, error);\n *   }\n * });\n *\n * fetchWithRetry()\n *   .then(data => console.log('Success:', data))\n *   .catch(error => console.error('Failed after retries:', error));\n * ```\n */\nexport const retry = <Task extends (...args: unknown[]) => Promise<TaskResult>, TaskResult>(\n  task: Task,\n  { maxAttempts = 3, delayMs = 300, backoff = true, onRetry }: RetryOptions = {},\n): ((...args: Parameters<Task>) => Promise<TaskResult>) => {\n  return async (...args: Parameters<Task>): Promise<TaskResult> => {\n    let lastError: unknown;\n\n    for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n      try {\n        return await task(...args);\n      } catch (e) {\n        lastError = e;\n\n        if (attempt < maxAttempts) {\n          onRetry?.(attempt, e);\n\n          const delayTime = backoff ? delayMs * 2 ** (attempt - 1) : delayMs;\n          await delay(delayTime);\n        }\n      }\n    }\n\n    throw lastError;\n  };\n};\n","export function assert(condition: any, message: string): asserts condition {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Checks if a value is null.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is null; otherwise, `false`.\n */\nexport const isNull = (value: unknown): value is null => value === null;\n\n/**\n * Checks if a value is null or undefined.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is `null` or `undefined`, otherwise `false`.\n */\nexport const isNil = (value: unknown): value is null | undefined =>\n  value === undefined || value === null;\n\n/**\n * Checks whether the provided value is considered \"empty\".\n *\n * A value is considered empty if it is:\n * - `null`\n * - `undefined`\n * - `''`\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is empty; otherwise, `false`.\n */\nexport const isNilOrEmptyString = (value: unknown): value is null | undefined =>\n  value === '' || isNil(value);\n\n/**\n * Checks if a value is neither `null` nor `undefined`.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is defined (not `null` or `undefined`); otherwise, `false`.\n */\nexport const isDefined = <T>(value: T): value is NonNullable<T> =>\n  value !== null && value !== undefined;\n\n/**\n * Checks if a value is a string.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a string; otherwise, `false`.\n */\nexport const isString = (value: unknown): value is string => typeof value === 'string';\n\n/**\n * Checks if a value is a number.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a number; otherwise, `false`.\n */\nexport const isNumber = (value: unknown): value is number => typeof value === 'number';\n\n/**\n * Checks if a value is a boolean.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a boolean; otherwise, `false`.\n */\nexport const isBool = (value: unknown): value is boolean => typeof value === 'boolean';\n\n/**\n * Checks if a value is an object.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an object; otherwise, `false`.\n */\nexport const isObject = (value: unknown): value is object => typeof value === 'object';\n\n/**\n * Checks if a value is an empty object (no own enumerable properties).\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an empty object; otherwise, `false`.\n */\nexport const isEmptyObject = (value: unknown): value is Record<string, never> =>\n  isObject(value) && !isNull(value) && Object.keys(value).length === 0;\n\n/**\n * Checks if a value is an array.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an array; otherwise, `false`.\n */\nexport const isArray = (value: unknown): value is unknown[] => Array.isArray(value);\n\n/**\n * Checks if a value is an empty array.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an empty array; otherwise, `false`.\n */\nexport const isEmptyArray = (value: unknown): value is [] => isArray(value) && value.length === 0;\n\n/**\n * Checks if a value is a function.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a function; otherwise, `false`.\n */\nexport const isFunction = (value: unknown) => typeof value === 'function';\n\n/**\n * Checks if a value is a Promise.\n *\n * @template T - The type of the value that the Promise resolves to.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Promise; otherwise, `false`.\n */\nexport const isPromise = <T = unknown>(value: unknown): value is Promise<T> =>\n  isFunction((value as Promise<T>)?.then);\n\n/**\n * Checks if a value is a Date object.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Date object; otherwise, `false`.\n */\nexport const isDate = (value: unknown): value is Date => value instanceof Date;\n\n/**\n * Checks if a value is a valid Date object (not Invalid Date).\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a valid Date object; otherwise, `false`.\n */\nexport const isValidDate = (value: unknown): value is Date =>\n  isDate(value) && !isNaN(value.getTime());\n\n/**\n * Checks if a value is a RegExp object.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a RegExp object; otherwise, `false`.\n */\nexport const isRegExp = (value: unknown): value is RegExp => value instanceof RegExp;\n\n/**\n * Checks if a value is a Map.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Map; otherwise, `false`.\n */\nexport const isMap = (value: unknown): value is Map<unknown, unknown> => value instanceof Map;\n\n/**\n * Checks if a value is a Set.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Set; otherwise, `false`.\n */\nexport const isSet = (value: unknown): value is Set<unknown> => value instanceof Set;\n\n/**\n * Checks if a value is a Symbol.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a Symbol; otherwise, `false`.\n */\nexport const isSymbol = (value: unknown): value is symbol => typeof value === 'symbol';\n\n/**\n * Checks if a value is undefined.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is undefined; otherwise, `false`.\n */\nexport const isUndefined = (value: unknown): value is undefined => value === undefined;\n\n/**\n * Checks if a value is a finite number.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is a finite number; otherwise, `false`.\n */\nexport const isFiniteNumber = (value: unknown): value is number =>\n  isNumber(value) && isFinite(value);\n\n/**\n * Checks if a value is an integer.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is an integer; otherwise, `false`.\n */\nexport const isInteger = (value: unknown): value is number =>\n  isNumber(value) && Number.isInteger(value);\n","/**\n * Calculates the Euclidean distance between two points in 2D space.\n *\n * @param startX - The X coordinate of the starting point.\n * @param startY - The Y coordinate of the starting point.\n * @param endX - The X coordinate of the ending point.\n * @param endY - The Y coordinate of the ending point.\n *\n * @returns The Euclidean distance between the two points.\n */\nexport const calculateEuclideanDistance = (\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n): number => {\n  const deltaX = endX - startX;\n  const deltaY = endY - startY;\n\n  return Math.hypot(deltaX, deltaY);\n};\n\n/**\n * Calculates the moving speed.\n *\n * @param distance - The distance.\n * @param elapsedTime - The time taken to move the distance.\n *\n * @returns The calculated speed, which is the absolute value of delta divided by elapsed time.\n */\nexport const calculateMovingSpeed = (distance: number, elapsedTime: number): number =>\n  Math.abs(distance / elapsedTime);\n\n/**\n * Calculates the specified percentage of a given value.\n *\n * @param value - The value to calculate the percentage of.\n * @param percentage - The percentage to calculate.\n *\n * @returns The calculated percentage of the value.\n */\nexport const calculatePercentage = (value: number, percentage: number): number => {\n  return (value * percentage) / 100;\n};\n","/**\n * Converts a string to kebab-case format.\n *\n * This function transforms camelCase or PascalCase strings into kebab-case by inserting\n * hyphens between lowercase and uppercase letters, then converting everything to lowercase.\n *\n * @param input - The string to convert to kebab-case.\n *\n * @returns The kebab-case formatted string.\n *\n * @example\n * ```ts\n * toKebabCase('helloWorld'); // → 'hello-world'\n * toKebabCase('HelloWorld'); // → 'hello-world'\n * toKebabCase('hello123World'); // → 'hello123-world'\n * ```\n */\nexport const toKebabCase = (input: string): string =>\n  input.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();\n\n/**\n * Converts a camelCase string to dash-case format.\n *\n * This function transforms camelCase strings into dash-case by inserting\n * hyphens before uppercase letters and converting them to lowercase.\n * The function ensures that no hyphen is added at the start of the output string,\n * even if the input begins with an uppercase letter.\n *\n * @param input - The camelCase string to convert to dash-case.\n *\n * @returns The dash-case formatted string.\n *\n * @example\n * ```ts\n * camelToDashCase('helloWorld'); // → 'hello-world'\n * camelToDashCase('HelloWorld'); // → 'hello-world'\n * camelToDashCase('backgroundColor'); // → 'background-color'\n * ```\n */\nexport const camelToDashCase = (input: string): string => {\n  // First handle the first character separately to avoid adding a hyphen at the start\n  const firstChar = input.charAt(0);\n  const restOfString = input.slice(1);\n\n  // Convert the first character to lowercase without adding a hyphen\n  const firstCharProcessed = firstChar.toLowerCase();\n\n  // Process the rest of the string normally, adding hyphens before uppercase letters\n  const restProcessed = restOfString.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);\n\n  return firstCharProcessed + restProcessed;\n};\n\n/**\n * Splits a camelCase or PascalCase string into separate words with spaces.\n *\n * This function inserts spaces between lowercase and uppercase letters,\n * making camelCase or PascalCase strings more human-readable without\n * altering their original capitalization.\n *\n * @param input - The camelCase or PascalCase string to split into words.\n *\n * @returns The string with spaces inserted between words.\n *\n * @example\n * ```ts\n * camelToWords('helloWorld'); // → 'hello World'\n * camelToWords('HelloWorld'); // → 'Hello World'\n * camelToWords('userIDNumber'); // → 'user ID Number'\n * ```\n */\nexport const camelToWords = (input: string) => input.replace(/([a-z0-9])([A-Z])/g, '$1 $2');\n\n/**\n * Splits a string into an array of filtered from redundant spaces words.\n *\n * @param input - The input string to be split.\n *\n * @returns An array of words from the input string.\n */\nexport const splitStringIntoWords = (input: string): string[] => input.split(' ').filter(Boolean);\n\n/**\n * Generates a short, consistent hash string from an input string using a DJB2-inspired algorithm.\n *\n * This function uses a variation of the DJB2 algorithm, which is a simple yet effective hashing algorithm\n * based on bitwise XOR (`^`) and multiplication by 33. It produces a non-negative 32-bit integer,\n * which is then converted to a base-36 string (digits + lowercase letters) to produce a compact output.\n *\n * Useful for:\n * - Generating stable class names in CSS-in-JS libraries.\n * - Producing consistent cache keys.\n * - Quick and lightweight hashing needs where cryptographic security is not required.\n *\n * ⚠️ This is not cryptographically secure and should not be used for hashing passwords or sensitive data.\n *\n * @param input - The input string to hash.\n *\n * @returns A short, base-36 encoded hash string.\n *\n * @example\n * ```ts\n * const className = hashString('background-color: red;');\n * // → 'e4k1z0x'\n * ```\n */\nexport const hashString = (input: string): string => {\n  let hash = 5381;\n\n  for (let i = 0; i < input.length; i++) {\n    hash = (hash * 33) ^ input.charCodeAt(i);\n  }\n\n  return (hash >>> 0).toString(36);\n};\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export * from './async';\nexport * from './string';\nexport * from './array';\nexport * from './function';\nexport * from './guards';\nexport * from './math';\nexport * from './dom';\nexport * from './file';\n"],"names":[],"ignoreList":[],"sourceRoot":""}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-var t={};function e(t,e){if(!t)throw new Error(e)}t.d=(e,r)=>{for(var n in r)t.o(r,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:r[n]})},t.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e);const r=t=>null===t,n=t=>null==t,a=t=>""===t||n(t),o=t=>null!=t,l=t=>"string"==typeof t,i=t=>"number"==typeof t,s=t=>"boolean"==typeof t,c=t=>"object"==typeof t,f=t=>c(t)&&!r(t)&&0===Object.keys(t).length,h=t=>Array.isArray(t),u=t=>h(t)&&0===t.length,y=t=>"function"==typeof t,p=t=>y(t?.then),w=t=>t instanceof Date,g=t=>w(t)&&!isNaN(t.getTime()),m=t=>t instanceof RegExp,b=t=>t instanceof Map,d=t=>t instanceof Set,M=t=>"symbol"==typeof t,x=t=>void 0===t,A=t=>i(t)&&isFinite(t),k=t=>i(t)&&Number.isInteger(t),P=t=>t.filter(Boolean),C=t=>[...new Set(t)],O=(t,r)=>(e(r>0,"Chunk size must be greater than 0"),Array.from({length:Math.ceil(t.length/r)},(e,n)=>t.slice(n*r,(n+1)*r))),X=(...t)=>{if(0===t.length)return[];if(1===t.length)return[...t[0]];const[e,...r]=t;return C(e).filter(t=>r.every(e=>e.includes(t)))},Y=(t,e)=>t.filter(t=>!e.includes(t)),j=(...t)=>e=>t.reduce((t,e)=>e(t),e),v=(...t)=>e=>t.reduceRight((t,e)=>e(t),e),L=async(t,e)=>{const r=[];for(let n=0;n<t.length;n++)r.push(await e(t[n],n,t));return r},R=async(t,e)=>Promise.all(t.map(e)),S=async(t,e)=>{const r=[];for(let n=0;n<t.length;n++){const a=t[n];await e(a,n,t)&&r.push(a)}return r},$=async(t,e)=>{const r=await R(t,async(t,r,n)=>!!await e(t,r,n)&&t);return P(r)},B=async(t,e)=>{for(let r=0;r<t.length;r++)if(await e(t[r],r,t))return!0;return!1},E=async(t,e)=>{for(let r=0;r<t.length;r++)if(!await e(t[r],r,t))return!1;return!0},F=async(t,e,r)=>{let n=r;for(let r=0;r<t.length;r++)n=await e(n,t[r],r,t);return n},N=async(t,e)=>{for(let r=0;r<t.length;r++)if(await e(t[r],r,t))return t[r];return null},T=t=>t.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),z=t=>{const e=t.charAt(0),r=t.slice(1);return e.toLowerCase()+r.replace(/[A-Z]/g,t=>`-${t.toLowerCase()}`)},D=t=>t.split(" ").filter(Boolean),Z=t=>{let e=5381;for(let r=0;r<t.length;r++)e=33*e^t.charCodeAt(r);return(e>>>0).toString(36)},H=()=>{},I=t=>(...e)=>!t(...e),V=(t,...e)=>"function"==typeof t?t(...e):t,W=t=>new Promise(e=>setTimeout(e,t)),q=async(t,e,r="Operation timed out")=>{try{return await Promise.race([t,W(e).then(()=>Promise.reject(new Error(r)))])}finally{}},G=(t,{maxAttempts:e=3,delayMs:r=300,backoff:n=!0,onRetry:a}={})=>async(...o)=>{let l;for(let i=1;i<=e;i++)try{return await t(...o)}catch(t){if(l=t,i<e){a?.(i,t);const e=n?r*2**(i-1):r;await W(e)}}throw l},J=(t,e,r,n)=>{const a=r-t,o=n-e;return Math.hypot(a,o)},K=(t,e)=>Math.abs(t/e),Q=(t,e)=>t*e/100,U=t=>{const e=window.getComputedStyle(t).getPropertyValue("transform").match(/^matrix\((.+)\)$/);if(!e)return{translateX:0,translateY:0,scaleX:1,scaleY:1,skewX:0,skewY:0};const[r,n,a,o,l,i]=e[1].split(", ").map(parseFloat);return{translateX:l,translateY:i,scaleX:r,scaleY:o,skewX:a,skewY:n}},_=t=>new Blob([t],{type:t.type}),tt=(t,e)=>new File([t],e,{type:t.type}),et=(t,e)=>Math.max(0,Math.min(t.right,e.right)-Math.max(t.left,e.left))*Math.max(0,Math.min(t.bottom,e.bottom)-Math.max(t.top,e.top))/(e.width*e.height),rt=t=>new DOMRect(t.offsetLeft,t.offsetTop,t.clientWidth,t.clientHeight);export{e as assert,J as calculateEuclideanDistance,K as calculateMovingSpeed,Q as calculatePercentage,z as camelToDashCase,O as chunk,_ as cloneBlob,P as compact,v as compose,tt as convertBlobToFile,W as delay,Y as difference,E as everyAsync,$ as filterParallel,S as filterSequential,N as findAsync,et as getDOMRectIntersectionRatio,rt as getElementOffsetRect,Z as hashString,X as intersection,V as invokeIfFunction,h as isArray,s as isBool,w as isDate,o as isDefined,u as isEmptyArray,f as isEmptyObject,A as isFiniteNumber,y as isFunction,k as isInteger,b as isMap,n as isNil,a as isNilOrEmptyString,r as isNull,i as isNumber,c as isObject,p as isPromise,m as isRegExp,d as isSet,l as isString,M as isSymbol,x as isUndefined,g as isValidDate,H as noop,I as not,U as parse2DMatrix,j as pipe,F as reduceAsync,G as retry,R as runParallel,L as runSequential,B as someAsync,D as splitStringIntoWords,q as timeout,T as toKebabCase,C as unique};
+var t={};function e(t,e){if(!t)throw new Error(e)}t.d=(e,r)=>{for(var n in r)t.o(r,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:r[n]})},t.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e);const r=t=>null===t,n=t=>null==t,a=t=>""===t||n(t),o=t=>null!=t,i=t=>"string"==typeof t,l=t=>"number"==typeof t,s=t=>"boolean"==typeof t,c=t=>"object"==typeof t,f=t=>c(t)&&!r(t)&&0===Object.keys(t).length,u=t=>Array.isArray(t),h=t=>u(t)&&0===t.length,y=t=>"function"==typeof t,p=t=>y(t?.then),g=t=>t instanceof Date,w=t=>g(t)&&!isNaN(t.getTime()),m=t=>t instanceof RegExp,d=t=>t instanceof Map,b=t=>t instanceof Set,A=t=>"symbol"==typeof t,M=t=>void 0===t,x=t=>l(t)&&isFinite(t),C=t=>l(t)&&Number.isInteger(t),T=t=>t.filter(Boolean),O=t=>[...new Set(t)],P=(t,r)=>(e(r>0,"Chunk size must be greater than 0"),Array.from({length:Math.ceil(t.length/r)},(e,n)=>t.slice(n*r,(n+1)*r))),k=(...t)=>{if(0===t.length)return[];if(1===t.length)return[...t[0]];const[e,...r]=t;return O(e).filter(t=>r.every(e=>e.includes(t)))},E=(t,e)=>t.filter(t=>!e.includes(t)),N=(...t)=>e=>t.reduce((t,e)=>e(t),e),S=(...t)=>e=>t.reduceRight((t,e)=>e(t),e),X=async(t,e)=>{const r=[];for(let n=0;n<t.length;n++)r.push(await e(t[n],n,t));return r},L=async(t,e)=>Promise.all(t.map(e)),Y=async(t,e)=>{const r=[];for(let n=0;n<t.length;n++){const a=t[n];await e(a,n,t)&&r.push(a)}return r},$=async(t,e)=>{const r=await L(t,async(t,r,n)=>!!await e(t,r,n)&&t);return T(r)},j=async(t,e)=>{for(let r=0;r<t.length;r++)if(await e(t[r],r,t))return!0;return!1},v=async(t,e)=>{for(let r=0;r<t.length;r++)if(!await e(t[r],r,t))return!1;return!0},R=async(t,e,r)=>{let n=r;for(let r=0;r<t.length;r++)n=await e(n,t[r],r,t);return n},B=async(t,e)=>{for(let r=0;r<t.length;r++)if(await e(t[r],r,t))return t[r];return null},z=t=>t.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),F=t=>{const e=t.charAt(0),r=t.slice(1);return e.toLowerCase()+r.replace(/[A-Z]/g,t=>`-${t.toLowerCase()}`)},I=t=>t.replace(/([a-z0-9])([A-Z])/g,"$1 $2"),Z=t=>t.split(" ").filter(Boolean),D=t=>{let e=5381;for(let r=0;r<t.length;r++)e=33*e^t.charCodeAt(r);return(e>>>0).toString(36)},U=()=>{},q=t=>(...e)=>!t(...e),H=(t,...e)=>"function"==typeof t?t(...e):t,V=t=>new Promise(e=>setTimeout(e,t)),W=async(t,e,r="Operation timed out")=>{try{return await Promise.race([t,V(e).then(()=>Promise.reject(new Error(r)))])}finally{}},G=(t,{maxAttempts:e=3,delayMs:r=300,backoff:n=!0,onRetry:a}={})=>async(...o)=>{let i;for(let l=1;l<=e;l++)try{return await t(...o)}catch(t){if(i=t,l<e){a?.(l,t);const e=n?r*2**(l-1):r;await V(e)}}throw i},J=(t,e,r,n)=>{const a=r-t,o=n-e;return Math.hypot(a,o)},K=(t,e)=>Math.abs(t/e),Q=(t,e)=>t*e/100,_=["INPUT","SELECT","TEXTAREA","BUTTON","A"],tt=t=>{const e=window.getComputedStyle(t).getPropertyValue("transform").match(/^matrix\((.+)\)$/);if(!e)return{translateX:0,translateY:0,scaleX:1,scaleY:1,skewX:0,skewY:0};const[r,n,a,o,i,l]=e[1].split(", ").map(parseFloat);return{translateX:i,translateY:l,scaleX:r,scaleY:o,skewX:a,skewY:n}},et=t=>new Blob([t],{type:t.type}),rt=(t,e)=>Math.max(0,Math.min(t.right,e.right)-Math.max(t.left,e.left))*Math.max(0,Math.min(t.bottom,e.bottom)-Math.max(t.top,e.top))/(e.width*e.height),nt=t=>new DOMRect(t.offsetLeft,t.offsetTop,t.clientWidth,t.clientHeight),at=t=>"A"===t.tagName,ot=t=>"true"===t.getAttribute("contenteditable"),it=t=>{if(!t)return!1;const e=window.getComputedStyle(t);if("hidden"===e.visibility||"none"===e.display)return!1;if("disabled"in t&&t.disabled)return!1;const r=t.getAttribute("tabindex");return"-1"!==r&&(_.includes(t.tagName)?!at(t)||""!==t.href:!!ot(t)||null!==r)},lt=t=>Array.from(t.querySelectorAll("*")).filter(it),st=t=>{const e=t.lastIndexOf(".");return e<=0||e===t.length-1?[t,""]:[t.slice(0,e),t.slice(e+1).toLowerCase()]},ct=t=>{if(!t)return[];const e=[];for(let r=0;r<t.length;r++)e.push(t[r]);return e},ft=(t,e)=>new File([t],e,{type:t.type});export{_ as FOCUSABLE_HTML_TAGS,e as assert,ft as blobToFile,J as calculateEuclideanDistance,K as calculateMovingSpeed,Q as calculatePercentage,F as camelToDashCase,I as camelToWords,P as chunk,et as cloneBlob,T as compact,S as compose,V as delay,E as difference,v as everyAsync,ct as fileListToFiles,$ as filterParallel,Y as filterSequential,B as findAsync,rt as getDOMRectIntersectionRatio,nt as getElementOffsetRect,lt as getFocusableHtmlElements,D as hashString,k as intersection,H as invokeIfFunction,at as isAnchorHtmlElement,u as isArray,s as isBool,ot as isContentEditableHtmlElement,g as isDate,o as isDefined,h as isEmptyArray,f as isEmptyObject,x as isFiniteNumber,y as isFunction,it as isHtmlElementFocusable,C as isInteger,d as isMap,n as isNil,a as isNilOrEmptyString,r as isNull,l as isNumber,c as isObject,p as isPromise,m as isRegExp,b as isSet,i as isString,A as isSymbol,M as isUndefined,w as isValidDate,U as noop,q as not,tt as parse2DMatrix,st as parseFileName,N as pipe,R as reduceAsync,G as retry,L as runParallel,X as runSequential,j as someAsync,Z as splitStringIntoWords,W as timeout,z as toKebabCase,O as unique};
 //# sourceMappingURL=index.mjs.map