@react-hive/honey-utils 1.5.0 → 1.7.0

package/dist/index.dev.cjs

@@ -12,8 +12,17 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   boolFilter: () => (/* binding */ boolFilter),
 /* harmony export */   chunk: () => (/* binding */ chunk),
+/* harmony export */   compose: () => (/* binding */ compose),
 /* harmony export */   difference: () => (/* binding */ difference),
+/* harmony export */   everyAsync: () => (/* binding */ everyAsync),
+/* harmony export */   filterAsync: () => (/* binding */ filterAsync),
+/* harmony export */   findAsync: () => (/* binding */ findAsync),
+/* harmony export */   forAsync: () => (/* binding */ forAsync),
 /* harmony export */   intersection: () => (/* binding */ intersection),
+/* harmony export */   mapAsync: () => (/* binding */ mapAsync),
+/* harmony export */   pipe: () => (/* binding */ pipe),
+/* harmony export */   reduceAsync: () => (/* binding */ reduceAsync),
+/* harmony export */   someAsync: () => (/* binding */ someAsync),
 /* harmony export */   unique: () => (/* binding */ unique)
 /* harmony export */ });
 /* harmony import */ var _guards__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./guards */ "./src/guards.ts");
@@ -115,6 +124,171 @@ const intersection = (...arrays) => {
  * ```
  */
 const difference = (array, exclude) => array.filter(item => !exclude.includes(item));
+/**
+ * Asynchronously iterates over an array and executes an async function on each item sequentially,
+ * collecting the results.
+ *
+ * Unlike `Promise.all`, this runs each promise one after another (not in parallel).
+ * Useful when order or timing matters (e.g., rate limits, UI updates, animations).
+ *
+ * @param array - The array of items to iterate over.
+ * @param predicate - An async function to execute for each item. Must return a value.
+ *
+ * @returns A promise that resolves with an array of results from each predicate call.
+ *
+ * @example
+ * ```ts
+ * const results = await forAsync([1, 2, 3], async (item) => {
+ *   await delay(100);
+ *
+ *   return item * 2;
+ * });
+ *
+ * console.log(results); // [2, 4, 6]
+ * ```
+ */
+const forAsync = async (array, predicate) => {
+    const results = [];
+    for (let i = 0; i < array.length; i++) {
+        results.push(await predicate(array[i], i, array));
+    }
+    return results;
+};
+/**
+ * Executes an asynchronous operation on each element of an array and waits for all promises to resolve.
+ *
+ * @param array - The array of items to operate on.
+ * @param predicate - The asynchronous operation to perform on each item.
+ *
+ * @returns A promise that resolves with an array of results after all operations are completed.
+ */
+const mapAsync = async (array, predicate) => Promise.all(array.map(predicate));
+/**
+ * A generic function that processes an array asynchronously and filters the results
+ * based on the provided async condition.
+ *
+ * @template Item - The type of the items in the array.
+ * @template Return - The type of the items returned by the condition.
+ *
+ * @param array - An array of items to be processed.
+ * @param predicate - An async function that returns a condition for each item.
+ *
+ * @returns A Promise that resolves to an array of items that match the condition.
+ */
+const filterAsync = async (array, predicate) => {
+    const results = await mapAsync(array, async (item, index, array) => (await predicate(item, index, array)) ? item : false);
+    return boolFilter(results);
+};
+/**
+ * Asynchronously checks if at least one element in the array satisfies the async condition.
+ *
+ * @param array - The array of items to check.
+ * @param predicate - An async function that returns a boolean.
+ *
+ * @returns A promise that resolves to true if any item passes the condition.
+ */
+const someAsync = async (array, predicate) => {
+    for (let i = 0; i < array.length; i++) {
+        if (await predicate(array[i], i, array)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Asynchronously checks if all elements in the array satisfy the async condition.
+ *
+ * @param array - The array of items to check.
+ * @param predicate - An async function that returns a boolean.
+ *
+ * @returns A promise that resolves to true if all items pass the condition.
+ */
+const everyAsync = async (array, predicate) => {
+    for (let i = 0; i < array.length; i++) {
+        if (!(await predicate(array[i], i, array))) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Asynchronously reduces an array to a single accumulated value.
+ *
+ * @template Item - The type of items in the array.
+ * @template Accumulator - The type of the accumulated result.
+ *
+ * @param array - The array to reduce.
+ * @param predicate - The async reducer function that processes each item and returns the updated accumulator.
+ * @param initialValue - The initial accumulator value.
+ *
+ * @returns A promise that resolves to the final accumulated result.
+ */
+const reduceAsync = async (array, predicate, initialValue) => {
+    let accumulator = initialValue;
+    for (let i = 0; i < array.length; i++) {
+        accumulator = await predicate(accumulator, array[i], i, array);
+    }
+    return accumulator;
+};
+/**
+ * Asynchronously finds the first element that satisfies the async condition.
+ *
+ * @param array - The array of items to search.
+ * @param predicate - An async function that returns a boolean.
+ *
+ * @returns A promise that resolves to the found item or null if none match.
+ */
+const findAsync = async (array, predicate) => {
+    for (let i = 0; i < array.length; i++) {
+        if (await predicate(array[i], i, array)) {
+            return array[i];
+        }
+    }
+    return null;
+};
+/**
+ * Composes multiple unary functions into a single function, applying them from left to right.
+ *
+ * Useful for building a data processing pipeline where the output of one function becomes the input of the next.
+ *
+ * Types are inferred up to 5 chained functions for full type safety. Beyond that, it falls back to the unknown.
+ *
+ * @param fns - A list of unary functions to compose.
+ *
+ * @returns A new function that applies all functions from left to right.
+ *
+ * @example
+ * ```ts
+ * const add = (x: number) => x + 1;
+ * const double = (x: number) => x * 2;
+ * const toStr = (x: number) => `Result: ${x}`;
+ *
+ * const result = pipe(add, double, toStr)(2);
+ * // => 'Result: 6'
+ * ```
+ */
+const pipe = (...fns) => (arg) => fns.reduce((prev, fn) => fn(prev), arg);
+/**
+ * Composes multiple unary functions into a single function, applying them from **right to left**.
+ *
+ * Often used for building functional pipelines where the innermost function runs first.
+ * Types are inferred up to 5 chained functions for full type safety.
+ *
+ * @param fns - A list of unary functions to compose.
+ *
+ * @returns A new function that applies all functions from right to left.
+ *
+ * @example
+ * ```ts
+ * const add = (x: number) => x + 1;
+ * const double = (x: number) => x * 2;
+ * const toStr = (x: number) => `Result: ${x}`;
+ *
+ * const result = compose(toStr, double, add)(2);
+ * // => 'Result: 6'
+ * ```
+ */
+const compose = (...fns) => (arg) => fns.reduceRight((prev, fn) => fn(prev), arg);
 
 
 /***/ }),
@@ -127,33 +301,81 @@ const difference = (array, exclude) => array.filter(item => !exclude.includes(it
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   getTransformationValues: () => (/* binding */ getTransformationValues)
+/* harmony export */   cloneBlob: () => (/* binding */ cloneBlob),
+/* harmony export */   convertBlobToFile: () => (/* binding */ convertBlobToFile),
+/* harmony export */   parse2DMatrix: () => (/* binding */ parse2DMatrix)
 /* harmony export */ });
 /**
- * Get various transformation values from the transformation matrix of an element.
+ * Extracts transformation values (translate, scale, skew) from the 2D transformation matrix of a given HTML element.
+ *
+ * Only works with 2D transforms (i.e., `matrix(a, b, c, d, e, f)`).
  *
- * @param element - The element with a transformation applied.
+ * @param element - The element with a CSS transform applied.
+ * @returns An object with parsed transformation values.
  *
- * @returns An object containing transformation values.
+ * @example
+ * ```ts
+ * const values = parse2DMatrix(myElement);
+ * console.log(values.translateX);
+ * console.log(values.scaleX);
+ * ```
  */
-const getTransformationValues = (element) => {
+const parse2DMatrix = (element) => {
     const computedStyles = window.getComputedStyle(element);
     const transformValue = computedStyles.getPropertyValue('transform');
-    const matrix = transformValue.match(/^matrix\((.+)\)$/);
-    if (!matrix) {
+    const matrixMatch = transformValue.match(/^matrix\((.+)\)$/);
+    if (!matrixMatch) {
         return {
             translateX: 0,
             translateY: 0,
+            scaleX: 1,
+            scaleY: 1,
+            skewX: 0,
+            skewY: 0,
         };
     }
-    const transformMatrix = matrix[1].split(', ');
-    const translateX = parseFloat(transformMatrix[4]);
-    const translateY = parseFloat(transformMatrix[5]);
+    const [scaleX, skewY, skewX, scaleY, translateX, translateY] = matrixMatch[1]
+        .split(', ')
+        .map(parseFloat);
     return {
         translateX,
         translateY,
+        scaleX,
+        scaleY,
+        skewX,
+        skewY,
     };
 };
+/**
+ * Creates a clone of a Blob object.
+ *
+ * @param blob - The Blob object to clone.
+ *
+ * @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,
+});
 
 
 /***/ }),
@@ -287,6 +509,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   isArray: () => (/* binding */ isArray),
 /* harmony export */   isBool: () => (/* binding */ isBool),
 /* harmony export */   isDate: () => (/* binding */ isDate),
+/* harmony export */   isDefined: () => (/* binding */ isDefined),
 /* harmony export */   isEmptyArray: () => (/* binding */ isEmptyArray),
 /* harmony export */   isEmptyObject: () => (/* binding */ isEmptyObject),
 /* harmony export */   isFiniteNumber: () => (/* binding */ isFiniteNumber),
@@ -319,6 +542,35 @@ function assert(condition, message) {
  * @returns `true` if the value is null; otherwise, `false`.
  */
 const isNull = (value) => value === null;
+/**
+ * Checks if a value is null or undefined.
+ *
+ * @param value - The value to check.
+ *
+ * @returns `true` if the value is `null` or `undefined`, otherwise `false`.
+ */
+const isNil = (value) => value === undefined || value === null;
+/**
+ * Checks whether the provided value is considered "empty".
+ *
+ * A value is considered empty if it is:
+ * - `null`
+ * - `undefined`
+ * - `''`
+ *
+ * @param value - The value to check.
+ *
+ * @returns `true` if the value is empty; otherwise, `false`.
+ */
+const isNilOrEmptyString = (value) => value === '' || isNil(value);
+/**
+ * Checks if a value is neither `null` nor `undefined`.
+ *
+ * @param value - The value to check.
+ *
+ * @returns `true` if the value is defined (not `null` or `undefined`); otherwise, `false`.
+ */
+const isDefined = (value) => value !== null && value !== undefined;
 /**
  * Checks if a value is a string.
  *
@@ -393,27 +645,6 @@ const isFunction = (value) => typeof value === 'function';
  * @returns `true` if the value is a Promise; otherwise, `false`.
  */
 const isPromise = (value) => isFunction(value?.then);
-/**
- * Checks if a value is null or undefined.
- *
- * @param value - The value to check.
- *
- * @returns `true` if the value is `null` or `undefined`, otherwise `false`.
- */
-const isNil = (value) => value === undefined || value === null;
-/**
- * Checks whether the provided value is considered "empty".
- *
- * A value is considered empty if it is:
- * - `null`
- * - `undefined`
- * - `''`
- *
- * @param value - The value to check.
- *
- * @returns `true` if the value is empty; otherwise, `false`.
- */
-const isNilOrEmptyString = (value) => value === '' || isNil(value);
 /**
  * Checks if a value is a Date object.
  *
@@ -715,15 +946,22 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   calculatePercentage: () => (/* reexport safe */ _math__WEBPACK_IMPORTED_MODULE_4__.calculatePercentage),
 /* harmony export */   camelToDashCase: () => (/* reexport safe */ _string__WEBPACK_IMPORTED_MODULE_0__.camelToDashCase),
 /* harmony export */   chunk: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.chunk),
+/* harmony export */   cloneBlob: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_5__.cloneBlob),
+/* harmony export */   compose: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.compose),
+/* harmony export */   convertBlobToFile: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_5__.convertBlobToFile),
 /* harmony export */   delay: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_2__.delay),
 /* harmony export */   difference: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.difference),
-/* harmony export */   getTransformationValues: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_5__.getTransformationValues),
+/* harmony export */   everyAsync: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.everyAsync),
+/* harmony export */   filterAsync: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.filterAsync),
+/* harmony export */   findAsync: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.findAsync),
+/* harmony export */   forAsync: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.forAsync),
 /* harmony export */   hashString: () => (/* reexport safe */ _string__WEBPACK_IMPORTED_MODULE_0__.hashString),
 /* harmony export */   intersection: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.intersection),
 /* harmony export */   invokeIfFunction: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_2__.invokeIfFunction),
 /* harmony export */   isArray: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isArray),
 /* harmony export */   isBool: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isBool),
 /* harmony export */   isDate: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isDate),
+/* harmony export */   isDefined: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isDefined),
 /* harmony export */   isEmptyArray: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isEmptyArray),
 /* harmony export */   isEmptyObject: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isEmptyObject),
 /* harmony export */   isFiniteNumber: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isFiniteNumber),
@@ -742,8 +980,13 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   isSymbol: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isSymbol),
 /* harmony export */   isUndefined: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isUndefined),
 /* harmony export */   isValidDate: () => (/* reexport safe */ _guards__WEBPACK_IMPORTED_MODULE_3__.isValidDate),
+/* harmony export */   mapAsync: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.mapAsync),
 /* harmony export */   noop: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_2__.noop),
+/* harmony export */   parse2DMatrix: () => (/* reexport safe */ _dom__WEBPACK_IMPORTED_MODULE_5__.parse2DMatrix),
+/* harmony export */   pipe: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.pipe),
+/* harmony export */   reduceAsync: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.reduceAsync),
 /* harmony export */   retry: () => (/* reexport safe */ _function__WEBPACK_IMPORTED_MODULE_2__.retry),
+/* harmony export */   someAsync: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.someAsync),
 /* harmony export */   splitStringIntoWords: () => (/* reexport safe */ _string__WEBPACK_IMPORTED_MODULE_0__.splitStringIntoWords),
 /* harmony export */   toKebabCase: () => (/* reexport safe */ _string__WEBPACK_IMPORTED_MODULE_0__.toKebabCase),
 /* harmony export */   unique: () => (/* reexport safe */ _array__WEBPACK_IMPORTED_MODULE_1__.unique)

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/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 * Filters out `null`, `undefined`, and other falsy values from an array,\n * returning a typed array of only truthy `Item` values.\n *\n * Useful when working with optional or nullable items that need to be sanitized.\n *\n * @template T - The type of the items in the array.\n *\n * @param array - An array of items that may include `null`, `undefined`, or falsy values.\n *\n * @returns A new array containing only truthy `Item` values.\n */\nexport const boolFilter = <T>(array: (T | false | null | undefined)[]): T[] =>\n  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","interface HTMLElementTransformationValues {\n  translateX: number;\n  translateY: number;\n}\n\n/**\n * Get various transformation values from the transformation matrix of an element.\n *\n * @param element - The element with a transformation applied.\n *\n * @returns An object containing transformation values.\n */\nexport const getTransformationValues = (element: HTMLElement): HTMLElementTransformationValues => {\n  const computedStyles = window.getComputedStyle(element);\n  const transformValue = computedStyles.getPropertyValue('transform');\n\n  const matrix = transformValue.match(/^matrix\\((.+)\\)$/);\n  if (!matrix) {\n    return {\n      translateX: 0,\n      translateY: 0,\n    };\n  }\n\n  const transformMatrix = matrix[1].split(', ');\n\n  const translateX = parseFloat(transformMatrix[4]);\n  const translateY = parseFloat(transformMatrix[5]);\n\n  return {\n    translateX,\n    translateY,\n  };\n};\n","export const noop = () => {};\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 * async function fetchWithTimeout() {\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\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 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 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 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.sqrt(deltaX ** 2 + deltaY ** 2);\n};\n\n/**\n * Calculates the moving speed.\n *\n * @param delta - The change in position (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 = (delta: number, elapsedTime: number): number =>\n  Math.abs(delta / 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 './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/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 * Filters out `null`, `undefined`, and other falsy values from an array,\n * returning a typed array of only truthy `Item` values.\n *\n * Useful when working with optional or nullable items that need to be sanitized.\n *\n * @template T - The type of the items in the array.\n *\n * @param array - An array of items that may include `null`, `undefined`, or falsy values.\n *\n * @returns A new array containing only truthy `Item` values.\n */\nexport const boolFilter = <T>(array: (T | false | null | undefined)[]): T[] =>\n  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\n/**\n * Asynchronously iterates over an array and executes an async function on each item sequentially,\n * collecting the results.\n *\n * Unlike `Promise.all`, this runs each promise one after another (not in parallel).\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 predicate - 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 predicate call.\n *\n * @example\n * ```ts\n * const results = await forAsync([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 forAsync = async <Item, Result>(\n  array: Item[],\n  predicate: (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 predicate(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 predicate - 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 */\nexport const mapAsync = async <Item, Return>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<Return>,\n): Promise<Return[]> => Promise.all(array.map(predicate));\n\n/**\n * A generic function that processes an array asynchronously and filters the results\n * based on the provided async condition.\n *\n * @template Item - The type of the items in the array.\n * @template Return - The type of the items returned by the condition.\n *\n * @param array - An array of items to be processed.\n * @param predicate - An async function that returns a condition for each item.\n *\n * @returns A Promise that resolves to an array of items that match the condition.\n */\nexport const filterAsync = async <Item>(\n  array: Item[],\n  predicate: (item: Item, index: number, array: Item[]) => Promise<boolean>,\n): Promise<Item[]> => {\n  const results = await mapAsync(array, async (item, index, array) =>\n    (await predicate(item, index, array)) ? item : false,\n  );\n\n  return boolFilter(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 predicate - 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  predicate: (\n    accumulator: Accumulator,\n    item: Item,\n    index: number,\n    array: Item[],\n  ) => 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 predicate(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\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","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","export const noop = () => {};\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 * async function fetchWithTimeout() {\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\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.sqrt(deltaX ** 2 + deltaY ** 2);\n};\n\n/**\n * Calculates the moving speed.\n *\n * @param delta - The change in position (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 = (delta: number, elapsedTime: number): number =>\n  Math.abs(delta / 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 './string';\nexport * from './array';\nexport * from './function';\nexport * from './guards';\nexport * from './math';\nexport * from './dom';\n"],"names":[],"sourceRoot":""}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-const t=t=>t.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),e=t=>{const e=t.charAt(0),r=t.slice(1);return e.toLowerCase()+r.replace(/[A-Z]/g,t=>`-${t.toLowerCase()}`)},r=t=>t.split(" ").filter(Boolean),n=t=>{let e=5381;for(let r=0;r<t.length;r++)e=33*e^t.charCodeAt(r);return(e>>>0).toString(36)};function o(t,e){if(!t)throw new Error(e)}const a=t=>null===t,s=t=>"string"==typeof t,l=t=>"number"==typeof t,i=t=>"boolean"==typeof t,c=t=>"object"==typeof t,f=t=>c(t)&&!a(t)&&0===Object.keys(t).length,u=t=>Array.isArray(t),h=t=>u(t)&&0===t.length,p=t=>"function"==typeof t,y=t=>p(t?.then),g=t=>null==t,m=t=>""===t||g(t),w=t=>t instanceof Date,b=t=>w(t)&&!isNaN(t.getTime()),A=t=>t instanceof RegExp,d=t=>t instanceof Map,C=t=>t instanceof Set,M=t=>"symbol"==typeof t,x=t=>void 0===t,S=t=>l(t)&&isFinite(t),$=t=>l(t)&&Number.isInteger(t),k=t=>t.filter(Boolean),F=t=>[...new Set(t)],L=(t,e)=>(o(e>0,"Chunk size must be greater than 0"),Array.from({length:Math.ceil(t.length/e)},(r,n)=>t.slice(n*e,(n+1)*e))),N=(...t)=>{if(0===t.length)return[];if(1===t.length)return[...t[0]];const[e,...r]=t;return F(e).filter(t=>r.every(e=>e.includes(t)))},j=(t,e)=>t.filter(t=>!e.includes(t)),v=()=>{},z=(t,...e)=>"function"==typeof t?t(...e):t,B=t=>new Promise(e=>setTimeout(e,t)),E=(t,{maxAttempts:e=3,delayMs:r=300,backoff:n=!0,onRetry:o}={})=>async(...a)=>{let s;for(let l=1;l<=e;l++)try{return await t(...a)}catch(t){if(s=t,l<e){o?.(l,t);const e=n?r*2**(l-1):r;await B(e)}}throw s},P=(t,e,r,n)=>{const o=r-t,a=n-e;return Math.sqrt(o**2+a**2)},R=(t,e)=>Math.abs(t/e),T=(t,e)=>t*e/100,X=t=>{const e=window.getComputedStyle(t).getPropertyValue("transform").match(/^matrix\((.+)\)$/);if(!e)return{translateX:0,translateY:0};const r=e[1].split(", ");return{translateX:parseFloat(r[4]),translateY:parseFloat(r[5])}};export{o as assert,k as boolFilter,P as calculateEuclideanDistance,R as calculateMovingSpeed,T as calculatePercentage,e as camelToDashCase,L as chunk,B as delay,j as difference,X as getTransformationValues,n as hashString,N as intersection,z as invokeIfFunction,u as isArray,i as isBool,w as isDate,h as isEmptyArray,f as isEmptyObject,S as isFiniteNumber,p as isFunction,$ as isInteger,d as isMap,g as isNil,m as isNilOrEmptyString,a as isNull,l as isNumber,c as isObject,y as isPromise,A as isRegExp,C as isSet,s as isString,M as isSymbol,x as isUndefined,b as isValidDate,v as noop,E as retry,r as splitStringIntoWords,t as toKebabCase,F as unique};
+const e=e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),t=e=>{const t=e.charAt(0),n=e.slice(1);return t.toLowerCase()+n.replace(/[A-Z]/g,e=>`-${e.toLowerCase()}`)},n=e=>e.split(" ").filter(Boolean),r=e=>{let t=5381;for(let n=0;n<e.length;n++)t=33*t^e.charCodeAt(n);return(t>>>0).toString(36)};function a(e,t){if(!e)throw new Error(t)}const o=e=>null===e,l=e=>null==e,s=e=>""===e||l(e),i=e=>null!=e,c=e=>"string"==typeof e,f=e=>"number"==typeof e,u=e=>"boolean"==typeof e,y=e=>"object"==typeof e,h=e=>y(e)&&!o(e)&&0===Object.keys(e).length,p=e=>Array.isArray(e),w=e=>p(e)&&0===e.length,g=e=>"function"==typeof e,m=e=>g(e?.then),b=e=>e instanceof Date,d=e=>b(e)&&!isNaN(e.getTime()),A=e=>e instanceof RegExp,k=e=>e instanceof Map,C=e=>e instanceof Set,X=e=>"symbol"==typeof e,Y=e=>void 0===e,M=e=>f(e)&&isFinite(e),x=e=>f(e)&&Number.isInteger(e),S=e=>e.filter(Boolean),$=e=>[...new Set(e)],B=(e,t)=>(a(t>0,"Chunk size must be greater than 0"),Array.from({length:Math.ceil(e.length/t)},(n,r)=>e.slice(r*t,(r+1)*t))),F=(...e)=>{if(0===e.length)return[];if(1===e.length)return[...e[0]];const[t,...n]=e;return $(t).filter(e=>n.every(t=>t.includes(e)))},L=(e,t)=>e.filter(e=>!t.includes(e)),N=async(e,t)=>{const n=[];for(let r=0;r<e.length;r++)n.push(await t(e[r],r,e));return n},P=async(e,t)=>Promise.all(e.map(t)),R=async(e,t)=>{const n=await P(e,async(e,n,r)=>!!await t(e,n,r)&&e);return S(n)},j=async(e,t)=>{for(let n=0;n<e.length;n++)if(await t(e[n],n,e))return!0;return!1},v=async(e,t)=>{for(let n=0;n<e.length;n++)if(!await t(e[n],n,e))return!1;return!0},z=async(e,t,n)=>{let r=n;for(let n=0;n<e.length;n++)r=await t(r,e[n],n,e);return r},E=async(e,t)=>{for(let n=0;n<e.length;n++)if(await t(e[n],n,e))return e[n];return null},T=(...e)=>t=>e.reduce((e,t)=>t(e),t),Z=(...e)=>t=>e.reduceRight((e,t)=>t(e),t),q=()=>{},D=(e,...t)=>"function"==typeof e?e(...t):e,I=e=>new Promise(t=>setTimeout(t,e)),O=(e,{maxAttempts:t=3,delayMs:n=300,backoff:r=!0,onRetry:a}={})=>async(...o)=>{let l;for(let s=1;s<=t;s++)try{return await e(...o)}catch(e){if(l=e,s<t){a?.(s,e);const t=r?n*2**(s-1):n;await I(t)}}throw l},V=(e,t,n,r)=>{const a=n-e,o=r-t;return Math.sqrt(a**2+o**2)},G=(e,t)=>Math.abs(e/t),H=(e,t)=>e*t/100,J=e=>{const t=window.getComputedStyle(e).getPropertyValue("transform").match(/^matrix\((.+)\)$/);if(!t)return{translateX:0,translateY:0,scaleX:1,scaleY:1,skewX:0,skewY:0};const[n,r,a,o,l,s]=t[1].split(", ").map(parseFloat);return{translateX:l,translateY:s,scaleX:n,scaleY:o,skewX:a,skewY:r}},K=e=>new Blob([e],{type:e.type}),Q=(e,t)=>new File([e],t,{type:e.type});export{a as assert,S as boolFilter,V as calculateEuclideanDistance,G as calculateMovingSpeed,H as calculatePercentage,t as camelToDashCase,B as chunk,K as cloneBlob,Z as compose,Q as convertBlobToFile,I as delay,L as difference,v as everyAsync,R as filterAsync,E as findAsync,N as forAsync,r as hashString,F as intersection,D as invokeIfFunction,p as isArray,u as isBool,b as isDate,i as isDefined,w as isEmptyArray,h as isEmptyObject,M as isFiniteNumber,g as isFunction,x as isInteger,k as isMap,l as isNil,s as isNilOrEmptyString,o as isNull,f as isNumber,y as isObject,m as isPromise,A as isRegExp,C as isSet,c as isString,X as isSymbol,Y as isUndefined,d as isValidDate,P as mapAsync,q as noop,J as parse2DMatrix,T as pipe,z as reduceAsync,O as retry,j as someAsync,n as splitStringIntoWords,e as toKebabCase,$ as unique};
 //# sourceMappingURL=index.mjs.map