@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.5

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

@@ -1,236 +0,0 @@
-import type {Simplify} from '../simplify';
-import type {UnknownArray} from '../unknown-array';
-import type {IsEqual} from '../is-equal';
-import type {KeysOfUnion} from '../keys-of-union';
-import type {RequiredKeysOf} from '../required-keys-of';
-import type {Merge} from '../merge';
-import type {IfAny} from '../if-any';
-import type {IfNever} from '../if-never';
-import type {OptionalKeysOf} from '../optional-keys-of';
-import type {FilterDefinedKeys, FilterOptionalKeys} from './keys';
-import type {NonRecursiveType} from './type';
-import type {ToString} from './string';
-
-/**
-Create an object type with the given key `<Key>` and value `<Value>`.
-
-It will copy the prefix and optional status of the same key from the given object `CopiedFrom` into the result.
-
-@example
-```
-type A = BuildObject<'a', string>;
-//=> {a: string}
-
-// Copy `readonly` and `?` from the key `a` of `{readonly a?: any}`
-type B = BuildObject<'a', string, {readonly a?: any}>;
-//=> {readonly a?: string}
-```
-*/
-export type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends object = {}> =
-	Key extends keyof CopiedFrom
-		? Pick<{[_ in keyof CopiedFrom]: Value}, Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof CopiedFrom
-				? Pick<{[_ in keyof CopiedFrom]: Value}, NumberKey>
-				: {[_ in Key]: Value}
-			: {[_ in Key]: Value};
-
-/**
-Returns a boolean for whether the given type is a plain key-value object.
-*/
-export type IsPlainObject<T> =
-	T extends NonRecursiveType | UnknownArray | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
-		? false
-		: T extends object
-			? true
-			: false;
-
-/**
-Extract the object field type if T is an object and K is a key of T, return `never` otherwise.
-
-It creates a type-safe way to access the member type of `unknown` type.
-*/
-export type ObjectValue<T, K> =
-	K extends keyof T
-		? T[K]
-		: ToString<K> extends keyof T
-			? T[ToString<K>]
-			: K extends `${infer NumberK extends number}`
-				? NumberK extends keyof T
-					? T[NumberK]
-					: never
-				: never;
-
-/**
-For an object T, if it has any properties that are a union with `undefined`, make those into optional properties instead.
-
-@example
-```
-type User = {
-	firstName: string;
-	lastName: string | undefined;
-};
-
-type OptionalizedUser = UndefinedToOptional<User>;
-//=> {
-// 	firstName: string;
-// 	lastName?: string;
-// }
-```
-*/
-export type UndefinedToOptional<T extends object> = Simplify<
-{
-	// Property is not a union with `undefined`, keep it as-is.
-	[Key in keyof Pick<T, FilterDefinedKeys<T>>]: T[Key];
-} & {
-	// Property _is_ a union with defined value. Set as optional (via `?`) and remove `undefined` from the union.
-	[Key in keyof Pick<T, FilterOptionalKeys<T>>]?: Exclude<T[Key], undefined>;
-}
->;
-
-/**
-Works similar to the built-in `Pick` utility type, except for the following differences:
-- Distributes over union types and allows picking keys from any member of the union type.
-- Primitives types are returned as-is.
-- Picks all keys if `Keys` is `any`.
-- Doesn't pick `number` from a `string` index signature.
-
-@example
-```
-type ImageUpload = {
-	url: string;
-	size: number;
-	thumbnailUrl: string;
-};
-
-type VideoUpload = {
-	url: string;
-	duration: number;
-	encodingFormat: string;
-};
-
-// Distributes over union types and allows picking keys from any member of the union type
-type MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, "url" | "size" | "duration">;
-//=> {url: string; size: number} | {url: string; duration: number}
-
-// Primitive types are returned as-is
-type Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;
-//=> string | number
-
-// Picks all keys if `Keys` is `any`
-type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
-//=> {a: 1; b: 2} | {c: 3}
-
-// Doesn't pick `number` from a `string` index signature
-type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
-//=> {}
-*/
-export type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
-	[P in keyof T as Extract<P, Keys>]: T[P]
-};
-
-/**
-Extract all possible values for a given key from a union of object types.
-
-@example
-```
-type Statuses = ValueOfUnion<{ id: 1, status: "open" } | { id: 2, status: "closed" }, "status">;
-//=> "open" | "closed"
-```
-*/
-export type ValueOfUnion<Union, Key extends KeysOfUnion<Union>> =
-	Union extends unknown ? Key extends keyof Union ? Union[Key] : never : never;
-
-/**
-Extract all readonly keys from a union of object types.
-
-@example
-```
-type User = {
-		readonly id: string;
-		name: string;
-};
-
-type Post = {
-		readonly id: string;
-		readonly author: string;
-		body: string;
-};
-
-type ReadonlyKeys = ReadonlyKeysOfUnion<User | Post>;
-//=> "id" | "author"
-```
-*/
-export type ReadonlyKeysOfUnion<Union> = Union extends unknown ? keyof {
-	[Key in keyof Union as IsEqual<{[K in Key]: Union[Key]}, {readonly [K in Key]: Union[Key]}> extends true ? Key : never]: never
-} : never;
-
-/**
-Merges user specified options with default options.
-
-@example
-```
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: true};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//=> {maxRecursionDepth: 10; leavesOnly: true}
-```
-
-@example
-```
-// Complains if default values are not provided for optional options
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
-```
-
-@example
-```
-// Complains if an option's default type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-
-@example
-```
-// Complains if an option's specified type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: 'yes'};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                                                   ~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-*/
-export type ApplyDefaultOptions<
-	Options extends object,
-	Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,
-	SpecifiedOptions extends Options,
-> =
-	IfAny<SpecifiedOptions, Defaults,
-	IfNever<SpecifiedOptions, Defaults,
-	Simplify<Merge<Defaults, {
-		[Key in keyof SpecifiedOptions
-		as Key extends OptionalKeysOf<Options>
-			? Extract<SpecifiedOptions[Key], undefined> extends never
-				? Key
-				: never
-			: Key
-		]: SpecifiedOptions[Key]
-	}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
-	>>;

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

@@ -1,210 +0,0 @@
-import type {NegativeInfinity, PositiveInfinity} from '../numeric';
-import type {Trim} from '../trim';
-import type {Whitespace} from './characters';
-import type {BuildTuple} from './tuple';
-
-/**
-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
-```
-StartsWith<'abcde', 'abc'>;
-//=> true
-
-StartsWith<'abcde', 'bc'>;
-//=> false
-
-StartsWith<string, 'bc'>;
-//=> never
-
-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
-```
-StringToArray<'abcde'>;
-//=> ['a', 'b', 'c', 'd', 'e']
-
-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
-```
-StringLength<'abcde'>;
-//=> 5
-
-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 the string is lowercased.
-*/
-export type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;
-
-/**
-Returns a boolean for whether the string is uppercased.
-*/
-export type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;
-
-/**
-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
-```
-SameLengthPositiveNumericStringGt<'50', '10'>;
-//=> true
-
-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
-```
-PositiveNumericStringGt<'500', '1'>;
-//=> true
-
-PositiveNumericStringGt<'1', '1'>;
-//=> false
-
-PositiveNumericStringGt<'1', '500'>;
-//=> false
-```
-*/
-export type PositiveNumericStringGt<A extends string, B extends string> = A extends B
-	? false
-	: [BuildTuple<StringLength<A>, 0>, BuildTuple<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
-```
-PositiveNumericCharacterGt<'5', '1'>;
-//=> true
-
-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;

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

@@ -1,90 +0,0 @@
-import type {GreaterThan} from '../greater-than';
-import type {LessThan} from '../less-than';
-import type {NegativeInfinity, PositiveInfinity} from '../numeric';
-import type {UnknownArray} from '../unknown-array';
-
-/**
-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] | Array<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 conditionaltype](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
-
-/**
-Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.
-
-If `<Fill>` is not provided, it will default to `unknown`.
-
-@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
-*/
-export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = number extends L
-	? Fill[]
-	: L extends T['length']
-		? T
-		: BuildTuple<L, Fill, [...T, Fill]>;
-
-/**
-Returns the maximum value from a tuple of integers.
-
-Note:
-- Float numbers are not supported.
-
-@example
-```
-ArrayMax<[1, 2, 5, 3]>;
-//=> 5
-
-ArrayMax<[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
-```
-ArrayMin<[1, 2, 5, 3]>;
-//=> 1
-
-ArrayMin<[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;

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

@@ -1,139 +0,0 @@
-import type {IsAny} from '../is-any';
-import type {IsNever} from '../is-never';
-import type {Primitive} from '../primitive';
-
-/**
-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);
-
-/**
-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
-```
-IsPrimitive<'string'>
-//=> true
-
-IsPrimitive<string>
-//=> true
-
-IsPrimitive<Object>
-//=> false
-```
-*/
-export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-
-/**
-Returns a boolean for whether A is false.
-
-@example
-```
-Not<true>;
-//=> false
-
-Not<false>;
-//=> true
-```
-*/
-export type Not<A extends boolean> = A extends true
-	? false
-	: A extends false
-		? true
-		: never;
-
-/**
-Returns a boolean for whether the given type is a union type.
-
-@example
-```
-type A = IsUnion<string | number>;
-//=> true
-
-type B = IsUnion<string>;
-//=> false
-```
-*/
-export type IsUnion<T> = InternalIsUnion<T>;
-
-/**
-The actual implementation of `IsUnion`.
-*/
-type InternalIsUnion<T, U = T> =
-(
-	// @link https://ghaiklor.github.io/type-challenges-solutions/en/medium-isunion.html
-	IsNever<T> extends true
-		? false
-		: T extends any
-			? [U] extends [T]
-				? false
-				: true
-			: never
-) extends infer Result
-	// In some cases `Result` will return `false | true` which is `boolean`,
-	// that means `T` has at least two types and it's a union type,
-	// so we will return `true` instead of `boolean`.
-	? boolean extends Result ? true
-		: Result
-	: never; // Should never happen
-
-/**
-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'
-```
-*/
-export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
-	IsAny<T> extends true
-		? IfAny
-		: IsNever<T> extends true
-			? IfNever
-			: IfNotAnyOrNever;