es-toolkit 1.46.1 → 1.47.0-dev.1823

package/dist/object/toMerged.js

@@ -1,30 +1,56 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const clone = require('./clone.js');
-const mergeWith = require('./mergeWith.js');
-const isPlainObject = require('../predicate/isPlainObject.js');
-
+const require_clone = require("./clone.js");
+const require_isPlainObject = require("../predicate/isPlainObject.js");
+const require_mergeWith = require("./mergeWith.js");
+//#region src/object/toMerged.ts
+/**
+* Merges the properties of the source object into a deep clone of the target object.
+* Unlike `merge`, This function does not modify the original target object.
+*
+* This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+*
+* - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+* - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+*
+* Note that this function does not mutate the target object.
+*
+* @param {T} target - The target object to be cloned and merged into. This object is not modified directly.
+* @param {S} source - The source object whose properties will be merged into the cloned target object.
+* @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object.
+*
+* @template T - Type of the target object.
+* @template S - Type of the source object.
+*
+* @example
+* const target = { a: 1, b: { x: 1, y: 2 } };
+* const source = { b: { y: 3, z: 4 }, c: 5 };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+*
+* @example
+* const target = { a: [1, 2], b: { x: 1 } };
+* const source = { a: [3], b: { y: 2 } };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+*
+* @example
+* const target = { a: null };
+* const source = { a: [1, 2, 3] };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: [1, 2, 3] }
+*/
 function toMerged(target, source) {
-    return mergeWith.mergeWith(clone.clone(target), source, function mergeRecursively(targetValue, sourceValue) {
-        if (Array.isArray(sourceValue)) {
-            if (Array.isArray(targetValue)) {
-                return mergeWith.mergeWith(clone.clone(targetValue), sourceValue, mergeRecursively);
-            }
-            else {
-                return mergeWith.mergeWith([], sourceValue, mergeRecursively);
-            }
-        }
-        else if (isPlainObject.isPlainObject(sourceValue)) {
-            if (isPlainObject.isPlainObject(targetValue)) {
-                return mergeWith.mergeWith(clone.clone(targetValue), sourceValue, mergeRecursively);
-            }
-            else {
-                return mergeWith.mergeWith({}, sourceValue, mergeRecursively);
-            }
-        }
-    });
+	return require_mergeWith.mergeWith(require_clone.clone(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);
+	});
 }
-
+//#endregion
 exports.toMerged = toMerged;

package/dist/object/toMerged.mjs

@@ -1,26 +1,56 @@
-import { clone } from './clone.mjs';
-import { mergeWith } from './mergeWith.mjs';
-import { isPlainObject } from '../predicate/isPlainObject.mjs';
-
+import { clone } from "./clone.mjs";
+import { isPlainObject } from "../predicate/isPlainObject.mjs";
+import { mergeWith } from "./mergeWith.mjs";
+//#region src/object/toMerged.ts
+/**
+* Merges the properties of the source object into a deep clone of the target object.
+* Unlike `merge`, This function does not modify the original target object.
+*
+* This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+*
+* - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+* - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+*
+* Note that this function does not mutate the target object.
+*
+* @param {T} target - The target object to be cloned and merged into. This object is not modified directly.
+* @param {S} source - The source object whose properties will be merged into the cloned target object.
+* @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object.
+*
+* @template T - Type of the target object.
+* @template S - Type of the source object.
+*
+* @example
+* const target = { a: 1, b: { x: 1, y: 2 } };
+* const source = { b: { y: 3, z: 4 }, c: 5 };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+*
+* @example
+* const target = { a: [1, 2], b: { x: 1 } };
+* const source = { a: [3], b: { y: 2 } };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+*
+* @example
+* const target = { a: null };
+* const source = { a: [1, 2, 3] };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: [1, 2, 3] }
+*/
 function toMerged(target, source) {
-    return mergeWith(clone(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);
-            }
-        }
-    });
+	return mergeWith(clone(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);
+	});
 }
-
+//#endregion
 export { toMerged };

package/dist/object/toSnakeCaseKeys.d.mts

@@ -1,8 +1,7 @@
+//#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;
+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.
  *
@@ -50,5 +49,5 @@ type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array
  * // }
  */
 declare function toSnakeCaseKeys<T>(obj: T): ToSnakeCaseKeys<T>;
-
-export { type ToSnakeCaseKeys, toSnakeCaseKeys };
+//#endregion
+export { toSnakeCaseKeys };

package/dist/object/toSnakeCaseKeys.d.ts

@@ -1,8 +1,7 @@
+//#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;
+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.
  *
@@ -50,5 +49,5 @@ type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array
  * // }
  */
 declare function toSnakeCaseKeys<T>(obj: T): ToSnakeCaseKeys<T>;
-
-export { type ToSnakeCaseKeys, toSnakeCaseKeys };
+//#endregion
+export { toSnakeCaseKeys };

package/dist/object/toSnakeCaseKeys.js

@@ -1,27 +1,66 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const isArray = require('../compat/predicate/isArray.js');
-const isPlainObject = require('../compat/predicate/isPlainObject.js');
-const snakeCase = require('../string/snakeCase.js');
-
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_snakeCase = require("../string/snakeCase.js");
+//#region src/object/toSnakeCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to snake_case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to snake_case format.
+*
+* @template T - The type of object.
+* @param {T} obj - The object to convert keys from.
+* @returns {ToSnakeCaseKeys<T>} A new object with all keys converted to snake_case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toSnakeCaseKeys(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 = toSnakeCaseKeys(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 = toSnakeCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   user_data: {
+* //     user_id: 1,
+* //     user_address: {
+* //       street_name: 'Main St',
+* //       zip_code: '12345'
+* //     }
+* //   }
+* // }
+*/
 function toSnakeCaseKeys(obj) {
-    if (isArray.isArray(obj)) {
-        return obj.map(item => toSnakeCaseKeys(item));
-    }
-    if (isPlainObject.isPlainObject(obj)) {
-        const result = {};
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const snakeKey = snakeCase.snakeCase(key);
-            const convertedValue = toSnakeCaseKeys(obj[key]);
-            result[snakeKey] = convertedValue;
-        }
-        return result;
-    }
-    return obj;
+	if (require_isArray.isArray(obj)) return obj.map((item) => toSnakeCaseKeys(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 snakeKey = require_snakeCase.snakeCase(key);
+			result[snakeKey] = toSnakeCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
 }
-
+//#endregion
 exports.toSnakeCaseKeys = toSnakeCaseKeys;

package/dist/object/toSnakeCaseKeys.mjs

@@ -1,23 +1,66 @@
-import { isArray } from '../compat/predicate/isArray.mjs';
-import { isPlainObject } from '../compat/predicate/isPlainObject.mjs';
-import { snakeCase } from '../string/snakeCase.mjs';
-
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { snakeCase } from "../string/snakeCase.mjs";
+//#region src/object/toSnakeCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to snake_case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to snake_case format.
+*
+* @template T - The type of object.
+* @param {T} obj - The object to convert keys from.
+* @returns {ToSnakeCaseKeys<T>} A new object with all keys converted to snake_case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toSnakeCaseKeys(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 = toSnakeCaseKeys(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 = toSnakeCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   user_data: {
+* //     user_id: 1,
+* //     user_address: {
+* //       street_name: 'Main St',
+* //       zip_code: '12345'
+* //     }
+* //   }
+* // }
+*/
 function toSnakeCaseKeys(obj) {
-    if (isArray(obj)) {
-        return obj.map(item => toSnakeCaseKeys(item));
-    }
-    if (isPlainObject(obj)) {
-        const result = {};
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const snakeKey = snakeCase(key);
-            const convertedValue = toSnakeCaseKeys(obj[key]);
-            result[snakeKey] = convertedValue;
-        }
-        return result;
-    }
-    return obj;
+	if (isArray(obj)) return obj.map((item) => toSnakeCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const snakeKey = snakeCase(key);
+			result[snakeKey] = toSnakeCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
 }
-
+//#endregion
 export { toSnakeCaseKeys };

package/dist/predicate/index.d.mts

@@ -1,32 +1,33 @@
-export { isArrayBuffer } from './isArrayBuffer.mjs';
-export { isBlob } from './isBlob.mjs';
-export { isBoolean } from './isBoolean.mjs';
-export { isBrowser } from './isBrowser.mjs';
-export { isBuffer } from './isBuffer.mjs';
-export { isDate } from './isDate.mjs';
-export { isEmptyObject } from './isEmptyObject.mjs';
-export { isEqual } from './isEqual.mjs';
-export { isEqualWith } from './isEqualWith.mjs';
-export { isError } from './isError.mjs';
-export { isFile } from './isFile.mjs';
-export { isFunction } from './isFunction.mjs';
-export { isJSON } from './isJSON.mjs';
-export { isJSONArray, isJSONObject, isJSONValue } from './isJSONValue.mjs';
-export { isLength } from './isLength.mjs';
-export { isMap } from './isMap.mjs';
-export { isNil } from './isNil.mjs';
-export { isNode } from './isNode.mjs';
-export { isNotNil } from './isNotNil.mjs';
-export { isNull } from './isNull.mjs';
-export { isNumber } from './isNumber.mjs';
-export { isPlainObject } from './isPlainObject.mjs';
-export { isPrimitive } from './isPrimitive.mjs';
-export { isPromise } from './isPromise.mjs';
-export { isRegExp } from './isRegExp.mjs';
-export { isSet } from './isSet.mjs';
-export { isString } from './isString.mjs';
-export { isSymbol } from './isSymbol.mjs';
-export { isTypedArray } from './isTypedArray.mjs';
-export { isUndefined } from './isUndefined.mjs';
-export { isWeakMap } from './isWeakMap.mjs';
-export { isWeakSet } from './isWeakSet.mjs';
+import { isEqual } from "./isEqual.mjs";
+import { isArrayBuffer } from "./isArrayBuffer.mjs";
+import { isBlob } from "./isBlob.mjs";
+import { isBoolean } from "./isBoolean.mjs";
+import { isBrowser } from "./isBrowser.mjs";
+import { isBuffer } from "./isBuffer.mjs";
+import { isDate } from "./isDate.mjs";
+import { isEmptyObject } from "./isEmptyObject.mjs";
+import { isEqualWith } from "./isEqualWith.mjs";
+import { isError } from "./isError.mjs";
+import { isFile } from "./isFile.mjs";
+import { isFunction } from "./isFunction.mjs";
+import { isJSON } from "./isJSON.mjs";
+import { isJSONArray, isJSONObject, isJSONValue } from "./isJSONValue.mjs";
+import { isLength } from "./isLength.mjs";
+import { isMap } from "./isMap.mjs";
+import { isNil } from "./isNil.mjs";
+import { isNode } from "./isNode.mjs";
+import { isNotNil } from "./isNotNil.mjs";
+import { isNull } from "./isNull.mjs";
+import { isNumber } from "./isNumber.mjs";
+import { isPlainObject } from "./isPlainObject.mjs";
+import { isPrimitive } from "./isPrimitive.mjs";
+import { isPromise } from "./isPromise.mjs";
+import { isRegExp } from "./isRegExp.mjs";
+import { isSet } from "./isSet.mjs";
+import { isString } from "./isString.mjs";
+import { isSymbol } from "./isSymbol.mjs";
+import { isTypedArray } from "./isTypedArray.mjs";
+import { isUndefined } from "./isUndefined.mjs";
+import { isWeakMap } from "./isWeakMap.mjs";
+import { isWeakSet } from "./isWeakSet.mjs";
+export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };

package/dist/predicate/index.d.ts

@@ -1,32 +1,33 @@
-export { isArrayBuffer } from './isArrayBuffer.js';
-export { isBlob } from './isBlob.js';
-export { isBoolean } from './isBoolean.js';
-export { isBrowser } from './isBrowser.js';
-export { isBuffer } from './isBuffer.js';
-export { isDate } from './isDate.js';
-export { isEmptyObject } from './isEmptyObject.js';
-export { isEqual } from './isEqual.js';
-export { isEqualWith } from './isEqualWith.js';
-export { isError } from './isError.js';
-export { isFile } from './isFile.js';
-export { isFunction } from './isFunction.js';
-export { isJSON } from './isJSON.js';
-export { isJSONArray, isJSONObject, isJSONValue } from './isJSONValue.js';
-export { isLength } from './isLength.js';
-export { isMap } from './isMap.js';
-export { isNil } from './isNil.js';
-export { isNode } from './isNode.js';
-export { isNotNil } from './isNotNil.js';
-export { isNull } from './isNull.js';
-export { isNumber } from './isNumber.js';
-export { isPlainObject } from './isPlainObject.js';
-export { isPrimitive } from './isPrimitive.js';
-export { isPromise } from './isPromise.js';
-export { isRegExp } from './isRegExp.js';
-export { isSet } from './isSet.js';
-export { isString } from './isString.js';
-export { isSymbol } from './isSymbol.js';
-export { isTypedArray } from './isTypedArray.js';
-export { isUndefined } from './isUndefined.js';
-export { isWeakMap } from './isWeakMap.js';
-export { isWeakSet } from './isWeakSet.js';
+import { isEqual } from "./isEqual.js";
+import { isArrayBuffer } from "./isArrayBuffer.js";
+import { isBlob } from "./isBlob.js";
+import { isBoolean } from "./isBoolean.js";
+import { isBrowser } from "./isBrowser.js";
+import { isBuffer } from "./isBuffer.js";
+import { isDate } from "./isDate.js";
+import { isEmptyObject } from "./isEmptyObject.js";
+import { isEqualWith } from "./isEqualWith.js";
+import { isError } from "./isError.js";
+import { isFile } from "./isFile.js";
+import { isFunction } from "./isFunction.js";
+import { isJSON } from "./isJSON.js";
+import { isJSONArray, isJSONObject, isJSONValue } from "./isJSONValue.js";
+import { isLength } from "./isLength.js";
+import { isMap } from "./isMap.js";
+import { isNil } from "./isNil.js";
+import { isNode } from "./isNode.js";
+import { isNotNil } from "./isNotNil.js";
+import { isNull } from "./isNull.js";
+import { isNumber } from "./isNumber.js";
+import { isPlainObject } from "./isPlainObject.js";
+import { isPrimitive } from "./isPrimitive.js";
+import { isPromise } from "./isPromise.js";
+import { isRegExp } from "./isRegExp.js";
+import { isSet } from "./isSet.js";
+import { isString } from "./isString.js";
+import { isSymbol } from "./isSymbol.js";
+import { isTypedArray } from "./isTypedArray.js";
+import { isUndefined } from "./isUndefined.js";
+import { isWeakMap } from "./isWeakMap.js";
+import { isWeakSet } from "./isWeakSet.js";
+export { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };