mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/type-fest/source/internal/string.d.ts

@@ -0,0 +1,202 @@
+import type {TupleOf} from '../tuple-of.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
+import type {Trim} from '../trim.d.ts';
+import type {Whitespace} from './characters.d.ts';
+
+/**
+Return a string representation of the given string or number.
+
+Note: This type is not the return type of the `.toString()` function.
+*/
+export type ToString<T> = T extends string | number ? `${T}` : never;
+
+/**
+Converts a numeric string to a number.
+
+@example
+```
+type PositiveInt = StringToNumber<'1234'>;
+//=> 1234
+
+type NegativeInt = StringToNumber<'-1234'>;
+//=> -1234
+
+type PositiveFloat = StringToNumber<'1234.56'>;
+//=> 1234.56
+
+type NegativeFloat = StringToNumber<'-1234.56'>;
+//=> -1234.56
+
+type PositiveInfinity = StringToNumber<'Infinity'>;
+//=> Infinity
+
+type NegativeInfinity = StringToNumber<'-Infinity'>;
+//=> -Infinity
+```
+
+@category String
+@category Numeric
+@category Template literal
+*/
+export type StringToNumber<S extends string> = S extends `${infer N extends number}`
+	? N
+	: S extends 'Infinity'
+		? PositiveInfinity
+		: S extends '-Infinity'
+			? NegativeInfinity
+			: never;
+
+/**
+Returns a boolean for whether the given string `S` starts with the given string `SearchString`.
+
+@example
+```
+type A = StartsWith<'abcde', 'abc'>;
+//=> true
+
+type B = StartsWith<'abcde', 'bc'>;
+//=> false
+
+type C = StartsWith<string, 'bc'>;
+//=> never
+
+type D = StartsWith<'abcde', string>;
+//=> never
+```
+
+@category String
+@category Template literal
+*/
+export type StartsWith<S extends string, SearchString extends string> = string extends S | SearchString
+	? never
+	: S extends `${SearchString}${infer T}`
+		? true
+		: false;
+
+/**
+Returns an array of the characters of the string.
+
+@example
+```
+type A = StringToArray<'abcde'>;
+//=> ['a', 'b', 'c', 'd', 'e']
+
+type B = StringToArray<string>;
+//=> never
+```
+
+@category String
+*/
+export type StringToArray<S extends string, Result extends string[] = []> = string extends S
+	? never
+	: S extends `${infer F}${infer R}`
+		? StringToArray<R, [...Result, F]>
+		: Result;
+
+/**
+Returns the length of the given string.
+
+@example
+```
+type A = StringLength<'abcde'>;
+//=> 5
+
+type B = StringLength<string>;
+//=> never
+```
+
+@category String
+@category Template literal
+*/
+export type StringLength<S extends string> = string extends S
+	? never
+	: StringToArray<S>['length'];
+
+/**
+Returns a boolean for whether a string is whitespace.
+*/
+export type IsWhitespace<T extends string> = T extends Whitespace
+	? true
+	: T extends `${Whitespace}${infer Rest}`
+		? IsWhitespace<Rest>
+		: false;
+
+/**
+Returns a boolean for whether the string is numeric.
+
+This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).
+*/
+export type IsNumeric<T extends string> = T extends `${number}`
+	? Trim<T> extends T
+		? true
+		: false
+	: false;
+
+/**
+Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both numeric strings and have the same length.
+
+@example
+```
+type A = SameLengthPositiveNumericStringGt<'50', '10'>;
+//=> true
+
+type B = SameLengthPositiveNumericStringGt<'10', '10'>;
+//=> false
+```
+*/
+type SameLengthPositiveNumericStringGt<A extends string, B extends string> = A extends `${infer FirstA}${infer RestA}`
+	? B extends `${infer FirstB}${infer RestB}`
+		? FirstA extends FirstB
+			? SameLengthPositiveNumericStringGt<RestA, RestB>
+			: PositiveNumericCharacterGt<FirstA, FirstB>
+		: never
+	: false;
+
+type NumericString = '0123456789';
+
+/**
+Returns a boolean for whether `A` is greater than `B`, where `A` and `B` are both positive numeric strings.
+
+@example
+```
+type A = PositiveNumericStringGt<'500', '1'>;
+//=> true
+
+type B = PositiveNumericStringGt<'1', '1'>;
+//=> false
+
+type C = PositiveNumericStringGt<'1', '500'>;
+//=> false
+```
+*/
+export type PositiveNumericStringGt<A extends string, B extends string> = A extends B
+	? false
+	: [TupleOf<StringLength<A>, 0>, TupleOf<StringLength<B>, 0>] extends infer R extends [readonly unknown[], readonly unknown[]]
+		? R[0] extends [...R[1], ...infer Remain extends readonly unknown[]]
+			? 0 extends Remain['length']
+				? SameLengthPositiveNumericStringGt<A, B>
+				: true
+			: false
+		: never;
+
+/**
+Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both positive numeric characters.
+
+@example
+```
+type A = PositiveNumericCharacterGt<'5', '1'>;
+//=> true
+
+type B = PositiveNumericCharacterGt<'1', '1'>;
+//=> false
+```
+*/
+type PositiveNumericCharacterGt<A extends string, B extends string> = NumericString extends `${infer HeadA}${A}${infer TailA}`
+	? NumericString extends `${infer HeadB}${B}${infer TailB}`
+		? HeadA extends `${HeadB}${infer _}${infer __}`
+			? true
+			: false
+		: never
+	: never;
+
+export {};

package/node_modules/type-fest/source/internal/tuple.d.ts

@@ -0,0 +1,79 @@
+import type {GreaterThan} from '../greater-than.d.ts';
+import type {LessThan} from '../less-than.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
+import type {UnknownArray} from '../unknown-array.d.ts';
+
+/**
+Infer the length of the given tuple `<T>`.
+
+Returns `never` if the given type is an non-fixed-length array like `Array<string>`.
+
+@example
+```
+type Tuple = TupleLength<[string, number, boolean]>;
+//=> 3
+
+type Array = TupleLength<string[]>;
+//=> never
+
+// Supports union types.
+type Union = TupleLength<[] | [1, 2, 3] | number[]>;
+//=> 1 | 3
+```
+*/
+export type TupleLength<T extends UnknownArray> =
+	// `extends unknown` is used to convert `T` (if `T` is a union type) to
+	// a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types))
+	T extends unknown
+		? number extends T['length']
+			? never // Return never if the given type is an non-flexed-length array like `Array<string>`
+			: T['length']
+		: never; // Should never happen
+
+/**
+Returns the maximum value from a tuple of integers.
+
+Note:
+- Float numbers are not supported.
+
+@example
+```
+type A = TupleMax<[1, 2, 5, 3]>;
+//=> 5
+
+type B = TupleMax<[1, 2, 5, 3, 99, -1]>;
+//=> 99
+```
+*/
+export type TupleMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number]
+	? never
+	: A extends [infer F extends number, ...infer R extends number[]]
+		? GreaterThan<F, Result> extends true
+			? TupleMax<R, F>
+			: TupleMax<R, Result>
+		: Result;
+
+/**
+Returns the minimum value from a tuple of integers.
+
+Note:
+- Float numbers are not supported.
+
+@example
+```
+type A = TupleMin<[1, 2, 5, 3]>;
+//=> 1
+
+type B = TupleMin<[1, 2, 5, 3, -5]>;
+//=> -5
+```
+*/
+export type TupleMin<A extends number[], Result extends number = PositiveInfinity> = number extends A[number]
+	? never
+	: A extends [infer F extends number, ...infer R extends number[]]
+		? LessThan<F, Result> extends true
+			? TupleMin<R, F>
+			: TupleMin<R, Result>
+		: Result;
+
+export {};

package/node_modules/type-fest/source/internal/type.d.ts

@@ -0,0 +1,165 @@
+import type {If} from '../if.d.ts';
+import type {IsAny} from '../is-any.d.ts';
+import type {IsNever} from '../is-never.d.ts';
+import type {Primitive} from '../primitive.d.ts';
+import type {UnknownArray} from '../unknown-array.d.ts';
+import type {UnionToIntersection} from '../union-to-intersection.d.ts';
+
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+export type BuiltIns = Primitive | void | Date | RegExp;
+
+/**
+Matches non-recursive types.
+*/
+export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
+
+/**
+Matches maps, sets, or arrays.
+*/
+export type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;
+
+/**
+Returns a boolean for whether the two given types extends the base type.
+*/
+export type IsBothExtends<BaseType, FirstType, SecondType> = FirstType extends BaseType
+	? SecondType extends BaseType
+		? true
+		: false
+	: false;
+
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =
+	T extends {(...arguments_: infer A): unknown; (...arguments_: infer B): unknown}
+		? B extends A
+			? A extends B
+				? false
+				: true
+			: true
+		: false;
+
+/**
+Returns a boolean for whether the given `boolean` is not `false`.
+*/
+export type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
+
+/**
+Returns a boolean for whether the given type is primitive value or primitive type.
+
+@example
+```
+type A = IsPrimitive<'string'>;
+//=> true
+
+type B = IsPrimitive<string>;
+//=> true
+
+type C = IsPrimitive<Object>;
+//=> false
+```
+*/
+export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
+
+/**
+Returns a boolean for whether A is false.
+
+@example
+```
+type A = Not<true>;
+//=> false
+
+type B = Not<false>;
+//=> true
+```
+*/
+export type Not<A extends boolean> = A extends true
+	? false
+	: A extends false
+		? true
+		: never;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
+
+@example
+```
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
+
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
+
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
+```
+
+Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:
+
+@example
+```ts
+import type {StringRepeat} from 'type-fest';
+
+type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
+
+// The following implementation is not tail recursive
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
+//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// To fix this, move the recursion into a helper type
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+
+type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
+
+type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
+//=> ''
+```
+*/
+export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
+	If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+
+/**
+Returns a boolean for whether the given type is `any` or `never`.
+
+This type can be better to use than {@link IfNotAnyOrNever `IfNotAnyOrNever`} in recursive types because it does not evaluate any branches.
+
+@example
+```
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `false`
+type A = IsAnyOrNever<string>;
+//=> false
+
+// When `T` is `any` => Returns `true`
+type B = IsAnyOrNever<any>;
+//=> true
+
+// When `T` is `never` => Returns `true`
+type C = IsAnyOrNever<never>;
+//=> true
+```
+*/
+export type IsAnyOrNever<T> = IsNotFalse<IsAny<T> | IsNever<T>>;
+
+/**
+Indicates the value of `exactOptionalPropertyTypes` compiler option.
+*/
+export type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?]
+	? false
+	: true;
+
+export {};

package/node_modules/type-fest/source/invariant-of.d.ts

@@ -0,0 +1,85 @@
+declare const invariantBrand: unique symbol;
+
+/**
+Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
+
+Use-case:
+- Prevent runtime errors that may occur due to assigning subtypes to supertypes.
+- Improve type signature of object methods like [`Object.keys()` or `Object.entries()`](https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208) by sealing the object type.
+
+@example
+```
+import type {InvariantOf} from 'type-fest';
+
+class Animal {
+	constructor(public name: string) {}
+}
+
+class Cat extends Animal {
+	meow() {
+		// do something
+	}
+}
+
+let animalArray: Animal[] = [new Animal('jerry')];
+const catArray: Cat[] = [new Cat('tom')];
+
+animalArray = catArray; // Okay if covariant
+animalArray.push(new Animal('another animal')); // Pushed an animal into catArray
+for (const c of catArray) {
+	c.meow();
+} // Allowed but, error at runtime
+
+let invariantAnimalArray: Array<InvariantOf<Animal>> = [new Animal('jerry')] as Array<InvariantOf<Animal>>;
+const invariantCatArray: Array<InvariantOf<Cat>> = [new Cat('tom')] as Array<InvariantOf<Cat>>;
+
+// @ts-expect-error
+invariantAnimalArray = invariantCatArray; // Error: Type 'InvariantOf<Cat>[]' is not assignable to type 'InvariantOf<Animal>[]'.
+```
+
+@example
+```
+import type {InvariantOf} from 'type-fest';
+
+// In covariance (default)
+
+type FooBar = {
+	foo: number;
+	bar: string;
+};
+
+type FooBarBaz = {
+	baz: boolean;
+} & FooBar;
+
+declare const fooBar: FooBar;
+declare const fooBarBaz: FooBarBaz;
+
+function keyOfFooBar(fooBar: FooBar) {
+	return Object.keys(fooBar) as Array<keyof FooBar>;
+}
+
+keyOfFooBar(fooBar); //=> (keyof FooBar)[]
+keyOfFooBar(fooBarBaz); //=> (keyof FooBar)[] but, (keyof FooBarBaz)[] at runtime
+
+// In invariance
+
+export function invariantOf<Type>(value: Type): InvariantOf<Type> {
+	return value as InvariantOf<Type>;
+}
+
+function keyOfInvariantFooBar(fooBar: InvariantOf<FooBar>) {
+	return Object.keys(fooBar) as Array<keyof FooBar>;
+}
+
+keyOfInvariantFooBar(invariantOf(fooBar)); // (keyof FooBar)[]
+
+// @ts-expect-error
+keyOfInvariantFooBar(invariantOf(fooBarBaz)); // Error: Argument of type 'InvariantOf<FooBarBaz>' is not assignable to parameter of type 'InvariantOf<FooBar>'.
+```
+
+@category Type
+*/
+export type InvariantOf<Type> = Type & {[invariantBrand]: (_: Type) => Type};
+
+export {};

package/node_modules/type-fest/source/is-any.d.ts

@@ -0,0 +1,31 @@
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+
+export {};

package/node_modules/type-fest/source/is-equal.d.ts

@@ -0,0 +1,41 @@
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsEqual<A, B> =
+	[A] extends [B]
+		? [B] extends [A]
+			? _IsEqual<A, B>
+			: false
+		: false;
+
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> =
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
+		? true
+		: false;
+
+export {};

package/node_modules/type-fest/source/is-float.d.ts

@@ -0,0 +1,43 @@
+/**
+Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
+
+Use-case:
+- If you want to make a conditional branch based on the result of whether a number is a float or not.
+
+@example
+```
+import type {IsFloat, PositiveInfinity} from 'type-fest';
+
+type A = IsFloat<1.5>;
+//=> true
+
+type B = IsFloat<-1.5>;
+//=> true
+
+type C = IsFloat<1e-7>;
+//=> true
+
+type D = IsFloat<1.0>;
+//=> false
+
+type E = IsFloat<PositiveInfinity>;
+//=> false
+
+type F = IsFloat<1.23e+21>;
+//=> false
+```
+
+@category Type Guard
+@category Numeric
+*/
+export type IsFloat<T> = T extends number
+	? `${T}` extends `${number}e${infer E extends '-' | '+'}${number}`
+		? E extends '-'
+			? true
+			: false
+		: `${T}` extends `${number}.${number}`
+			? true
+			: false
+	: false;
+
+export {};

package/node_modules/type-fest/source/is-integer.d.ts

@@ -0,0 +1,60 @@
+import type {Not} from './internal/index.d.ts';
+import type {IsFloat} from './is-float.d.ts';
+import type {PositiveInfinity, NegativeInfinity} from './numeric.d.ts';
+
+/**
+Returns a boolean for whether the given number is an integer, like `-5`, `1.0`, or `100`.
+
+Use-case:
+- If you want to make a conditional branch based on the result of whether a number is an integer or not.
+
+@example
+```
+import type {IsInteger, PositiveInfinity} from 'type-fest';
+
+type A = IsInteger<1>;
+//=> true
+
+type B = IsInteger<1.0>;
+//=> true
+
+type C = IsInteger<-1>;
+//=> true
+
+type D = IsInteger<0b10>;
+//=> true
+
+type E = IsInteger<0o10>;
+//=> true
+
+type F = IsInteger<0x10>;
+//=> true
+
+type G = IsInteger<1.23e+21>;
+//=> true
+
+type H = IsInteger<1.5>;
+//=> false
+
+type I = IsInteger<PositiveInfinity>;
+//=> false
+
+type J = IsInteger<1e-7>;
+//=> false
+```
+
+@category Type Guard
+@category Numeric
+*/
+export type IsInteger<T> =
+	T extends bigint
+		? true
+		: T extends number
+			? number extends T
+				? false
+				: T extends PositiveInfinity | NegativeInfinity
+					? false
+					: Not<IsFloat<T>>
+			: false;
+
+export {};