mimo-reasonix 0.1.0 → 0.1.1

package/node_modules/type-fest/source/camel-cased-properties.d.ts

@@ -0,0 +1,49 @@
+import type {CamelCase, CamelCaseOptions, _DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+
+/**
+Convert top-level object properties to camel case.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link CamelCasedPropertiesDeep}
+@see {@link CamelCase}
+
+@example
+```
+import type {CamelCasedProperties} from 'type-fest';
+
+type User = {
+	UserId: number;
+	UserName: string;
+};
+
+const result: CamelCasedProperties<User> = {
+	userId: 1,
+	userName: 'Tom',
+};
+
+const preserveConsecutiveUppercase: CamelCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
+	fooBAR: 'string',
+};
+
+const splitOnPunctuation: CamelCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	fooBar: 'string',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type CamelCasedProperties<Value, Options extends CamelCaseOptions = {}> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
+		? Value
+		: {
+			[K in keyof Value as
+			CamelCase<K, ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>>
+			]: Value[K];
+		};
+
+export {};

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

@@ -0,0 +1,67 @@
+/**
+Matches any uppercase letter in the basic Latin alphabet (A-Z).
+
+@example
+```
+import type {UppercaseLetter} from 'type-fest';
+
+const a: UppercaseLetter = 'A'; // Valid
+// @ts-expect-error
+const b: UppercaseLetter = 'a'; // Invalid
+// @ts-expect-error
+const c: UppercaseLetter = 'AB'; // Invalid
+```
+
+@category Type
+*/
+export type UppercaseLetter = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+
+/**
+Matches any lowercase letter in the basic Latin alphabet (a-z).
+
+@example
+```
+import type {LowercaseLetter} from 'type-fest';
+
+const a: LowercaseLetter = 'a'; // Valid
+// @ts-expect-error
+const b: LowercaseLetter = 'A'; // Invalid
+```
+
+@category Type
+*/
+export type LowercaseLetter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+
+/**
+Matches any digit as a string ('0'-'9').
+
+@example
+```
+import type {DigitCharacter} from 'type-fest';
+
+const a: DigitCharacter = '0'; // Valid
+// @ts-expect-error
+const b: DigitCharacter = 0; // Invalid
+```
+
+@category Type
+*/
+export type DigitCharacter = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+
+/**
+Matches any lowercase letter (a-z), uppercase letter (A-Z), or digit ('0'-'9') in the basic Latin alphabet.
+
+@example
+```
+import type {Alphanumeric} from 'type-fest';
+
+const a: Alphanumeric = 'A'; // Valid
+// @ts-expect-error
+const b: Alphanumeric = '#'; // Invalid
+```
+
+@category Type
+*/
+export type Alphanumeric = LowercaseLetter | UppercaseLetter | DigitCharacter;
+
+export {};

package/node_modules/type-fest/source/conditional-except.d.ts

@@ -0,0 +1,47 @@
+import type {Except} from './except.d.ts';
+import type {ConditionalKeys} from './conditional-keys.d.ts';
+
+/**
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	constructor(public name: string, public successes: number, public failures: bigint) {}
+
+	run() {
+		// do something
+	}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+type Example = {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+};
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+export type ConditionalExcept<Base, Condition> = Except<
+	Base,
+	ConditionalKeys<Base, Condition>
+>;
+
+export {};

package/node_modules/type-fest/source/conditional-keys.d.ts

@@ -0,0 +1,63 @@
+import type {ExtendsStrict} from './extends-strict.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {TupleToObject} from './tuple-to-object.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type Example = {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+};
+
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
+
+Note: To extract optional keys, make sure your `Condition` is a union of `undefined` (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<{a?: string}, string | undefined>;
+//=> 'a'
+
+type NoMatchingKeys = ConditionalKeys<{a?: string}, string>;
+//=> never
+```
+
+You can also extract array indices whose value match the specified condition, as shown below:
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringValueIndices = ConditionalKeys<[string, number, string], string>;
+//=> '0' | '2'
+
+type NumberValueIndices = ConditionalKeys<[string, number?, string?], number | undefined>;
+//=> '1'
+```
+
+@category Object
+*/
+export type ConditionalKeys<Base, Condition> = (Base extends UnknownArray ? TupleToObject<Base> : Base) extends infer _Base // Remove non-numeric keys from arrays
+	? IfNotAnyOrNever<_Base, _ConditionalKeys<_Base, Condition>, keyof _Base>
+	: never;
+
+type _ConditionalKeys<Base, Condition> = keyof {
+	[
+	Key in (keyof Base & {}) as // `& {}` prevents homomorphism
+	ExtendsStrict<Base[Key], Condition> extends true ? Key : never
+	]: never
+};
+
+export {};

package/node_modules/type-fest/source/conditional-pick-deep.d.ts

@@ -0,0 +1,122 @@
+import type {IsEqual} from './is-equal.d.ts';
+import type {ConditionalExcept} from './conditional-except.d.ts';
+import type {ConditionalSimplifyDeep} from './conditional-simplify-deep.d.ts';
+import type {UnknownRecord} from './unknown-record.d.ts';
+import type {EmptyObject} from './empty-object.d.ts';
+import type {ApplyDefaultOptions, IsPlainObject} from './internal/index.d.ts';
+
+/**
+Used to mark properties that should be excluded.
+*/
+declare const conditionalPickDeepSymbol: unique symbol;
+
+/**
+Assert the condition according to the {@link ConditionalPickDeepOptions.condition|condition} option.
+*/
+type AssertCondition<Type, Condition, Options extends ConditionalPickDeepOptions> = Options['condition'] extends 'equality'
+	? IsEqual<Type, Condition>
+	: Type extends Condition
+		? true
+		: false;
+
+/**
+ConditionalPickDeep options.
+
+@see {@link ConditionalPickDeep}
+*/
+export type ConditionalPickDeepOptions = {
+	/**
+	The condition assertion mode.
+
+	@default 'extends'
+	*/
+	condition?: 'extends' | 'equality';
+};
+
+type DefaultConditionalPickDeepOptions = {
+	condition: 'extends';
+};
+
+/**
+Pick keys recursively from the shape that matches the given condition.
+
+@see {@link ConditionalPick}
+
+@example
+```
+import type {ConditionalPickDeep} from 'type-fest';
+
+type Example = {
+	a: string;
+	b: string | boolean;
+	c: {
+		d: string;
+		e: {
+			f?: string;
+			g?: boolean;
+			h: string | boolean;
+			i: boolean | bigint;
+		};
+		j: boolean;
+	};
+};
+
+type StringPick = ConditionalPickDeep<Example, string>;
+//=> {a: string; c: {d: string}}
+
+type StringPickOptional = ConditionalPickDeep<Example, string | undefined>;
+//=> {a: string; c: {d: string; e: {f?: string}}}
+
+type StringPickOptionalOnly = ConditionalPickDeep<Example, string | undefined, {condition: 'equality'}>;
+//=> {c: {e: {f?: string}}}
+
+type BooleanPick = ConditionalPickDeep<Example, boolean | undefined>;
+//=> {c: {e: {g?: boolean}; j: boolean}}
+
+type NumberPick = ConditionalPickDeep<Example, number>;
+//=> never
+
+type StringOrBooleanPick = ConditionalPickDeep<Example, string | boolean>;
+//=> {
+// 	a: string;
+// 	b: string | boolean;
+// 	c: {
+// 		d: string;
+// 		e: {
+// 			h: string | boolean;
+// 		};
+// 		j: boolean;
+// 	};
+// }
+
+type StringOrBooleanPickOnly = ConditionalPickDeep<Example, string | boolean, {condition: 'equality'}>;
+//=> {b: string | boolean; c: {e: {h: string | boolean}}}
+```
+
+@category Object
+*/
+export type ConditionalPickDeep<
+	Type,
+	Condition,
+	Options extends ConditionalPickDeepOptions = {},
+> = _NeverIfEmpty<_ConditionalPickDeep<
+	Type,
+	Condition,
+	ApplyDefaultOptions<ConditionalPickDeepOptions, DefaultConditionalPickDeepOptions, Options>
+>>;
+
+type _NeverIfEmpty<Type> = Type extends EmptyObject ? never : Type;
+
+type _ConditionalPickDeep<
+	Type,
+	Condition,
+	Options extends Required<ConditionalPickDeepOptions>,
+> = ConditionalSimplifyDeep<ConditionalExcept<{
+	[Key in keyof Type]: AssertCondition<Type[Key], Condition, Options> extends true
+		? Type[Key]
+		: IsPlainObject<Type[Key]> extends true
+			? _ConditionalPickDeep<Type[Key], Condition, Options>
+			: typeof conditionalPickDeepSymbol;
+}, (typeof conditionalPickDeepSymbol | undefined) | EmptyObject>, never, UnknownRecord>;
+
+export {};

package/node_modules/type-fest/source/conditional-pick.d.ts

@@ -0,0 +1,48 @@
+import type {ConditionalKeys} from './conditional-keys.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
+/**
+Pick keys from the shape that matches the given `Condition`.
+
+This is useful when you want to create a new type from a specific subset of an existing type. For example, you might want to pick all the primitive properties from a class and form a new automatically derived type.
+
+@example
+```
+import type {Primitive, ConditionalPick} from 'type-fest';
+
+class Awesome {
+	constructor(public name: string, public successes: number, public failures: bigint) {}
+
+	run() {
+		// do something
+	}
+}
+
+type PickPrimitivesFromAwesome = ConditionalPick<Awesome, Primitive>;
+//=> {name: string; successes: number; failures: bigint}
+```
+
+@example
+```
+import type {ConditionalPick} from 'type-fest';
+
+type Example = {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+};
+
+type StringKeysOnly = ConditionalPick<Example, string>;
+//=> {a: string}
+```
+
+@category Object
+*/
+export type ConditionalPick<Base, Condition> = ConditionalKeys<Base, Condition> extends infer Keys
+	? IsNever<Keys> extends true
+		? never
+		: Pick<Base, Keys & keyof Base>
+	: never;
+
+export {};

package/node_modules/type-fest/source/conditional-simplify-deep.d.ts

@@ -0,0 +1,73 @@
+/**
+Recursively simplifies a type while including and/or excluding certain types from being simplified.
+
+@example
+```
+import type {ConditionalSimplifyDeep} from 'type-fest';
+
+type TypeA = {
+	foo: {
+		a: string;
+	};
+};
+
+type TypeB = {
+	foo: {
+		b: string;
+	};
+};
+
+type SimplifyDeepTypeAB = ConditionalSimplifyDeep<TypeA & TypeB, never, object>;
+//=> {foo: {a: string; b: string}}
+```
+
+@example
+```
+import type {ConditionalSimplifyDeep} from 'type-fest';
+
+type SomeComplexType1 = {
+	a1: string;
+	b1: number;
+	c1: boolean;
+};
+
+type SomeComplexType2 = {
+	a2: string;
+	b2: number;
+	c2: boolean;
+};
+
+type TypeA = {
+	foo: {
+		a: string;
+		complexType: SomeComplexType1;
+	};
+};
+
+type TypeB = {
+	foo: {
+		b: string;
+		complexType: SomeComplexType2;
+	};
+};
+
+type SimplifyDeepTypeAB = ConditionalSimplifyDeep<TypeA & TypeB, SomeComplexType1 | SomeComplexType2, object>;
+//=> {
+// 	foo: {
+// 		a: string;
+// 		complexType: SomeComplexType1 & SomeComplexType2;
+// 		b: string;
+// 	};
+// }
+```
+
+@see {@link SimplifyDeep}
+@category Object
+*/
+export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
+	? Type
+	: Type extends IncludeType
+		? {[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>}
+		: Type;
+
+export {};

package/node_modules/type-fest/source/conditional-simplify.d.ts

@@ -0,0 +1,50 @@
+/**
+Simplifies a type while including and/or excluding certain types from being simplified.
+
+Useful to improve type hints shown in editors. And also to transform an `interface` into a `type` to aid with assignability.
+
+@example
+```
+import type {ConditionalSimplify} from 'type-fest';
+
+type TypeA = {
+	a: string;
+};
+
+type TypeB = {
+	b: string;
+};
+
+type TypeAB = TypeA & TypeB;
+//=> TypeA & TypeB
+
+type SimplifyTypeAB = ConditionalSimplify<TypeAB, never, object>;
+//=> {a: string; b: string}
+```
+
+@example
+```
+import type {ConditionalSimplify} from 'type-fest';
+
+type Simplify<T> = ConditionalSimplify<T, Set<unknown> | Map<unknown, unknown> | unknown[], object>;
+
+type A = Simplify<Set<number> & Set<string>>;
+//=> Set<number> & Set<string>
+
+type B = Simplify<Map<number, number> & Map<string, string>>;
+//=> Map<number, number> & Map<string, string>
+
+type C = Simplify<{a: number} & {b: string}>;
+//=> {a: number; b: string}
+```
+
+@see {@link ConditionalSimplifyDeep}
+@category Object
+*/
+export type ConditionalSimplify<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
+	? Type
+	: Type extends IncludeType
+		? {[TypeKey in keyof Type]: Type[TypeKey]}
+		: Type;
+
+export {};

package/node_modules/type-fest/source/delimiter-case.d.ts

@@ -0,0 +1,78 @@
+import type {ApplyDefaultOptions, AsciiPunctuation, StartsWith} from './internal/index.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
+import type {Merge} from './merge.d.ts';
+import type {RemovePrefix} from './remove-prefix.d.ts';
+import type {_DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
+
+export type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {splitOnNumbers: false}>;
+
+/**
+Convert an array of words to delimiter case starting with a delimiter with input capitalization.
+*/
+type DelimiterCaseFromArray<
+	Words extends string[],
+	Delimiter extends string,
+	OutputString extends string = '',
+> = Words extends [
+	infer FirstWord extends string,
+	...infer RemainingWords extends string[],
+]
+	? DelimiterCaseFromArray<RemainingWords, Delimiter, `${OutputString}${
+		StartsWith<FirstWord, AsciiPunctuation> extends true ? '' : Delimiter
+	}${FirstWord}`>
+	: OutputString;
+
+/**
+Convert a string literal to a custom string delimiter casing.
+
+This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
+
+@see {@link KebabCase}
+@see {@link SnakeCase}
+
+@example
+```
+import type {DelimiterCase} from 'type-fest';
+
+// Simple
+
+const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
+const someVariableWithPunctuation: DelimiterCase<'div.card::after', '#', {splitOnPunctuation: true}> = 'div#card#after';
+
+// Advanced
+
+type OddlyCasedProperties<T> = {
+	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+};
+
+type SomeOptions = {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+};
+
+const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
+	'dry#run': true,
+	'include#file': 'bar.js',
+	foo: 123,
+};
+```
+
+@category Change case
+@category Template literal
+ */
+export type DelimiterCase<
+	Value,
+	Delimiter extends string,
+	Options extends WordsOptions = {},
+> = Value extends string
+	? IsStringLiteral<Value> extends false
+		? Value
+		: Lowercase<RemovePrefix<DelimiterCaseFromArray<
+			Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>,
+			Delimiter
+		>, string, {strict: false}>>
+	: Value;
+
+export {};