free-types-core 0.8.2 → 0.8.4

package/dist/Const.d.ts

@@ -1,28 +1,28 @@
-import { Type } from './Type';
-export { Const, $Const };
-/**
- * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
-*/
-declare type Const<T> = {
-    type: T;
-    constraints: any;
-    arguments: any[] & {
-        length: any;
-    };
-    0: any;
-    1: any;
-    2: any;
-    3: any;
-    4: any;
-    5: any;
-    6: any;
-    7: any;
-    8: any;
-    9: any;
-};
-/**
- * Turn the input into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
-*/
-interface $Const extends Type<1> {
-    type: Const<this[0]>;
-}
+import { Type } from './Type';
+export { Const, $Const };
+/**
+ * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
+*/
+declare type Const<T> = {
+    type: T;
+    constraints: any;
+    arguments: any[] & {
+        length: any;
+    };
+    0: any;
+    1: any;
+    2: any;
+    3: any;
+    4: any;
+    5: any;
+    6: any;
+    7: any;
+    8: any;
+    9: any;
+};
+/**
+ * Turn the input into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
+*/
+interface $Const extends Type<1> {
+    type: Const<this[0]>;
+}

package/dist/Const.js

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

package/dist/Remaining.d.ts

@@ -1,5 +1,5 @@
-import { Type } from './Type';
-import { Slice, Subtract } from './utils';
-export { Remaining };
-/** Use as a type constraint to match a Type whose state of application is known */
-declare type Remaining<T extends Type, R extends number> = unknown[] extends T['constraints'] ? Type : Type<Slice<T['constraints'], Subtract<T['constraints']['length'], R>, T['constraints']['length']>, T['type']>;
+import { Type } from './Type';
+import { Slice, Subtract } from './utils';
+export { Remaining };
+/** Use as a type constraint to match a Type whose state of application is known */
+declare type Remaining<T extends Type, R extends number> = unknown[] extends T['constraints'] ? Type : Type<Slice<T['constraints'], Subtract<T['constraints']['length'], R>, T['constraints']['length']>, T['type']>;

package/dist/Remaining.js

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

package/dist/Replace.d.ts

@@ -1,9 +1,9 @@
-import { unwrap, Unwrapped, Search } from './unwrap';
-import { apply } from './apply';
-import { TypesMap } from './TypesMap';
-export { Replace };
-/** Replace the inner value of a type with compatible arguments.
- *
- *  Can be used to constrain the inner value of a type
- */
-declare type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = apply<U['type'], Args>;
+import { unwrap, Unwrapped, Search } from './unwrap';
+import { apply } from './apply';
+import { TypesMap } from './TypesMap';
+export { Replace };
+/** Replace the inner value of a type with compatible arguments.
+ *
+ *  Can be used to constrain the inner value of a type
+ */
+declare type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = apply<U['type'], Args>;

package/dist/Replace.js

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

package/dist/Type.d.ts

@@ -1,24 +1,24 @@
-import { Tuple } from './utils';
-export { Type };
-/** Extend `Type<Input?, Output?>` with an interface to produce a free type, or use it as a type constraint.*/
-declare type Type<Input extends number | unknown[] = unknown[], Output = unknown> = CreateType<{
-    type: Output;
-    constraints: Constraints<Input, Slots<Input>>;
-    arguments: unknown[];
-}>;
-interface CreateType<T extends {
-    type: unknown;
-    constraints: unknown[];
-}> {
-    [k: number]: unknown;
-    type: T['type'];
-    constraints: T['constraints'];
-    arguments: unknown[];
-}
-declare type Slots<T> = T extends Precomputable ? PrecomputedSlots[T & Precomputable] : Tuple<T extends unknown[] ? T['length'] : T extends number ? T : number>;
-declare type Constraints<Input, Slots> = number extends Input ? unknown[] : unknown[] extends Input ? unknown[] : Input extends unknown[] ? Input : Slots;
-declare type PrecomputedSlots = {
-    [I in Precomputable]: Tuple<Seq10[I]>;
-};
-declare type Precomputable = Seq10[number];
-declare type Seq10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+import { Tuple } from './utils';
+export { Type };
+/** Extend `Type<Input?, Output?>` with an interface to produce a free type, or use it as a type constraint.*/
+declare type Type<Input extends number | unknown[] = unknown[], Output = unknown> = CreateType<{
+    type: Output;
+    constraints: Constraints<Input, Slots<Input>>;
+    arguments: unknown[];
+}>;
+interface CreateType<T extends {
+    type: unknown;
+    constraints: unknown[];
+}> {
+    [k: number]: unknown;
+    type: T['type'];
+    constraints: T['constraints'];
+    arguments: unknown[];
+}
+declare type Slots<T> = T extends Precomputable ? PrecomputedSlots[T & Precomputable] : Tuple<T extends unknown[] ? T['length'] : T extends number ? T : number>;
+declare type Constraints<Input, Slots> = number extends Input ? unknown[] : unknown[] extends Input ? unknown[] : Input extends unknown[] ? Input : Slots;
+declare type PrecomputedSlots = {
+    [I in Precomputable]: Tuple<Seq10[I]>;
+};
+declare type Precomputable = Seq10[number];
+declare type Seq10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

package/dist/Type.js

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

package/dist/TypesMap.d.ts

@@ -1,17 +1,17 @@
-import * as free from './free-types';
-/** A mapping of everyday free types which you can extend with module augmentation. */
-export interface TypesMap {
-    Record: free.Record;
-    Array: free.Array;
-    Tuple: free.Tuple;
-    ReadonlyTuple: free.ReadonlyTuple;
-    ReadonlyArray: free.ReadonlyArray;
-    Set: free.Set;
-    ReadonlySet: free.ReadonlySet;
-    WeakSet: free.WeakSet;
-    Map: free.Map;
-    ReadonlyMap: free.ReadonlyMap;
-    WeakMap: free.WeakMap;
-    Function: free.Function;
-    Promise: free.Promise;
-}
+import * as free from './free-types';
+/** A mapping of everyday free types which you can extend with module augmentation. */
+export interface TypesMap {
+    Record: free.Record;
+    Array: free.Array;
+    Tuple: free.Tuple;
+    ReadonlyTuple: free.ReadonlyTuple;
+    ReadonlyArray: free.ReadonlyArray;
+    Set: free.Set;
+    ReadonlySet: free.ReadonlySet;
+    WeakSet: free.WeakSet;
+    Map: free.Map;
+    ReadonlyMap: free.ReadonlyMap;
+    WeakMap: free.WeakMap;
+    Function: free.Function;
+    Promise: free.Promise;
+}

package/dist/TypesMap.js

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

package/dist/apply.d.ts

@@ -1,22 +1,22 @@
-import { Type } from './Type';
-import { ArrayKeys, Next } from './utils';
-export { apply, $apply, Generic };
-/** Apply a free type with all its arguments and evaluate the type */
-declare type apply<$T extends Type, Args extends $T['constraints'] = []> = applyUnsafe<$T, Args>;
-interface $apply<Args extends unknown[] = []> extends Type<[Type]> {
-    type: apply<this[0] extends Type ? this[0] : Type, Args>;
-}
-/** Apply a free type `$T` with its type constraints. */
-declare type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
-declare type applyUnsafe<$T extends {
-    type: unknown;
-    constraints: {
-        length: number;
-    };
-}, Args extends unknown[]> = number extends $T['constraints']['length'] ? _apply<$T, Args> : _apply<$T, Take<Args, Required<$T['constraints']>['length']>>;
-declare type _apply<T extends {
-    type: unknown;
-}, Args> = (T & Omit<Args, ArrayKeys> & {
-    arguments: Args;
-})['type'];
-declare type Take<T extends unknown[], To extends number, I extends number = 0, R extends unknown[] = []> = I extends To ? R : Take<T, To, Next<I>, [...R, T[I]]>;
+import { Type } from './Type';
+import { ArrayKeys, Next } from './utils';
+export { apply, $apply, Generic };
+/** Apply a free type with all its arguments and evaluate the type */
+declare type apply<$T extends Type, Args extends $T['constraints'] = []> = applyUnsafe<$T, Args>;
+interface $apply<Args extends unknown[] = []> extends Type<[Type]> {
+    type: apply<this[0] extends Type ? this[0] : Type, Args>;
+}
+/** Apply a free type `$T` with its type constraints. */
+declare type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
+declare type applyUnsafe<$T extends {
+    type: unknown;
+    constraints: {
+        length: number;
+    };
+}, Args extends unknown[]> = number extends $T['constraints']['length'] ? _apply<$T, Args> : _apply<$T, Take<Args, Required<$T['constraints']>['length']>>;
+declare type _apply<T extends {
+    type: unknown;
+}, Args> = (T & Omit<Args, ArrayKeys> & {
+    arguments: Args;
+})['type'];
+declare type Take<T extends unknown[], To extends number, I extends number = 0, R extends unknown[] = []> = I extends To ? R : Take<T, To, Next<I>, [...R, T[I]]>;

package/dist/apply.js

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

package/dist/free-types.d.ts

@@ -1,63 +1,63 @@
-import { Type } from './Type';
-import { ToTuple } from './utils';
-export { $Id as Id, $Record as Record, $Array as Array, $Tuple as Tuple, $ReadonlyTuple as ReadonlyTuple, $ReadonlyArray as ReadonlyArray, $Set as Set, $ReadonlySet as ReadonlySet, $WeakSet as WeakSet, $Map as Map, $ReadonlyMap as ReadonlyMap, $WeakMap as WeakMap, $Function as Function, $UnaryFunction as UnaryFunction, $Promise as Promise };
-interface $Id extends Type<1> {
-    type: this[0];
-}
-declare type Key = string | number | symbol;
-interface $Record extends Type<[Key, unknown]> {
-    type: Record<this[0] & Key, this[1]>;
-}
-interface $Array extends Type<1> {
-    type: Array<this[0]>;
-}
-interface $Tuple extends Type {
-    type: ToTuple<this['arguments']>;
-}
-interface $ReadonlyTuple extends Type {
-    type: Readonly<ToTuple<this['arguments']>>;
-}
-interface $ReadonlyArray extends Type<1> {
-    type: ReadonlyArray<this[0]>;
-}
-interface $Set extends Type<1> {
-    type: Set<this[0]>;
-}
-interface $ReadonlySet extends Type<1> {
-    type: ReadonlySet<this[0]>;
-}
-interface $WeakSet extends Type<[object]> {
-    type: WeakSet<this[0] extends object ? this[0] : object>;
-}
-interface $Map extends Type<2> {
-    type: Map<this[0], this[1]>;
-}
-interface $ReadonlyMap extends Type<2> {
-    type: ReadonlyMap<this[0], this[1]>;
-}
-interface $WeakMap extends Type<[object, unknown]> {
-    type: WeakMap<this[0] extends object ? this[0] : object, this[1]>;
-}
-interface $Function extends Type<[any[], unknown]> {
-    type: (...args: this[0] extends any[] ? this[0] : any[]) => this[1];
-}
-interface $UnaryFunction extends Type<2> {
-    type: (a: unknown extends this[0] ? any : this[0]) => this[1];
-}
-interface $Promise extends Type<1> {
-    type: Promise<this[0]>;
-}
-declare global {
-    interface Set<T> {
-    }
-    interface ReadonlySet<T> {
-    }
-    interface WeakSet<T> {
-    }
-    interface Map<K, V> {
-    }
-    interface ReadonlyMap<K, V> {
-    }
-    interface WeakMap<K, V> {
-    }
-}
+import { Type } from './Type';
+import { ToTuple } from './utils';
+export { $Id as Id, $Record as Record, $Array as Array, $Tuple as Tuple, $ReadonlyTuple as ReadonlyTuple, $ReadonlyArray as ReadonlyArray, $Set as Set, $ReadonlySet as ReadonlySet, $WeakSet as WeakSet, $Map as Map, $ReadonlyMap as ReadonlyMap, $WeakMap as WeakMap, $Function as Function, $UnaryFunction as UnaryFunction, $Promise as Promise };
+interface $Id extends Type<1> {
+    type: this[0];
+}
+declare type Key = string | number | symbol;
+interface $Record extends Type<[Key, unknown]> {
+    type: Record<this[0] & Key, this[1]>;
+}
+interface $Array extends Type<1> {
+    type: Array<this[0]>;
+}
+interface $Tuple extends Type {
+    type: ToTuple<this['arguments']>;
+}
+interface $ReadonlyTuple extends Type {
+    type: Readonly<ToTuple<this['arguments']>>;
+}
+interface $ReadonlyArray extends Type<1> {
+    type: ReadonlyArray<this[0]>;
+}
+interface $Set extends Type<1> {
+    type: Set<this[0]>;
+}
+interface $ReadonlySet extends Type<1> {
+    type: ReadonlySet<this[0]>;
+}
+interface $WeakSet extends Type<[object]> {
+    type: WeakSet<this[0] extends object ? this[0] : object>;
+}
+interface $Map extends Type<2> {
+    type: Map<this[0], this[1]>;
+}
+interface $ReadonlyMap extends Type<2> {
+    type: ReadonlyMap<this[0], this[1]>;
+}
+interface $WeakMap extends Type<[object, unknown]> {
+    type: WeakMap<this[0] extends object ? this[0] : object, this[1]>;
+}
+interface $Function extends Type<[any[], unknown]> {
+    type: (...args: this[0] extends any[] ? this[0] : any[]) => this[1];
+}
+interface $UnaryFunction extends Type<2> {
+    type: (a: unknown extends this[0] ? any : this[0]) => this[1];
+}
+interface $Promise extends Type<1> {
+    type: Promise<this[0]>;
+}
+declare global {
+    interface Set<T> {
+    }
+    interface ReadonlySet<T> {
+    }
+    interface WeakSet<T> {
+    }
+    interface Map<K, V> {
+    }
+    interface ReadonlyMap<K, V> {
+    }
+    interface WeakMap<K, V> {
+    }
+}

package/dist/free-types.js

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

package/dist/helpers.d.ts

@@ -1,62 +1,62 @@
-import { Next, IsUnknown, Prev } from './utils';
-export { At, Checked, Lossy, Optional, A, B, C, D, E };
-declare type Type<N extends number> = {
-    constraints: {
-        [K in Prev<N>]: unknown;
-    };
-    arguments: unknown[];
-};
-declare type Type_<N extends number> = {
-    constraints: {
-        [K in Prev<N>]?: unknown;
-    };
-    arguments: unknown[];
-};
-declare type Default = {
-    constraints: [0, 1, 2, 3, 4];
-    arguments: unknown[];
-};
-/** - safely index `this`
- * - optionally take a fallback
-*/
-declare type At<N extends number, This extends Type<Next<N>>, Fallback = unknown> = IsUnknown<This['arguments'][N]> extends true ? Fallback : This['arguments'][N];
-/** - safely index `this`
- * - defuse the corresponding type constraint with an inline conditional
- * - optionally take a fallback
- */
-declare type Checked<N extends number, This extends Type<Next<N>>, Fallback = N extends keyof This['constraints'] ? This['constraints'][N] : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends This['constraints'][N] ? This['arguments'][N] : Fallback : never;
-/** - safely index `this`
- * - works on optional parameters
- * - defuse the corresponding type constraint with an inline conditional
- * - optionally take a fallback
- */
-declare type Optional<N extends number, This extends Type_<Next<N>>, Fallback = N extends keyof This['constraints'] ? Exclude<This['constraints'][N], undefined> : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends Exclude<This['constraints'][N], undefined> ? This['arguments'][N] : Fallback : never;
-/** - safely index `this`
- * - intersect the corresponding type constraint
- */
-declare type Lossy<N extends number, This extends Type<Next<N>>> = N extends keyof This['constraints'] ? This['arguments'][N] & This['constraints'][N] : never;
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `0` When no argument is supplied
-*/
-declare type A<This extends Type<1> = Default> = This['arguments'][0] & This['constraints'][0];
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `1` When no argument is supplied
-*/
-declare type B<This extends Type<2> = Default> = This['arguments'][1] & This['constraints'][1];
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `2` When no argument is supplied
-*/
-declare type C<This extends Type<3> = Default> = This['arguments'][2] & This['constraints'][2];
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `3` When no argument is supplied
-*/
-declare type D<This extends Type<4> = Default> = This['arguments'][3] & This['constraints'][3];
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `4` When no argument is supplied
-*/
-declare type E<This extends Type<5> = Default> = This['arguments'][4] & This['constraints'][4];
+import { Next, IsUnknown, Prev } from './utils';
+export { At, Checked, Lossy, Optional, A, B, C, D, E };
+declare type Type<N extends number> = {
+    constraints: {
+        [K in Prev<N>]: unknown;
+    };
+    arguments: unknown[];
+};
+declare type Type_<N extends number> = {
+    constraints: {
+        [K in Prev<N>]?: unknown;
+    };
+    arguments: unknown[];
+};
+declare type Default = {
+    constraints: [0, 1, 2, 3, 4];
+    arguments: unknown[];
+};
+/** - safely index `this`
+ * - optionally take a fallback
+*/
+declare type At<N extends number, This extends Type<Next<N>>, Fallback = unknown> = IsUnknown<This['arguments'][N]> extends true ? Fallback : This['arguments'][N];
+/** - safely index `this`
+ * - defuse the corresponding type constraint with an inline conditional
+ * - optionally take a fallback
+ */
+declare type Checked<N extends number, This extends Type<Next<N>>, Fallback = N extends keyof This['constraints'] ? This['constraints'][N] : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends This['constraints'][N] ? This['arguments'][N] : Fallback : never;
+/** - safely index `this`
+ * - works on optional parameters
+ * - defuse the corresponding type constraint with an inline conditional
+ * - optionally take a fallback
+ */
+declare type Optional<N extends number, This extends Type_<Next<N>>, Fallback = N extends keyof This['constraints'] ? Exclude<This['constraints'][N], undefined> : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends Exclude<This['constraints'][N], undefined> ? This['arguments'][N] : Fallback : never;
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ */
+declare type Lossy<N extends number, This extends Type<Next<N>>> = N extends keyof This['constraints'] ? This['arguments'][N] & This['constraints'][N] : never;
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `0` When no argument is supplied
+*/
+declare type A<This extends Type<1> = Default> = This['arguments'][0] & This['constraints'][0];
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `1` When no argument is supplied
+*/
+declare type B<This extends Type<2> = Default> = This['arguments'][1] & This['constraints'][1];
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `2` When no argument is supplied
+*/
+declare type C<This extends Type<3> = Default> = This['arguments'][2] & This['constraints'][2];
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `3` When no argument is supplied
+*/
+declare type D<This extends Type<4> = Default> = This['arguments'][3] & This['constraints'][3];
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `4` When no argument is supplied
+*/
+declare type E<This extends Type<5> = Default> = This['arguments'][4] & This['constraints'][4];

package/dist/helpers.js

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

package/dist/hkt.d.ts

@@ -1,19 +1,19 @@
-import { Type } from "./Type";
-export { HKT, Contra };
-/** Interfaces extending this type are able to use `hkt` internally. */
-declare type HKT = {
-    HKT: [any, ...any[]];
-};
-/** Expect a free type with contravariant arguments */
-declare type Contra<$T, $U extends Type> = Type & _Contra<$T, $U>['type'];
-interface _Contra<$T, $U extends Type> {
-    type: $U['constraints'] extends this['$T']['constraints'] ? this['$T']['type'] extends $U['type'] ? Type : Type<this['$T']['constraints'], $U['type']> : {
-        [K in 'Contravariance issue']: [
-            'the input',
-            $U['constraints'],
-            'is not assignable to',
-            this['$T']['constraints']
-        ];
-    };
-    $T: $T extends Type ? $T : never;
-}
+import { Type } from "./Type";
+export { HKT, Contra };
+/** Interfaces extending this type are able to use `hkt` internally. */
+declare type HKT = {
+    HKT: [any, ...any[]];
+};
+/** Expect a free type with contravariant arguments */
+declare type Contra<$T, $U extends Type> = Type & _Contra<$T, $U>['type'];
+interface _Contra<$T, $U extends Type> {
+    type: $U['constraints'] extends this['$T']['constraints'] ? this['$T']['type'] extends $U['type'] ? Type : Type<this['$T']['constraints'], $U['type']> : {
+        [K in 'Contravariance issue']: [
+            'the input',
+            $U['constraints'],
+            'is not assignable to',
+            this['$T']['constraints']
+        ];
+    };
+    $T: $T extends Type ? $T : never;
+}

package/dist/hkt.js

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

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-export * from './apply';
-export * from './partial';
-export * from './Remaining';
-export * from './Type';
-export * from './Const';
-export * from './helpers';
-export * from './inferArgs';
-export * from './unwrap';
-export * from './Replace';
-export * from './hkt';
-export * as free from './free-types';
-export { Slice, ToTuple, Head, Tail, Last, Init, IsUnknown, IsOptional, Next, Prev } from './utils';
-export { TypesMap } from './TypesMap';
+export * from './apply';
+export * from './partial';
+export * from './Remaining';
+export * from './Type';
+export * from './Const';
+export * from './helpers';
+export * from './inferArgs';
+export * from './unwrap';
+export * from './Replace';
+export * from './hkt';
+export * as free from './free-types';
+export { Slice, ToTuple, Head, Tail, Last, Init, IsUnknown, IsOptional, Next, Prev } from './utils';
+export { TypesMap } from './TypesMap';

package/dist/index.js

@@ -1,11 +1,11 @@
-export * from './apply';
-export * from './partial';
-export * from './Remaining';
-export * from './Type';
-export * from './Const';
-export * from './helpers';
-export * from './inferArgs';
-export * from './unwrap';
-export * from './Replace';
-export * from './hkt';
-export * as free from './free-types';
+export * from './apply';
+export * from './partial';
+export * from './Remaining';
+export * from './Type';
+export * from './Const';
+export * from './helpers';
+export * from './inferArgs';
+export * from './unwrap';
+export * from './Replace';
+export * from './hkt';
+export * as free from './free-types';

package/dist/inferArgs.d.ts

@@ -1,29 +1,29 @@
-import { Type } from './Type';
-import { apply } from './apply';
-export { inferArgs };
-declare type inferArgs<T, $T extends Type> = T extends apply<$T, [
-    infer A,
-    infer B,
-    infer C,
-    infer D,
-    infer E,
-    infer F,
-    infer G,
-    infer H,
-    infer I,
-    infer J
-]> ? Extract<[A, B, C, D, E, F, G, H, I, J]>[$T['constraints']['length']] : never;
-interface Extract<T extends unknown[]> {
-    [k: number]: unknown[];
-    0: [];
-    1: [T[0]];
-    2: [T[0], T[1]];
-    3: [T[0], T[1], T[2]];
-    4: [T[0], T[1], T[2], T[3]];
-    5: [T[0], T[1], T[2], T[3], T[4]];
-    6: [T[0], T[1], T[2], T[3], T[4], T[5]];
-    7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6]];
-    8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7]];
-    9: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8]];
-    10: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9]];
-}
+import { Type } from './Type';
+import { apply } from './apply';
+export { inferArgs };
+declare type inferArgs<T, $T extends Type> = T extends apply<$T, [
+    infer A,
+    infer B,
+    infer C,
+    infer D,
+    infer E,
+    infer F,
+    infer G,
+    infer H,
+    infer I,
+    infer J
+]> ? Extract<[A, B, C, D, E, F, G, H, I, J]>[$T['constraints']['length']] : never;
+interface Extract<T extends unknown[]> {
+    [k: number]: unknown[];
+    0: [];
+    1: [T[0]];
+    2: [T[0], T[1]];
+    3: [T[0], T[1], T[2]];
+    4: [T[0], T[1], T[2], T[3]];
+    5: [T[0], T[1], T[2], T[3], T[4]];
+    6: [T[0], T[1], T[2], T[3], T[4], T[5]];
+    7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6]];
+    8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7]];
+    9: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8]];
+    10: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9]];
+}

package/dist/inferArgs.js

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

package/dist/partial.d.ts

@@ -1,20 +1,20 @@
-import { Type } from './Type';
-import { apply } from './apply';
-import { Slice, Subtract, ToTuple } from './utils';
-export { partial, partialRight, PartialRight, $partial };
-export { PartialType };
-/** Return a new type based upon `$T`, with `Args` already applied, expecting the remaining arguments */
-declare type partial<$T extends Type, Args extends Partial<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? Args extends unknown[] ? _partial<$T, Args> : never : never;
-/** A free version of `partial` */
-interface $partial<$T extends Type> extends Type<1> {
-    type: _partial<$T, [this['arguments'][0]]>;
-}
-declare type _partial<$T extends Type, Args extends unknown[]> = PartialType<$T, Args, Slice<$T['constraints'], Args['length'], Required<$T['constraints']>['length']>, 'left'>;
-/** Return a new type based upon `$T`, with `Args` already applied to the rightmost parameters of `$T`, and expecting the remaining arguments */
-declare type partialRight<$T extends Type, Args extends PartialRight<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? PartialType<$T, Args, Slice<$T['constraints'], 0, Subtract<Required<$T['constraints']>['length'], Args['length']>>, 'right'> : never;
-declare type PartialRight<T extends unknown[], R = never> = T extends [unknown, ...(infer Rest)] ? PartialRight<Rest, T | R> : [] | R;
-interface PartialType<$T extends Type, Applied extends unknown[], Constraints extends unknown[], Direction> extends Type {
-    type: apply<$T, Direction extends 'left' ? [...Applied, ...ToTuple<this['arguments']>] : [...ToTuple<this['arguments']>, ...Applied]>;
-    constraints: Constraints;
-    arguments: unknown[];
-}
+import { Type } from './Type';
+import { apply } from './apply';
+import { Slice, Subtract, ToTuple } from './utils';
+export { partial, partialRight, PartialRight, $partial };
+export { PartialType };
+/** Return a new type based upon `$T`, with `Args` already applied, expecting the remaining arguments */
+declare type partial<$T extends Type, Args extends Partial<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? Args extends unknown[] ? _partial<$T, Args> : never : never;
+/** A free version of `partial` */
+interface $partial<$T extends Type> extends Type<1> {
+    type: _partial<$T, [this['arguments'][0]]>;
+}
+declare type _partial<$T extends Type, Args extends unknown[]> = PartialType<$T, Args, Slice<$T['constraints'], Args['length'], Required<$T['constraints']>['length']>, 'left'>;
+/** Return a new type based upon `$T`, with `Args` already applied to the rightmost parameters of `$T`, and expecting the remaining arguments */
+declare type partialRight<$T extends Type, Args extends PartialRight<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? PartialType<$T, Args, Slice<$T['constraints'], 0, Subtract<Required<$T['constraints']>['length'], Args['length']>>, 'right'> : never;
+declare type PartialRight<T extends unknown[], R = never> = T extends [unknown, ...(infer Rest)] ? PartialRight<Rest, T | R> : [] | R;
+interface PartialType<$T extends Type, Applied extends unknown[], Constraints extends unknown[], Direction> extends Type {
+    type: apply<$T, Direction extends 'left' ? [...Applied, ...ToTuple<this['arguments']>] : [...ToTuple<this['arguments']>, ...Applied]>;
+    constraints: Constraints;
+    arguments: unknown[];
+}

package/dist/partial.js

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

package/dist/unwrap.d.ts

@@ -1,43 +1,47 @@
-import { ArrayKeys, Eq, And, Extends, Not } from './utils';
-import { Type } from './Type';
-import { inferArgs } from './inferArgs';
-import { Generic, apply } from './apply';
-import { TypesMap } from './TypesMap';
-import { Tuple, ReadonlyTuple, Array, ReadonlyArray } from './free-types';
-declare type Search = Type | SearchList;
-declare type SearchList = Type[] | Record<string, Type> | Interface;
-declare type Interface = {
-    [k: string]: any;
-} & {
-    [Symbol.toStringTag]?: never;
-};
-declare global {
-    interface SymbolConstructor {
-        readonly toStringTag: unique symbol;
-    }
-    interface Symbol {
-        readonly [Symbol.toStringTag]: string;
-    }
-    var Symbol: SymbolConstructor;
-}
-export { unwrap, Unwrapped, Search };
-/** Decompose a type into its constituents */
-declare type unwrap<T, From extends Search = TypesMap> = And<Extends<T, readonly unknown[]>, Not<Extends<From, Type | Type[]>>> extends true ? unwrapLists<T extends readonly unknown[] ? T : never> : _unwrap<T, From extends Type ? [From] : From>;
-declare type unwrapLists<T> = T extends unknown[] ? T extends [unknown, ...unknown[]] ? Unwrapped<'Tuple', Tuple, T> : Unwrapped<'Array', Array, [T[0]]> : T extends readonly [unknown, ...unknown[]] ? Unwrapped<'ReadonlyTuple', ReadonlyTuple, Mutable<T>> : Unwrapped<'ReadonlyArray', ReadonlyArray, [(T & unknown[])[0]]>;
-declare type Mutable<T> = {
-    -readonly [K in keyof T]: K extends ArrayKeys ? T[K] : T[K];
-};
-declare type _unwrap<T, From extends SearchList, R = {
-    [K in keyof From as K extends ArrayKeys ? never : K extends string ? K : never]: From[K] extends Type ? Branch<T, From[K], K>[T extends Generic<From[K]> ? 'match' : 'miss'] : never;
-}> = R[keyof R];
-interface Branch<T, $T extends Type, K> {
-    match: Disambiguate<T, $T, inferArgs<T, $T>, K & string>;
-    miss: never;
-}
-declare type Disambiguate<T, $T extends Type, Args extends unknown[], K extends string> = Eq<T, apply<$T, Args>> extends true ? Unwrapped<K, $T, Args> : never;
-/** The result of unwrapping a type with `unwrap` */
-declare type Unwrapped<URI extends string = string, T extends Type = Type, A = unknown[]> = {
-    URI: URI;
-    type: T;
-    args: A;
-};
+import { ArrayKeys, Eq, And, Extends, Not, IsAny } from './utils';
+import { Type } from './Type';
+import { inferArgs } from './inferArgs';
+import { Generic, apply } from './apply';
+import { TypesMap } from './TypesMap';
+import { Tuple, ReadonlyTuple, Array, ReadonlyArray } from './free-types';
+declare type Search = Type | SearchList;
+declare type SearchList = Type[] | Record<string, Type> | Interface;
+declare type Interface = {
+    [k: string]: any;
+} & {
+    [Symbol.toStringTag]?: never;
+};
+declare global {
+    interface SymbolConstructor {
+        readonly toStringTag: unique symbol;
+    }
+    interface Symbol {
+        readonly [Symbol.toStringTag]: string;
+    }
+    var Symbol: SymbolConstructor;
+}
+export { unwrap, Unwrapped, Search };
+/** Decompose a type into its constituents */
+declare type unwrap<T, From extends Search = TypesMap> = IsAny<T> extends true ? Any : And<Extends<T, readonly unknown[]>, Not<Extends<From, Type | Type[]>>> extends true ? unwrapLists<T extends readonly unknown[] ? T : never> : _unwrap<T, From extends Type ? [From] : From>;
+declare type unwrapLists<T> = T extends unknown[] ? T extends [unknown, ...unknown[]] ? Unwrapped<'Tuple', Tuple, T> : Unwrapped<'Array', Array, [T[0]]> : T extends readonly [unknown, ...unknown[]] ? Unwrapped<'ReadonlyTuple', ReadonlyTuple, Mutable<T>> : Unwrapped<'ReadonlyArray', ReadonlyArray, [(T & unknown[])[0]]>;
+declare type Mutable<T> = {
+    -readonly [K in keyof T]: K extends ArrayKeys ? T[K] : T[K];
+};
+declare type _unwrap<T, From extends SearchList, R = {
+    [K in keyof From as K extends ArrayKeys ? never : K extends string ? K : never]: From[K] extends Type ? Branch<T, From[K], K>[T extends Generic<From[K]> ? 'match' : 'miss'] : never;
+}> = R[keyof R];
+interface Branch<T, $T extends Type, K> {
+    match: Disambiguate<T, $T, inferArgs<T, $T>, K & string>;
+    miss: never;
+}
+declare type Disambiguate<T, $T extends Type, Args extends unknown[], K extends string> = Eq<T, apply<$T, Args>> extends true ? Unwrapped<K, $T, Args> : never;
+/** The result of unwrapping a type with `unwrap` */
+declare type Unwrapped<URI extends string = string, T extends Type = Type, A = unknown[]> = {
+    URI: URI;
+    type: T;
+    args: A;
+};
+interface $Any extends Type {
+    type: any;
+}
+declare type Any = Unwrapped<'any', $Any, any>;

package/dist/unwrap.js

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

package/dist/utils.d.ts

@@ -1,34 +1,34 @@
-export { Natural, Prev, Next, Subtract };
-export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init };
-export { Extends, Eq, And, Not, IsUnknown, IsAny, IsOptional };
-declare type Natural = [0, ..._Next];
-declare type Prev<I extends number> = number extends I ? number : number & _Prev[I];
-declare type _Prev = [never, ...Natural];
-declare type Next<I extends number> = number extends I ? number : number & _Next[I];
-declare type _Next = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
-declare type Subtract<A extends number, B extends number> = number extends A ? number : number extends B ? number : _Subtract<A, B>;
-declare type _Subtract<A extends number, B extends number, _A = Prev<A>, _B = Prev<B>> = B extends 0 ? A : [_A] extends [never] ? never : [_B] extends never ? never : _Subtract<_A & number, _B & number>;
-declare type ArrayKeys = Exclude<keyof [], never>;
-declare type Slice<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = number extends To ? SliceOpenEndedTuple<T, From> : SliceTuple<T, From, To, I, R>;
-declare type SliceOpenEndedTuple<T extends unknown[], From extends number> = From extends 0 ? T : T extends [unknown, ...infer R] ? SliceOpenEndedTuple<R, Prev<From>> : never;
-declare type SliceTuple<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = I extends To ? R : Slice<T, From, To, Next<I>, IsOptional<T, I> extends true ? [...R, T[I]?] : [...R, T[I]]>;
-declare type IsOptional<T extends unknown[], I extends number> = [
-    {
-        [K in T['length'] as K]: K extends I ? never : unknown;
-    }[I]
-] extends [never] ? true : false;
-declare type ToTuple<T extends readonly unknown[], I extends number = 0, R extends unknown[] = []> = any[] extends T ? T[0][] : I extends T['length'] ? R : ToTuple<T, Next<I>, [...R, T[I]]>;
-declare type Tuple<L extends number, T = unknown, R extends unknown[] = []> = number extends L ? T[] : L extends R['length'] ? R : Tuple<L, T, [T, ...R]>;
-declare type Head<T extends [unknown, ...unknown[]]> = T[0];
-declare type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
-declare type Last<T extends unknown[]> = T[Prev<T['length']>];
-declare type Init<T extends [unknown, ...unknown[]]> = T extends [...infer R, unknown] ? R : never;
-declare type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
-declare type IsAny<T> = Extends<T | anything, T & anything>;
-declare type Extends<A, B> = [A] extends [B] ? true : false;
-declare type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
-declare type And<A, B> = Fork<A, Fork<B, B, false>, false>;
-declare type Fork<P, T, F> = P extends false ? F : T;
-declare type Not<T> = Extends<T, false>;
-declare const thing: unique symbol;
-declare type anything = typeof thing;
+export { Natural, Prev, Next, Subtract };
+export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init };
+export { Extends, Eq, And, Not, IsUnknown, IsAny, IsOptional };
+declare type Natural = [0, ..._Next];
+declare type Prev<I extends number> = number extends I ? number : number & _Prev[I];
+declare type _Prev = [never, ...Natural];
+declare type Next<I extends number> = number extends I ? number : number & _Next[I];
+declare type _Next = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
+declare type Subtract<A extends number, B extends number> = number extends A ? number : number extends B ? number : _Subtract<A, B>;
+declare type _Subtract<A extends number, B extends number, _A = Prev<A>, _B = Prev<B>> = B extends 0 ? A : [_A] extends [never] ? never : [_B] extends never ? never : _Subtract<_A & number, _B & number>;
+declare type ArrayKeys = Exclude<keyof [], never>;
+declare type Slice<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = number extends To ? SliceOpenEndedTuple<T, From> : SliceTuple<T, From, To, I, R>;
+declare type SliceOpenEndedTuple<T extends unknown[], From extends number> = From extends 0 ? T : T extends [unknown, ...infer R] ? SliceOpenEndedTuple<R, Prev<From>> : never;
+declare type SliceTuple<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = I extends To ? R : Slice<T, From, To, Next<I>, IsOptional<T, I> extends true ? [...R, T[I]?] : [...R, T[I]]>;
+declare type IsOptional<T extends readonly unknown[], I extends number> = [
+    {
+        [K in T['length'] as K]: K extends I ? never : unknown;
+    }[I]
+] extends [never] ? true : false;
+declare type ToTuple<T extends readonly unknown[], I extends number = 0, R extends unknown[] = []> = any[] extends T ? T[0][] : I extends T['length'] ? R : ToTuple<T, Next<I>, [...R, T[I]]>;
+declare type Tuple<L extends number, T = unknown, R extends unknown[] = []> = number extends L ? T[] : L extends R['length'] ? R : Tuple<L, T, [T, ...R]>;
+declare type Head<T extends [unknown, ...unknown[]]> = T[0];
+declare type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
+declare type Last<T extends unknown[]> = T[Prev<T['length']>];
+declare type Init<T extends [unknown, ...unknown[]]> = T extends [...infer R, unknown] ? R : never;
+declare type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
+declare type IsAny<T> = Extends<T | anything, T & anything>;
+declare type Extends<A, B> = [A] extends [B] ? true : false;
+declare type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
+declare type And<A, B> = Fork<A, Fork<B, B, false>, false>;
+declare type Fork<P, T, F> = P extends false ? F : T;
+declare type Not<T> = Extends<T, false>;
+declare const thing: unique symbol;
+declare type anything = typeof thing;

package/dist/utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "free-types-core",
-    "version": "0.8.2",
+    "version": "0.8.4",
     "description": "A type-level library enabling the creation and the manipulation of type constructors which are detached from their type parameters.",
     "keywords:": [
         "higher kinded type",