@duplojs/lang 0.0.0

package/README.md

@@ -0,0 +1,9 @@
+# @duplojs/lang
+
+[![NPM version](https://img.shields.io/npm/v/@duplojs/lang)](https://www.npmjs.com/package/@duplojs/lang)
+
+## Install
+
+```bash
+npm install @duplojs/lang
+```

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+exports.__exportAll = __exportAll;

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/array/at/default.cjs

@@ -0,0 +1,11 @@
+//#region scripts/array/at/default.ts
+function at(...args) {
+	if (args.length === 1) {
+		const [index] = args;
+		return (array) => at(array, index);
+	}
+	const [input, index] = args;
+	return input.at(index);
+}
+//#endregion
+exports.at = at;

package/dist/array/at/default.d.ts

@@ -0,0 +1,4 @@
+import { IsIndexCovered, IsIndexOutOfRange } from '../constraints';
+export type At<GenericArray extends readonly unknown[], GenericIndex extends number> = IsIndexOutOfRange<GenericArray, GenericIndex> extends true ? undefined : IsIndexCovered<GenericArray, GenericIndex> extends true ? GenericArray[number] : GenericArray[number] | undefined;
+export declare function at<GenericArray extends readonly unknown[], GenericIndex extends number>(index: GenericIndex): (array: GenericArray) => At<GenericArray, GenericIndex>;
+export declare function at<GenericArray extends readonly unknown[], GenericIndex extends number>(array: GenericArray, index: GenericIndex): At<GenericArray, GenericIndex>;

package/dist/array/at/default.mjs

@@ -0,0 +1,11 @@
+//#region scripts/array/at/default.ts
+function at(...args) {
+	if (args.length === 1) {
+		const [index] = args;
+		return (array) => at(array, index);
+	}
+	const [input, index] = args;
+	return input.at(index);
+}
+//#endregion
+export { at };

package/dist/array/at/first.cjs

@@ -0,0 +1,6 @@
+//#region scripts/array/at/first.ts
+function first(array) {
+	return array[0];
+}
+//#endregion
+exports.first = first;

package/dist/array/at/first.d.ts

@@ -0,0 +1,3 @@
+import { At } from './default';
+export type First<GenericArray extends readonly unknown[]> = At<GenericArray, 0>;
+export declare function first<GenericArray extends readonly unknown[]>(array: GenericArray): First<GenericArray>;

package/dist/array/at/first.mjs

@@ -0,0 +1,6 @@
+//#region scripts/array/at/first.ts
+function first(array) {
+	return array[0];
+}
+//#endregion
+export { first };

package/dist/array/at/index.d.ts

@@ -0,0 +1,3 @@
+export * from './default';
+export * from './first';
+export * from './last';

package/dist/array/at/last.cjs

@@ -0,0 +1,6 @@
+//#region scripts/array/at/last.ts
+function last(array) {
+	return array.at(-1);
+}
+//#endregion
+exports.last = last;

package/dist/array/at/last.d.ts

@@ -0,0 +1,6 @@
+import { ExtractLengthEqual, ExtractMinElements, LengthEqual, MinElements } from '../constraints';
+import type * as DCommon from '../../common';
+type ComputeLastOutputFromMinElements<GenericArray extends readonly unknown[]> = ExtractMinElements<GenericArray, unknown> extends MinElements<infer InferredMin> ? DCommon.Not<DCommon.IsEqual<InferredMin, 0>> extends true ? GenericArray[number] : GenericArray[number] | undefined : GenericArray[number] | undefined;
+export type Last<GenericArray extends readonly unknown[]> = GenericArray extends readonly [...unknown[], infer InferredLast] ? InferredLast : ExtractLengthEqual<GenericArray, unknown> extends LengthEqual<infer InferredLength> ? DCommon.Not<DCommon.IsEqual<InferredLength, 0>> extends true ? GenericArray[number] : undefined : ComputeLastOutputFromMinElements<GenericArray>;
+export declare function last<GenericArray extends readonly unknown[]>(array: GenericArray): Last<GenericArray>;
+export {};

package/dist/array/at/last.mjs

@@ -0,0 +1,6 @@
+//#region scripts/array/at/last.ts
+function last(array) {
+	return array.at(-1);
+}
+//#endregion
+export { last };

package/dist/array/chunk.cjs

@@ -0,0 +1,13 @@
+//#region scripts/array/chunk.ts
+function chunk(...args) {
+	if (args.length === 1) {
+		const [size] = args;
+		return (array) => chunk(array, size);
+	}
+	const [array, size] = args;
+	const result = [];
+	for (let index = 0; index < array.length; index += size) result.push(array.slice(index, index + size));
+	return result;
+}
+//#endregion
+exports.chunk = chunk;

package/dist/array/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare function chunk<GenericArray extends readonly unknown[]>(size: number): (array: GenericArray) => GenericArray[number][][];
+export declare function chunk<GenericArray extends readonly unknown[]>(array: GenericArray, size: number): GenericArray[number][][];

package/dist/array/chunk.mjs

@@ -0,0 +1,13 @@
+//#region scripts/array/chunk.ts
+function chunk(...args) {
+	if (args.length === 1) {
+		const [size] = args;
+		return (array) => chunk(array, size);
+	}
+	const [array, size] = args;
+	const result = [];
+	for (let index = 0; index < array.length; index += size) result.push(array.slice(index, index + size));
+	return result;
+}
+//#endregion
+export { chunk };

package/dist/array/coalescing.cjs

@@ -0,0 +1,6 @@
+//#region scripts/array/coalescing.ts
+function coalescing(value) {
+	return value instanceof Array ? value : [value];
+}
+//#endregion
+exports.coalescing = coalescing;

package/dist/array/coalescing.d.ts

@@ -0,0 +1,3 @@
+import type * as DCommon from '../common';
+export type Coalescing<GenericValue extends unknown> = GenericValue extends readonly any[] ? GenericValue : readonly [GenericValue];
+export declare function coalescing<GenericValue extends DCommon.AnyValue>(value: GenericValue): Coalescing<GenericValue>;

package/dist/array/coalescing.mjs

@@ -0,0 +1,6 @@
+//#region scripts/array/coalescing.ts
+function coalescing(value) {
+	return value instanceof Array ? value : [value];
+}
+//#endregion
+export { coalescing };

package/dist/array/concat.cjs

@@ -0,0 +1,11 @@
+//#region scripts/array/concat.ts
+function concat(...args) {
+	if (args.length === 1) {
+		const [elements] = args;
+		return (array) => concat(array, elements);
+	}
+	const [array, elements, ...elementsRest] = args;
+	return array.concat(elements, ...elementsRest);
+}
+//#endregion
+exports.concat = concat;

package/dist/array/concat.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+type ConcatOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][] = []> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number] | GenericElementsRest[number][number])[], "minElements">;
+export declare function concat<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]>(elements: GenericElements): (array: GenericArray) => ConcatOutput<GenericArray, GenericElements>;
+export declare function concat<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][]>(array: GenericArray, elements: GenericElements, ...elementsRest: GenericElementsRest): ConcatOutput<GenericArray, GenericElements, GenericElementsRest>;
+export {};

package/dist/array/concat.mjs

@@ -0,0 +1,11 @@
+//#region scripts/array/concat.ts
+function concat(...args) {
+	if (args.length === 1) {
+		const [elements] = args;
+		return (array) => concat(array, elements);
+	}
+	const [array, elements, ...elementsRest] = args;
+	return array.concat(elements, ...elementsRest);
+}
+//#endregion
+export { concat };

package/dist/array/constraints/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './lengthEqual';
+export type * from './maxElements';
+export type * from './minElements';
+export type * from './types';

package/dist/array/constraints/lengthEqual.d.ts

@@ -0,0 +1,10 @@
+import { ExtractMaxElements, MaxElements } from './maxElements';
+import { ExtractMinElements, MinElements } from './minElements';
+import type * as DNumber from '../../number';
+import type * as DCommon from '../../common';
+export type LengthEqualConstraintName = "array-length-equal";
+export interface LengthEqual<GenericLength extends number> extends DCommon.DynamicConstraint<LengthEqualConstraintName, GenericLength> {
+}
+export type ExtractLengthEqual<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends unknown ? DCommon.Coalescing<DCommon.UnionToIntersection<(GenericConstraint extends LengthEqual<infer InferredLength> ? InferredLength extends number ? LengthEqual<InferredLength> : never : never) | (GenericConstraint extends DCommon.AnyTuple ? number extends GenericConstraint["length"] ? never : LengthEqual<GenericConstraint["length"]> : never)>, unknown, GenericDefault> : never;
+export type ComputeLengthEqualCompatibility<GenericValue extends unknown, GenericExpect extends unknown, GenericDefault extends unknown = never> = DCommon.NeverCoalescing<(ExtractLengthEqual<GenericExpect, unknown> extends LengthEqual<infer InferredTo> ? InferredTo extends number ? ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredFrom> ? InferredFrom extends number ? DCommon.IsEqual<InferredFrom, InferredTo> extends true ? DCommon.CompatibilityConstraintResult<true, InferredFrom, InferredTo> : DCommon.CompatibilityConstraintResult<false, InferredFrom, InferredTo> : never : never : never : never), GenericDefault>;
+export type IsImpossibleToApplyLengthEqual<GenericValue extends unknown, GenericExpect extends unknown> = DCommon.NeverCoalescing<(GenericValue extends readonly unknown[] ? ExtractLengthEqual<GenericExpect, unknown> extends LengthEqual<infer InferredTo> ? InferredTo extends number ? ((ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredLength> ? InferredLength extends number ? DCommon.IsEqual<InferredLength, InferredTo> extends true ? false : true : never : never) | (ExtractMinElements<GenericValue, unknown> extends MinElements<infer InferredMin> ? InferredMin extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredMin> extends true ? false : true : never : never) | (ExtractMaxElements<GenericValue, unknown> extends MaxElements<infer InferredMax> ? InferredMax extends number ? DNumber.IsGreaterOrEqual<InferredMax, InferredTo> extends true ? false : true : never : never)) : never : true : false), false> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, true> extends true ? true : false : never;

package/dist/array/constraints/maxElements.d.ts

@@ -0,0 +1,10 @@
+import { ExtractLengthEqual, LengthEqual } from './lengthEqual';
+import { ExtractMinElements, MinElements } from './minElements';
+import type * as DNumber from '../../number';
+import type * as DCommon from '../../common';
+export type MaxElementsConstraintName = "array-max-elements";
+export interface MaxElements<GenericMax extends number> extends DCommon.DynamicConstraint<MaxElementsConstraintName, GenericMax> {
+}
+export type ExtractMaxElements<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends unknown ? DCommon.Coalescing<DCommon.UnionToIntersection<(GenericConstraint extends MaxElements<infer InferredMax> ? InferredMax extends number ? MaxElements<InferredMax> : never : never) | (GenericConstraint extends DCommon.AnyTuple ? number extends GenericConstraint["length"] ? never : MaxElements<GenericConstraint["length"]> : never) | (GenericConstraint extends LengthEqual<infer InferredLength> ? InferredLength extends number ? MaxElements<InferredLength> : never : never)>, unknown, GenericDefault> : never;
+export type ComputeMaxElementsCompatibility<GenericValue extends unknown, GenericExpect extends unknown, GenericDefault extends unknown = never> = DCommon.NeverCoalescing<(ExtractMaxElements<GenericExpect, unknown> extends MaxElements<infer InferredTo> ? InferredTo extends number ? ExtractMaxElements<GenericValue, unknown> extends MaxElements<infer InferredFrom> ? InferredFrom extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredFrom> extends true ? DCommon.CompatibilityConstraintResult<true, InferredFrom, InferredTo> : DCommon.CompatibilityConstraintResult<false, InferredFrom, InferredTo> : never : never : never : never), GenericDefault>;
+export type IsImpossibleToApplyMaxElements<GenericValue extends unknown, GenericExpect extends unknown> = DCommon.NeverCoalescing<(GenericValue extends readonly unknown[] ? ExtractMaxElements<GenericExpect, unknown> extends MaxElements<infer InferredTo> ? InferredTo extends number ? ((ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredLength> ? InferredLength extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredLength> extends true ? false : true : never : never) | (ExtractMinElements<GenericValue, unknown> extends MinElements<infer InferredMin> ? InferredMin extends number ? DNumber.IsGreaterOrEqual<InferredTo, InferredMin> extends true ? false : true : never : never)) : never : true : false), false> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, true> extends true ? true : false : never;

package/dist/array/constraints/minElements.d.ts

@@ -0,0 +1,11 @@
+import { ExtractLengthEqual, LengthEqual } from './lengthEqual';
+import { ExtractMaxElements, MaxElements } from './maxElements';
+import type * as DNumber from '../../number';
+import type * as DCommon from '../../common';
+import type * as DTuple from '../../tuple';
+export type MinElementsConstraintName = "array-min-elements";
+export interface MinElements<GenericMin extends number> extends DCommon.DynamicConstraint<MinElementsConstraintName, GenericMin> {
+}
+export type ExtractMinElements<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends unknown ? DCommon.Coalescing<DCommon.UnionToIntersection<(GenericConstraint extends MinElements<infer InferredMin> ? InferredMin extends number ? MinElements<InferredMin> : never : never) | (GenericConstraint extends DCommon.AnyTuple ? MinElements<DTuple.CountMinElement<Extract<DCommon.RemoveConstraint<GenericConstraint>, DCommon.AnyTuple>>> : never) | (GenericConstraint extends LengthEqual<infer InferredLength> ? InferredLength extends number ? MinElements<InferredLength> : never : never)>, unknown, GenericDefault> : never;
+export type ComputeMinElementsCompatibility<GenericValue extends unknown, GenericExpect extends unknown, GenericDefault extends unknown = never> = DCommon.NeverCoalescing<(ExtractMinElements<GenericExpect, unknown> extends MinElements<infer InferredTo> ? InferredTo extends number ? ExtractMinElements<GenericValue, unknown> extends MinElements<infer InferredFrom> ? InferredFrom extends number ? DNumber.IsLessOrEqual<InferredTo, InferredFrom> extends true ? DCommon.CompatibilityConstraintResult<true, InferredFrom, InferredTo> : DCommon.CompatibilityConstraintResult<false, InferredFrom, InferredTo> : never : never : never : never), GenericDefault>;
+export type IsImpossibleToApplyMinElements<GenericValue extends unknown, GenericExpect extends unknown> = DCommon.NeverCoalescing<(GenericValue extends readonly unknown[] ? ExtractMinElements<GenericExpect, unknown> extends MinElements<infer InferredTo> ? InferredTo extends number ? ((ExtractLengthEqual<GenericValue, unknown> extends LengthEqual<infer InferredLength> ? InferredLength extends number ? DNumber.IsGreaterOrEqual<InferredLength, InferredTo> extends true ? false : true : never : never) | (ExtractMaxElements<GenericValue, unknown> extends MaxElements<infer InferredMax> ? InferredMax extends number ? DNumber.IsGreaterOrEqual<InferredMax, InferredTo> extends true ? false : true : never : never)) : never : true : false), false> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, true> extends true ? true : false : never;

package/dist/array/constraints/types/hasAtLeastElements.d.ts

@@ -0,0 +1,5 @@
+import { ExtractMinElements, MinElements } from '../minElements';
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import type * as DCommon from '../../../common';
+import type * as DNumber from '../../../number';
+export type HasAtLeastElements<GenericArray extends readonly unknown[], GenericMin extends number> = DCommon.IsEqual<GenericMin, number> extends true ? false : ExtractLengthEqual<GenericArray, unknown> extends LengthEqual<infer InferredLength> ? DNumber.IsGreaterOrEqual<InferredLength, GenericMin> : ExtractMinElements<GenericArray, unknown> extends MinElements<infer InferredMin> ? DNumber.IsGreaterOrEqual<InferredMin, GenericMin> : false;

package/dist/array/constraints/types/hasAtMostElements.d.ts

@@ -0,0 +1,5 @@
+import { ExtractMaxElements, MaxElements } from '../maxElements';
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import type * as DCommon from '../../../common';
+import type * as DNumber from '../../../number';
+export type HasAtMostElements<GenericArray extends readonly unknown[], GenericMax extends number> = DCommon.IsEqual<GenericMax, number> extends true ? false : ExtractLengthEqual<GenericArray, unknown> extends LengthEqual<infer InferredLength> ? DNumber.IsGreaterOrEqual<GenericMax, InferredLength> : ExtractMaxElements<GenericArray, unknown> extends MaxElements<infer InferredMax> ? DNumber.IsGreaterOrEqual<GenericMax, InferredMax> : false;

package/dist/array/constraints/types/hasExactLength.d.ts

@@ -0,0 +1,3 @@
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import type * as DCommon from '../../../common';
+export type HasExactLength<GenericArray extends readonly unknown[], GenericLength extends number> = ExtractLengthEqual<GenericArray, unknown> extends LengthEqual<infer InferredLength> ? DCommon.IsEqual<InferredLength, GenericLength> : false;

package/dist/array/constraints/types/index.d.ts

@@ -0,0 +1,9 @@
+export type * from './reapplyCompatiblesConstraints';
+export type * from './isIndexCovered';
+export type * from './isIndexOutOfRange';
+export type * from './hasAtLeastElements';
+export type * from './hasAtMostElements';
+export type * from './hasExactLength';
+export type * from './requireAtLeastElements';
+export type * from './requireAtMostElements';
+export type * from './requireExactLength';

package/dist/array/constraints/types/isIndexCovered.d.ts

@@ -0,0 +1,5 @@
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import { ExtractMinElements, MinElements } from '../minElements';
+import type * as DCommon from '../../../common';
+import type * as DNumber from '../../../number';
+export type IsIndexCovered<GenericArray extends readonly unknown[], GenericIndex extends number> = DCommon.IsEqual<GenericIndex, number> extends true ? false : ExtractLengthEqual<GenericArray, unknown> extends LengthEqual<infer InferredLength> ? DNumber.IsGreater<InferredLength, GenericIndex> : ExtractMinElements<GenericArray, unknown> extends MinElements<infer InferredMin> ? DNumber.IsGreater<InferredMin, GenericIndex> : false;

package/dist/array/constraints/types/isIndexOutOfRange.d.ts

@@ -0,0 +1,5 @@
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import { ExtractMaxElements, MaxElements } from '../maxElements';
+import type * as DCommon from '../../../common';
+import type * as DNumber from '../../../number';
+export type IsIndexOutOfRange<GenericArray extends readonly unknown[], GenericIndex extends number> = DCommon.IsEqual<GenericIndex, number> extends true ? false : ExtractLengthEqual<GenericArray, unknown> extends LengthEqual<infer InferredLength> ? DNumber.IsGreaterOrEqual<GenericIndex, InferredLength> : ExtractMaxElements<GenericArray, unknown> extends MaxElements<infer InferredMax> ? DNumber.IsGreaterOrEqual<GenericIndex, InferredMax> : false;

package/dist/array/constraints/types/reapplyCompatiblesConstraints.d.ts

@@ -0,0 +1,24 @@
+import { ExtractLengthEqual, LengthEqual } from '../lengthEqual';
+import { ExtractMaxElements, MaxElements } from '../maxElements';
+import { ExtractMinElements, MinElements } from '../minElements';
+import type * as DCommon from '../../../common';
+type ApplyLengthEqual<GenericOutput extends readonly unknown[], GenericSource extends readonly unknown[], GenericReapplyConstraint extends "maxElements" | "minElements" | "lengthEqual"> = "lengthEqual" extends GenericReapplyConstraint ? DCommon.Or<[
+    DCommon.ContainExtends<GenericSource, LengthEqual<number>>,
+    DCommon.Not<DCommon.IsExtends<GenericOutput, DCommon.AnyTuple>>
+]> extends true ? ExtractLengthEqual<GenericSource, unknown> extends LengthEqual<infer InferredLength> ? (GenericOutput & DCommon.UnionToIntersection<InferredLength extends number ? LengthEqual<InferredLength> : never>) : GenericOutput : GenericOutput : GenericOutput;
+type ApplyMinElements<GenericOutput extends readonly unknown[], GenericSource extends readonly unknown[], GenericReapplyConstraint extends "maxElements" | "minElements" | "lengthEqual"> = "minElements" extends GenericReapplyConstraint ? DCommon.Or<[
+    DCommon.ContainExtends<GenericSource, MinElements<number>>,
+    DCommon.And<[
+        DCommon.Not<DCommon.ContainExtends<GenericOutput, LengthEqual<number>>>,
+        DCommon.Not<DCommon.IsExtends<GenericOutput, DCommon.AnyTuple>>
+    ]>
+]> extends true ? ExtractMinElements<GenericSource, unknown> extends MinElements<infer InferredMin> ? (GenericOutput & DCommon.UnionToIntersection<InferredMin extends number ? MinElements<InferredMin> : never>) : GenericOutput : GenericOutput : GenericOutput;
+type ApplyMaxElements<GenericOutput extends readonly unknown[], GenericSource extends readonly unknown[], GenericReapplyConstraint extends "maxElements" | "minElements" | "lengthEqual"> = "maxElements" extends GenericReapplyConstraint ? DCommon.Or<[
+    DCommon.ContainExtends<GenericSource, MaxElements<number>>,
+    DCommon.And<[
+        DCommon.Not<DCommon.ContainExtends<GenericOutput, LengthEqual<number>>>,
+        DCommon.Not<DCommon.IsExtends<GenericOutput, DCommon.AnyTuple>>
+    ]>
+]> extends true ? ExtractMaxElements<GenericSource, unknown> extends MaxElements<infer InferredMax> ? (GenericOutput & DCommon.UnionToIntersection<InferredMax extends number ? MaxElements<InferredMax> : never>) : GenericOutput : GenericOutput : GenericOutput;
+export type ReapplyCompatiblesConstraints<GenericSource extends readonly unknown[], GenericOutput extends readonly unknown[], GenericReapplyConstraint extends "maxElements" | "minElements" | "lengthEqual" = "maxElements" | "minElements" | "lengthEqual"> = ApplyMaxElements<ApplyMinElements<ApplyLengthEqual<GenericOutput, GenericSource, GenericReapplyConstraint>, GenericSource, GenericReapplyConstraint>, GenericSource, GenericReapplyConstraint>;
+export {};

package/dist/array/constraints/types/requireAtLeastElements.d.ts

@@ -0,0 +1,3 @@
+import { HasAtLeastElements } from './hasAtLeastElements';
+import type * as DCommon from '../../../common';
+export type RequireAtLeastElements<GenericArray extends readonly unknown[], GenericMin extends number> = HasAtLeastElements<GenericArray, GenericMin> extends true ? unknown : DCommon.ComputedTypeError<`Array must have at least ${GenericMin} elements.`>;

package/dist/array/constraints/types/requireAtMostElements.d.ts

@@ -0,0 +1,3 @@
+import { HasAtMostElements } from './hasAtMostElements';
+import type * as DCommon from '../../../common';
+export type RequireAtMostElements<GenericArray extends readonly unknown[], GenericMax extends number> = HasAtMostElements<GenericArray, GenericMax> extends true ? unknown : DCommon.ComputedTypeError<`Array must have at most ${GenericMax} elements.`>;

package/dist/array/constraints/types/requireExactLength.d.ts

@@ -0,0 +1,3 @@
+import { HasExactLength } from './hasExactLength';
+import type * as DCommon from '../../../common';
+export type RequireExactLength<GenericArray extends readonly unknown[], GenericLength extends number> = HasExactLength<GenericArray, GenericLength> extends true ? unknown : DCommon.ComputedTypeError<`Array must have exactly ${GenericLength} elements.`>;

package/dist/array/copyWithin.cjs

@@ -0,0 +1,11 @@
+//#region scripts/array/copyWithin.ts
+function copyWithin(...args) {
+	if (!Array.isArray(args[0])) {
+		const [target, start, end] = args;
+		return (array) => copyWithin(array, target, start, end);
+	}
+	const [array, target, start, end] = args;
+	return array.slice().copyWithin(target, start, end);
+}
+//#endregion
+exports.copyWithin = copyWithin;

package/dist/array/copyWithin.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+type CopyWithinOutput<GenericArray extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][]>;
+export declare function copyWithin<GenericArray extends readonly unknown[]>(target: number, start: number, end?: number): (array: GenericArray) => CopyWithinOutput<GenericArray>;
+export declare function copyWithin<GenericArray extends readonly unknown[]>(array: GenericArray, target: number, start: number, end?: number): CopyWithinOutput<GenericArray>;
+export {};

package/dist/array/copyWithin.mjs

@@ -0,0 +1,11 @@
+//#region scripts/array/copyWithin.ts
+function copyWithin(...args) {
+	if (!Array.isArray(args[0])) {
+		const [target, start, end] = args;
+		return (array) => copyWithin(array, target, start, end);
+	}
+	const [array, target, start, end] = args;
+	return array.slice().copyWithin(target, start, end);
+}
+//#endregion
+export { copyWithin };

package/dist/array/every.cjs

@@ -0,0 +1,14 @@
+//#region scripts/array/every.ts
+function every(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (array) => every(array, predicate);
+	}
+	const [array, predicate] = args;
+	return array.every((element, index) => predicate(element, {
+		index,
+		self: array
+	}));
+}
+//#endregion
+exports.every = every;

package/dist/array/every.d.ts

@@ -0,0 +1,6 @@
+export interface EveryPredicateFunctionParams<GenericArray extends readonly unknown[] = readonly unknown[]> {
+    index: number;
+    self: GenericArray;
+}
+export declare function every<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: EveryPredicateFunctionParams<GenericArray>) => boolean): (array: GenericArray) => boolean;
+export declare function every<GenericArray extends readonly unknown[]>(array: GenericArray, predicate: (element: GenericArray[number], params: EveryPredicateFunctionParams<GenericArray>) => boolean): boolean;

package/dist/array/every.mjs

@@ -0,0 +1,14 @@
+//#region scripts/array/every.ts
+function every(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (array) => every(array, predicate);
+	}
+	const [array, predicate] = args;
+	return array.every((element, index) => predicate(element, {
+		index,
+		self: array
+	}));
+}
+//#endregion
+export { every };

package/dist/array/fill/all.cjs

@@ -0,0 +1,11 @@
+//#region scripts/array/fill/all.ts
+function fillAll(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (array) => fillAll(array, value);
+	}
+	const [array, value] = args;
+	return array.slice().fill(value);
+}
+//#endregion
+exports.fillAll = fillAll;

package/dist/array/fill/all.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from '../constraints';
+type FillAllOutput<GenericArray extends readonly unknown[], GenericElement extends unknown> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[]>;
+export declare function fillAll<GenericElement extends unknown>(element: GenericElement): <GenericArray extends readonly unknown[]>(array: GenericArray) => FillAllOutput<GenericArray, GenericElement>;
+export declare function fillAll<GenericElement extends unknown, GenericArray extends readonly unknown[]>(array: GenericArray, element: GenericElement): FillAllOutput<GenericArray, GenericElement>;
+export {};

package/dist/array/fill/all.mjs

@@ -0,0 +1,11 @@
+//#region scripts/array/fill/all.ts
+function fillAll(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (array) => fillAll(array, value);
+	}
+	const [array, value] = args;
+	return array.slice().fill(value);
+}
+//#endregion
+export { fillAll };

package/dist/array/fill/default.cjs

@@ -0,0 +1,11 @@
+//#region scripts/array/fill/default.ts
+function fill(...args) {
+	if (args.length === 3) {
+		const [value, start, end] = args;
+		return (array) => fill(array, value, start, end);
+	}
+	const [array, value, start, end] = args;
+	return array.slice().fill(value, start, end);
+}
+//#endregion
+exports.fill = fill;

package/dist/array/fill/default.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from '../constraints';
+type FillOutput<GenericArray extends readonly unknown[], GenericValue extends unknown> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[]>;
+export declare function fill<GenericArray extends readonly unknown[], GenericValue extends unknown>(value: GenericValue, start: number, end: number): (array: GenericArray) => FillOutput<GenericArray, GenericValue>;
+export declare function fill<GenericArray extends readonly unknown[], GenericValue extends unknown>(array: GenericArray, value: GenericValue, start: number, end: number): FillOutput<GenericArray, GenericValue>;
+export {};

package/dist/array/fill/default.mjs

@@ -0,0 +1,11 @@
+//#region scripts/array/fill/default.ts
+function fill(...args) {
+	if (args.length === 3) {
+		const [value, start, end] = args;
+		return (array) => fill(array, value, start, end);
+	}
+	const [array, value, start, end] = args;
+	return array.slice().fill(value, start, end);
+}
+//#endregion
+export { fill };

package/dist/array/fill/index.d.ts

@@ -0,0 +1,2 @@
+export * from './default';
+export * from './all';

package/dist/array/filter.cjs

@@ -0,0 +1,14 @@
+//#region scripts/array/filter.ts
+function filter(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (array) => filter(array, predicate);
+	}
+	const [array, predicate] = args;
+	return array.filter((element, index) => predicate(element, {
+		index,
+		self: array
+	}));
+}
+//#endregion
+exports.filter = filter;

package/dist/array/filter.d.ts

@@ -0,0 +1,11 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+export interface FilterPredicateFunctionParams<GenericArray extends readonly unknown[] = readonly unknown[]> {
+    index: number;
+    self: GenericArray;
+}
+type FilterOutput<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number] = GenericArray[number]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[], "maxElements">;
+export declare function filter<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number]>(predicate: (element: GenericArray[number], params: FilterPredicateFunctionParams<GenericArray>) => element is GenericElement): (array: GenericArray) => FilterOutput<GenericArray, GenericElement>;
+export declare function filter<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number]>(array: GenericArray, predicate: (element: GenericArray[number], params: FilterPredicateFunctionParams<GenericArray>) => element is GenericElement): FilterOutput<GenericArray, GenericElement>;
+export declare function filter<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: FilterPredicateFunctionParams<GenericArray>) => boolean): (array: GenericArray) => FilterOutput<GenericArray>;
+export declare function filter<GenericArray extends readonly unknown[]>(array: GenericArray, predicate: (element: GenericArray[number], params: FilterPredicateFunctionParams<GenericArray>) => boolean): FilterOutput<GenericArray>;
+export {};

package/dist/array/filter.mjs

@@ -0,0 +1,14 @@
+//#region scripts/array/filter.ts
+function filter(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (array) => filter(array, predicate);
+	}
+	const [array, predicate] = args;
+	return array.filter((element, index) => predicate(element, {
+		index,
+		self: array
+	}));
+}
+//#endregion
+export { filter };

package/dist/array/find.cjs

@@ -0,0 +1,14 @@
+//#region scripts/array/find.ts
+function find(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (array) => find(array, predicate);
+	}
+	const [array, predicate] = args;
+	return array.find((element, index) => predicate(element, {
+		index,
+		self: array
+	}));
+}
+//#endregion
+exports.find = find;

package/dist/array/find.d.ts

@@ -0,0 +1,8 @@
+export interface FindPredicateFunctionParams<GenericArray extends readonly unknown[] = readonly unknown[]> {
+    index: number;
+    self: GenericArray;
+}
+export declare function find<GenericArray extends readonly unknown[], GenericOutput extends GenericArray[number]>(predicate: (element: GenericArray[number], params: FindPredicateFunctionParams<GenericArray>) => element is GenericOutput): (array: GenericArray) => GenericOutput | undefined;
+export declare function find<GenericArray extends readonly unknown[], GenericOutput extends GenericArray[number]>(array: GenericArray, predicate: (element: GenericArray[number], params: FindPredicateFunctionParams<GenericArray>) => element is GenericOutput): GenericOutput | undefined;
+export declare function find<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: FindPredicateFunctionParams<GenericArray>) => boolean): (array: GenericArray) => GenericArray[number] | undefined;
+export declare function find<GenericArray extends readonly unknown[]>(array: GenericArray, predicate: (element: GenericArray[number], params: FindPredicateFunctionParams<GenericArray>) => boolean): GenericArray[number] | undefined;

package/dist/array/find.mjs

@@ -0,0 +1,14 @@
+//#region scripts/array/find.ts
+function find(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (array) => find(array, predicate);
+	}
+	const [array, predicate] = args;
+	return array.find((element, index) => predicate(element, {
+		index,
+		self: array
+	}));
+}
+//#endregion
+export { find };

package/dist/array/findAndReplace.cjs

@@ -0,0 +1,18 @@
+//#region scripts/array/findAndReplace.ts
+function findAndReplace(...args) {
+	if (args.length === 2) {
+		const [predicate, value] = args;
+		return (array) => findAndReplace(array, predicate, value);
+	}
+	const [array, predicate, value] = args;
+	for (let index = 0; index < array.length; index++) if (predicate(array[index], {
+		index,
+		self: array
+	})) {
+		const newArray = array.slice();
+		newArray[index] = value;
+		return newArray;
+	}
+}
+//#endregion
+exports.findAndReplace = findAndReplace;

package/dist/array/findAndReplace.d.ts

@@ -0,0 +1,10 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+import type * as DCommon from '../common';
+export interface FindAndReplacePredicateFunctionParams<GenericArray extends readonly unknown[] = readonly unknown[]> {
+    index: number;
+    self: GenericArray;
+}
+type FindAndReplaceOutput<GenericArray extends readonly unknown[], GenericValue extends DCommon.AnyValue> = (ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[]> | undefined);
+export declare function findAndReplace<GenericArray extends readonly unknown[], GenericValue extends DCommon.AnyValue>(predicate: (element: GenericArray[number], params: FindAndReplacePredicateFunctionParams<GenericArray>) => boolean, value: GenericValue): (array: GenericArray) => Extract<FindAndReplaceOutput<GenericArray, GenericValue>, any>;
+export declare function findAndReplace<GenericArray extends readonly unknown[], GenericValue extends DCommon.AnyValue>(array: GenericArray, predicate: (element: GenericArray[number], params: FindAndReplacePredicateFunctionParams<GenericArray>) => boolean, value: GenericValue): Extract<FindAndReplaceOutput<GenericArray, GenericValue>, any>;
+export {};