@quantiya/codevibe-claude-plugin 2.0.12 → 2.0.13

package/node_modules/es-toolkit/dist/fp/iterator/uniqBy.mjs

@@ -1,25 +0,0 @@
-import { uniqBy as uniqBy$1 } from "../../iterator/uniqBy.mjs";
-//#region src/fp/iterator/uniqBy.ts
-/**
-* Creates a function that lazily yields the elements of an iterator whose mapped
-* key has not been seen before, preserving first-occurrence order, for use with
-* {@link pipe}. Keys are compared with SameValueZero semantics.
-*
-* @template T - The type of elements produced by the source iterator.
-* @template K - The type of the key used for comparison.
-* @param getKey - Maps an element to the key used to detect duplicates.
-* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
-*
-* @example
-* import { pipe } from 'es-toolkit/fp';
-* import { uniqBy, toArray } from 'es-toolkit/fp/iterator';
-*
-* pipe([1.1, 1.2, 2.3].values(), uniqBy(Math.floor), toArray()); // => [1.1, 2.3]
-*/
-function uniqBy(getKey) {
-	return function uniqByInIterator(source) {
-		return uniqBy$1(source, getKey);
-	};
-}
-//#endregion
-export { uniqBy };

package/node_modules/es-toolkit/dist/fp/iterator/zip.d.mts

@@ -1,20 +0,0 @@
-//#region src/fp/iterator/zip.d.ts
-/**
- * Creates a function that lazily pairs the elements of the piped iterator with
- * those of `other`, for use with {@link pipe}. Iteration stops as soon as either
- * iterator is exhausted.
- *
- * @template T - The type of elements produced by the piped iterator.
- * @template U - The type of elements produced by `other`.
- * @param other - The iterator to pair with the piped one.
- * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
- *
- * @example
- * import { pipe } from 'es-toolkit/fp';
- * import { zip, toArray } from 'es-toolkit/fp/iterator';
- *
- * pipe([1, 2, 3].values(), zip(['a', 'b'].values()), toArray()); // => [[1, 'a'], [2, 'b']]
- */
-declare function zip<T, U>(other: Iterator<U>): (source: Iterator<T>) => IteratorObject<[T, U], undefined>;
-//#endregion
-export { zip };

package/node_modules/es-toolkit/dist/fp/iterator/zip.d.ts

@@ -1,20 +0,0 @@
-//#region src/fp/iterator/zip.d.ts
-/**
- * Creates a function that lazily pairs the elements of the piped iterator with
- * those of `other`, for use with {@link pipe}. Iteration stops as soon as either
- * iterator is exhausted.
- *
- * @template T - The type of elements produced by the piped iterator.
- * @template U - The type of elements produced by `other`.
- * @param other - The iterator to pair with the piped one.
- * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
- *
- * @example
- * import { pipe } from 'es-toolkit/fp';
- * import { zip, toArray } from 'es-toolkit/fp/iterator';
- *
- * pipe([1, 2, 3].values(), zip(['a', 'b'].values()), toArray()); // => [[1, 'a'], [2, 'b']]
- */
-declare function zip<T, U>(other: Iterator<U>): (source: Iterator<T>) => IteratorObject<[T, U], undefined>;
-//#endregion
-export { zip };

package/node_modules/es-toolkit/dist/fp/iterator/zip.js

@@ -1,25 +0,0 @@
-const require_zip = require("../../iterator/zip.js");
-//#region src/fp/iterator/zip.ts
-/**
-* Creates a function that lazily pairs the elements of the piped iterator with
-* those of `other`, for use with {@link pipe}. Iteration stops as soon as either
-* iterator is exhausted.
-*
-* @template T - The type of elements produced by the piped iterator.
-* @template U - The type of elements produced by `other`.
-* @param other - The iterator to pair with the piped one.
-* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
-*
-* @example
-* import { pipe } from 'es-toolkit/fp';
-* import { zip, toArray } from 'es-toolkit/fp/iterator';
-*
-* pipe([1, 2, 3].values(), zip(['a', 'b'].values()), toArray()); // => [[1, 'a'], [2, 'b']]
-*/
-function zip(other) {
-	return function zipInIterator(source) {
-		return require_zip.zip(source, other);
-	};
-}
-//#endregion
-exports.zip = zip;

package/node_modules/es-toolkit/dist/fp/iterator/zip.mjs

@@ -1,25 +0,0 @@
-import { zip as zip$1 } from "../../iterator/zip.mjs";
-//#region src/fp/iterator/zip.ts
-/**
-* Creates a function that lazily pairs the elements of the piped iterator with
-* those of `other`, for use with {@link pipe}. Iteration stops as soon as either
-* iterator is exhausted.
-*
-* @template T - The type of elements produced by the piped iterator.
-* @template U - The type of elements produced by `other`.
-* @param other - The iterator to pair with the piped one.
-* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
-*
-* @example
-* import { pipe } from 'es-toolkit/fp';
-* import { zip, toArray } from 'es-toolkit/fp/iterator';
-*
-* pipe([1, 2, 3].values(), zip(['a', 'b'].values()), toArray()); // => [[1, 'a'], [2, 'b']]
-*/
-function zip(other) {
-	return function zipInIterator(source) {
-		return zip$1(source, other);
-	};
-}
-//#endregion
-export { zip };

package/node_modules/es-toolkit/dist/iterator/_internal/iterator.js

@@ -1,74 +0,0 @@
-//#region src/iterator/_internal/iterator.ts
-/**
-* Wraps a `next` function into a lazy {@link IteratorObject} whose prototype is
-* the native `Iterator.prototype`. The result therefore behaves exactly like a
-* value returned by a built-in iterator helper (e.g. `array.values().map(...)`):
-* it is single-shot, it is iterable via `Symbol.iterator` (returning itself),
-* and it carries every native helper method (`map`, `filter`, `take`, `drop`,
-* `flatMap`, `reduce`, `toArray`, ...) so results can be chained with them.
-*
-* The result also follows the IteratorClose protocol of the native helpers, so
-* upstream resources (e.g. `try/finally` blocks in generator sources) are
-* released. `onClose` runs exactly once, at whichever of these happens first:
-* the consumer terminates early (`return()`, e.g. from `take` or a `for...of`
-* `break`), `next` throws, or `next` reports done. After the iterator is
-* closed, `next` is never called again and every subsequent step is done.
-*
-* Using a hand-rolled `next` rather than a generator function is a deliberate
-* performance choice — driving the iterator protocol directly measured roughly
-* twice as fast as `yield`-based generators for the same transforms, while
-* `Object.create(Iterator.prototype)` adds no measurable overhead over a plain
-* object literal.
-*
-* @template T - The type of values produced by the iterator.
-* @param next - Called to produce each step; return `{ done: true, value: undefined }` to finish.
-* @param onClose - Called once when the iterator closes; use it to close upstream iterators.
-* @returns A lazy {@link IteratorObject} that yields the values produced by `next`.
-*
-* @example
-* function repeat<T>(value: T, times: number): IteratorObject<T, undefined> {
-*   let remaining = times;
-*   return iterator(function () {
-*     if (remaining <= 0) {
-*       return { value: undefined, done: true };
-*     }
-*     remaining--;
-*     return { value, done: false };
-*   });
-* }
-*/
-function iterator(next, onClose) {
-	let closed = false;
-	const close = () => {
-		if (!closed) {
-			closed = true;
-			onClose?.();
-		}
-	};
-	const result = Object.create(Iterator.prototype);
-	result.next = function() {
-		if (closed) return {
-			value: void 0,
-			done: true
-		};
-		let step;
-		try {
-			step = next();
-		} catch (error) {
-			close();
-			throw error;
-		}
-		if (step.done) close();
-		return step;
-	};
-	result.return = function() {
-		close();
-		return {
-			value: void 0,
-			done: true
-		};
-	};
-	return result;
-}
-//#endregion
-exports.iterator = iterator;

package/node_modules/es-toolkit/dist/iterator/_internal/iterator.mjs

@@ -1,74 +0,0 @@
-//#region src/iterator/_internal/iterator.ts
-/**
-* Wraps a `next` function into a lazy {@link IteratorObject} whose prototype is
-* the native `Iterator.prototype`. The result therefore behaves exactly like a
-* value returned by a built-in iterator helper (e.g. `array.values().map(...)`):
-* it is single-shot, it is iterable via `Symbol.iterator` (returning itself),
-* and it carries every native helper method (`map`, `filter`, `take`, `drop`,
-* `flatMap`, `reduce`, `toArray`, ...) so results can be chained with them.
-*
-* The result also follows the IteratorClose protocol of the native helpers, so
-* upstream resources (e.g. `try/finally` blocks in generator sources) are
-* released. `onClose` runs exactly once, at whichever of these happens first:
-* the consumer terminates early (`return()`, e.g. from `take` or a `for...of`
-* `break`), `next` throws, or `next` reports done. After the iterator is
-* closed, `next` is never called again and every subsequent step is done.
-*
-* Using a hand-rolled `next` rather than a generator function is a deliberate
-* performance choice — driving the iterator protocol directly measured roughly
-* twice as fast as `yield`-based generators for the same transforms, while
-* `Object.create(Iterator.prototype)` adds no measurable overhead over a plain
-* object literal.
-*
-* @template T - The type of values produced by the iterator.
-* @param next - Called to produce each step; return `{ done: true, value: undefined }` to finish.
-* @param onClose - Called once when the iterator closes; use it to close upstream iterators.
-* @returns A lazy {@link IteratorObject} that yields the values produced by `next`.
-*
-* @example
-* function repeat<T>(value: T, times: number): IteratorObject<T, undefined> {
-*   let remaining = times;
-*   return iterator(function () {
-*     if (remaining <= 0) {
-*       return { value: undefined, done: true };
-*     }
-*     remaining--;
-*     return { value, done: false };
-*   });
-* }
-*/
-function iterator(next, onClose) {
-	let closed = false;
-	const close = () => {
-		if (!closed) {
-			closed = true;
-			onClose?.();
-		}
-	};
-	const result = Object.create(Iterator.prototype);
-	result.next = function() {
-		if (closed) return {
-			value: void 0,
-			done: true
-		};
-		let step;
-		try {
-			step = next();
-		} catch (error) {
-			close();
-			throw error;
-		}
-		if (step.done) close();
-		return step;
-	};
-	result.return = function() {
-		close();
-		return {
-			value: void 0,
-			done: true
-		};
-	};
-	return result;
-}
-//#endregion
-export { iterator };

package/node_modules/es-toolkit/dist/iterator/cartesianProduct.d.mts

@@ -1,33 +0,0 @@
-//#region src/iterator/cartesianProduct.d.ts
-type IteratorValue<T> = T extends Iterator<infer V> ? V : never;
-/**
- * Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
- * of the source iterators, yielding every possible tuple formed by picking one
- * element from each source, in lexicographic order — the rightmost source
- * advances fastest, like the digits of an odometer.
- *
- * Because every source except the first is traversed many times, those sources
- * are buffered into arrays when iteration starts. The first source is consumed
- * lazily, one element at a time, so it may be infinite. When iteration ends —
- * because the first source ran out, a buffered source was empty, or the
- * consumer terminated early — every source is closed via its `return` method.
- *
- * If no sources are passed, a single empty tuple is yielded, matching the
- * array `cartesianProduct`. If any source is empty, nothing is yielded.
- *
- * @template T - A tuple of the source iterator types.
- * @param sources - The iterators to take the product of.
- * @returns A lazy iterator over tuples representing the Cartesian product.
- *
- * @example
- * cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
- * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
- *
- * @example
- * // The first source may be infinite; elements are produced on demand.
- * cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
- * // => [[0, 'a'], [0, 'b'], [1, 'a']]
- */
-declare function cartesianProduct<T extends Array<Iterator<unknown>>>(...sources: T): IteratorObject<{ [K in keyof T]: IteratorValue<T[K]> }, undefined>;
-//#endregion
-export { cartesianProduct };

package/node_modules/es-toolkit/dist/iterator/cartesianProduct.d.ts

@@ -1,33 +0,0 @@
-//#region src/iterator/cartesianProduct.d.ts
-type IteratorValue<T> = T extends Iterator<infer V> ? V : never;
-/**
- * Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
- * of the source iterators, yielding every possible tuple formed by picking one
- * element from each source, in lexicographic order — the rightmost source
- * advances fastest, like the digits of an odometer.
- *
- * Because every source except the first is traversed many times, those sources
- * are buffered into arrays when iteration starts. The first source is consumed
- * lazily, one element at a time, so it may be infinite. When iteration ends —
- * because the first source ran out, a buffered source was empty, or the
- * consumer terminated early — every source is closed via its `return` method.
- *
- * If no sources are passed, a single empty tuple is yielded, matching the
- * array `cartesianProduct`. If any source is empty, nothing is yielded.
- *
- * @template T - A tuple of the source iterator types.
- * @param sources - The iterators to take the product of.
- * @returns A lazy iterator over tuples representing the Cartesian product.
- *
- * @example
- * cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
- * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
- *
- * @example
- * // The first source may be infinite; elements are produced on demand.
- * cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
- * // => [[0, 'a'], [0, 'b'], [1, 'a']]
- */
-declare function cartesianProduct<T extends Array<Iterator<unknown>>>(...sources: T): IteratorObject<{ [K in keyof T]: IteratorValue<T[K]> }, undefined>;
-//#endregion
-export { cartesianProduct };

package/node_modules/es-toolkit/dist/iterator/cartesianProduct.js

@@ -1,95 +0,0 @@
-const require_iterator = require("./_internal/iterator.js");
-//#region src/iterator/cartesianProduct.ts
-/**
-* Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
-* of the source iterators, yielding every possible tuple formed by picking one
-* element from each source, in lexicographic order — the rightmost source
-* advances fastest, like the digits of an odometer.
-*
-* Because every source except the first is traversed many times, those sources
-* are buffered into arrays when iteration starts. The first source is consumed
-* lazily, one element at a time, so it may be infinite. When iteration ends —
-* because the first source ran out, a buffered source was empty, or the
-* consumer terminated early — every source is closed via its `return` method.
-*
-* If no sources are passed, a single empty tuple is yielded, matching the
-* array `cartesianProduct`. If any source is empty, nothing is yielded.
-*
-* @template T - A tuple of the source iterator types.
-* @param sources - The iterators to take the product of.
-* @returns A lazy iterator over tuples representing the Cartesian product.
-*
-* @example
-* cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
-* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
-*
-* @example
-* // The first source may be infinite; elements are produced on demand.
-* cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
-* // => [[0, 'a'], [0, 'b'], [1, 'a']]
-*/
-function cartesianProduct(...sources) {
-	const pools = [];
-	const indices = [];
-	let firstValue;
-	let state = "initial";
-	return require_iterator.iterator(function() {
-		if (state === "done") return {
-			value: void 0,
-			done: true
-		};
-		if (state === "initial") {
-			state = "active";
-			if (sources.length === 0) {
-				state = "done";
-				return {
-					value: [],
-					done: false
-				};
-			}
-			for (let index = 1; index < sources.length; index++) {
-				const pool = [];
-				let step = sources[index].next();
-				while (!step.done) {
-					pool.push(step.value);
-					step = sources[index].next();
-				}
-				pools.push(pool);
-			}
-			if (pools.some((pool) => pool.length === 0)) return {
-				value: void 0,
-				done: true
-			};
-			const step = sources[0].next();
-			if (step.done) return {
-				value: void 0,
-				done: true
-			};
-			firstValue = step.value;
-			for (let index = 0; index < pools.length; index++) indices.push(0);
-		}
-		const tuple = new Array(sources.length);
-		tuple[0] = firstValue;
-		for (let index = 0; index < indices.length; index++) tuple[index + 1] = pools[index][indices[index]];
-		let position = indices.length - 1;
-		while (position >= 0) {
-			indices[position]++;
-			if (indices[position] < pools[position].length) break;
-			indices[position] = 0;
-			position--;
-		}
-		if (position < 0) {
-			const step = sources[0].next();
-			if (step.done) state = "done";
-			else firstValue = step.value;
-		}
-		return {
-			value: tuple,
-			done: false
-		};
-	}, () => {
-		for (const source of sources) source.return?.();
-	});
-}
-//#endregion
-exports.cartesianProduct = cartesianProduct;

package/node_modules/es-toolkit/dist/iterator/cartesianProduct.mjs

@@ -1,95 +0,0 @@
-import { iterator } from "./_internal/iterator.mjs";
-//#region src/iterator/cartesianProduct.ts
-/**
-* Lazily computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
-* of the source iterators, yielding every possible tuple formed by picking one
-* element from each source, in lexicographic order — the rightmost source
-* advances fastest, like the digits of an odometer.
-*
-* Because every source except the first is traversed many times, those sources
-* are buffered into arrays when iteration starts. The first source is consumed
-* lazily, one element at a time, so it may be infinite. When iteration ends —
-* because the first source ran out, a buffered source was empty, or the
-* consumer terminated early — every source is closed via its `return` method.
-*
-* If no sources are passed, a single empty tuple is yielded, matching the
-* array `cartesianProduct`. If any source is empty, nothing is yielded.
-*
-* @template T - A tuple of the source iterator types.
-* @param sources - The iterators to take the product of.
-* @returns A lazy iterator over tuples representing the Cartesian product.
-*
-* @example
-* cartesianProduct([1, 2].values(), ['a', 'b'].values()).toArray();
-* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
-*
-* @example
-* // The first source may be infinite; elements are produced on demand.
-* cartesianProduct(range(0, Infinity), ['a', 'b'].values()).take(3).toArray();
-* // => [[0, 'a'], [0, 'b'], [1, 'a']]
-*/
-function cartesianProduct(...sources) {
-	const pools = [];
-	const indices = [];
-	let firstValue;
-	let state = "initial";
-	return iterator(function() {
-		if (state === "done") return {
-			value: void 0,
-			done: true
-		};
-		if (state === "initial") {
-			state = "active";
-			if (sources.length === 0) {
-				state = "done";
-				return {
-					value: [],
-					done: false
-				};
-			}
-			for (let index = 1; index < sources.length; index++) {
-				const pool = [];
-				let step = sources[index].next();
-				while (!step.done) {
-					pool.push(step.value);
-					step = sources[index].next();
-				}
-				pools.push(pool);
-			}
-			if (pools.some((pool) => pool.length === 0)) return {
-				value: void 0,
-				done: true
-			};
-			const step = sources[0].next();
-			if (step.done) return {
-				value: void 0,
-				done: true
-			};
-			firstValue = step.value;
-			for (let index = 0; index < pools.length; index++) indices.push(0);
-		}
-		const tuple = new Array(sources.length);
-		tuple[0] = firstValue;
-		for (let index = 0; index < indices.length; index++) tuple[index + 1] = pools[index][indices[index]];
-		let position = indices.length - 1;
-		while (position >= 0) {
-			indices[position]++;
-			if (indices[position] < pools[position].length) break;
-			indices[position] = 0;
-			position--;
-		}
-		if (position < 0) {
-			const step = sources[0].next();
-			if (step.done) state = "done";
-			else firstValue = step.value;
-		}
-		return {
-			value: tuple,
-			done: false
-		};
-	}, () => {
-		for (const source of sources) source.return?.();
-	});
-}
-//#endregion
-export { cartesianProduct };

package/node_modules/es-toolkit/dist/iterator/chunk.d.mts

@@ -1,21 +0,0 @@
-//#region src/iterator/chunk.d.ts
-/**
- * Lazily groups the elements of `source` into arrays of length `size`. The final
- * chunk holds the remaining elements when the source length is not an exact
- * multiple of `size`, so it may be shorter.
- *
- * Each chunk is produced only when requested, so this works with infinite
- * iterators when bounded by a short-circuiting helper.
- *
- * @template T - The type of elements produced by the iterator.
- * @param source - The iterator to split into chunks.
- * @param size - The length of each chunk; must be an integer greater than zero.
- * @returns A lazy iterator over arrays of up to `size` elements.
- * @throws {Error} Throws an error if `size` is not an integer greater than zero.
- *
- * @example
- * chunk([1, 2, 3, 4, 5].values(), 2).toArray(); // => [[1, 2], [3, 4], [5]]
- */
-declare function chunk<T>(source: Iterator<T>, size: number): IteratorObject<T[], undefined>;
-//#endregion
-export { chunk };

package/node_modules/es-toolkit/dist/iterator/chunk.d.ts

@@ -1,21 +0,0 @@
-//#region src/iterator/chunk.d.ts
-/**
- * Lazily groups the elements of `source` into arrays of length `size`. The final
- * chunk holds the remaining elements when the source length is not an exact
- * multiple of `size`, so it may be shorter.
- *
- * Each chunk is produced only when requested, so this works with infinite
- * iterators when bounded by a short-circuiting helper.
- *
- * @template T - The type of elements produced by the iterator.
- * @param source - The iterator to split into chunks.
- * @param size - The length of each chunk; must be an integer greater than zero.
- * @returns A lazy iterator over arrays of up to `size` elements.
- * @throws {Error} Throws an error if `size` is not an integer greater than zero.
- *
- * @example
- * chunk([1, 2, 3, 4, 5].values(), 2).toArray(); // => [[1, 2], [3, 4], [5]]
- */
-declare function chunk<T>(source: Iterator<T>, size: number): IteratorObject<T[], undefined>;
-//#endregion
-export { chunk };

package/node_modules/es-toolkit/dist/iterator/chunk.js

@@ -1,40 +0,0 @@
-const require_iterator = require("./_internal/iterator.js");
-//#region src/iterator/chunk.ts
-/**
-* Lazily groups the elements of `source` into arrays of length `size`. The final
-* chunk holds the remaining elements when the source length is not an exact
-* multiple of `size`, so it may be shorter.
-*
-* Each chunk is produced only when requested, so this works with infinite
-* iterators when bounded by a short-circuiting helper.
-*
-* @template T - The type of elements produced by the iterator.
-* @param source - The iterator to split into chunks.
-* @param size - The length of each chunk; must be an integer greater than zero.
-* @returns A lazy iterator over arrays of up to `size` elements.
-* @throws {Error} Throws an error if `size` is not an integer greater than zero.
-*
-* @example
-* chunk([1, 2, 3, 4, 5].values(), 2).toArray(); // => [[1, 2], [3, 4], [5]]
-*/
-function chunk(source, size) {
-	if (!Number.isInteger(size) || size <= 0) throw new Error("Size must be an integer greater than zero.");
-	return require_iterator.iterator(function() {
-		const buffer = [];
-		while (buffer.length < size) {
-			const result = source.next();
-			if (result.done) break;
-			buffer.push(result.value);
-		}
-		if (buffer.length === 0) return {
-			value: void 0,
-			done: true
-		};
-		return {
-			value: buffer,
-			done: false
-		};
-	}, () => void source.return?.());
-}
-//#endregion
-exports.chunk = chunk;

package/node_modules/es-toolkit/dist/iterator/chunk.mjs

@@ -1,40 +0,0 @@
-import { iterator } from "./_internal/iterator.mjs";
-//#region src/iterator/chunk.ts
-/**
-* Lazily groups the elements of `source` into arrays of length `size`. The final
-* chunk holds the remaining elements when the source length is not an exact
-* multiple of `size`, so it may be shorter.
-*
-* Each chunk is produced only when requested, so this works with infinite
-* iterators when bounded by a short-circuiting helper.
-*
-* @template T - The type of elements produced by the iterator.
-* @param source - The iterator to split into chunks.
-* @param size - The length of each chunk; must be an integer greater than zero.
-* @returns A lazy iterator over arrays of up to `size` elements.
-* @throws {Error} Throws an error if `size` is not an integer greater than zero.
-*
-* @example
-* chunk([1, 2, 3, 4, 5].values(), 2).toArray(); // => [[1, 2], [3, 4], [5]]
-*/
-function chunk(source, size) {
-	if (!Number.isInteger(size) || size <= 0) throw new Error("Size must be an integer greater than zero.");
-	return iterator(function() {
-		const buffer = [];
-		while (buffer.length < size) {
-			const result = source.next();
-			if (result.done) break;
-			buffer.push(result.value);
-		}
-		if (buffer.length === 0) return {
-			value: void 0,
-			done: true
-		};
-		return {
-			value: buffer,
-			done: false
-		};
-	}, () => void source.return?.());
-}
-//#endregion
-export { chunk };

package/node_modules/es-toolkit/dist/iterator/count.d.mts

@@ -1,18 +0,0 @@
-//#region src/iterator/count.d.ts
-/**
- * Consumes `source` and returns the number of elements it produces. This is a
- * terminal operation: it pulls every element, so it must not be used on an
- * infinite iterator.
- *
- * Unlike `source.toArray().length`, this counts without allocating an array.
- *
- * @template T - The type of elements produced by the iterator.
- * @param source - The iterator to count.
- * @returns The number of elements produced by `source`.
- *
- * @example
- * count([1, 2, 3].values()); // => 3
- */
-declare function count<T>(source: Iterator<T>): number;
-//#endregion
-export { count };