es-toolkit 1.50.0-dev.1990 → 1.50.0-dev.1992

package/dist/bigint/median.mjs

@@ -0,0 +1,28 @@
+//#region src/bigint/median.ts
+/**
+* Calculates the median of an array of bigints.
+*
+* The median is the middle value of a sorted array. When the array has an even number of elements,
+* the two middle values are averaged. Because bigints have no fractional part, that average is
+* truncated toward zero: `median([1n, 2n])` is `1n` and `median([-3n, -2n])` is `-2n`.
+*
+* @param nums - An array of bigints to calculate the median of.
+* @returns The median of the array.
+* @throws {RangeError} If the array is empty, since there is no bigint that represents "no median".
+*
+* @example
+* const result = median([1n, 2n, 3n, 4n, 5n]);
+* // result will be 3n
+*
+* const truncated = median([1n, 2n, 3n, 4n]);
+* // truncated will be 2n, because (2n + 3n) / 2n truncates toward zero
+*/
+function median(nums) {
+	if (nums.length === 0) throw new RangeError("Cannot compute the median of an empty array.");
+	const sorted = nums.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	const middleIndex = Math.floor(sorted.length / 2);
+	if (sorted.length % 2 === 0) return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2n;
+	return sorted[middleIndex];
+}
+//#endregion
+export { median };

package/dist/bigint/medianBy.d.mts

@@ -0,0 +1,21 @@
+//#region src/bigint/medianBy.d.ts
+/**
+ * Calculates the median of an array by mapping each element to a bigint.
+ *
+ * This function maps every element to a bigint and returns the median of those values. Because
+ * bigints have no fractional part, the average taken for even-length arrays is truncated toward zero.
+ *
+ * @template T - The type of elements in the array.
+ * @param items - An array of elements to calculate the median of.
+ * @param getValue - A function that maps an element to the bigint to use.
+ * @returns The median of the mapped bigints.
+ * @throws {RangeError} If the array is empty, since there is no bigint that represents "no median".
+ *
+ * @example
+ * const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+ * const result = medianBy(accounts, account => account.balance);
+ * // result will be 20n
+ */
+declare function medianBy<T>(items: readonly T[], getValue: (element: T) => bigint): bigint;
+//#endregion
+export { medianBy };

package/dist/bigint/medianBy.d.ts

@@ -0,0 +1,21 @@
+//#region src/bigint/medianBy.d.ts
+/**
+ * Calculates the median of an array by mapping each element to a bigint.
+ *
+ * This function maps every element to a bigint and returns the median of those values. Because
+ * bigints have no fractional part, the average taken for even-length arrays is truncated toward zero.
+ *
+ * @template T - The type of elements in the array.
+ * @param items - An array of elements to calculate the median of.
+ * @param getValue - A function that maps an element to the bigint to use.
+ * @returns The median of the mapped bigints.
+ * @throws {RangeError} If the array is empty, since there is no bigint that represents "no median".
+ *
+ * @example
+ * const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+ * const result = medianBy(accounts, account => account.balance);
+ * // result will be 20n
+ */
+declare function medianBy<T>(items: readonly T[], getValue: (element: T) => bigint): bigint;
+//#endregion
+export { medianBy };

package/dist/bigint/medianBy.js

@@ -0,0 +1,24 @@
+const require_median = require("./median.js");
+//#region src/bigint/medianBy.ts
+/**
+* Calculates the median of an array by mapping each element to a bigint.
+*
+* This function maps every element to a bigint and returns the median of those values. Because
+* bigints have no fractional part, the average taken for even-length arrays is truncated toward zero.
+*
+* @template T - The type of elements in the array.
+* @param items - An array of elements to calculate the median of.
+* @param getValue - A function that maps an element to the bigint to use.
+* @returns The median of the mapped bigints.
+* @throws {RangeError} If the array is empty, since there is no bigint that represents "no median".
+*
+* @example
+* const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+* const result = medianBy(accounts, account => account.balance);
+* // result will be 20n
+*/
+function medianBy(items, getValue) {
+	return require_median.median(items.map((item) => getValue(item)));
+}
+//#endregion
+exports.medianBy = medianBy;

package/dist/bigint/medianBy.mjs

@@ -0,0 +1,24 @@
+import { median } from "./median.mjs";
+//#region src/bigint/medianBy.ts
+/**
+* Calculates the median of an array by mapping each element to a bigint.
+*
+* This function maps every element to a bigint and returns the median of those values. Because
+* bigints have no fractional part, the average taken for even-length arrays is truncated toward zero.
+*
+* @template T - The type of elements in the array.
+* @param items - An array of elements to calculate the median of.
+* @param getValue - A function that maps an element to the bigint to use.
+* @returns The median of the mapped bigints.
+* @throws {RangeError} If the array is empty, since there is no bigint that represents "no median".
+*
+* @example
+* const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+* const result = medianBy(accounts, account => account.balance);
+* // result will be 20n
+*/
+function medianBy(items, getValue) {
+	return median(items.map((item) => getValue(item)));
+}
+//#endregion
+export { medianBy };

package/dist/bigint/min.d.mts

@@ -0,0 +1,18 @@
+//#region src/bigint/min.d.ts
+/**
+ * Finds the smallest bigint in an array.
+ *
+ * This function iterates through the array and returns the smallest element. Unlike `Math.min`,
+ * which cannot accept bigints, it compares values directly so arbitrarily large integers stay exact.
+ *
+ * @param nums - An array of bigints to search.
+ * @returns The smallest bigint in the array.
+ * @throws {RangeError} If the array is empty, since there is no bigint that represents "no minimum".
+ *
+ * @example
+ * const result = min([1n, 5n, 3n]);
+ * // result will be 1n
+ */
+declare function min(nums: readonly bigint[]): bigint;
+//#endregion
+export { min };

package/dist/bigint/min.d.ts

@@ -0,0 +1,18 @@
+//#region src/bigint/min.d.ts
+/**
+ * Finds the smallest bigint in an array.
+ *
+ * This function iterates through the array and returns the smallest element. Unlike `Math.min`,
+ * which cannot accept bigints, it compares values directly so arbitrarily large integers stay exact.
+ *
+ * @param nums - An array of bigints to search.
+ * @returns The smallest bigint in the array.
+ * @throws {RangeError} If the array is empty, since there is no bigint that represents "no minimum".
+ *
+ * @example
+ * const result = min([1n, 5n, 3n]);
+ * // result will be 1n
+ */
+declare function min(nums: readonly bigint[]): bigint;
+//#endregion
+export { min };

package/dist/bigint/min.js

@@ -0,0 +1,23 @@
+//#region src/bigint/min.ts
+/**
+* Finds the smallest bigint in an array.
+*
+* This function iterates through the array and returns the smallest element. Unlike `Math.min`,
+* which cannot accept bigints, it compares values directly so arbitrarily large integers stay exact.
+*
+* @param nums - An array of bigints to search.
+* @returns The smallest bigint in the array.
+* @throws {RangeError} If the array is empty, since there is no bigint that represents "no minimum".
+*
+* @example
+* const result = min([1n, 5n, 3n]);
+* // result will be 1n
+*/
+function min(nums) {
+	if (nums.length === 0) throw new RangeError("Cannot find the minimum of an empty array.");
+	let result = nums[0];
+	for (let i = 1; i < nums.length; i++) if (nums[i] < result) result = nums[i];
+	return result;
+}
+//#endregion
+exports.min = min;

package/dist/bigint/min.mjs

@@ -0,0 +1,23 @@
+//#region src/bigint/min.ts
+/**
+* Finds the smallest bigint in an array.
+*
+* This function iterates through the array and returns the smallest element. Unlike `Math.min`,
+* which cannot accept bigints, it compares values directly so arbitrarily large integers stay exact.
+*
+* @param nums - An array of bigints to search.
+* @returns The smallest bigint in the array.
+* @throws {RangeError} If the array is empty, since there is no bigint that represents "no minimum".
+*
+* @example
+* const result = min([1n, 5n, 3n]);
+* // result will be 1n
+*/
+function min(nums) {
+	if (nums.length === 0) throw new RangeError("Cannot find the minimum of an empty array.");
+	let result = nums[0];
+	for (let i = 1; i < nums.length; i++) if (nums[i] < result) result = nums[i];
+	return result;
+}
+//#endregion
+export { min };

package/dist/bigint/minBy.d.mts

@@ -0,0 +1,21 @@
+//#region src/bigint/minBy.d.ts
+/**
+ * Finds the element in an array that has the smallest bigint value returned by `getValue`.
+ *
+ * This function maps every element to a bigint and returns the element with the smallest value.
+ * If several elements tie, the first one is returned.
+ *
+ * @template T - The type of elements in the array.
+ * @param items - An array of elements to search.
+ * @param getValue - A function that maps an element to the bigint to compare by.
+ * @returns The element with the smallest mapped bigint.
+ * @throws {RangeError} If the array is empty, since there is no element to return.
+ *
+ * @example
+ * const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+ * const result = minBy(accounts, account => account.balance);
+ * // result will be { balance: 10n }
+ */
+declare function minBy<T>(items: readonly T[], getValue: (element: T, index: number, array: readonly T[]) => bigint): T;
+//#endregion
+export { minBy };

package/dist/bigint/minBy.d.ts

@@ -0,0 +1,21 @@
+//#region src/bigint/minBy.d.ts
+/**
+ * Finds the element in an array that has the smallest bigint value returned by `getValue`.
+ *
+ * This function maps every element to a bigint and returns the element with the smallest value.
+ * If several elements tie, the first one is returned.
+ *
+ * @template T - The type of elements in the array.
+ * @param items - An array of elements to search.
+ * @param getValue - A function that maps an element to the bigint to compare by.
+ * @returns The element with the smallest mapped bigint.
+ * @throws {RangeError} If the array is empty, since there is no element to return.
+ *
+ * @example
+ * const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+ * const result = minBy(accounts, account => account.balance);
+ * // result will be { balance: 10n }
+ */
+declare function minBy<T>(items: readonly T[], getValue: (element: T, index: number, array: readonly T[]) => bigint): T;
+//#endregion
+export { minBy };

package/dist/bigint/minBy.js

@@ -0,0 +1,34 @@
+//#region src/bigint/minBy.ts
+/**
+* Finds the element in an array that has the smallest bigint value returned by `getValue`.
+*
+* This function maps every element to a bigint and returns the element with the smallest value.
+* If several elements tie, the first one is returned.
+*
+* @template T - The type of elements in the array.
+* @param items - An array of elements to search.
+* @param getValue - A function that maps an element to the bigint to compare by.
+* @returns The element with the smallest mapped bigint.
+* @throws {RangeError} If the array is empty, since there is no element to return.
+*
+* @example
+* const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+* const result = minBy(accounts, account => account.balance);
+* // result will be { balance: 10n }
+*/
+function minBy(items, getValue) {
+	if (items.length === 0) throw new RangeError("Cannot find the minimum of an empty array.");
+	let minElement = items[0];
+	let min = getValue(items[0], 0, items);
+	for (let i = 1; i < items.length; i++) {
+		const element = items[i];
+		const value = getValue(element, i, items);
+		if (value < min) {
+			min = value;
+			minElement = element;
+		}
+	}
+	return minElement;
+}
+//#endregion
+exports.minBy = minBy;

package/dist/bigint/minBy.mjs

@@ -0,0 +1,34 @@
+//#region src/bigint/minBy.ts
+/**
+* Finds the element in an array that has the smallest bigint value returned by `getValue`.
+*
+* This function maps every element to a bigint and returns the element with the smallest value.
+* If several elements tie, the first one is returned.
+*
+* @template T - The type of elements in the array.
+* @param items - An array of elements to search.
+* @param getValue - A function that maps an element to the bigint to compare by.
+* @returns The element with the smallest mapped bigint.
+* @throws {RangeError} If the array is empty, since there is no element to return.
+*
+* @example
+* const accounts = [{ balance: 10n }, { balance: 30n }, { balance: 20n }];
+* const result = minBy(accounts, account => account.balance);
+* // result will be { balance: 10n }
+*/
+function minBy(items, getValue) {
+	if (items.length === 0) throw new RangeError("Cannot find the minimum of an empty array.");
+	let minElement = items[0];
+	let min = getValue(items[0], 0, items);
+	for (let i = 1; i < items.length; i++) {
+		const element = items[i];
+		const value = getValue(element, i, items);
+		if (value < min) {
+			min = value;
+			minElement = element;
+		}
+	}
+	return minElement;
+}
+//#endregion
+export { minBy };

package/dist/bigint/percentile.d.mts

@@ -0,0 +1,23 @@
+//#region src/bigint/percentile.d.ts
+/**
+ * Calculates the value at a given percentile in an array of bigints.
+ *
+ * This function uses the [nearest-rank method](https://en.wikipedia.org/wiki/Percentile#The_nearest-rank_method),
+ * so it always returns one of the values that is already in the array and never interpolates between them.
+ *
+ * @param arr - An array of bigints to calculate the percentile of.
+ * @param percentile - The percentile to look up, as a number between `0` and `100`.
+ * @returns The bigint at the given percentile.
+ * @throws {Error} If `percentile` is not a number between `0` and `100`.
+ * @throws {RangeError} If the array is empty, since there is no bigint to return.
+ *
+ * @example
+ * const result = percentile([1n, 2n, 3n, 4n, 5n], 50);
+ * // result will be 3n
+ *
+ * const p90 = percentile([1n, 2n, 3n, 4n, 5n], 90);
+ * // p90 will be 5n
+ */
+declare function percentile(arr: readonly bigint[], percentile: number): bigint;
+//#endregion
+export { percentile };

package/dist/bigint/percentile.d.ts

@@ -0,0 +1,23 @@
+//#region src/bigint/percentile.d.ts
+/**
+ * Calculates the value at a given percentile in an array of bigints.
+ *
+ * This function uses the [nearest-rank method](https://en.wikipedia.org/wiki/Percentile#The_nearest-rank_method),
+ * so it always returns one of the values that is already in the array and never interpolates between them.
+ *
+ * @param arr - An array of bigints to calculate the percentile of.
+ * @param percentile - The percentile to look up, as a number between `0` and `100`.
+ * @returns The bigint at the given percentile.
+ * @throws {Error} If `percentile` is not a number between `0` and `100`.
+ * @throws {RangeError} If the array is empty, since there is no bigint to return.
+ *
+ * @example
+ * const result = percentile([1n, 2n, 3n, 4n, 5n], 50);
+ * // result will be 3n
+ *
+ * const p90 = percentile([1n, 2n, 3n, 4n, 5n], 90);
+ * // p90 will be 5n
+ */
+declare function percentile(arr: readonly bigint[], percentile: number): bigint;
+//#endregion
+export { percentile };

package/dist/bigint/percentile.js

@@ -0,0 +1,31 @@
+//#region src/bigint/percentile.ts
+/**
+* Calculates the value at a given percentile in an array of bigints.
+*
+* This function uses the [nearest-rank method](https://en.wikipedia.org/wiki/Percentile#The_nearest-rank_method),
+* so it always returns one of the values that is already in the array and never interpolates between them.
+*
+* @param arr - An array of bigints to calculate the percentile of.
+* @param percentile - The percentile to look up, as a number between `0` and `100`.
+* @returns The bigint at the given percentile.
+* @throws {Error} If `percentile` is not a number between `0` and `100`.
+* @throws {RangeError} If the array is empty, since there is no bigint to return.
+*
+* @example
+* const result = percentile([1n, 2n, 3n, 4n, 5n], 50);
+* // result will be 3n
+*
+* const p90 = percentile([1n, 2n, 3n, 4n, 5n], 90);
+* // p90 will be 5n
+*/
+function percentile(arr, percentile) {
+	if (Number.isNaN(Number(percentile))) throw new Error(`Expected percentile to be a number but got "${percentile}".`);
+	if (percentile < 0) throw new Error(`Expected percentile to be >= 0 but got "${percentile}".`);
+	if (percentile > 100) throw new Error(`Expected percentile to be <= 100 but got "${percentile}".`);
+	if (arr.length === 0) throw new RangeError("Cannot compute the percentile of an empty array.");
+	const sorted = arr.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	if (percentile === 0) return sorted[0];
+	return sorted[Math.ceil(sorted.length * (percentile / 100)) - 1];
+}
+//#endregion
+exports.percentile = percentile;

package/dist/bigint/percentile.mjs

@@ -0,0 +1,31 @@
+//#region src/bigint/percentile.ts
+/**
+* Calculates the value at a given percentile in an array of bigints.
+*
+* This function uses the [nearest-rank method](https://en.wikipedia.org/wiki/Percentile#The_nearest-rank_method),
+* so it always returns one of the values that is already in the array and never interpolates between them.
+*
+* @param arr - An array of bigints to calculate the percentile of.
+* @param percentile - The percentile to look up, as a number between `0` and `100`.
+* @returns The bigint at the given percentile.
+* @throws {Error} If `percentile` is not a number between `0` and `100`.
+* @throws {RangeError} If the array is empty, since there is no bigint to return.
+*
+* @example
+* const result = percentile([1n, 2n, 3n, 4n, 5n], 50);
+* // result will be 3n
+*
+* const p90 = percentile([1n, 2n, 3n, 4n, 5n], 90);
+* // p90 will be 5n
+*/
+function percentile(arr, percentile) {
+	if (Number.isNaN(Number(percentile))) throw new Error(`Expected percentile to be a number but got "${percentile}".`);
+	if (percentile < 0) throw new Error(`Expected percentile to be >= 0 but got "${percentile}".`);
+	if (percentile > 100) throw new Error(`Expected percentile to be <= 100 but got "${percentile}".`);
+	if (arr.length === 0) throw new RangeError("Cannot compute the percentile of an empty array.");
+	const sorted = arr.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	if (percentile === 0) return sorted[0];
+	return sorted[Math.ceil(sorted.length * (percentile / 100)) - 1];
+}
+//#endregion
+export { percentile };

package/dist/bigint/range.d.mts

@@ -0,0 +1,45 @@
+//#region src/bigint/range.d.ts
+/**
+ * Returns an array of bigints from `0n` up to, but not including, `end`.
+ *
+ * @param end - The exclusive end of the range.
+ * @returns An array of bigints.
+ *
+ * @example
+ * const result = range(4n);
+ * // result will be [0n, 1n, 2n, 3n]
+ */
+declare function range(end: bigint): bigint[];
+/**
+ * Returns an array of bigints from `start` up to, but not including, `end`.
+ *
+ * @param start - The inclusive start of the range.
+ * @param end - The exclusive end of the range.
+ * @returns An array of bigints.
+ *
+ * @example
+ * const result = range(2n, 5n);
+ * // result will be [2n, 3n, 4n]
+ */
+declare function range(start: bigint, end: bigint): bigint[];
+/**
+ * Returns an array of bigints from `start` up to, but not including, `end`, incrementing by `step`.
+ *
+ * A negative `step` counts down. If `step` points away from `end`, an empty array is returned.
+ *
+ * @param start - The inclusive start of the range.
+ * @param end - The exclusive end of the range.
+ * @param step - The amount to increment by. Must not be `0n`.
+ * @returns An array of bigints.
+ * @throws {Error} If `step` is `0n`.
+ *
+ * @example
+ * const result = range(0n, 10n, 2n);
+ * // result will be [0n, 2n, 4n, 6n, 8n]
+ *
+ * const countdown = range(5n, 0n, -1n);
+ * // countdown will be [5n, 4n, 3n, 2n, 1n]
+ */
+declare function range(start: bigint, end: bigint, step: bigint): bigint[];
+//#endregion
+export { range };

package/dist/bigint/range.d.ts

@@ -0,0 +1,45 @@
+//#region src/bigint/range.d.ts
+/**
+ * Returns an array of bigints from `0n` up to, but not including, `end`.
+ *
+ * @param end - The exclusive end of the range.
+ * @returns An array of bigints.
+ *
+ * @example
+ * const result = range(4n);
+ * // result will be [0n, 1n, 2n, 3n]
+ */
+declare function range(end: bigint): bigint[];
+/**
+ * Returns an array of bigints from `start` up to, but not including, `end`.
+ *
+ * @param start - The inclusive start of the range.
+ * @param end - The exclusive end of the range.
+ * @returns An array of bigints.
+ *
+ * @example
+ * const result = range(2n, 5n);
+ * // result will be [2n, 3n, 4n]
+ */
+declare function range(start: bigint, end: bigint): bigint[];
+/**
+ * Returns an array of bigints from `start` up to, but not including, `end`, incrementing by `step`.
+ *
+ * A negative `step` counts down. If `step` points away from `end`, an empty array is returned.
+ *
+ * @param start - The inclusive start of the range.
+ * @param end - The exclusive end of the range.
+ * @param step - The amount to increment by. Must not be `0n`.
+ * @returns An array of bigints.
+ * @throws {Error} If `step` is `0n`.
+ *
+ * @example
+ * const result = range(0n, 10n, 2n);
+ * // result will be [0n, 2n, 4n, 6n, 8n]
+ *
+ * const countdown = range(5n, 0n, -1n);
+ * // countdown will be [5n, 4n, 3n, 2n, 1n]
+ */
+declare function range(start: bigint, end: bigint, step: bigint): bigint[];
+//#endregion
+export { range };

package/dist/bigint/range.js

@@ -0,0 +1,24 @@
+const require_bigIntRangeLength = require("../_internal/bigIntRangeLength.js");
+//#region src/bigint/range.ts
+/**
+* Returns an array of bigints from `start` up to, but not including, `end`, incrementing by `step`.
+*
+* @param start - The exclusive end of the range when called with one argument, otherwise the inclusive start.
+* @param end - The exclusive end of the range.
+* @param step - The amount to increment by. Must not be `0n`.
+* @returns An array of bigints.
+* @throws {Error} If `step` is `0n`.
+*/
+function range(start, end, step = 1n) {
+	if (end == null) {
+		end = start;
+		start = 0n;
+	}
+	if (step === 0n) throw new Error("The step value must be a non-zero bigint.");
+	const length = require_bigIntRangeLength.bigIntRangeLength(start, end, step);
+	const result = new Array(length);
+	for (let i = 0; i < length; i++) result[i] = start + BigInt(i) * step;
+	return result;
+}
+//#endregion
+exports.range = range;

package/dist/bigint/range.mjs

@@ -0,0 +1,24 @@
+import { bigIntRangeLength } from "../_internal/bigIntRangeLength.mjs";
+//#region src/bigint/range.ts
+/**
+* Returns an array of bigints from `start` up to, but not including, `end`, incrementing by `step`.
+*
+* @param start - The exclusive end of the range when called with one argument, otherwise the inclusive start.
+* @param end - The exclusive end of the range.
+* @param step - The amount to increment by. Must not be `0n`.
+* @returns An array of bigints.
+* @throws {Error} If `step` is `0n`.
+*/
+function range(start, end, step = 1n) {
+	if (end == null) {
+		end = start;
+		start = 0n;
+	}
+	if (step === 0n) throw new Error("The step value must be a non-zero bigint.");
+	const length = bigIntRangeLength(start, end, step);
+	const result = new Array(length);
+	for (let i = 0; i < length; i++) result[i] = start + BigInt(i) * step;
+	return result;
+}
+//#endregion
+export { range };

package/dist/bigint/rangeRight.d.mts

@@ -0,0 +1,43 @@
+//#region src/bigint/rangeRight.d.ts
+/**
+ * Returns an array of bigints from `0n` up to, but not including, `end`, in descending order.
+ *
+ * @param end - The exclusive end of the range.
+ * @returns An array of bigints.
+ *
+ * @example
+ * const result = rangeRight(4n);
+ * // result will be [3n, 2n, 1n, 0n]
+ */
+declare function rangeRight(end: bigint): bigint[];
+/**
+ * Returns an array of bigints from `start` up to, but not including, `end`, in descending order.
+ *
+ * @param start - The inclusive start of the range.
+ * @param end - The exclusive end of the range.
+ * @returns An array of bigints.
+ *
+ * @example
+ * const result = rangeRight(2n, 5n);
+ * // result will be [4n, 3n, 2n]
+ */
+declare function rangeRight(start: bigint, end: bigint): bigint[];
+/**
+ * Returns an array of bigints from `start` up to, but not including, `end`, incrementing by `step`,
+ * in descending order.
+ *
+ * A negative `step` counts down. If `step` points away from `end`, an empty array is returned.
+ *
+ * @param start - The inclusive start of the range.
+ * @param end - The exclusive end of the range.
+ * @param step - The amount to increment by. Must not be `0n`.
+ * @returns An array of bigints.
+ * @throws {Error} If `step` is `0n`.
+ *
+ * @example
+ * const result = rangeRight(0n, 10n, 2n);
+ * // result will be [8n, 6n, 4n, 2n, 0n]
+ */
+declare function rangeRight(start: bigint, end: bigint, step: bigint): bigint[];
+//#endregion
+export { rangeRight };