@elench/testkit 0.1.99 → 0.1.101

package/node_modules/es-toolkit/dist/function/partialRight.mjs

@@ -0,0 +1,23 @@
+function partialRight(func, ...partialArgs) {
+    return partialRightImpl(func, placeholderSymbol, ...partialArgs);
+}
+function partialRightImpl(func, placeholder, ...partialArgs) {
+    const partialedRight = function (...providedArgs) {
+        const placeholderLength = partialArgs.filter(arg => arg === placeholder).length;
+        const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+        const remainingArgs = providedArgs.slice(0, rangeLength);
+        let providedArgsIndex = rangeLength;
+        const substitutedArgs = partialArgs
+            .slice()
+            .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg));
+        return func.apply(this, remainingArgs.concat(substitutedArgs));
+    };
+    if (func.prototype) {
+        partialedRight.prototype = Object.create(func.prototype);
+    }
+    return partialedRight;
+}
+const placeholderSymbol = Symbol('partialRight.placeholder');
+partialRight.placeholder = placeholderSymbol;
+
+export { partialRight, partialRightImpl };

package/node_modules/es-toolkit/dist/function/rest.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/node_modules/es-toolkit/dist/function/rest.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/node_modules/es-toolkit/dist/function/rest.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function rest(func, startIndex = func.length - 1) {
+    return function (...args) {
+        const rest = args.slice(startIndex);
+        const params = args.slice(0, startIndex);
+        while (params.length < startIndex) {
+            params.push(undefined);
+        }
+        return func.apply(this, [...params, rest]);
+    };
+}
+
+exports.rest = rest;

package/node_modules/es-toolkit/dist/function/rest.mjs

@@ -0,0 +1,12 @@
+function rest(func, startIndex = func.length - 1) {
+    return function (...args) {
+        const rest = args.slice(startIndex);
+        const params = args.slice(0, startIndex);
+        while (params.length < startIndex) {
+            params.push(undefined);
+        }
+        return func.apply(this, [...params, rest]);
+    };
+}
+
+export { rest };

package/node_modules/es-toolkit/dist/function/retry.d.mts

@@ -0,0 +1,90 @@
+interface RetryOptions {
+    /**
+     * Delay between retries. Can be a static number (milliseconds) or a function
+     * that computes delay dynamically based on the current attempt.
+     *
+     * @default 0
+     * @example
+     * delay: (attempts) => attempt * 50
+     */
+    delay?: number | ((attempts: number) => number);
+    /**
+     * The number of retries to attempt.
+     * @default Number.POSITIVE_INFINITY
+     */
+    retries?: number;
+    /**
+     * An AbortSignal to cancel the retry operation.
+     */
+    signal?: AbortSignal;
+    /**
+     * A function that determines whether to retry based on the error and attempt number.
+     * If not provided, all errors will trigger a retry.
+     *
+     * @param {unknown} error - The error that occurred.
+     * @param {number} attempt - The current attempt number (0-indexed).
+     * @returns {boolean} Whether to retry.
+     *
+     * @example
+     * shouldRetry: (error, attempt) => error.status >= 500
+     */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+}
+/**
+ * Retries a function that returns a promise until it resolves successfully.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Basic usage with default retry options
+ * retry(() => fetchData()).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>): Promise<T>;
+/**
+ * Retries a function that returns a promise a specified number of times.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {number} retries - The number of retries to attempt. Default is Infinity.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function up to 3 times
+ * retry(() => fetchData(), 3).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, retries: number): Promise<T>;
+/**
+ * Retries a function that returns a promise with specified options.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {RetryOptions} options - Options to configure the retry behavior.
+ * @param {number | ((attempts: number) => number)} [options.delay=0] - Delay(milliseconds) between retries.
+ * @param {number} [options.retries=Infinity] - The number of retries to attempt.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation.
+ * @param {(error: unknown, attempt: number) => boolean} [options.shouldRetry] - A function that determines whether to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function with a delay of 1000ms between attempts
+ * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data));
+ *
+ * @example
+ * // Retry a function with a fixed delay
+ * retry(() => fetchData(), { delay: 1000, retries: 5 });
+ *
+ * // Retry a function with a delay increasing linearly by 50ms per attempt
+ * retry(() => fetchData(), { delay: (attempts) => attempt * 50, retries: 5 });
+ *
+ * @example
+ * // Retry a function with exponential backoff + jitter (max delay 10 seconds)
+ * retry(() => fetchData(), {
+ *   delay: (attempts) => Math.min(Math.random() * 100 * 2 ** attempts, 10000),
+ *   retries: 5
+ * });
+ */
+declare function retry<T>(func: () => Promise<T>, options: RetryOptions): Promise<T>;
+
+export { retry };

package/node_modules/es-toolkit/dist/function/retry.d.ts

@@ -0,0 +1,90 @@
+interface RetryOptions {
+    /**
+     * Delay between retries. Can be a static number (milliseconds) or a function
+     * that computes delay dynamically based on the current attempt.
+     *
+     * @default 0
+     * @example
+     * delay: (attempts) => attempt * 50
+     */
+    delay?: number | ((attempts: number) => number);
+    /**
+     * The number of retries to attempt.
+     * @default Number.POSITIVE_INFINITY
+     */
+    retries?: number;
+    /**
+     * An AbortSignal to cancel the retry operation.
+     */
+    signal?: AbortSignal;
+    /**
+     * A function that determines whether to retry based on the error and attempt number.
+     * If not provided, all errors will trigger a retry.
+     *
+     * @param {unknown} error - The error that occurred.
+     * @param {number} attempt - The current attempt number (0-indexed).
+     * @returns {boolean} Whether to retry.
+     *
+     * @example
+     * shouldRetry: (error, attempt) => error.status >= 500
+     */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+}
+/**
+ * Retries a function that returns a promise until it resolves successfully.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Basic usage with default retry options
+ * retry(() => fetchData()).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>): Promise<T>;
+/**
+ * Retries a function that returns a promise a specified number of times.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {number} retries - The number of retries to attempt. Default is Infinity.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function up to 3 times
+ * retry(() => fetchData(), 3).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, retries: number): Promise<T>;
+/**
+ * Retries a function that returns a promise with specified options.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {RetryOptions} options - Options to configure the retry behavior.
+ * @param {number | ((attempts: number) => number)} [options.delay=0] - Delay(milliseconds) between retries.
+ * @param {number} [options.retries=Infinity] - The number of retries to attempt.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation.
+ * @param {(error: unknown, attempt: number) => boolean} [options.shouldRetry] - A function that determines whether to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function with a delay of 1000ms between attempts
+ * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data));
+ *
+ * @example
+ * // Retry a function with a fixed delay
+ * retry(() => fetchData(), { delay: 1000, retries: 5 });
+ *
+ * // Retry a function with a delay increasing linearly by 50ms per attempt
+ * retry(() => fetchData(), { delay: (attempts) => attempt * 50, retries: 5 });
+ *
+ * @example
+ * // Retry a function with exponential backoff + jitter (max delay 10 seconds)
+ * retry(() => fetchData(), {
+ *   delay: (attempts) => Math.min(Math.random() * 100 * 2 ** attempts, 10000),
+ *   retries: 5
+ * });
+ */
+declare function retry<T>(func: () => Promise<T>, options: RetryOptions): Promise<T>;
+
+export { retry };

package/node_modules/es-toolkit/dist/function/retry.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const delay = require('../promise/delay.js');
+
+const DEFAULT_DELAY = 0;
+const DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+const DEFAULT_SHOULD_RETRY = () => true;
+async function retry(func, _options) {
+    let delay$1;
+    let retries;
+    let signal;
+    let shouldRetry;
+    if (typeof _options === 'number') {
+        delay$1 = DEFAULT_DELAY;
+        retries = _options;
+        signal = undefined;
+        shouldRetry = DEFAULT_SHOULD_RETRY;
+    }
+    else {
+        delay$1 = _options?.delay ?? DEFAULT_DELAY;
+        retries = _options?.retries ?? DEFAULT_RETRIES;
+        signal = _options?.signal;
+        shouldRetry = _options?.shouldRetry ?? DEFAULT_SHOULD_RETRY;
+    }
+    let error;
+    for (let attempts = 0; attempts <= retries; attempts++) {
+        if (signal?.aborted) {
+            throw error ?? new Error(`The retry operation was aborted due to an abort signal.`);
+        }
+        try {
+            return await func();
+        }
+        catch (err) {
+            error = err;
+            if (!shouldRetry(err, attempts)) {
+                throw err;
+            }
+            const currentDelay = typeof delay$1 === 'function' ? delay$1(attempts) : delay$1;
+            await delay.delay(currentDelay);
+        }
+    }
+    throw error;
+}
+
+exports.retry = retry;

package/node_modules/es-toolkit/dist/function/retry.mjs

@@ -0,0 +1,43 @@
+import { delay } from '../promise/delay.mjs';
+
+const DEFAULT_DELAY = 0;
+const DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+const DEFAULT_SHOULD_RETRY = () => true;
+async function retry(func, _options) {
+    let delay$1;
+    let retries;
+    let signal;
+    let shouldRetry;
+    if (typeof _options === 'number') {
+        delay$1 = DEFAULT_DELAY;
+        retries = _options;
+        signal = undefined;
+        shouldRetry = DEFAULT_SHOULD_RETRY;
+    }
+    else {
+        delay$1 = _options?.delay ?? DEFAULT_DELAY;
+        retries = _options?.retries ?? DEFAULT_RETRIES;
+        signal = _options?.signal;
+        shouldRetry = _options?.shouldRetry ?? DEFAULT_SHOULD_RETRY;
+    }
+    let error;
+    for (let attempts = 0; attempts <= retries; attempts++) {
+        if (signal?.aborted) {
+            throw error ?? new Error(`The retry operation was aborted due to an abort signal.`);
+        }
+        try {
+            return await func();
+        }
+        catch (err) {
+            error = err;
+            if (!shouldRetry(err, attempts)) {
+                throw err;
+            }
+            const currentDelay = typeof delay$1 === 'function' ? delay$1(attempts) : delay$1;
+            await delay(currentDelay);
+        }
+    }
+    throw error;
+}
+
+export { retry };

package/node_modules/es-toolkit/dist/function/spread.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Creates a new function that spreads elements of an array argument into individual arguments
+ * for the original function.
+ *
+ * @template F - A function type with any number of parameters and any return type.
+ * @param {F} func - The function to be transformed. It can be any function with any number of arguments.
+ * @returns {(argsArr: Parameters<F>) => ReturnType<F>} - A new function that takes an array of arguments and returns the result of calling the original function with those arguments.
+ *
+ * @example
+ * function add(a, b) {
+ *   return a + b;
+ * }
+ *
+ * const spreadAdd = spread(add);
+ * console.log(spreadAdd([1, 2])); // Output: 3
+ */
+declare function spread<F extends (...args: any[]) => any>(func: F): (argsArr: Parameters<F>) => ReturnType<F>;
+
+export { spread };

package/node_modules/es-toolkit/dist/function/spread.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Creates a new function that spreads elements of an array argument into individual arguments
+ * for the original function.
+ *
+ * @template F - A function type with any number of parameters and any return type.
+ * @param {F} func - The function to be transformed. It can be any function with any number of arguments.
+ * @returns {(argsArr: Parameters<F>) => ReturnType<F>} - A new function that takes an array of arguments and returns the result of calling the original function with those arguments.
+ *
+ * @example
+ * function add(a, b) {
+ *   return a + b;
+ * }
+ *
+ * const spreadAdd = spread(add);
+ * console.log(spreadAdd([1, 2])); // Output: 3
+ */
+declare function spread<F extends (...args: any[]) => any>(func: F): (argsArr: Parameters<F>) => ReturnType<F>;
+
+export { spread };

package/node_modules/es-toolkit/dist/function/spread.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function spread(func) {
+    return function (argsArr) {
+        return func.apply(this, argsArr);
+    };
+}
+
+exports.spread = spread;

package/node_modules/es-toolkit/dist/function/spread.mjs

@@ -0,0 +1,7 @@
+function spread(func) {
+    return function (argsArr) {
+        return func.apply(this, argsArr);
+    };
+}
+
+export { spread };

package/node_modules/es-toolkit/dist/function/throttle.d.mts

@@ -0,0 +1,48 @@
+interface ThrottleOptions {
+    /**
+     * An optional AbortSignal to cancel the throttled function.
+     */
+    signal?: AbortSignal;
+    /**
+     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+     * @default ["leading", "trailing"]
+     */
+    edges?: Array<'leading' | 'trailing'>;
+}
+interface ThrottledFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
+    cancel: () => void;
+    flush: () => void;
+}
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction<F>;
+
+export { type ThrottleOptions, type ThrottledFunction, throttle };

package/node_modules/es-toolkit/dist/function/throttle.d.ts

@@ -0,0 +1,48 @@
+interface ThrottleOptions {
+    /**
+     * An optional AbortSignal to cancel the throttled function.
+     */
+    signal?: AbortSignal;
+    /**
+     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+     * @default ["leading", "trailing"]
+     */
+    edges?: Array<'leading' | 'trailing'>;
+}
+interface ThrottledFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
+    cancel: () => void;
+    flush: () => void;
+}
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction<F>;
+
+export { type ThrottleOptions, type ThrottledFunction, throttle };

package/node_modules/es-toolkit/dist/function/throttle.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const debounce = require('./debounce.js');
+
+function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) {
+    let pendingAt = null;
+    const debounced = debounce.debounce(function (...args) {
+        pendingAt = Date.now();
+        func.apply(this, args);
+    }, throttleMs, { signal, edges });
+    const throttled = function (...args) {
+        if (pendingAt == null) {
+            pendingAt = Date.now();
+        }
+        if (Date.now() - pendingAt >= throttleMs) {
+            pendingAt = Date.now();
+            func.apply(this, args);
+            debounced.cancel();
+            debounced.schedule();
+            return;
+        }
+        debounced.apply(this, args);
+    };
+    throttled.cancel = debounced.cancel;
+    throttled.flush = debounced.flush;
+    return throttled;
+}
+
+exports.throttle = throttle;

package/node_modules/es-toolkit/dist/function/throttle.mjs

@@ -0,0 +1,27 @@
+import { debounce } from './debounce.mjs';
+
+function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) {
+    let pendingAt = null;
+    const debounced = debounce(function (...args) {
+        pendingAt = Date.now();
+        func.apply(this, args);
+    }, throttleMs, { signal, edges });
+    const throttled = function (...args) {
+        if (pendingAt == null) {
+            pendingAt = Date.now();
+        }
+        if (Date.now() - pendingAt >= throttleMs) {
+            pendingAt = Date.now();
+            func.apply(this, args);
+            debounced.cancel();
+            debounced.schedule();
+            return;
+        }
+        debounced.apply(this, args);
+    };
+    throttled.cancel = debounced.cancel;
+    throttled.flush = debounced.flush;
+    return throttled;
+}
+
+export { throttle };

package/node_modules/es-toolkit/dist/function/unary.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Creates a function that accepts up to one argument, ignoring any additional arguments.
+ *
+ * @template F - The type of the function.
+ * @param {F} func - The function to cap arguments for.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+ *
+ * @example
+ * function fn(a, b, c) {
+ *   console.log(arguments);
+ * }
+ *
+ * unary(fn)(1, 2, 3); // [Arguments] { '0': 1 }
+ */
+declare function unary<F extends (...args: any[]) => any>(func: F): (...args: any[]) => ReturnType<F>;
+
+export { unary };

package/node_modules/es-toolkit/dist/function/unary.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a function that accepts up to one argument, ignoring any additional arguments.
+ *
+ * @template F - The type of the function.
+ * @param {F} func - The function to cap arguments for.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+ *
+ * @example
+ * function fn(a, b, c) {
+ *   console.log(arguments);
+ * }
+ *
+ * unary(fn)(1, 2, 3); // [Arguments] { '0': 1 }
+ */
+declare function unary<F extends (...args: any[]) => any>(func: F): (...args: any[]) => ReturnType<F>;
+
+export { unary };

package/node_modules/es-toolkit/dist/function/unary.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const ary = require('./ary.js');
+
+function unary(func) {
+    return ary.ary(func, 1);
+}
+
+exports.unary = unary;

package/node_modules/es-toolkit/dist/function/unary.mjs

@@ -0,0 +1,7 @@
+import { ary } from './ary.mjs';
+
+function unary(func) {
+    return ary(func, 1);
+}
+
+export { unary };