es-toolkit 1.50.0 → 1.51.0-dev.2069

package/dist/iterator/takeWhile.js

@@ -0,0 +1,34 @@
+const require_iterator = require("./_internal/iterator.js");
+//#region src/iterator/takeWhile.ts
+/**
+* Lazily yields elements from `source` as long as `shouldContinue` returns a
+* truthy value, stopping at (and excluding) the first element for which it
+* returns a falsy value. The remaining elements are never pulled from `source`.
+*
+* The native iterator helpers offer `take` (by count) but not a predicate-based
+* `takeWhile`, which is why this is provided.
+*
+* @template T - The type of elements produced by the iterator.
+* @param source - The iterator to take elements from.
+* @param shouldContinue - Called with `(value, index)`; iteration stops once it returns falsy.
+* @returns A lazy iterator over the leading run of matching elements.
+*
+* @example
+* takeWhile([1, 2, 3, 4, 1].values(), x => x < 3).toArray(); // => [1, 2]
+*/
+function takeWhile(source, shouldContinue) {
+	let index = 0;
+	return require_iterator.iterator(function() {
+		const result = source.next();
+		if (result.done || !shouldContinue(result.value, index++)) return {
+			value: void 0,
+			done: true
+		};
+		return {
+			value: result.value,
+			done: false
+		};
+	}, () => void source.return?.());
+}
+//#endregion
+exports.takeWhile = takeWhile;

package/dist/iterator/takeWhile.mjs

@@ -0,0 +1,34 @@
+import { iterator } from "./_internal/iterator.mjs";
+//#region src/iterator/takeWhile.ts
+/**
+* Lazily yields elements from `source` as long as `shouldContinue` returns a
+* truthy value, stopping at (and excluding) the first element for which it
+* returns a falsy value. The remaining elements are never pulled from `source`.
+*
+* The native iterator helpers offer `take` (by count) but not a predicate-based
+* `takeWhile`, which is why this is provided.
+*
+* @template T - The type of elements produced by the iterator.
+* @param source - The iterator to take elements from.
+* @param shouldContinue - Called with `(value, index)`; iteration stops once it returns falsy.
+* @returns A lazy iterator over the leading run of matching elements.
+*
+* @example
+* takeWhile([1, 2, 3, 4, 1].values(), x => x < 3).toArray(); // => [1, 2]
+*/
+function takeWhile(source, shouldContinue) {
+	let index = 0;
+	return iterator(function() {
+		const result = source.next();
+		if (result.done || !shouldContinue(result.value, index++)) return {
+			value: void 0,
+			done: true
+		};
+		return {
+			value: result.value,
+			done: false
+		};
+	}, () => void source.return?.());
+}
+//#endregion
+export { takeWhile };

package/dist/iterator/uniqBy.d.mts

@@ -0,0 +1,22 @@
+//#region src/iterator/uniqBy.d.ts
+/**
+ * Lazily yields the elements of `source` whose mapped key has not been seen
+ * before, preserving the order of first occurrence. Keys are compared with
+ * SameValueZero semantics (matching `Set`).
+ *
+ * Deduplication is streaming: each element is emitted as soon as it is found to
+ * be unique, so this works with infinite iterators when bounded by a
+ * short-circuiting helper.
+ *
+ * @template T - The type of elements produced by the iterator.
+ * @template K - The type of the key used for comparison.
+ * @param source - The iterator to deduplicate.
+ * @param getKey - Maps an element to the key used to detect duplicates.
+ * @returns A lazy iterator over the elements with duplicate keys removed.
+ *
+ * @example
+ * uniqBy([1.1, 1.2, 2.3, 2.4].values(), Math.floor).toArray(); // => [1.1, 2.3]
+ */
+declare function uniqBy<T, K>(source: Iterator<T>, getKey: (value: T) => K): IteratorObject<T, undefined>;
+//#endregion
+export { uniqBy };

package/dist/iterator/uniqBy.d.ts

@@ -0,0 +1,22 @@
+//#region src/iterator/uniqBy.d.ts
+/**
+ * Lazily yields the elements of `source` whose mapped key has not been seen
+ * before, preserving the order of first occurrence. Keys are compared with
+ * SameValueZero semantics (matching `Set`).
+ *
+ * Deduplication is streaming: each element is emitted as soon as it is found to
+ * be unique, so this works with infinite iterators when bounded by a
+ * short-circuiting helper.
+ *
+ * @template T - The type of elements produced by the iterator.
+ * @template K - The type of the key used for comparison.
+ * @param source - The iterator to deduplicate.
+ * @param getKey - Maps an element to the key used to detect duplicates.
+ * @returns A lazy iterator over the elements with duplicate keys removed.
+ *
+ * @example
+ * uniqBy([1.1, 1.2, 2.3, 2.4].values(), Math.floor).toArray(); // => [1.1, 2.3]
+ */
+declare function uniqBy<T, K>(source: Iterator<T>, getKey: (value: T) => K): IteratorObject<T, undefined>;
+//#endregion
+export { uniqBy };

package/dist/iterator/uniqBy.js

@@ -0,0 +1,43 @@
+const require_iterator = require("./_internal/iterator.js");
+//#region src/iterator/uniqBy.ts
+/**
+* Lazily yields the elements of `source` whose mapped key has not been seen
+* before, preserving the order of first occurrence. Keys are compared with
+* SameValueZero semantics (matching `Set`).
+*
+* Deduplication is streaming: each element is emitted as soon as it is found to
+* be unique, so this works with infinite iterators when bounded by a
+* short-circuiting helper.
+*
+* @template T - The type of elements produced by the iterator.
+* @template K - The type of the key used for comparison.
+* @param source - The iterator to deduplicate.
+* @param getKey - Maps an element to the key used to detect duplicates.
+* @returns A lazy iterator over the elements with duplicate keys removed.
+*
+* @example
+* uniqBy([1.1, 1.2, 2.3, 2.4].values(), Math.floor).toArray(); // => [1.1, 2.3]
+*/
+function uniqBy(source, getKey) {
+	const seen = /* @__PURE__ */ new Set();
+	return require_iterator.iterator(function() {
+		let result = source.next();
+		while (!result.done) {
+			const key = getKey(result.value);
+			if (!seen.has(key)) {
+				seen.add(key);
+				return {
+					value: result.value,
+					done: false
+				};
+			}
+			result = source.next();
+		}
+		return {
+			value: void 0,
+			done: true
+		};
+	}, () => void source.return?.());
+}
+//#endregion
+exports.uniqBy = uniqBy;

package/dist/iterator/uniqBy.mjs

@@ -0,0 +1,43 @@
+import { iterator } from "./_internal/iterator.mjs";
+//#region src/iterator/uniqBy.ts
+/**
+* Lazily yields the elements of `source` whose mapped key has not been seen
+* before, preserving the order of first occurrence. Keys are compared with
+* SameValueZero semantics (matching `Set`).
+*
+* Deduplication is streaming: each element is emitted as soon as it is found to
+* be unique, so this works with infinite iterators when bounded by a
+* short-circuiting helper.
+*
+* @template T - The type of elements produced by the iterator.
+* @template K - The type of the key used for comparison.
+* @param source - The iterator to deduplicate.
+* @param getKey - Maps an element to the key used to detect duplicates.
+* @returns A lazy iterator over the elements with duplicate keys removed.
+*
+* @example
+* uniqBy([1.1, 1.2, 2.3, 2.4].values(), Math.floor).toArray(); // => [1.1, 2.3]
+*/
+function uniqBy(source, getKey) {
+	const seen = /* @__PURE__ */ new Set();
+	return iterator(function() {
+		let result = source.next();
+		while (!result.done) {
+			const key = getKey(result.value);
+			if (!seen.has(key)) {
+				seen.add(key);
+				return {
+					value: result.value,
+					done: false
+				};
+			}
+			result = source.next();
+		}
+		return {
+			value: void 0,
+			done: true
+		};
+	}, () => void source.return?.());
+}
+//#endregion
+export { uniqBy };

package/dist/iterator/zip.d.mts

@@ -0,0 +1,23 @@
+//#region src/iterator/zip.d.ts
+type IteratorValue<T> = T extends Iterator<infer V> ? V : never;
+/**
+ * Lazily combines several iterators into a single iterator of tuples, pairing
+ * the elements at matching positions. Iteration stops as soon as the **shortest**
+ * source is exhausted.
+ *
+ * Stopping at the shortest source (rather than padding to the longest, as the
+ * array `zip` does) is what makes this safe to use with infinite iterators:
+ * `zip(range(0, Infinity), names.values())` ends with `names`. When iteration
+ * ends — because a source ran out or the consumer terminated early — every
+ * source is closed via its `return` method.
+ *
+ * @template T - A tuple of the source iterator types.
+ * @param sources - The iterators to zip together.
+ * @returns A lazy iterator over tuples of the paired elements.
+ *
+ * @example
+ * zip([1, 2, 3].values(), ['a', 'b'].values()).toArray(); // => [[1, 'a'], [2, 'b']]
+ */
+declare function zip<T extends Array<Iterator<unknown>>>(...sources: T): IteratorObject<{ [K in keyof T]: IteratorValue<T[K]> }, undefined>;
+//#endregion
+export { zip };

package/dist/iterator/zip.d.ts

@@ -0,0 +1,23 @@
+//#region src/iterator/zip.d.ts
+type IteratorValue<T> = T extends Iterator<infer V> ? V : never;
+/**
+ * Lazily combines several iterators into a single iterator of tuples, pairing
+ * the elements at matching positions. Iteration stops as soon as the **shortest**
+ * source is exhausted.
+ *
+ * Stopping at the shortest source (rather than padding to the longest, as the
+ * array `zip` does) is what makes this safe to use with infinite iterators:
+ * `zip(range(0, Infinity), names.values())` ends with `names`. When iteration
+ * ends — because a source ran out or the consumer terminated early — every
+ * source is closed via its `return` method.
+ *
+ * @template T - A tuple of the source iterator types.
+ * @param sources - The iterators to zip together.
+ * @returns A lazy iterator over tuples of the paired elements.
+ *
+ * @example
+ * zip([1, 2, 3].values(), ['a', 'b'].values()).toArray(); // => [[1, 'a'], [2, 'b']]
+ */
+declare function zip<T extends Array<Iterator<unknown>>>(...sources: T): IteratorObject<{ [K in keyof T]: IteratorValue<T[K]> }, undefined>;
+//#endregion
+export { zip };

package/dist/iterator/zip.js

@@ -0,0 +1,45 @@
+const require_iterator = require("./_internal/iterator.js");
+//#region src/iterator/zip.ts
+/**
+* Lazily combines several iterators into a single iterator of tuples, pairing
+* the elements at matching positions. Iteration stops as soon as the **shortest**
+* source is exhausted.
+*
+* Stopping at the shortest source (rather than padding to the longest, as the
+* array `zip` does) is what makes this safe to use with infinite iterators:
+* `zip(range(0, Infinity), names.values())` ends with `names`. When iteration
+* ends — because a source ran out or the consumer terminated early — every
+* source is closed via its `return` method.
+*
+* @template T - A tuple of the source iterator types.
+* @param sources - The iterators to zip together.
+* @returns A lazy iterator over tuples of the paired elements.
+*
+* @example
+* zip([1, 2, 3].values(), ['a', 'b'].values()).toArray(); // => [[1, 'a'], [2, 'b']]
+*/
+function zip(...sources) {
+	return require_iterator.iterator(function() {
+		if (sources.length === 0) return {
+			value: void 0,
+			done: true
+		};
+		const tuple = new Array(sources.length);
+		for (let index = 0; index < sources.length; index++) {
+			const result = sources[index].next();
+			if (result.done) return {
+				value: void 0,
+				done: true
+			};
+			tuple[index] = result.value;
+		}
+		return {
+			value: tuple,
+			done: false
+		};
+	}, () => {
+		for (const source of sources) source.return?.();
+	});
+}
+//#endregion
+exports.zip = zip;

package/dist/iterator/zip.mjs

@@ -0,0 +1,45 @@
+import { iterator } from "./_internal/iterator.mjs";
+//#region src/iterator/zip.ts
+/**
+* Lazily combines several iterators into a single iterator of tuples, pairing
+* the elements at matching positions. Iteration stops as soon as the **shortest**
+* source is exhausted.
+*
+* Stopping at the shortest source (rather than padding to the longest, as the
+* array `zip` does) is what makes this safe to use with infinite iterators:
+* `zip(range(0, Infinity), names.values())` ends with `names`. When iteration
+* ends — because a source ran out or the consumer terminated early — every
+* source is closed via its `return` method.
+*
+* @template T - A tuple of the source iterator types.
+* @param sources - The iterators to zip together.
+* @returns A lazy iterator over tuples of the paired elements.
+*
+* @example
+* zip([1, 2, 3].values(), ['a', 'b'].values()).toArray(); // => [[1, 'a'], [2, 'b']]
+*/
+function zip(...sources) {
+	return iterator(function() {
+		if (sources.length === 0) return {
+			value: void 0,
+			done: true
+		};
+		const tuple = new Array(sources.length);
+		for (let index = 0; index < sources.length; index++) {
+			const result = sources[index].next();
+			if (result.done) return {
+				value: void 0,
+				done: true
+			};
+			tuple[index] = result.value;
+		}
+		return {
+			value: tuple,
+			done: false
+		};
+	}, () => {
+		for (const source of sources) source.return?.();
+	});
+}
+//#endregion
+export { zip };

package/dist/object/cloneDeepWith.d.mts

@@ -34,7 +34,9 @@
  * // Clone an array with a customizer
  * const arr = [1, 2, 3];
  * const clonedArr = cloneDeepWith(arr, (value) => {
- *   return value + 1; // Increment each value
+ *   if (typeof value === 'number') {
+ *     return value + 1; // Increment each number
+ *   }
  * });
  * console.log(clonedArr); // [2, 3, 4]
  * console.log(clonedArr === arr); // false

package/dist/object/cloneDeepWith.d.ts

@@ -34,7 +34,9 @@
  * // Clone an array with a customizer
  * const arr = [1, 2, 3];
  * const clonedArr = cloneDeepWith(arr, (value) => {
- *   return value + 1; // Increment each value
+ *   if (typeof value === 'number') {
+ *     return value + 1; // Increment each number
+ *   }
  * });
  * console.log(clonedArr); // [2, 3, 4]
  * console.log(clonedArr === arr); // false

package/dist/object/cloneDeepWith.js

@@ -40,7 +40,9 @@ const require_isBuffer = require("../predicate/isBuffer.js");
 * // Clone an array with a customizer
 * const arr = [1, 2, 3];
 * const clonedArr = cloneDeepWith(arr, (value) => {
-*   return value + 1; // Increment each value
+*   if (typeof value === 'number') {
+*     return value + 1; // Increment each number
+*   }
 * });
 * console.log(clonedArr); // [2, 3, 4]
 * console.log(clonedArr === arr); // false

package/dist/object/cloneDeepWith.mjs

@@ -40,7 +40,9 @@ import { isBuffer } from "../predicate/isBuffer.mjs";
 * // Clone an array with a customizer
 * const arr = [1, 2, 3];
 * const clonedArr = cloneDeepWith(arr, (value) => {
-*   return value + 1; // Increment each value
+*   if (typeof value === 'number') {
+*     return value + 1; // Increment each number
+*   }
 * });
 * console.log(clonedArr); // [2, 3, 4]
 * console.log(clonedArr === arr); // false

package/dist/object/deepFreeze.d.mts

@@ -0,0 +1,20 @@
+//#region src/object/deepFreeze.d.ts
+/**
+ * Deeply freezes an object, making it and all nested objects immutable.
+ *
+ * Unlike `Object.freeze`, which only freezes the immediate properties of an object,
+ * `deepFreeze` recursively freezes all nested objects and arrays.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to deeply freeze.
+ * @returns {T} The deeply frozen object.
+ *
+ * @example
+ * const frozen = deepFreeze({ user: { name: "Alex", age: 20 } });
+ *
+ * frozen.user = {}; // TypeError in strict mode
+ * frozen.user.age = 22; // TypeError in strict mode
+ */
+declare function deepFreeze<T>(obj: T): T;
+//#endregion
+export { deepFreeze };

package/dist/object/deepFreeze.d.ts

@@ -0,0 +1,20 @@
+//#region src/object/deepFreeze.d.ts
+/**
+ * Deeply freezes an object, making it and all nested objects immutable.
+ *
+ * Unlike `Object.freeze`, which only freezes the immediate properties of an object,
+ * `deepFreeze` recursively freezes all nested objects and arrays.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to deeply freeze.
+ * @returns {T} The deeply frozen object.
+ *
+ * @example
+ * const frozen = deepFreeze({ user: { name: "Alex", age: 20 } });
+ *
+ * frozen.user = {}; // TypeError in strict mode
+ * frozen.user.age = 22; // TypeError in strict mode
+ */
+declare function deepFreeze<T>(obj: T): T;
+//#endregion
+export { deepFreeze };

package/dist/object/deepFreeze.js

@@ -0,0 +1,29 @@
+//#region src/object/deepFreeze.ts
+/**
+* Deeply freezes an object, making it and all nested objects immutable.
+*
+* Unlike `Object.freeze`, which only freezes the immediate properties of an object,
+* `deepFreeze` recursively freezes all nested objects and arrays.
+*
+* @template T - The type of the object.
+* @param {T} obj - The object to deeply freeze.
+* @returns {T} The deeply frozen object.
+*
+* @example
+* const frozen = deepFreeze({ user: { name: "Alex", age: 20 } });
+*
+* frozen.user = {}; // TypeError in strict mode
+* frozen.user.age = 22; // TypeError in strict mode
+*/
+function deepFreeze(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	Object.freeze(obj);
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const value = obj[keys[i]];
+		if (value !== null && typeof value === "object" && !Object.isFrozen(value)) deepFreeze(value);
+	}
+	return obj;
+}
+//#endregion
+exports.deepFreeze = deepFreeze;

package/dist/object/deepFreeze.mjs

@@ -0,0 +1,29 @@
+//#region src/object/deepFreeze.ts
+/**
+* Deeply freezes an object, making it and all nested objects immutable.
+*
+* Unlike `Object.freeze`, which only freezes the immediate properties of an object,
+* `deepFreeze` recursively freezes all nested objects and arrays.
+*
+* @template T - The type of the object.
+* @param {T} obj - The object to deeply freeze.
+* @returns {T} The deeply frozen object.
+*
+* @example
+* const frozen = deepFreeze({ user: { name: "Alex", age: 20 } });
+*
+* frozen.user = {}; // TypeError in strict mode
+* frozen.user.age = 22; // TypeError in strict mode
+*/
+function deepFreeze(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	Object.freeze(obj);
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const value = obj[keys[i]];
+		if (value !== null && typeof value === "object" && !Object.isFrozen(value)) deepFreeze(value);
+	}
+	return obj;
+}
+//#endregion
+export { deepFreeze };

package/dist/object/flattenObject.d.mts

@@ -5,12 +5,18 @@ interface FlattenObjectOptions {
    * @default '.'
    */
   delimiter?: string;
+  /**
+   * If true, arrays are kept as values instead of being flattened.
+   * @default false
+   */
+  preserveArrays?: boolean;
 }
 /**
  * Flattens a nested object into a single level object with delimiter-separated keys.
  *
  * @param object - The object to flatten.
  * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+ * @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
  * @returns The flattened object.
  *
  * @example
@@ -31,9 +37,18 @@ interface FlattenObjectOptions {
  * //   'd.0': 2,
  * //   'd.1': 3
  * // }
+ *
+ * const preserved = flattenObject(nestedObject, { preserveArrays: true });
+ * console.log(preserved);
+ * // Output:
+ * // {
+ * //   'a.b.c': 1,
+ * //   'd': [2, 3]
+ * // }
  */
 declare function flattenObject(object: object, {
-  delimiter
+  delimiter,
+  preserveArrays
 }?: FlattenObjectOptions): Record<string, any>;
 //#endregion
 export { flattenObject };

package/dist/object/flattenObject.d.ts

@@ -5,12 +5,18 @@ interface FlattenObjectOptions {
    * @default '.'
    */
   delimiter?: string;
+  /**
+   * If true, arrays are kept as values instead of being flattened.
+   * @default false
+   */
+  preserveArrays?: boolean;
 }
 /**
  * Flattens a nested object into a single level object with delimiter-separated keys.
  *
  * @param object - The object to flatten.
  * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+ * @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
  * @returns The flattened object.
  *
  * @example
@@ -31,9 +37,18 @@ interface FlattenObjectOptions {
  * //   'd.0': 2,
  * //   'd.1': 3
  * // }
+ *
+ * const preserved = flattenObject(nestedObject, { preserveArrays: true });
+ * console.log(preserved);
+ * // Output:
+ * // {
+ * //   'a.b.c': 1,
+ * //   'd': [2, 3]
+ * // }
  */
 declare function flattenObject(object: object, {
-  delimiter
+  delimiter,
+  preserveArrays
 }?: FlattenObjectOptions): Record<string, any>;
 //#endregion
 export { flattenObject };

package/dist/object/flattenObject.js

@@ -5,6 +5,7 @@ const require_isPlainObject = require("../predicate/isPlainObject.js");
 *
 * @param object - The object to flatten.
 * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+* @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
 * @returns The flattened object.
 *
 * @example
@@ -25,11 +26,19 @@ const require_isPlainObject = require("../predicate/isPlainObject.js");
 * //   'd.0': 2,
 * //   'd.1': 3
 * // }
+*
+* const preserved = flattenObject(nestedObject, { preserveArrays: true });
+* console.log(preserved);
+* // Output:
+* // {
+* //   'a.b.c': 1,
+* //   'd': [2, 3]
+* // }
 */
-function flattenObject(object, { delimiter = "." } = {}) {
-	return flattenObjectImpl(object, "", delimiter);
+function flattenObject(object, { delimiter = ".", preserveArrays = false } = {}) {
+	return flattenObjectImpl(object, "", delimiter, preserveArrays);
 }
-function flattenObjectImpl(object, prefix, delimiter) {
+function flattenObjectImpl(object, prefix, delimiter, preserveArrays) {
 	const result = {};
 	const keys = Object.keys(object);
 	for (let i = 0; i < keys.length; i++) {
@@ -37,11 +46,11 @@ function flattenObjectImpl(object, prefix, delimiter) {
 		const value = object[key];
 		const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
 		if (require_isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
-		if (Array.isArray(value) && value.length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+		if (Array.isArray(value) && !preserveArrays && value.length > 0) {
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
 		result[prefixedKey] = value;

package/dist/object/flattenObject.mjs

@@ -5,6 +5,7 @@ import { isPlainObject } from "../predicate/isPlainObject.mjs";
 *
 * @param object - The object to flatten.
 * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+* @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
 * @returns The flattened object.
 *
 * @example
@@ -25,11 +26,19 @@ import { isPlainObject } from "../predicate/isPlainObject.mjs";
 * //   'd.0': 2,
 * //   'd.1': 3
 * // }
+*
+* const preserved = flattenObject(nestedObject, { preserveArrays: true });
+* console.log(preserved);
+* // Output:
+* // {
+* //   'a.b.c': 1,
+* //   'd': [2, 3]
+* // }
 */
-function flattenObject(object, { delimiter = "." } = {}) {
-	return flattenObjectImpl(object, "", delimiter);
+function flattenObject(object, { delimiter = ".", preserveArrays = false } = {}) {
+	return flattenObjectImpl(object, "", delimiter, preserveArrays);
 }
-function flattenObjectImpl(object, prefix, delimiter) {
+function flattenObjectImpl(object, prefix, delimiter, preserveArrays) {
 	const result = {};
 	const keys = Object.keys(object);
 	for (let i = 0; i < keys.length; i++) {
@@ -37,11 +46,11 @@ function flattenObjectImpl(object, prefix, delimiter) {
 		const value = object[key];
 		const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
 		if (isPlainObject(value) && Object.keys(value).length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
-		if (Array.isArray(value) && value.length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+		if (Array.isArray(value) && !preserveArrays && value.length > 0) {
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
 		result[prefixedKey] = value;