@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

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

@@ -1,76 +0,0 @@
-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() {}
-}
-
-let animalArray: Animal[] = [animal];
-let catArray: Cat[] = [cat];
-
-animalArray = catArray; // Okay if covariant
-animalArray.push(new Animal('another animal')); // Pushed an animal into catArray
-catArray.forEach(c => c.meow()); // Allowed but, error at runtime
-
-let invariantAnimalArray: InvariantOf<Animal>[] = [animal] as InvariantOf<Animal>[];
-let invariantCatArray: InvariantOf<Cat>[] = [cat] as InvariantOf<Cat>[];
-
-invariantAnimalArray = invariantCatArray; // Error: Type 'InvariantOf<Cat>[]' is not assignable to type 'InvariantOf<Animal>[]'.
-```
-
-@example
-```
-import type {InvariantOf} from 'type-fest';
-
-// In covariance (default)
-
-interface FooBar {
-	foo: number;
-	bar: string
-}
-
-interface FooBarBaz extends FooBar {
-	baz: boolean
-}
-
-declare const fooBar: FooBar
-declare const fooBarBaz: FooBarBaz
-
-function keyOfFooBar(fooBar: FooBar) {
-	return Object.keys(fooBar) as (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 (keyof FooBar)[]
-}
-
-keyOfInvariantFooBar(invariantOf(fooBar)); // (keyof FooBar)[]
-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};

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

@@ -1,33 +0,0 @@
-// Can eventually be replaced with the built-in once this library supports
-// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
-type NoInfer<T> = T extends infer U ? U : never;
-
-/**
-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>(obj: O, key: K) {
-	return obj[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;

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

@@ -1,31 +0,0 @@
-/**
-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> =
-	(<G>() => G extends A & G | G ? 1 : 2) extends
-	(<G>() => G extends B & G | G ? 1 : 2)
-		? true
-		: false;

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

@@ -1,41 +0,0 @@
-/**
-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;

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

@@ -1,58 +0,0 @@
-import type {Not} from './internal';
-import type {IsFloat} from './is-float';
-import type {PositiveInfinity, NegativeInfinity} from './numeric';
-
-/**
-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.23+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;

package/node_modules/ink/node_modules/type-fest/source/is-literal.d.ts

@@ -1,296 +0,0 @@
-import type {Primitive} from './primitive';
-import type {Numeric} from './numeric';
-import type {IsNotFalse, IsPrimitive} from './internal';
-import type {IsNever} from './is-never';
-import type {IfNever} from './if-never';
-
-/**
-Returns a boolean for whether the given type `T` is the specified `LiteralType`.
-
-@link https://stackoverflow.com/a/52806744/10292952
-
-@example
-```
-LiteralCheck<1, number>
-//=> true
-
-LiteralCheck<number, number>
-//=> false
-
-LiteralCheck<1, string>
-//=> false
-```
-*/
-type LiteralCheck<T, LiteralType extends Primitive> = (
-	IsNever<T> extends false // Must be wider than `never`
-		? [T] extends [LiteralType & infer U] // Remove any branding
-			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
-				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
-					? false
-					: true
-				: false
-			: false
-		: false
-);
-
-/**
-Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
-
-@example
-```
-LiteralChecks<1, Numeric>
-//=> true
-
-LiteralChecks<1n, Numeric>
-//=> true
-
-LiteralChecks<bigint, Numeric>
-//=> false
-```
-*/
-type LiteralChecks<T, LiteralUnionType> = (
-	// Conditional type to force union distribution.
-	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
-	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
-	IsNotFalse<LiteralUnionType extends Primitive
-		? LiteralCheck<T, LiteralUnionType>
-		: never
-	>
-);
-
-/**
-Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed string manipulation functions
-	- constraining strings to be a string literal
-	- type utilities, such as when constructing parsers and ASTs
-
-The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-@example
-```
-import type {IsStringLiteral} from 'type-fest';
-
-type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
-
-// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
-function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
-	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
-}
-
-const output = capitalize('hello, world!');
-//=> 'Hello, world!'
-```
-
-@example
-```
-// String types with infinite set of possible values return `false`.
-
-import type {IsStringLiteral} from 'type-fest';
-
-type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
-//=> false
-
-type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
-//=> false
-
-// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
-
-type Length<S extends string, Counter extends never[] = []> =
-	IsStringLiteral<S> extends false
-		? number // return `number` for infinite string types
-		: S extends `${string}${infer Tail}`
-			? Length<Tail, [...Counter, never]>
-			: Counter['length'];
-
-type L1 = Length<Lowercase<string>>;
-//=> number
-
-type L2 = Length<`${number}`>;
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsStringLiteral<T> = IfNever<T, false,
-// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
-// and since `{}` extends index signatures, the result becomes `false`.
-T extends string
-	? {} extends Record<T, never>
-		? false
-		: true
-	: false>;
-
-/**
-Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsNumericLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
-type EndsWith<TValue, TEndsWith extends string> =
-	TValue extends string
-		? IsStringLiteral<TEndsWith> extends true
-			? IsStringLiteral<TValue> extends true
-				? TValue extends `${string}${TEndsWith}`
-					? true
-					: false
-				: boolean
-			: boolean
-		: TValue extends number
-			? IsNumericLiteral<TValue> extends true
-				? EndsWith<`${TValue}`, TEndsWith>
-				: false
-			: false;
-
-function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
-	return `${input}`.endsWith(end) as EndsWith<Input, End>;
-}
-
-endsWith('abc', 'c');
-//=> true
-
-endsWith(123456, '456');
-//=> true
-
-const end = '123' as string;
-
-endsWith('abc123', end);
-//=> boolean
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
-
-/**
-Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsBooleanLiteral} from 'type-fest';
-
-const id = 123;
-
-type GetId<AsString extends boolean> =
-	IsBooleanLiteral<AsString> extends true
-		? AsString extends true
-			? `${typeof id}`
-			: typeof id
-		: number | string;
-
-function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
-	return (options?.asString ? `${id}` : id) as GetId<AsString>;
-}
-
-const numberId = getId();
-//=> 123
-
-const stringId = getId({asString: true});
-//=> '123'
-
-declare const runtimeBoolean: boolean;
-const eitherId = getId({asString: runtimeBoolean});
-//=> number | string
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
-
-/**
-Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsSymbolLiteral} from 'type-fest';
-
-type Get<Obj extends Record<symbol, number>, Key extends keyof Obj> =
-	IsSymbolLiteral<Key> extends true
-		? Obj[Key]
-		: number;
-
-function get<Obj extends Record<symbol, number>, Key extends keyof Obj>(o: Obj, key: Key) {
-	return o[key] as Get<Obj, Key>;
-}
-
-const symbolLiteral = Symbol('literal');
-const symbolValue: symbol = Symbol('value');
-
-get({[symbolLiteral]: 1} as const, symbolLiteral);
-//=> 1
-
-get({[symbolValue]: 1} as const, symbolValue);
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
-
-/** Helper type for `IsLiteral`. */
-type IsLiteralUnion<T> =
-	| IsStringLiteral<T>
-	| IsNumericLiteral<T>
-	| IsBooleanLiteral<T>
-	| IsSymbolLiteral<T>;
-
-/**
-Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/string-literals/StripLeading.ts
-export type StripLeading<A, B> =
-	A extends string
-		? B extends string
-			? IsLiteral<A> extends true
-				? string extends B ? never : A extends `${B & string}${infer After}` ? After : A
-				: string
-			: A
-		: A;
-
-function stripLeading<Input extends string, Strip extends string>(input: Input, strip: Strip) {
-	return input.replace(`^${strip}`, '') as StripLeading<Input, Strip>;
-}
-
-stripLeading('abc123', 'abc');
-//=> '123'
-
-const str = 'abc123' as string;
-
-stripLeading(str, 'abc');
-//=> string
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsLiteral<T> =
-	IsPrimitive<T> extends true
-		? IsNotFalse<IsLiteralUnion<T>>
-		: false;

package/node_modules/ink/node_modules/type-fest/source/is-never.d.ts

@@ -1,42 +0,0 @@
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNever<T> = [T] extends [never] ? true : false;

package/node_modules/ink/node_modules/type-fest/source/is-null.d.ts

@@ -1,20 +0,0 @@
-/**
-Returns a boolean for whether the given type is `null`.
-
-@example
-```
-import type {IsNull} from 'type-fest';
-
-type NonNullFallback<T, Fallback> = IsNull<T> extends true ? Fallback : T;
-
-type Example1 = NonNullFallback<null, string>;
-//=> string
-
-type Example2 = NonNullFallback<number, string>;
-//=? number
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNull<T> = [T] extends [null] ? true : false;

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

@@ -1,89 +0,0 @@
-import type {IfAny} from './if-any';
-import type {IfNever} from './if-never';
-import type {ApplyDefaultOptions} from './internal';
-import type {UnknownArray} from './unknown-array';
-
-/**
-@see {@link IsTuple}
-*/
-export type IsTupleOptions = {
-	/**
-	Consider only fixed length arrays as tuples.
-
-	- When set to `true` (default), arrays with rest elements (e.g., `[1, ...number[]]`) are _not_ considered as tuples.
-	- When set to `false`, arrays with at least one non-rest element (e.g., `[1, ...number[]]`) are considered as tuples.
-
-	@default true
-
-	@example
-	```ts
-	import type {IsTuple} from 'type-fest';
-
-	type Example1 = IsTuple<[number, ...number[]], {fixedLengthOnly: true}>;
-	//=> false
-
-	type Example2 = IsTuple<[number, ...number[]], {fixedLengthOnly: false}>;
-	//=> true
-	```
-	*/
-	fixedLengthOnly?: boolean;
-};
-
-type DefaultIsTupleOptions = {
-	fixedLengthOnly: true;
-};
-
-/**
-Returns a boolean for whether the given array is a tuple.
-
-Use-case:
-- If you want to make a conditional branch based on the result of whether an array is a tuple or not.
-
-Note: `IsTuple` returns `boolean` when instantiated with a union of tuple and non-tuple (e.g., `IsTuple<[1, 2] | number[]>`).
-
-@example
-```ts
-import type {IsTuple} from 'type-fest';
-
-type Tuple = IsTuple<[1, 2, 3]>;
-//=> true
-
-type NotTuple = IsTuple<number[]>;
-//=> false
-
-type TupleWithOptionalItems = IsTuple<[1?, 2?]>;
-//=> true
-
-type RestItemsNotAllowed = IsTuple<[1, 2, ...number[]]>;
-//=> false
-
-type RestItemsAllowed = IsTuple<[1, 2, ...number[]], {fixedLengthOnly: false}>;
-//=> true
-```
-
-@see {@link IsTupleOptions}
-
-@category Type Guard
-@category Utilities
-*/
-export type IsTuple<
-	TArray extends UnknownArray,
-	Options extends IsTupleOptions = {},
-> =
-	_IsTuple<TArray, ApplyDefaultOptions<IsTupleOptions, DefaultIsTupleOptions, Options>>;
-
-type _IsTuple<
-	TArray extends UnknownArray,
-	Options extends Required<IsTupleOptions>,
-> =
-	IfAny<TArray, boolean, IfNever<TArray, false,
-	TArray extends unknown // For distributing `TArray`
-		? number extends TArray['length']
-			? Options['fixedLengthOnly'] extends false
-				? IfNever<keyof TArray & `${number}`,
-				TArray extends readonly [...any, any] ? true : false, // To handle cases where a non-rest element follows a rest element, e.g., `[...number[], number]`
-				true>
-				: false
-			: true
-		: false
-	>>;