@fncts/base 0.0.1

package/typeclass/WitherableWithIndex.d.ts

@@ -0,0 +1,114 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { FilterableWithIndexMin } from "@fncts/base/typeclass/FilterableWithIndex";
+import type { TraversableWithIndexMin } from "@fncts/base/typeclass/TraversableWithIndex";
+import type { WitherableMin } from "@fncts/base/typeclass/Witherable";
+import { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIndex";
+import { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
+import { Witherable } from "@fncts/base/typeclass/Witherable";
+/**
+ * @tsplus type fncts.WitherableWithIndex
+ */
+export interface WitherableWithIndex<F extends HKT, FC = HKT.None> extends FilterableWithIndex<F, FC>, TraversableWithIndex<F, FC>, Witherable<F, FC> {
+    readonly witherWithIndex_: witherWithIndex_<F, FC>;
+    readonly witherWithIndex: witherWithIndex<F, FC>;
+    readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
+    readonly wiltWithIndex: wiltWithIndex<F, FC>;
+}
+/**
+ * @tsplus type fncts.WitherableWithIndexOps
+ */
+export interface WitherableWithIndexOps {
+}
+export declare const WitherableWithIndex: WitherableWithIndexOps;
+export declare type WitherableWithIndexMin<F extends HKT, FC = HKT.None> = FilterableWithIndexMin<F, FC> & TraversableWithIndexMin<F, FC> & WitherableMin<F, FC> & {
+    readonly witherWithIndex_: witherWithIndex_<F, FC>;
+    readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
+};
+/**
+ * @tsplus static fncts.WitherableWithIndexOps __call
+ * @tsplus location "@fncts/base/typeclass/WitherableWithIndex"
+ */
+export declare function mkWitherableWithIndex<F extends HKT, FC = HKT.None>(F: WitherableWithIndexMin<F, FC>): WitherableWithIndex<F, FC>;
+export interface witherWithIndex<F extends HKT, FC = HKT.None> {
+    <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, KF>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>) => <QF, WF, XF, IF, SF, RF, EF>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+export interface witherWithIndex_<F extends HKT, FC = HKT.None> {
+    <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+export interface witherWithIndexSelf<F extends HKT, FC = HKT.None> {
+    <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+export declare function mkWitherWithIndex<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+}) => (G: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>) => witherWithIndex<F, FC>;
+export declare function mkWitherWithIndex_<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+}) => (G: Applicative<HKT.F<G>>) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>) => witherWithIndex_<F, FC>;
+export interface wiltWithIndex<F extends HKT, FC = HKT.None> {
+    <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2, KF>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>) => <QF, WF, XF, IF, SF, RF, EF>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]>;
+}
+export interface wiltWithIndex_<F extends HKT, FC = HKT.None> {
+    <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]>;
+}
+export interface wiltWithIndexSelf<F extends HKT, FC = HKT.None> {
+    <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B1, B2>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B1, B2>>) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]>;
+}
+export declare function mkWiltWithIndex<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2, G>(_: {
+    A: A;
+    B: B;
+    B2: B2;
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+}) => (G: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B, B2>>) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => HKT.FK1<G, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]>) => wiltWithIndex<F, FC>;
+export declare function mkWiltWithIndex_<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B1, B2, G>(_: {
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+    A: A;
+    B: B1;
+    B2: B2;
+}) => (G: Applicative<HKT.F<G>>) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B1, B2>>) => HKT.FK1<G, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]>) => wiltWithIndex_<F, FC>;
+export interface FilterWithIndexAFn_<F extends HKT, CF = HKT.None> {
+    <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <KF, QF, WF, XF, IF, SF, RF, EF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>, p: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+}
+export declare function filterWithIndexAF_<F extends HKT, CF = HKT.None>(F: WitherableWithIndexMin<F, CF>): FilterWithIndexAFn_<F, CF>;
+export interface filterWithIndexA<F extends HKT, CF = HKT.None> {
+    <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <KF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(p: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>) => <QF, WF, XF, IF, SF, RF, EF>(fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+}
+export declare function filterWithIndexAF<F extends HKT, CF = HKT.None>(F: WitherableWithIndexMin<F, CF>): filterWithIndexA<F, CF>;

package/typeclass/builtin/Symbol.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    /**
+     * @tsplus type fncts.builtin.SymbolOps
+     */
+    export interface SymbolConstructor {
+    }
+}
+export {};

package/typeclass/builtin.d.ts

@@ -0,0 +1 @@
+export * from "./builtin/Symbol.js";

package/typeclass.d.ts

@@ -0,0 +1,36 @@
+export * from "./typeclass/Align.js";
+export * from "./typeclass/Alt.js";
+export * from "./typeclass/Alternative.js";
+export * from "./typeclass/Applicative.js";
+export * from "./typeclass/ApplicativeExcept.js";
+export * from "./typeclass/Apply.js";
+export * from "./typeclass/builtin.js";
+export * from "./typeclass/Chain.js";
+export * from "./typeclass/Closure.js";
+export * from "./typeclass/Eq.js";
+export * from "./typeclass/Equatable.js";
+export * from "./typeclass/Fail.js";
+export * from "./typeclass/Filterable.js";
+export * from "./typeclass/FilterableWithIndex.js";
+export * from "./typeclass/Foldable.js";
+export * from "./typeclass/FoldableWithIndex.js";
+export * from "./typeclass/Functor.js";
+export * from "./typeclass/FunctorWithIndex.js";
+export * from "./typeclass/Has.js";
+export * from "./typeclass/Hash.js";
+export * from "./typeclass/Hashable.js";
+export * from "./typeclass/HashEq.js";
+export * from "./typeclass/Monad.js";
+export * from "./typeclass/MonadExcept.js";
+export * from "./typeclass/Monoid.js";
+export * from "./typeclass/Nil.js";
+export * from "./typeclass/Ord.js";
+export * from "./typeclass/Ordering.js";
+export * from "./typeclass/Pointed.js";
+export * from "./typeclass/Semialign.js";
+export * from "./typeclass/Semigroup.js";
+export * from "./typeclass/Semimonoidal.js";
+export * from "./typeclass/Traversable.js";
+export * from "./typeclass/TraversableWithIndex.js";
+export * from "./typeclass/Witherable.js";
+export * from "./typeclass/WitherableWithIndex.js";

package/types/extractions.d.ts

@@ -0,0 +1,12 @@
+export declare type ExtractContravariantPhantom<A, P extends PropertyKey> = [A] extends [{
+    [K in P]: (_: infer T) => void;
+}] ? T : never;
+export declare type ExtractCovariantPhantom<A, P extends PropertyKey> = [A] extends [{
+    [K in P]: () => infer T;
+}] ? T : never;
+export declare type _W<A> = ExtractCovariantPhantom<A, "_W">;
+export declare type _S1<A> = ExtractContravariantPhantom<A, "_S1">;
+export declare type _S2<A> = ExtractCovariantPhantom<A, "_S2">;
+export declare type _R<A> = ExtractContravariantPhantom<A, "_R">;
+export declare type _E<A> = ExtractCovariantPhantom<A, "_E">;
+export declare type _A<A> = ExtractCovariantPhantom<A, "_A">;

package/types/test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/utility.d.ts

@@ -0,0 +1,8 @@
+export declare type Primitive = string | number | boolean | null | symbol;
+export declare type Constructor<A> = {
+    new (...args: any[]): A;
+};
+export declare type Nullable<A> = A | null | undefined;
+export declare type IsInt<N extends number> = N & (`${N}` extends `${bigint}` ? N : never);
+export interface Spreadable extends Record<PropertyKey, any> {
+}

package/types.d.ts

@@ -0,0 +1,3 @@
+export * from "./types/extractions.js";
+export * from "./types/test.js";
+export * from "./types/utility.js";

package/util/AnsiFormat.d.ts

@@ -0,0 +1,107 @@
+export declare const reset: (s: string) => string, bold: (s: string) => string, dim: (s: string) => string, italic: (s: string) => string, underline: (s: string) => string, blink: (s: string) => string, reversed: (s: string) => string, invisible: (s: string) => string, strikethrough: (s: string) => string, black: (s: string) => string, red: (s: string) => string, green: (s: string) => string, yellow: (s: string) => string, blue: (s: string) => string, magenta: (s: string) => string, cyan: (s: string) => string, white: (s: string) => string, brightBlack: (s: string) => string, brightRed: (s: string) => string, brightGreen: (s: string) => string, brightYellow: (s: string) => string, brightBlue: (s: string) => string, brightMagenta: (s: string) => string, brightCyan: (s: string) => string, brightWhite: (s: string) => string, bgBlack: (s: string) => string, bgRed: (s: string) => string, bgGreen: (s: string) => string, bgYellow: (s: string) => string, bgBlue: (s: string) => string, bgMagenta: (s: string) => string, bgCyan: (s: string) => string, bgWhite: (s: string) => string, bgBrightBlack: (s: string) => string, bgBrightRed: (s: string) => string, bgBrightGreen: (s: string) => string, bgBrightYellow: (s: string) => string, bgBrightBlue: (s: string) => string, bgBrightMagenta: (s: string) => string, bgBrightCyan: (s: string) => string, bgBrightWhite: (s: string) => string;
+export declare function rgb(r: number, g: number, b: number): (s: string) => string;
+export declare function bg_rgb(r: number, g: number, b: number): (s: string) => string;
+/**
+ * Foreground color for ANSI black
+ */
+export declare const BLACK: "\u001B[30m";
+/**
+ * Foreground color for ANSI red
+ */
+export declare const RED: "\u001B[31m";
+/**
+ * Foreground color for ANSI green
+ */
+export declare const GREEN: "\u001B[32m";
+/**
+ * Foreground color for ANSI yellow
+ */
+export declare const YELLOW: "\u001B[33m";
+/**
+ * Foreground color for ANSI blue
+ */
+export declare const BLUE: "\u001B[34m";
+/**
+ * Foreground color for ANSI magenta
+ */
+export declare const MAGENTA: "\u001B[35m";
+/**
+ * Foreground color for ANSI cyan
+ */
+export declare const CYAN: "\u001B[36m";
+/**
+ * Foreground color for ANSI white
+ */
+export declare const WHITE: "\u001B[37m";
+/**
+ * Background color for ANSI black
+ */
+export declare const BLACK_B: "\u001B[40m";
+/**
+ * Background color for ANSI red
+ */
+export declare const RED_B: "\u001B[41m";
+/**
+ * Background color for ANSI green
+ */
+export declare const GREEN_B: "\u001B[42m";
+/**
+ * Background color for ANSI yellow
+ */
+export declare const YELLOW_B: "\u001B[43m";
+/**
+ * Background color for ANSI blue
+ */
+export declare const BLUE_B: "\u001B[44m";
+/**
+ * Background color for ANSI magenta
+ */
+export declare const MAGENTA_B: "\u001B[45m";
+/**
+ * Background color for ANSI cyan
+ */
+export declare const CYAN_B: "\u001B[46m";
+/**
+ * Background color for ANSI white
+ */
+export declare const WHITE_B: "\u001B[47m";
+/**
+ * Reset ANSI styles
+ */
+export declare const RESET: "\u001B[0m";
+/**
+ * ANSI bold
+ */
+export declare const BOLD: "\u001B[1m";
+/**
+ * ANSI underline
+ */
+export declare const UNDERLINE: "\u001B[4m";
+/**
+ * ANSI blink
+ */
+export declare const BLINK: "\u001B[5m";
+/**
+ * ANSI reversed
+ */
+export declare const REVERSED: "\u001B[7m";
+/**
+ * ANSI invisible
+ */
+export declare const INVISIBLE: "\u001B[8m";
+/**
+ * Reset ANSI foreground
+ */
+export declare const RESET_FG: "\u001B[39m";
+/**
+ * Reset ANSI background
+ */
+export declare const RESET_BG: "\u001B[49m";
+/**
+ * ANSI 24bit foreground
+ */
+export declare const RGB: <r extends number, g extends number, b extends number>(r: r, g: g, b: b) => `\u001B[38;2;${r};${g};${b}m`;
+/**
+ * ANSI 24bit background
+ */
+export declare const RGB_B: <r extends number, g extends number, b extends number>(r: r, g: g, b: b) => `\u001B[48;2;${r};${g};${b}m`;

package/util/PCGRandom.d.ts

@@ -0,0 +1,50 @@
+export declare function isNothing<T>(value: T | null | undefined): boolean;
+export declare type PCGRandomState = [number, number, number, number];
+export declare type OptionalNumber = number | null | undefined;
+/**
+ * PCG is a family of simple fast space-efficient statistically good algorithms for random number generation. Unlike
+ * many general-purpose RNGs, they are also hard to predict.
+ */
+export declare class PCGRandom {
+    private _state;
+    /**
+     * Creates an instance of PCGRandom.
+     *
+     * @param {any} seed - The low 32 bits of the seed (0 is used for high 32 bits).
+     *
+     * @memberOf PCGRandom
+     */
+    constructor(seed?: OptionalNumber);
+    /**
+     * Creates an instance of PCGRandom.
+     *
+     * @param {any} seedHi - The high 32 bits of the seed.
+     * @param {any} seedLo - The how 32 bits of the seed.
+     * @param {any} inc - The low 32 bits of the incrementer (0 is used for high 32 bits).
+     *
+     * @memberOf PCGRandom
+     */
+    constructor(seedHi: OptionalNumber, seedLo: OptionalNumber, inc?: OptionalNumber);
+    /**
+     * Creates an instance of PCGRandom.
+     *
+     * @param {any} seedHi - The high 32 bits of the seed.
+     * @param {any} seedLo - The how 32 bits of the seed.
+     * @param {any} incHi - The high 32 bits of the incrementer.
+     * @param {any} incLo - The how 32 bits of the incrementer.
+     *
+     * @memberOf PCGRandom
+     */
+    constructor(seedHi: OptionalNumber, seedLo: OptionalNumber, incHi: OptionalNumber, incLo: OptionalNumber);
+    /**
+     * @returns A copy of the internal state of this random number generator as a JavaScript Array
+     */
+    getState(): PCGRandomState;
+    /**
+     * Restore state previously retrieved using getState()
+     */
+    setState(state: PCGRandomState): void;
+    private _next;
+    integer(max: number): number;
+    number(): number;
+}

package/util/assert.d.ts

@@ -0,0 +1,5 @@
+export declare class AssertionError extends Error {
+    readonly message: string;
+    constructor(message: string);
+}
+export declare function assert(assertion: boolean, message: string): void;

package/util/pattern.d.ts

@@ -0,0 +1,68 @@
+export declare const pattern_: <N extends string>(n: N) => {
+    <X extends {
+        [k in N]: string;
+    }, K extends {
+        [k in X[N]]: (_: Extract<X, {
+            [_tag in N]: k;
+        }>) => any;
+    }>(m: X, _: K): ReturnType<K[keyof K]>;
+    <X extends {
+        [k in N]: string;
+    }, K extends {
+        [k in X[N]]?: (_: Extract<X, {
+            [_tag in N]: k;
+        }>) => any;
+    }, H>(m: X, _: K, __: (_: Exclude<X, {
+        _tag: keyof K;
+    }>) => H): {
+        [k in keyof K]: ReturnType<NonNullable<K[k]>>;
+    }[keyof K] | H;
+};
+export declare const pattern: <N extends string>(n: N) => {
+    <X extends {
+        [k in N]: string;
+    }, K extends {
+        [k in X[N]]: (_: Extract<X, {
+            [_tag in N]: k;
+        }>) => any;
+    }>(_: K): (m: X) => ReturnType<K[keyof K]>;
+    <X extends {
+        [k in N]: string;
+    }, K extends {
+        [k in X[N]]?: (_: Extract<X, {
+            [_tag in N]: k;
+        }>) => any;
+    }, H>(_: K, __: (_: Exclude<X, {
+        _tag: keyof K;
+    }>) => H): (m: X) => {
+        [k in keyof K]: ReturnType<NonNullable<K[k]>>;
+    }[keyof K] | H;
+};
+export declare const matchTag_: {
+    <X extends {
+        _tag: string;
+    }, K extends { [k in X["_tag"]]: (_: Extract<X, {
+        _tag: k;
+    }>) => any; }>(m: X, _: K): ReturnType<K[keyof K]>;
+    <X_1 extends {
+        _tag: string;
+    }, K_1 extends { [k_1 in X_1["_tag"]]?: ((_: Extract<X_1, {
+        _tag: k_1;
+    }>) => any) | undefined; }, H>(m: X_1, _: K_1, __: (_: Exclude<X_1, {
+        _tag: keyof K_1;
+    }>) => H): H | { [k_2 in keyof K_1]: ReturnType<NonNullable<K_1[k_2]>>; }[keyof K_1];
+};
+export declare const matchTag: {
+    <X extends {
+        _tag: string;
+    }, K extends { [k in X["_tag"]]: (_: Extract<X, {
+        _tag: k;
+    }>) => any; }>(_: K): (m: X) => ReturnType<K[keyof K]>;
+    <X_1 extends {
+        _tag: string;
+    }, K_1 extends { [k_1 in X_1["_tag"]]?: ((_: Extract<X_1, {
+        _tag: k_1;
+    }>) => any) | undefined; }, H>(_: K_1, __: (_: Exclude<X_1, {
+        _tag: keyof K_1;
+    }>) => H): (m: X_1) => H | { [k_2 in keyof K_1]: ReturnType<NonNullable<K_1[k_2]>>; }[keyof K_1];
+};

package/util/predicates.d.ts

@@ -0,0 +1,36 @@
+import type { Constructor, Primitive } from "@fncts/base/types";
+export declare function isDefined<A>(value: A | undefined): value is A;
+export declare function isUndefined<A>(value: A | undefined): value is undefined;
+export declare function isNonNull<A>(value: A | null): value is A;
+export declare function isNull<A>(value: A | null): value is null;
+export declare function isNonNullable<A>(value: A | null | undefined): value is A;
+export declare function isNullable<A>(value: A | null | undefined): value is null | undefined;
+export declare function isIterable<A>(value: unknown): value is Iterable<A>;
+export declare function isArray<A>(value: A | Array<A> | ReadonlyArray<A>): value is Array<A>;
+export declare function isArray<A>(value: unknown): value is Array<A>;
+export declare function isObject<A extends Function>(value: A): false;
+export declare function isObject(value: unknown): value is object & Record<PropertyKey, any>;
+export declare function isObject<A>(value: A | Primitive): value is A & Record<PropertyKey, unknown>;
+export declare function hasTypeId<X extends symbol>(value: unknown, typeId: X): value is {
+    readonly _typeId: X;
+} & Record<PropertyKey, unknown>;
+export declare function isFunction(value: unknown): value is Function;
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function isByte(n: unknown): n is number;
+export declare function isSymbol(value: unknown): value is symbol;
+export declare function isPlain(value: unknown): value is object;
+export declare function isInstanceOf<C extends Constructor<A>, A>(type: C): (value: unknown) => value is A;
+export declare function isMap(u: unknown): u is Map<unknown, unknown>;
+export declare function isWeakMap(u: unknown): u is WeakMap<object, unknown>;
+export declare function isPromise(u: unknown): u is Promise<unknown>;
+export declare function isSet(u: unknown): u is Set<unknown>;
+export declare function isWeakSet(u: unknown): u is WeakSet<object>;
+export declare function isDate(u: unknown): u is Date;
+export declare type TypedArray = BigInt64Array | BigUint64Array | Float64Array | Float32Array | Int32Array | Int16Array | Int8Array | Uint32Array | Uint16Array | Uint8Array | Uint8ClampedArray;
+export declare function isTypedArray(u: unknown): u is TypedArray;
+export declare function isRegExp(u: unknown): u is RegExp;
+export declare function isAnyArrayBuffer(u: unknown): u is ArrayBuffer | SharedArrayBuffer;
+export declare function isArrayBuffer(u: unknown): u is ArrayBuffer;
+export declare function isDataView(u: unknown): u is DataView;

package/util/rand/Random.d.ts

@@ -0,0 +1,69 @@
+import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
+/**
+ * Wrapper around an instance of a `pure-rand`'s random number generator
+ * offering a simpler interface to deal with random with impure patterns
+ *
+ * @public
+ */
+export declare class MutableRandom {
+    private internalRng;
+    private static MIN_INT;
+    private static MAX_INT;
+    private static DBL_FACTOR;
+    private static DBL_DIVISOR;
+    /**
+     * Create a mutable random number generator
+     * @param internalRng - Immutable random generator from pure-rand library
+     */
+    constructor(internalRng: RandomGenerator);
+    /**
+     * Clone the random number generator
+     */
+    clone(): MutableRandom;
+    private uniformIn;
+    /**
+     * Generate an integer having `bits` random bits
+     * @param bits - Number of bits to generate
+     */
+    next(bits: number): number;
+    /**
+     * Generate a random boolean
+     */
+    nextBoolean(): boolean;
+    /**
+     * Generate a random integer (32 bits)
+     */
+    nextInt(): number;
+    /**
+     * Generate a random integer between min (included) and max (included)
+     * @param min - Minimal integer value
+     * @param max - Maximal integer value
+     */
+    nextInt(min: number, max: number): number;
+    /**
+     * Generate a random bigint between min (included) and max (included)
+     * @param min - Minimal bigint value
+     * @param max - Maximal bigint value
+     */
+    nextBigInt(min: bigint, max: bigint): bigint;
+    /**
+     * Generate a random ArrayInt between min (included) and max (included)
+     * @param min - Minimal ArrayInt value
+     * @param max - Maximal ArrayInt value
+     */
+    nextArrayInt(min: {
+        sign: 1 | -1;
+        data: number[];
+    }, max: {
+        sign: 1 | -1;
+        data: number[];
+    }): {
+        sign: 1 | -1;
+        data: number[];
+    };
+    /**
+     * Generate a random floating point number between 0.0 (included) and 1.0 (excluded)
+     */
+    nextDouble(): number;
+    setSeed(seed: number): void;
+}

package/util/rand/distribution/Distribution.d.ts

@@ -0,0 +1,9 @@
+import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
+/**
+ * Generate random value based on a given RandomGenerator.
+ * Return the generated value and an offsetted version of the RandomGenerator.
+ * @public
+ */
+declare type Distribution<T> = (rng: RandomGenerator) => T;
+export default Distribution;
+export { Distribution };

package/util/rand/distribution/UniformArrayIntDistribution.d.ts

@@ -0,0 +1,23 @@
+import type Distribution from "@fncts/base/util/rand/distribution/Distribution";
+import type { ArrayInt } from "@fncts/base/util/rand/distribution/internals/ArrayInt";
+import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
+/**
+ * Uniformly generate random ArrayInt values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ *
+ * @public
+ */
+declare function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt): Distribution<ArrayInt>;
+/**
+ * Uniformly generate random ArrayInt values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ * @param rng - Instance of RandomGenerator to extract random values from
+ *
+ * @public
+ */
+declare function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt, rng: RandomGenerator): ArrayInt;
+export { uniformArrayIntDistribution };

package/util/rand/distribution/UniformBigIntDistribution.d.ts

@@ -0,0 +1,22 @@
+import type Distribution from "@fncts/base/util/rand/distribution/Distribution";
+import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
+/**
+ * Uniformly generate random bigint values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ *
+ * @public
+ */
+declare function uniformBigIntDistribution(from: bigint, to: bigint): Distribution<bigint>;
+/**
+ * Uniformly generate random bigint values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ * @param rng - Instance of RandomGenerator to extract random values from
+ *
+ * @public
+ */
+declare function uniformBigIntDistribution(from: bigint, to: bigint, rng: RandomGenerator): bigint;
+export { uniformBigIntDistribution };

package/util/rand/distribution/UniformIntDistribution.d.ts

@@ -0,0 +1,22 @@
+import type Distribution from "@fncts/base/util/rand/distribution/Distribution";
+import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
+/**
+ * Uniformly generate random integer values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ *
+ * @public
+ */
+declare function uniformIntDistribution(from: number, to: number): Distribution<number>;
+/**
+ * Uniformly generate random integer values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ * @param rng - Instance of RandomGenerator to extract random values from
+ *
+ * @public
+ */
+declare function uniformIntDistribution(from: number, to: number, rng: RandomGenerator): number;
+export { uniformIntDistribution };