es-toolkit 1.50.0 → 1.51.0-dev.2069

package/dist/object/toConstantCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { constantCase } from "../string/constantCase.mjs";
+//#region src/object/toConstantCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to CONSTANT_CASE format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to CONSTANT_CASE.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toConstantCaseKeys(obj);
+* // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toConstantCaseKeys(arr);
+* // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toConstantCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   USER_DATA: {
+* //     USER_ID: 1,
+* //     USER_ADDRESS: {
+* //       STREET_NAME: 'Main St',
+* //       ZIP_CODE: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toConstantCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toConstantCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const constantKey = constantCase(key);
+			result[constantKey] = toConstantCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toKebabCaseKeys.d.mts

@@ -0,0 +1,52 @@
+import { ToKebabCaseKeys } from "../types/ToKebabCaseKeys.mjs";
+
+//#region src/object/toKebabCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to kebab-case.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to kebab-case format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to kebab-case.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toKebabCaseKeys(obj);
+ * // result will be { 'user-id': 1, 'first-name': 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toKebabCaseKeys(arr);
+ * // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toKebabCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   'user-data': {
+ * //     'user-id': 1,
+ * //     'user-address': {
+ * //       'street-name': 'Main St',
+ * //       'zip-code': '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toKebabCaseKeys<T>(obj: T): ToKebabCaseKeys<T>;
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toKebabCaseKeys.d.ts

@@ -0,0 +1,52 @@
+import { ToKebabCaseKeys } from "../types/ToKebabCaseKeys.js";
+
+//#region src/object/toKebabCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to kebab-case.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to kebab-case format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to kebab-case.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toKebabCaseKeys(obj);
+ * // result will be { 'user-id': 1, 'first-name': 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toKebabCaseKeys(arr);
+ * // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toKebabCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   'user-data': {
+ * //     'user-id': 1,
+ * //     'user-address': {
+ * //       'street-name': 'Main St',
+ * //       'zip-code': '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toKebabCaseKeys<T>(obj: T): ToKebabCaseKeys<T>;
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toKebabCaseKeys.js

@@ -0,0 +1,66 @@
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_kebabCase = require("../string/kebabCase.js");
+//#region src/object/toKebabCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to kebab-case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to kebab-case format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to kebab-case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toKebabCaseKeys(obj);
+* // result will be { 'user-id': 1, 'first-name': 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toKebabCaseKeys(arr);
+* // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toKebabCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   'user-data': {
+* //     'user-id': 1,
+* //     'user-address': {
+* //       'street-name': 'Main St',
+* //       'zip-code': '12345'
+* //     }
+* //   }
+* // }
+*/
+function toKebabCaseKeys(obj) {
+	if (require_isArray.isArray(obj)) return obj.map((item) => toKebabCaseKeys(item));
+	if (require_isPlainObject.isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const kebabKey = require_kebabCase.kebabCase(key);
+			result[kebabKey] = toKebabCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+exports.toKebabCaseKeys = toKebabCaseKeys;

package/dist/object/toKebabCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { kebabCase } from "../string/kebabCase.mjs";
+//#region src/object/toKebabCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to kebab-case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to kebab-case format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to kebab-case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toKebabCaseKeys(obj);
+* // result will be { 'user-id': 1, 'first-name': 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toKebabCaseKeys(arr);
+* // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toKebabCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   'user-data': {
+* //     'user-id': 1,
+* //     'user-address': {
+* //       'street-name': 'Main St',
+* //       'zip-code': '12345'
+* //     }
+* //   }
+* // }
+*/
+function toKebabCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toKebabCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const kebabKey = kebabCase(key);
+			result[kebabKey] = toKebabCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toMerged.js

@@ -1,6 +1,7 @@
 const require_clone = require("./clone.js");
 const require_cloneDeep = require("./cloneDeep.js");
 const require_isPlainObject = require("../predicate/isPlainObject.js");
+const require_isMergeableValue = require("../_internal/isMergeableValue.js");
 const require_mergeWith = require("./mergeWith.js");
 //#region src/object/toMerged.ts
 /**
@@ -47,10 +48,9 @@ const require_mergeWith = require("./mergeWith.js");
 */
 function toMerged(target, source) {
 	return require_mergeWith.mergeWith(require_cloneDeep.cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
-		if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) return require_mergeWith.mergeWith(require_clone.clone(targetValue), sourceValue, mergeRecursively);
-		else return require_mergeWith.mergeWith([], sourceValue, mergeRecursively);
-		else if (require_isPlainObject.isPlainObject(sourceValue)) if (require_isPlainObject.isPlainObject(targetValue)) return require_mergeWith.mergeWith(require_clone.clone(targetValue), sourceValue, mergeRecursively);
-		else return require_mergeWith.mergeWith({}, sourceValue, mergeRecursively);
+		if (require_isMergeableValue.isMergeableValue(sourceValue) && require_isMergeableValue.isMergeableValue(targetValue)) return require_mergeWith.mergeWith(require_clone.clone(targetValue), sourceValue, mergeRecursively);
+		else if (Array.isArray(sourceValue)) return require_mergeWith.mergeWith([], sourceValue, mergeRecursively);
+		else if (require_isPlainObject.isPlainObject(sourceValue)) return require_mergeWith.mergeWith({}, sourceValue, mergeRecursively);
 	});
 }
 //#endregion

package/dist/object/toMerged.mjs

@@ -1,6 +1,7 @@
 import { clone } from "./clone.mjs";
 import { cloneDeep } from "./cloneDeep.mjs";
 import { isPlainObject } from "../predicate/isPlainObject.mjs";
+import { isMergeableValue } from "../_internal/isMergeableValue.mjs";
 import { mergeWith } from "./mergeWith.mjs";
 //#region src/object/toMerged.ts
 /**
@@ -47,10 +48,9 @@ import { mergeWith } from "./mergeWith.mjs";
 */
 function toMerged(target, source) {
 	return mergeWith(cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
-		if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
-		else return mergeWith([], sourceValue, mergeRecursively);
-		else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
-		else return mergeWith({}, sourceValue, mergeRecursively);
+		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
+		else if (Array.isArray(sourceValue)) return mergeWith([], sourceValue, mergeRecursively);
+		else if (isPlainObject(sourceValue)) return mergeWith({}, sourceValue, mergeRecursively);
 	});
 }
 //#endregion

package/dist/object/toPascalCaseKeys.d.mts

@@ -0,0 +1,52 @@
+import { ToPascalCaseKeys } from "../types/ToPascalCaseKeys.mjs";
+
+//#region src/object/toPascalCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to PascalCase.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to PascalCase format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to PascalCase.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toPascalCaseKeys(obj);
+ * // result will be { UserId: 1, FirstName: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toPascalCaseKeys(arr);
+ * // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toPascalCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   UserData: {
+ * //     UserId: 1,
+ * //     UserAddress: {
+ * //       StreetName: 'Main St',
+ * //       ZipCode: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toPascalCaseKeys<T>(obj: T): ToPascalCaseKeys<T>;
+//#endregion
+export { toPascalCaseKeys };

package/dist/object/toPascalCaseKeys.d.ts

@@ -0,0 +1,52 @@
+import { ToPascalCaseKeys } from "../types/ToPascalCaseKeys.js";
+
+//#region src/object/toPascalCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to PascalCase.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to PascalCase format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to PascalCase.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toPascalCaseKeys(obj);
+ * // result will be { UserId: 1, FirstName: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toPascalCaseKeys(arr);
+ * // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toPascalCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   UserData: {
+ * //     UserId: 1,
+ * //     UserAddress: {
+ * //       StreetName: 'Main St',
+ * //       ZipCode: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toPascalCaseKeys<T>(obj: T): ToPascalCaseKeys<T>;
+//#endregion
+export { toPascalCaseKeys };

package/dist/object/toPascalCaseKeys.js

@@ -0,0 +1,66 @@
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_pascalCase = require("../string/pascalCase.js");
+//#region src/object/toPascalCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to PascalCase.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to PascalCase format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to PascalCase.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toPascalCaseKeys(obj);
+* // result will be { UserId: 1, FirstName: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toPascalCaseKeys(arr);
+* // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toPascalCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   UserData: {
+* //     UserId: 1,
+* //     UserAddress: {
+* //       StreetName: 'Main St',
+* //       ZipCode: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toPascalCaseKeys(obj) {
+	if (require_isArray.isArray(obj)) return obj.map((item) => toPascalCaseKeys(item));
+	if (require_isPlainObject.isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const pascalKey = require_pascalCase.pascalCase(key);
+			result[pascalKey] = toPascalCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+exports.toPascalCaseKeys = toPascalCaseKeys;

package/dist/object/toPascalCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { pascalCase } from "../string/pascalCase.mjs";
+//#region src/object/toPascalCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to PascalCase.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to PascalCase format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to PascalCase.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toPascalCaseKeys(obj);
+* // result will be { UserId: 1, FirstName: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toPascalCaseKeys(arr);
+* // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toPascalCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   UserData: {
+* //     UserId: 1,
+* //     UserAddress: {
+* //       StreetName: 'Main St',
+* //       ZipCode: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toPascalCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toPascalCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const pascalKey = pascalCase(key);
+			result[pascalKey] = toPascalCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toPascalCaseKeys };

package/dist/object/toSnakeCaseKeys.d.mts

@@ -1,7 +1,6 @@
+import { ToSnakeCaseKeys } from "../types/ToSnakeCaseKeys.mjs";
+
 //#region src/object/toSnakeCaseKeys.d.ts
-type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to snake_case.
  *

package/dist/object/toSnakeCaseKeys.d.ts

@@ -1,7 +1,6 @@
+import { ToSnakeCaseKeys } from "../types/ToSnakeCaseKeys.js";
+
 //#region src/object/toSnakeCaseKeys.d.ts
-type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to snake_case.
  *

package/dist/promise/index.d.mts

@@ -1,7 +1,8 @@
+import { limitAsync } from "./limitAsync.mjs";
 import { allKeyed } from "./allKeyed.mjs";
 import { delay } from "./delay.mjs";
 import { Mutex } from "./mutex.mjs";
 import { Semaphore } from "./semaphore.mjs";
 import { timeout } from "./timeout.mjs";
 import { withTimeout } from "./withTimeout.mjs";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/index.d.ts

@@ -1,7 +1,8 @@
+import { limitAsync } from "./limitAsync.js";
 import { allKeyed } from "./allKeyed.js";
 import { delay } from "./delay.js";
 import { Mutex } from "./mutex.js";
 import { Semaphore } from "./semaphore.js";
 import { timeout } from "./timeout.js";
 import { withTimeout } from "./withTimeout.js";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/index.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_semaphore = require("./semaphore.js");
+const require_limitAsync = require("./limitAsync.js");
 const require_delay = require("./delay.js");
 const require_allKeyed = require("./allKeyed.js");
 const require_mutex = require("./mutex.js");
@@ -9,5 +10,6 @@ exports.Mutex = require_mutex.Mutex;
 exports.Semaphore = require_semaphore.Semaphore;
 exports.allKeyed = require_allKeyed.allKeyed;
 exports.delay = require_delay.delay;
+exports.limitAsync = require_limitAsync.limitAsync;
 exports.timeout = require_timeout.timeout;
 exports.withTimeout = require_withTimeout.withTimeout;

package/dist/promise/index.mjs

@@ -1,7 +1,8 @@
 import { Semaphore } from "./semaphore.mjs";
+import { limitAsync } from "./limitAsync.mjs";
 import { delay } from "./delay.mjs";
 import { allKeyed } from "./allKeyed.mjs";
 import { Mutex } from "./mutex.mjs";
 import { timeout } from "./timeout.mjs";
 import { withTimeout } from "./withTimeout.mjs";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };