@fncts/typelevel 0.0.1

package/Any.d.ts

@@ -0,0 +1,48 @@
+import type { Boolean, False, True } from "./Boolean.js";
+import type { BuiltIn } from "./BuiltIn.js";
+import type { List } from "./List.js";
+import type { Has } from "./Union.js";
+export declare type Cast<A, B> = A extends B ? A : B;
+export declare type Try<A1, A2, Catch = never> = A1 extends A2 ? A1 : Catch;
+export declare type Extends<A, B> = [A] extends [never] ? False : A extends B ? True : False;
+export declare type Contains<A, B> = Extends<A, B> extends True ? True : False;
+export declare type Equals<A, B> = (<X>() => X extends B ? True : False) extends <X>() => X extends A ? True : False ? True : False;
+export declare type If<B extends Boolean, Then, Else = never> = B extends True ? Then : Else;
+export declare type Match = "default" | "extends->" | "contains->" | "equals" | "<-extends" | "<-contains";
+export declare type Is<A, B, _ extends Match> = {
+    default: Extends<A, B>;
+    "extends->": Extends<A, B>;
+    "contains->": Contains<A, B>;
+    "<-extends": Extends<B, A>;
+    "<-contains": Contains<B, A>;
+    equals: Equals<A, B>;
+}[_];
+export declare type Key = string | number | symbol;
+export declare type Literal = string | number | bigint | boolean;
+export declare type Keys<A> = A extends List ? Exclude<keyof A, keyof any[]> | number : keyof A;
+export declare type KnownKeys<A> = {
+    [K in keyof A]: string extends K ? never : number extends K ? never : K;
+} extends {
+    [K in keyof A]: infer U;
+} ? U & Keys<A> : never;
+export declare type ComputeRaw<A> = A extends Function ? A : {
+    [K in keyof A]: A[K];
+} & unknown;
+export declare type ComputeFlat<A> = A extends BuiltIn ? A : A extends Array<any> ? A extends Array<Record<Key, any>> ? Array<{
+    [K in keyof A[number]]: A[number][K];
+} & unknown> : A : A extends ReadonlyArray<any> ? A extends ReadonlyArray<Record<Key, any>> ? ReadonlyArray<{
+    [K in keyof A[number]]: A[number][K];
+} & unknown> : A : {
+    [K in keyof A]: A[K];
+} & unknown;
+export declare type ComputeDeep<A, Seen = never> = A extends BuiltIn ? A : {
+    [False]: A extends Array<any> ? A extends Array<Record<Key, any>> ? Array<{
+        [K in keyof A[number]]: ComputeDeep<A[number][K], A | Seen>;
+    } & unknown> : A : A extends ReadonlyArray<any> ? A extends ReadonlyArray<Record<Key, any>> ? ReadonlyArray<{
+        [K in keyof A[number]]: ComputeDeep<A[number][K], A | Seen>;
+    } & unknown> : A : {
+        [K in keyof A]: ComputeDeep<A[K], A | Seen>;
+    } & unknown;
+    [True]: A;
+}[Has<Seen, A>];
+export declare type At<A, K extends Key> = A extends List ? number extends A["length"] ? K extends number | `${number}` ? A[never] | undefined : undefined : K extends keyof A ? A[K] : undefined : unknown extends A ? unknown : K extends keyof A ? A[K] : undefined;

package/Boolean.d.ts

@@ -0,0 +1,39 @@
+export declare const False: unique symbol;
+export declare const True: unique symbol;
+export declare type False = typeof False;
+export declare type True = typeof True;
+export declare type Boolean = True | False;
+export declare type Or<B1 extends Boolean, B2 extends Boolean> = {
+    [False]: {
+        [False]: False;
+        [True]: True;
+    };
+    [True]: {
+        [False]: True;
+        [True]: True;
+    };
+}[B1][B2];
+export declare type And<B1 extends Boolean, B2 extends Boolean> = {
+    [False]: {
+        [False]: False;
+        [True]: False;
+    };
+    [True]: {
+        [False]: False;
+        [True]: True;
+    };
+}[B1][B2];
+export declare type Xor<B1 extends Boolean, B2 extends Boolean> = {
+    [False]: {
+        [False]: False;
+        [True]: True;
+    };
+    [True]: {
+        [False]: True;
+        [True]: False;
+    };
+}[B1][B2];
+export declare type Not<B extends Boolean> = {
+    [False]: True;
+    [True]: False;
+}[B];

package/BuiltIn.d.ts

@@ -0,0 +1,3 @@
+export declare type BuiltIn = Function | Error | Date | {
+    readonly [Symbol.toStringTag]: string;
+} | RegExp | Generator;

package/Check.d.ts

@@ -0,0 +1,70 @@
+import type { False, True } from "./Boolean.js";
+import type * as Union from "./Union.js";
+declare type EqualsWrapped<T> = T extends infer R & {} ? {
+    [P in keyof R]: R[P];
+} : never;
+/**
+ * @tsplus type fncts.Check
+ */
+export declare type Check<Condition> = [Condition] extends [never] ? Check.False : Check.True;
+export declare namespace Check {
+    /**
+     * @tsplus type fncts.Check.True
+     */
+    type True = typeof True;
+    /**
+     * @tsplus type fncts.Check.False
+     */
+    type False = typeof False;
+    /**
+     * @tsplus type fncts.Check.Result
+     */
+    type Result = True | False;
+    /**
+     * @tsplus type fncts.Check.Not
+     */
+    type Not<A> = [A] extends [never] ? unknown : never;
+    /**
+     * @tsplus type fncts.Check.Extends
+     */
+    type Extends<A, B> = [A] extends [never] ? never : [A] extends [B] ? unknown : never;
+    /**
+     * @tsplus type fncts.Check.IsUnion
+     */
+    type IsUnion<T> = [T] extends [Union.IntersectionOf<T>] ? never : unknown;
+    /**
+     * @tsplus type fncts.Check.IsEqual
+     */
+    type IsEqual<A, B> = (<T>() => T extends EqualsWrapped<A> ? 1 : 2) extends <T>() => T extends EqualsWrapped<B> ? 1 : 2 ? unknown : never;
+    /**
+     * @tsplus type fncts.Check.IsLiteral
+     */
+    type IsLiteral<A extends string | number> = Not<Extends<string, A> | Extends<number, A>>;
+    /**
+     * @tsplus type fncts.Check.IsStruct
+     */
+    type IsStruct<A> = Extends<keyof A, string> & Not<IsUnion<A>>;
+    /**
+     * @tsplus type fncts.Check.HaveSameLength
+     */
+    type HaveSameLength<A extends {
+        length: number;
+    }, B extends {
+        length: number;
+    }> = IsEqual<A["length"], B["length"]>;
+    /**
+     * @tsplus type fncts.Check.IsTagged
+     */
+    type IsTagged<Tag extends PropertyKey, A extends {
+        [k in Tag]: string;
+    }> = IsUnion<A[Tag]> & IsUnion<A> & HaveSameLength<Union.ListOf<A[Tag]>, Union.ListOf<A>>;
+    /**
+     * @tsplus type fncts.Check.If
+     */
+    type If<B, Then, Else = never> = B extends never ? Else : Then;
+    /**
+     * @tsplus type fncts.Check.Or
+     */
+    type Or<A, B> = A extends never ? B : A;
+}
+export {};

package/Function.d.ts

@@ -0,0 +1,11 @@
+import type { Try } from "@fncts/typelevel/Any";
+export declare type Narrowable = string | number | boolean | bigint;
+export declare type Exact<A, B> = B extends unknown ? A extends B ? A extends Narrowable ? A : {
+    [K in keyof A]: K extends keyof B ? Exact<A[K], B[K]> : never;
+} : B : never;
+export declare type NoInfer<A> = [A][A extends any ? 0 : never];
+declare type NarrowRaw<A> = (A extends [] ? [] : never) | (A extends Narrowable ? A : never) | {
+    [K in keyof A]: A[K] extends Function ? A[K] : NarrowRaw<A[K]>;
+};
+export declare type Narrow<A> = Try<A, [], NarrowRaw<A>>;
+export {};

package/HKT.d.ts

@@ -0,0 +1,186 @@
+import type * as Union from "./Union.js";
+export interface HKT {
+    readonly K?: unknown;
+    readonly Q?: unknown;
+    readonly W?: unknown;
+    readonly X?: unknown;
+    readonly I?: unknown;
+    readonly S?: unknown;
+    readonly R?: unknown;
+    readonly E?: unknown;
+    readonly A?: unknown;
+    readonly type?: unknown;
+    readonly index?: unknown;
+    readonly variance: {
+        readonly K?: HKT.Variance;
+        readonly Q?: HKT.Variance;
+        readonly W?: HKT.Variance;
+        readonly X?: HKT.Variance;
+        readonly I?: HKT.Variance;
+        readonly S?: HKT.Variance;
+        readonly R?: HKT.Variance;
+        readonly E?: HKT.Variance;
+        readonly A?: HKT.Variance;
+    };
+}
+export declare namespace HKT {
+    const URI: unique symbol;
+    const CURI: unique symbol;
+    export type Variance = "-" | "+" | "_";
+    export type VarianceOf<F extends HKT, N extends ParamName> = F["variance"][N];
+    export type CovariantE = HKT & {
+        readonly variance: {
+            E: "+";
+        };
+    };
+    export type ContravariantR = HKT & {
+        readonly variance: {
+            R: "-";
+        };
+    };
+    export interface Typeclass<F extends HKT, C = None> {
+        readonly [URI]: F;
+        readonly [CURI]: C;
+    }
+    export interface Typeclass2<F extends HKT, G extends HKT, C = None, D = None> {
+        readonly _F: F;
+        readonly _G: G;
+        readonly _CF: C;
+        readonly _CG: D;
+    }
+    export interface Compose2<F extends HKT, G extends HKT, C = None, D = None> extends HKT {
+        readonly type: Kind<F, C, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], Kind<G, D, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>>;
+    }
+    export interface FK<F, K, Q, W, X, I, S, R, E, A> {
+        readonly _F: F;
+        readonly _K: K;
+        readonly _Q: Q;
+        readonly _W: W;
+        readonly _X: X;
+        readonly _I: I;
+        readonly _S: S;
+        readonly _R: R;
+        readonly _E: E;
+        readonly _A: A;
+    }
+    export interface FK1<F, A> {
+        readonly _F: F;
+        readonly _K: unknown;
+        readonly _Q: unknown;
+        readonly _W: unknown;
+        readonly _X: unknown;
+        readonly _I: unknown;
+        readonly _S: unknown;
+        readonly _R: unknown;
+        readonly _E: unknown;
+        readonly _A: A;
+    }
+    export interface F<F> extends HKT {
+        readonly type: FK<F, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>;
+        readonly variance: {
+            readonly K: "_";
+            readonly Q: "_";
+            readonly W: "_";
+            readonly X: "_";
+            readonly I: "_";
+            readonly S: "_";
+            readonly R: "_";
+            readonly E: "_";
+            readonly A: "_";
+        };
+    }
+    export interface FCoE<F> extends HKT {
+        readonly type: FK<F, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>;
+        readonly variance: {
+            readonly K: "_";
+            readonly Q: "_";
+            readonly W: "_";
+            readonly X: "_";
+            readonly I: "_";
+            readonly S: "_";
+            readonly R: "_";
+            readonly E: "+";
+            readonly A: "_";
+        };
+    }
+    export interface FContraR<F> extends HKT {
+        readonly type: FK<F, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>;
+        readonly variance: {
+            readonly K: "_";
+            readonly Q: "_";
+            readonly W: "_";
+            readonly X: "_";
+            readonly I: "_";
+            readonly S: "_";
+            readonly R: "-";
+            readonly E: "_";
+            readonly A: "_";
+        };
+    }
+    export type ParamName = "K" | "Q" | "W" | "X" | "I" | "S" | "R" | "E" | "A";
+    export type Kind<F extends HKT, C, K, Q, W, X, I, S, R, E, A> = F extends {
+        readonly type: unknown;
+    } ? (F & {
+        readonly K: OrFix<C, "K", K>;
+        readonly Q: OrFix<C, "Q", Q>;
+        readonly W: OrFix<C, "W", W>;
+        readonly X: OrFix<C, "X", X>;
+        readonly I: OrFix<C, "I", I>;
+        readonly S: OrFix<C, "S", S>;
+        readonly R: OrFix<C, "R", R>;
+        readonly E: OrFix<C, "E", E>;
+        readonly A: A;
+    })["type"] : FK<F, K, Q, W, X, I, S, R, E, A>;
+    export type Infer<F extends HKT, C, N extends ParamName | "C", K> = [K] extends [
+        Kind<F, C, infer K, infer Q, infer W, infer X, infer I, infer S, infer R, infer E, infer A>
+    ] ? N extends "C" ? C : N extends "K" ? K : N extends "Q" ? Q : N extends "W" ? W : N extends "X" ? X : N extends "I" ? I : N extends "S" ? S : N extends "R" ? R : N extends "E" ? E : N extends "A" ? A : never : never;
+    export interface Lows {
+        "-": unknown;
+        "+": never;
+        _: any;
+    }
+    export type Low<F extends HKT, N extends ParamName> = F["variance"][N] extends Variance ? Lows[F["variance"][N]] : never;
+    export interface Mixes<P extends ReadonlyArray<unknown>> {
+        "-": P extends [any] ? P[0] : P extends [any, any] ? P[0] & P[1] : P extends [any, any, any] ? P[0] & P[1] & P[2] : P extends [any, any, any, any] ? P[0] & P[1] & P[2] & P[3] : P extends [any, any, any, any, any] ? P[0] & P[1] & P[2] & P[3] & P[4] : Union.IntersectionOf<P[number]>;
+        "+": P[number];
+        _: P[0];
+    }
+    export type Mix<F extends HKT, N extends ParamName, P extends ReadonlyArray<unknown>> = F["variance"][N] extends Variance ? Mixes<P>[F["variance"][N]] : P[0];
+    export type OrNever<K> = unknown extends K ? never : K;
+    export type MixStruct<F extends HKT, N extends ParamName, X, Y> = F["variance"][N] extends "_" ? X : F["variance"][N] extends "+" ? Y[keyof Y] : F["variance"][N] extends "-" ? Union.IntersectionOf<{
+        [k in keyof Y]: OrNever<Y[k]>;
+    }[keyof Y]> : X;
+    export interface Intros<A, B> {
+        "-": B;
+        "+": B;
+        _: A;
+    }
+    export type Intro<F extends HKT, N extends ParamName, A, B> = F["variance"][N] extends Variance ? Intros<A, B>[F["variance"][N]] : A;
+    /**
+     * Type parameter constraint
+     */
+    export type None = {};
+    const Fix: unique symbol;
+    export interface Fix<N extends ParamName, A> {
+        [Fix]: {
+            [K in N]: () => A;
+        };
+    }
+    const Extend: unique symbol;
+    export interface Extend<N extends ParamName, A> {
+        [Extend]: {
+            [K in N]: () => A;
+        };
+    }
+    export type OrFix<C, N extends ParamName, A> = C extends Fix<N, infer X> ? X : A;
+    export type OrExtend<C, N extends ParamName, A> = C extends Extend<N, infer X> ? A extends X ? A : X : A;
+    export type GetExtends<C, N extends ParamName, A> = C extends Extend<N, infer X> ? X : A;
+    export type IndexFor<F extends HKT, K> = F extends {
+        readonly index: unknown;
+    } ? F["index"] : K;
+    /**
+     * @tsplus macro identity
+     */
+    export function instance<F>(_: Omit<F, typeof URI | typeof CURI | "_F" | "_G" | "_CF" | "_CG">): F;
+    export {};
+}

package/Intersection.d.ts

@@ -0,0 +1 @@
+export declare type Erase<A, B> = A & B extends B & infer C ? C : A;

package/Iteration.d.ts

@@ -0,0 +1,216 @@
+export declare type Iteration = [
+    value: number,
+    sign: "-" | "0" | "+",
+    prev: keyof IterationMap,
+    next: keyof IterationMap,
+    oppo: keyof IterationMap
+];
+export declare type IterationMap = {
+    __: [number, "-" | "0" | "+", "__", "__", "__"];
+    "-100": [-100, "-", "__", "-99", "100"];
+    "-99": [-99, "-", "-100", "-98", "99"];
+    "-98": [-98, "-", "-99", "-97", "98"];
+    "-97": [-97, "-", "-98", "-96", "97"];
+    "-96": [-96, "-", "-97", "-95", "96"];
+    "-95": [-95, "-", "-96", "-94", "95"];
+    "-94": [-94, "-", "-95", "-93", "94"];
+    "-93": [-93, "-", "-94", "-92", "93"];
+    "-92": [-92, "-", "-93", "-91", "92"];
+    "-91": [-91, "-", "-92", "-90", "91"];
+    "-90": [-90, "-", "-91", "-89", "90"];
+    "-89": [-89, "-", "-90", "-88", "89"];
+    "-88": [-88, "-", "-89", "-87", "88"];
+    "-87": [-87, "-", "-88", "-86", "87"];
+    "-86": [-86, "-", "-87", "-85", "86"];
+    "-85": [-85, "-", "-86", "-84", "85"];
+    "-84": [-84, "-", "-85", "-83", "84"];
+    "-83": [-83, "-", "-84", "-82", "83"];
+    "-82": [-82, "-", "-83", "-81", "82"];
+    "-81": [-81, "-", "-82", "-80", "81"];
+    "-80": [-80, "-", "-81", "-79", "80"];
+    "-79": [-79, "-", "-80", "-78", "79"];
+    "-78": [-78, "-", "-79", "-77", "78"];
+    "-77": [-77, "-", "-78", "-76", "77"];
+    "-76": [-76, "-", "-77", "-75", "76"];
+    "-75": [-75, "-", "-76", "-74", "75"];
+    "-74": [-74, "-", "-75", "-73", "74"];
+    "-73": [-73, "-", "-74", "-72", "73"];
+    "-72": [-72, "-", "-73", "-71", "72"];
+    "-71": [-71, "-", "-72", "-70", "71"];
+    "-70": [-70, "-", "-71", "-69", "70"];
+    "-69": [-69, "-", "-70", "-68", "69"];
+    "-68": [-68, "-", "-69", "-67", "68"];
+    "-67": [-67, "-", "-68", "-66", "67"];
+    "-66": [-66, "-", "-67", "-65", "66"];
+    "-65": [-65, "-", "-66", "-64", "65"];
+    "-64": [-64, "-", "-65", "-63", "64"];
+    "-63": [-63, "-", "-64", "-62", "63"];
+    "-62": [-62, "-", "-63", "-61", "62"];
+    "-61": [-61, "-", "-62", "-60", "61"];
+    "-60": [-60, "-", "-61", "-59", "60"];
+    "-59": [-59, "-", "-60", "-58", "59"];
+    "-58": [-58, "-", "-59", "-57", "58"];
+    "-57": [-57, "-", "-58", "-56", "57"];
+    "-56": [-56, "-", "-57", "-55", "56"];
+    "-55": [-55, "-", "-56", "-54", "55"];
+    "-54": [-54, "-", "-55", "-53", "54"];
+    "-53": [-53, "-", "-54", "-52", "53"];
+    "-52": [-52, "-", "-53", "-51", "52"];
+    "-51": [-51, "-", "-52", "-50", "51"];
+    "-50": [-50, "-", "-51", "-49", "50"];
+    "-49": [-49, "-", "-50", "-48", "49"];
+    "-48": [-48, "-", "-49", "-47", "48"];
+    "-47": [-47, "-", "-48", "-46", "47"];
+    "-46": [-46, "-", "-47", "-45", "46"];
+    "-45": [-45, "-", "-46", "-44", "45"];
+    "-44": [-44, "-", "-45", "-43", "44"];
+    "-43": [-43, "-", "-44", "-42", "43"];
+    "-42": [-42, "-", "-43", "-41", "42"];
+    "-41": [-41, "-", "-42", "-40", "41"];
+    "-40": [-40, "-", "-41", "-39", "40"];
+    "-39": [-39, "-", "-40", "-38", "39"];
+    "-38": [-38, "-", "-39", "-37", "38"];
+    "-37": [-37, "-", "-38", "-36", "37"];
+    "-36": [-36, "-", "-37", "-35", "36"];
+    "-35": [-35, "-", "-36", "-34", "35"];
+    "-34": [-34, "-", "-35", "-33", "34"];
+    "-33": [-33, "-", "-34", "-32", "33"];
+    "-32": [-32, "-", "-33", "-31", "32"];
+    "-31": [-31, "-", "-32", "-30", "31"];
+    "-30": [-30, "-", "-31", "-29", "30"];
+    "-29": [-29, "-", "-30", "-28", "29"];
+    "-28": [-28, "-", "-29", "-27", "28"];
+    "-27": [-27, "-", "-28", "-26", "27"];
+    "-26": [-26, "-", "-27", "-25", "26"];
+    "-25": [-25, "-", "-26", "-24", "25"];
+    "-24": [-24, "-", "-25", "-23", "24"];
+    "-23": [-23, "-", "-24", "-22", "23"];
+    "-22": [-22, "-", "-23", "-21", "22"];
+    "-21": [-21, "-", "-22", "-20", "21"];
+    "-20": [-20, "-", "-21", "-19", "20"];
+    "-19": [-19, "-", "-20", "-18", "19"];
+    "-18": [-18, "-", "-19", "-17", "18"];
+    "-17": [-17, "-", "-18", "-16", "17"];
+    "-16": [-16, "-", "-17", "-15", "16"];
+    "-15": [-15, "-", "-16", "-14", "15"];
+    "-14": [-14, "-", "-15", "-13", "14"];
+    "-13": [-13, "-", "-14", "-12", "13"];
+    "-12": [-12, "-", "-13", "-11", "12"];
+    "-11": [-11, "-", "-12", "-10", "11"];
+    "-10": [-10, "-", "-11", "-9", "10"];
+    "-9": [-9, "-", "-10", "-8", "9"];
+    "-8": [-8, "-", "-9", "-7", "8"];
+    "-7": [-7, "-", "-8", "-6", "7"];
+    "-6": [-6, "-", "-7", "-5", "6"];
+    "-5": [-5, "-", "-6", "-4", "5"];
+    "-4": [-4, "-", "-5", "-3", "4"];
+    "-3": [-3, "-", "-4", "-2", "3"];
+    "-2": [-2, "-", "-3", "-1", "2"];
+    "-1": [-1, "-", "-2", "0", "1"];
+    "0": [0, "0", "-1", "1", "0"];
+    "1": [1, "+", "0", "2", "-1"];
+    "2": [2, "+", "1", "3", "-2"];
+    "3": [3, "+", "2", "4", "-3"];
+    "4": [4, "+", "3", "5", "-4"];
+    "5": [5, "+", "4", "6", "-5"];
+    "6": [6, "+", "5", "7", "-6"];
+    "7": [7, "+", "6", "8", "-7"];
+    "8": [8, "+", "7", "9", "-8"];
+    "9": [9, "+", "8", "10", "-9"];
+    "10": [10, "+", "9", "11", "-10"];
+    "11": [11, "+", "10", "12", "-11"];
+    "12": [12, "+", "11", "13", "-12"];
+    "13": [13, "+", "12", "14", "-13"];
+    "14": [14, "+", "13", "15", "-14"];
+    "15": [15, "+", "14", "16", "-15"];
+    "16": [16, "+", "15", "17", "-16"];
+    "17": [17, "+", "16", "18", "-17"];
+    "18": [18, "+", "17", "19", "-18"];
+    "19": [19, "+", "18", "20", "-19"];
+    "20": [20, "+", "19", "21", "-20"];
+    "21": [21, "+", "20", "22", "-21"];
+    "22": [22, "+", "21", "23", "-22"];
+    "23": [23, "+", "22", "24", "-23"];
+    "24": [24, "+", "23", "25", "-24"];
+    "25": [25, "+", "24", "26", "-25"];
+    "26": [26, "+", "25", "27", "-26"];
+    "27": [27, "+", "26", "28", "-27"];
+    "28": [28, "+", "27", "29", "-28"];
+    "29": [29, "+", "28", "30", "-29"];
+    "30": [30, "+", "29", "31", "-30"];
+    "31": [31, "+", "30", "32", "-31"];
+    "32": [32, "+", "31", "33", "-32"];
+    "33": [33, "+", "32", "34", "-33"];
+    "34": [34, "+", "33", "35", "-34"];
+    "35": [35, "+", "34", "36", "-35"];
+    "36": [36, "+", "35", "37", "-36"];
+    "37": [37, "+", "36", "38", "-37"];
+    "38": [38, "+", "37", "39", "-38"];
+    "39": [39, "+", "38", "40", "-39"];
+    "40": [40, "+", "39", "41", "-40"];
+    "41": [41, "+", "40", "42", "-41"];
+    "42": [42, "+", "41", "43", "-42"];
+    "43": [43, "+", "42", "44", "-43"];
+    "44": [44, "+", "43", "45", "-44"];
+    "45": [45, "+", "44", "46", "-45"];
+    "46": [46, "+", "45", "47", "-46"];
+    "47": [47, "+", "46", "48", "-47"];
+    "48": [48, "+", "47", "49", "-48"];
+    "49": [49, "+", "48", "50", "-49"];
+    "50": [50, "+", "49", "51", "-50"];
+    "51": [51, "+", "50", "52", "-51"];
+    "52": [52, "+", "51", "53", "-52"];
+    "53": [53, "+", "52", "54", "-53"];
+    "54": [54, "+", "53", "55", "-54"];
+    "55": [55, "+", "54", "56", "-55"];
+    "56": [56, "+", "55", "57", "-56"];
+    "57": [57, "+", "56", "58", "-57"];
+    "58": [58, "+", "57", "59", "-58"];
+    "59": [59, "+", "58", "60", "-59"];
+    "60": [60, "+", "59", "61", "-60"];
+    "61": [61, "+", "60", "62", "-61"];
+    "62": [62, "+", "61", "63", "-62"];
+    "63": [63, "+", "62", "64", "-63"];
+    "64": [64, "+", "63", "65", "-64"];
+    "65": [65, "+", "64", "66", "-65"];
+    "66": [66, "+", "65", "67", "-66"];
+    "67": [67, "+", "66", "68", "-67"];
+    "68": [68, "+", "67", "69", "-68"];
+    "69": [69, "+", "68", "70", "-69"];
+    "70": [70, "+", "69", "71", "-70"];
+    "71": [71, "+", "70", "72", "-71"];
+    "72": [72, "+", "71", "73", "-72"];
+    "73": [73, "+", "72", "74", "-73"];
+    "74": [74, "+", "73", "75", "-74"];
+    "75": [75, "+", "74", "76", "-75"];
+    "76": [76, "+", "75", "77", "-76"];
+    "77": [77, "+", "76", "78", "-77"];
+    "78": [78, "+", "77", "79", "-78"];
+    "79": [79, "+", "78", "80", "-79"];
+    "80": [80, "+", "79", "81", "-80"];
+    "81": [81, "+", "80", "82", "-81"];
+    "82": [82, "+", "81", "83", "-82"];
+    "83": [83, "+", "82", "84", "-83"];
+    "84": [84, "+", "83", "85", "-84"];
+    "85": [85, "+", "84", "86", "-85"];
+    "86": [86, "+", "85", "87", "-86"];
+    "87": [87, "+", "86", "88", "-87"];
+    "88": [88, "+", "87", "89", "-88"];
+    "89": [89, "+", "88", "90", "-89"];
+    "90": [90, "+", "89", "91", "-90"];
+    "91": [91, "+", "90", "92", "-91"];
+    "92": [92, "+", "91", "93", "-92"];
+    "93": [93, "+", "92", "94", "-93"];
+    "94": [94, "+", "93", "95", "-94"];
+    "95": [95, "+", "94", "96", "-95"];
+    "96": [96, "+", "95", "97", "-96"];
+    "97": [97, "+", "96", "98", "-97"];
+    "98": [98, "+", "97", "99", "-98"];
+    "99": [99, "+", "98", "100", "-99"];
+    "100": [100, "+", "99", "__", "-100"];
+};
+export declare type IterationOf<N extends number> = `${N}` extends keyof IterationMap ? IterationMap[`${N}`] : IterationMap["__"];
+export declare type Next<I extends Iteration> = IterationMap[I[3]];
+export declare type Prev<I extends Iteration> = IterationMap[I[2]];
+export declare type Pos<I extends Iteration> = I[0];
+export declare type Key<I extends Iteration> = `${Pos<I>}`;

package/List.d.ts

@@ -0,0 +1,15 @@
+import type * as O from "./Object.js";
+export declare type List<A = any> = ReadonlyArray<A>;
+export declare type Prepend<L extends List, A> = [A, ...L];
+export declare type Append<L extends List, A> = [...L, A];
+export declare type Concat<L1 extends List, L2 extends List> = [...L1, ...L2];
+export declare type Length<L extends List> = L["length"];
+export declare type Head<L extends List> = L[0];
+export declare type Tail<L extends List> = L extends readonly [] ? L : L extends readonly [any?, ...infer Tail] ? Tail : L;
+export declare type Init<L extends List> = L extends readonly [] ? L : L extends readonly [...infer Init, any?] ? Init : L;
+export declare type Last<L extends List> = L[Length<Tail<L>>];
+export declare type UnionOf<L extends List> = L[number];
+export declare type PrependAll<L extends List, A, O extends List = []> = Length<L> extends 0 ? O : PrependAll<Tail<L>, A, [...O, A, Head<L>]>;
+export declare type Pop<L extends List> = L extends readonly [...infer LBody, any] | readonly [...infer LBody, any?] ? LBody : L;
+export declare type ObjectOf<L extends List> = L extends unknown ? number extends Length<L> ? O._Pick<L, number> : O._Omit<L, keyof any[]> : never;
+export declare type RequiredKeys<L extends List> = O.RequiredKeys<ObjectOf<L>>;