mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/type-fest/source/has-writable-keys.d.ts

@@ -0,0 +1,23 @@
+import type {WritableKeysOf} from './writable-keys-of.d.ts';
+
+/**
+Returns a boolean for whether the given type has any writable fields.
+
+This is useful when you want to create an API whose behavior depends on the presence or absence of writable fields.
+
+@example
+```
+import type {HasWritableKeys, WritableKeysOf} from 'type-fest';
+
+type UpdateService<Entity extends object> = {
+	removeField: HasWritableKeys<Entity> extends true
+		? (field: WritableKeysOf<Entity>) => Promise<void>
+		: never;
+};
+```
+
+@category Utilities
+*/
+export type HasWritableKeys<BaseType extends object> = WritableKeysOf<BaseType> extends never ? false : true;
+
+export {};

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

@@ -0,0 +1,28 @@
+import type {IsAny} from './is-any.d.ts';
+
+/**
+An if-else-like type that resolves depending on whether the given type is `any`.
+
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
+@see {@link IsAny}
+
+@example
+```
+import type {IfAny} from 'type-fest';
+
+type ShouldBeTrue = IfAny<any>;
+//=> true
+
+type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (
+	IsAny<T> extends true ? TypeIfAny : TypeIfNotAny
+);
+
+export {};

package/node_modules/type-fest/source/if-empty-object.d.ts

@@ -0,0 +1,30 @@
+import type {IsEmptyObject} from './empty-object.d.ts';
+
+/**
+An if-else-like type that resolves depending on whether the given type is `{}`.
+
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
+@see {@link IsEmptyObject}
+
+@example
+```
+import type {IfEmptyObject} from 'type-fest';
+
+type ShouldBeTrue = IfEmptyObject<{}>;
+//=> true
+
+type ShouldBeBar = IfEmptyObject<{key: any}, 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfEmptyObject<
+	T,
+	TypeIfEmptyObject = true,
+	TypeIfNotEmptyObject = false,
+> = IsEmptyObject<T> extends true ? TypeIfEmptyObject : TypeIfNotEmptyObject;
+
+export {};

package/node_modules/type-fest/source/if-never.d.ts

@@ -0,0 +1,28 @@
+import type {IsNever} from './is-never.d.ts';
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+export {};

package/node_modules/type-fest/source/if-null.d.ts

@@ -0,0 +1,28 @@
+import type {IsNull} from './is-null.d.ts';
+
+/**
+An if-else-like type that resolves depending on whether the given type is `null`.
+
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
+@see {@link IsNull}
+
+@example
+```
+import type {IfNull} from 'type-fest';
+
+type ShouldBeTrue = IfNull<null>;
+//=> true
+
+type ShouldBeBar = IfNull<'not null', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfNull<T, TypeIfNull = true, TypeIfNotNull = false> = (
+	IsNull<T> extends true ? TypeIfNull : TypeIfNotNull
+);
+
+export {};

package/node_modules/type-fest/source/if-unknown.d.ts

@@ -0,0 +1,28 @@
+import type {IsUnknown} from './is-unknown.d.ts';
+
+/**
+An if-else-like type that resolves depending on whether the given type is `unknown`.
+
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
+@see {@link IsUnknown}
+
+@example
+```
+import type {IfUnknown} from 'type-fest';
+
+type ShouldBeTrue = IfUnknown<unknown>;
+//=> true
+
+type ShouldBeBar = IfUnknown<'not unknown', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfUnknown<T, TypeIfUnknown = true, TypeIfNotUnknown = false> = (
+	IsUnknown<T> extends true ? TypeIfUnknown : TypeIfNotUnknown
+);
+
+export {};

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

@@ -0,0 +1,102 @@
+import type {IsNever} from './is-never.d.ts';
+
+/**
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
+
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
+
+@example
+```
+import type {If} from 'type-fest';
+
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import type {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import type {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
+
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type If<Type extends boolean, IfBranch, ElseBranch> =
+	IsNever<Type> extends true
+		? ElseBranch
+		: Type extends true
+			? IfBranch
+			: ElseBranch;
+
+export {};

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

@@ -0,0 +1,24 @@
+import type {IsEqual} from './is-equal.d.ts';
+
+/**
+Returns a boolean for whether the given array includes the given item.
+
+This can be useful if another type wants to make a decision based on whether the array includes that item.
+
+@example
+```
+import type {Includes} from 'type-fest';
+
+type hasRed<array extends any[]> = Includes<array, 'red'>;
+```
+
+@category Array
+*/
+export 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;
+
+export {};

package/node_modules/type-fest/source/int-closed-range.d.ts

@@ -0,0 +1,45 @@
+import type {IntRange} from './int-range.d.ts';
+import type {Sum} from './sum.d.ts';
+
+/**
+Generate a union of numbers between a specified start and end (both inclusive), with an optional step.
+
+You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntClosedRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8 | 10`.
+
+Note: `Start` or `End` must be non-negative and smaller than `999`.
+
+Use-cases:
+1. This can be used to define a set of valid input/output values. for example:
+
+@example
+```
+import type {IntClosedRange} from 'type-fest';
+
+type Age = IntClosedRange<0, 20>;
+//=> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+
+type FontSize = IntClosedRange<10, 20>;
+//=> 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+
+type EvenNumber = IntClosedRange<0, 10, 2>;
+//=> 0 | 2 | 4 | 6 | 8 | 10
+```
+
+2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntClosedRange<0, 100>;`
+
+@example
+```
+import type {IntClosedRange} from 'type-fest';
+
+type ZeroToNine = IntClosedRange<0, 9>;
+//=> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+
+type Hundreds = IntClosedRange<100, 900, 100>;
+//=> 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
+```
+
+@see {@link IntRange}
+*/
+export type IntClosedRange<Start extends number, End extends number, Skip extends number = 1> = IntRange<Start, Sum<End, 1>, Skip>;
+
+export {};

package/node_modules/type-fest/source/int-range.d.ts

@@ -0,0 +1,67 @@
+import type {TupleOf} from './tuple-of.d.ts';
+import type {Subtract} from './subtract.d.ts';
+
+/**
+Generate a union of numbers between a specified start (inclusive) and end (exclusive), with an optional step.
+
+You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8`.
+
+Note: `Start` or `End` must be non-negative and smaller than `1000`.
+
+Use-cases:
+1. This can be used to define a set of valid input/output values. for example:
+
+@example
+```
+import type {IntRange} from 'type-fest';
+
+type Age = IntRange<0, 20>;
+//=> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19
+
+type FontSize = IntRange<10, 20>;
+//=> 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19
+
+type EvenNumber = IntRange<0, 11, 2>;
+//=> 0 | 2 | 4 | 6 | 8 | 10
+```
+
+2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntRange<0, 100>;`
+
+@example
+```
+import type {IntRange} from 'type-fest';
+
+type ZeroToNine = IntRange<0, 10>;
+//=> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+
+type Hundreds = IntRange<100, 901, 100>;
+//=> 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
+```
+
+@see {@link IntClosedRange}
+*/
+export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
+
+/**
+The actual implementation of `IntRange`. It's private because it has some arguments that don't need to be exposed.
+*/
+type PrivateIntRange<
+	Start extends number,
+	End extends number,
+	Step extends number,
+	// The gap between each number, gap = step - 1
+	Gap extends number = Subtract<Step, 1>,
+	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
+	List extends unknown[] = TupleOf<Start, never>,
+	EndLengthTuple extends unknown[] = TupleOf<End>,
+> = Gap extends 0
+	// Handle the case that without `Step`
+	? List['length'] extends End // The result of "List[length] === End"
+		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
+		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
+	// Handle the case that with `Step`
+	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
+		? Exclude<List[number], never>
+		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>]>;
+
+export {};

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

@@ -0,0 +1,144 @@
+import type {If} from '../if.d.ts';
+import type {IsNever} from '../is-never.d.ts';
+import type {OptionalKeysOf} from '../optional-keys-of.d.ts';
+import type {UnknownArray} from '../unknown-array.d.ts';
+import type {IsExactOptionalPropertyTypesEnabled, IfNotAnyOrNever} from './type.d.ts';
+
+/**
+Matches any unknown array or tuple.
+*/
+export type UnknownArrayOrTuple = readonly [...unknown[]];
+// TODO: should unknown-array be updated?
+
+/**
+Extracts the type of the first element of an array or tuple.
+*/
+export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]]
+	? THead
+	: never;
+
+/**
+Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = StaticPartOfArray<A>;
+//=> [string, number, boolean]
+```
+*/
+export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> =
+	T extends unknown
+		? number extends T['length']
+			? T extends readonly [infer U, ...infer V]
+				? StaticPartOfArray<V, [...Result, U]>
+				: Result
+			: T
+		: never; // Should never happen
+
+/**
+Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = VariablePartOfArray<A>;
+//=> string[]
+```
+*/
+export type VariablePartOfArray<T extends UnknownArray> =
+	T extends unknown
+		? T extends readonly [...StaticPartOfArray<T>, ...infer U]
+			? U
+			: []
+		: never; // Should never happen
+
+/**
+Set the given array to readonly if `IsReadonly` is `true`, otherwise set the given array to normal, then return the result.
+
+@example
+```
+type ReadonlyStringArray = readonly string[];
+type NormalStringArray = string[];
+
+type ReadonlyResult = SetArrayAccess<NormalStringArray, true>;
+//=> readonly string[]
+
+type NormalResult = SetArrayAccess<ReadonlyStringArray, false>;
+//=> string[]
+```
+*/
+export type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
+	T extends readonly [...infer U]
+		? IsReadonly extends true
+			? readonly [...U]
+			: [...U]
+		: T;
+
+/**
+Returns whether the given array `T` is readonly.
+*/
+export type IsArrayReadonly<T extends UnknownArray> = If<IsNever<T>, false, T extends unknown[] ? false : true>;
+
+/**
+Transforms a tuple type by replacing it's rest element with a single element that has the same type as the rest element, while keeping all the non-rest elements intact.
+
+@example
+```
+type A = CollapseRestElement<[string, string, ...number[]]>;
+//=> [string, string, number]
+
+type B = CollapseRestElement<[...string[], number, number]>;
+//=> [string, number, number]
+
+type C = CollapseRestElement<[string, string, ...Array<number | bigint>]>;
+//=> [string, string, number | bigint]
+
+type D = CollapseRestElement<[string, number]>;
+//=> [string, number]
+```
+
+Note: Optional modifiers (`?`) are removed from elements unless the `exactOptionalPropertyTypes` compiler option is disabled. When disabled, there's an additional `| undefined` for optional elements.
+
+@example
+```
+// `exactOptionalPropertyTypes` enabled
+type A = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string, string, number]
+
+// `exactOptionalPropertyTypes` disabled
+type B = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string | undefined, string | undefined, number]
+```
+*/
+export type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+
+type _CollapseRestElement<
+	TArray extends UnknownArray,
+	ForwardAccumulator extends UnknownArray = [],
+	BackwardAccumulator extends UnknownArray = [],
+> =
+	TArray extends UnknownArray // For distributing `TArray`
+		? keyof TArray & `${number}` extends never
+			// Enters this branch, if `TArray` is empty (e.g., []),
+			// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+			? TArray extends readonly [...infer Rest, infer Last]
+				? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+				: TArray extends readonly []
+					? [...ForwardAccumulator, ...BackwardAccumulator]
+					: [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
+			: TArray extends readonly [(infer First)?, ...infer Rest]
+				? _CollapseRestElement<
+					Rest,
+					[
+						...ForwardAccumulator,
+						'0' extends OptionalKeysOf<TArray>
+							? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+							: First,
+					],
+					BackwardAccumulator
+				>
+				: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+		: never; // Should never happen
+
+export {};

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

@@ -0,0 +1,65 @@
+export type Whitespace =
+	| '\u{9}' // '\t'
+	| '\u{A}' // '\n'
+	| '\u{B}' // '\v'
+	| '\u{C}' // '\f'
+	| '\u{D}' // '\r'
+	| '\u{20}' // ' '
+	| '\u{85}'
+	| '\u{A0}'
+	| '\u{1680}'
+	| '\u{2000}'
+	| '\u{2001}'
+	| '\u{2002}'
+	| '\u{2003}'
+	| '\u{2004}'
+	| '\u{2005}'
+	| '\u{2006}'
+	| '\u{2007}'
+	| '\u{2008}'
+	| '\u{2009}'
+	| '\u{200A}'
+	| '\u{2028}'
+	| '\u{2029}'
+	| '\u{202F}'
+	| '\u{205F}'
+	| '\u{3000}'
+	| '\u{FEFF}';
+
+export type WordSeparators = '-' | '_' | Whitespace;
+
+export type AsciiPunctuation =
+	| '!'
+	| '"'
+	| '#'
+	| '$'
+	| '%'
+	| '&'
+	| '\''
+	| '('
+	| ')'
+	| '*'
+	| '+'
+	| ','
+	| '-'
+	| '.'
+	| '/'
+	| ':'
+	| ';'
+	| '<'
+	| '='
+	| '>'
+	| '?'
+	| '@'
+	| '['
+	| '\\'
+	| ']'
+	| '^'
+	| '_'
+	| '`'
+	| '{'
+	| '|'
+	| '}'
+	| '~';
+
+export {};

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

@@ -0,0 +1,49 @@
+import type {Simplify} from '../simplify.d.ts';
+
+// Returns `never` if the key is optional otherwise return the key type.
+type RequiredFilter<Type, Key extends keyof Type> = undefined extends Type[Key]
+	? Type[Key] extends undefined
+		? Key
+		: never
+	: Key;
+
+// Returns `never` if the key is required otherwise return the key type.
+type OptionalFilter<Type, Key extends keyof Type> = undefined extends Type[Key]
+	? Type[Key] extends undefined
+		? never
+		: Key
+	: never;
+
+/**
+Enforce optional keys (by adding the `?` operator) for keys that have a union with `undefined`.
+
+@example
+```
+import type {EnforceOptional} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b?: string;
+	c: undefined;
+	d: number | undefined;
+};
+
+type FooBar = EnforceOptional<Foo>;
+// => {
+// 	a: string;
+// 	b?: string;
+// 	c: undefined;
+// 	d?: number;
+// }
+```
+
+@internal
+@category Object
+*/
+export type EnforceOptional<ObjectType> = Simplify<{
+	[Key in keyof ObjectType as RequiredFilter<ObjectType, Key>]: ObjectType[Key]
+} & {
+	[Key in keyof ObjectType as OptionalFilter<ObjectType, Key>]?: Exclude<ObjectType[Key], undefined>
+}>;
+
+export {};

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

@@ -0,0 +1,11 @@
+export type * from './array.d.ts';
+export type * from './characters.d.ts';
+export type * from './keys.d.ts';
+export type * from './numeric.d.ts';
+export type * from './object.d.ts';
+export type * from './string.d.ts';
+export type * from './tuple.d.ts';
+export type * from './type.d.ts';
+export type * from './enforce-optional.d.ts';
+
+export {};