@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

package/node_modules/ink/node_modules/type-fest/source/multidimensional-readonly-array.d.ts

@@ -1,48 +0,0 @@
-import type {Subtract} from './subtract';
-import type {IsEqual} from './is-equal';
-
-type Recursive<T> = ReadonlyArray<Recursive<T>>;
-
-/**
-Creates a type that represents a multidimensional readonly array that of the given type and dimension.
-
-Use-cases:
-- Return a n-dimensional array from functions.
-- Declare a n-dimensional array by defining its dimensions rather than declaring `[]` repetitively.
-- Infer the dimensions of a n-dimensional array automatically from function arguments.
-- Avoid the need to know in advance the dimensions of a n-dimensional array allowing them to be dynamic.
-
-@example
-```
-import type {MultidimensionalReadonlyArray} from 'type-fest';
-
-function emptyMatrix<T extends number>(dimensions: T): MultidimensionalReadonlyArray<unknown, T> {
-	const matrix: unknown[] = [];
-
-	let subMatrix = matrix;
-	for (let dimension = 1; dimension < dimensions; ++dimension) {
-		console.log(`Initializing dimension #${dimension}`);
-
-		subMatrix[0] = [];
-		if (dimension < dimensions - 1) {
-			subMatrix = subMatrix[0] as unknown[];
-		} else {
-			subMatrix[0] = 42;
-		}
-	}
-
-	return matrix as MultidimensionalReadonlyArray<unknown, T>;
-}
-
-const matrix = emptyMatrix(3);
-
-const answer = matrix[0][0][0]; // 42
-```
-
-@category Array
-*/
-export type MultidimensionalReadonlyArray<Element, Dimensions extends number> = number extends Dimensions
-	? Recursive<Element>
-	: IsEqual<Dimensions, 0> extends true
-		? Element
-		: ReadonlyArray<MultidimensionalReadonlyArray<Element, Subtract<Dimensions, 1>>>;

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

@@ -1,35 +0,0 @@
-import type {HasRequiredKeys} from './has-required-keys';
-import type {RequireAtLeastOne} from './require-at-least-one';
-
-/**
-Represents an object with at least 1 non-optional key.
-
-This is useful when you need an object where all keys are optional, but there must be at least 1 key.
-
-@example
-```
-import type {NonEmptyObject} from 'type-fest';
-
-type User = {
-	name: string;
-	surname: string;
-	id: number;
-};
-
-type UpdateRequest<Entity extends object> = NonEmptyObject<Partial<Entity>>;
-
-const update1: UpdateRequest<User> = {
-	name: 'Alice',
-	surname: 'Acme',
-};
-
-// At least 1 key is required, therefore this will report a 2322 error:
-// Type '{}' is not assignable to type 'UpdateRequest<User>'
-const update2: UpdateRequest<User> = {};
-```
-
-@see Use `IsEmptyObject` to check whether an object is empty.
-
-@category Object
-*/
-export type NonEmptyObject<T extends object> = HasRequiredKeys<T> extends true ? T : RequireAtLeastOne<T, keyof T>;

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

@@ -1,28 +0,0 @@
-/**
-Matches any non-empty string.
-
-This is useful when you need a string that is not empty, for example, as a function parameter.
-
-NOTE:
-- This returns `never` not just when instantiated with an empty string, but also when an empty string is a subtype of the instantiated type, like `string` or `Uppercase<string>`.
-
-@example
-```
-import type {NonEmptyString} from 'type-fest';
-
-declare function foo<T extends string>(string: NonEmptyString<T>): void;
-
-foo('a');
-//=> OK
-
-foo('');
-//=> Error: Argument of type '""' is not assignable to parameter of type 'never'.
-
-declare const someString: string
-foo(someString);
-//=> Error: Argument of type 'string' is not assignable to parameter of type 'never'.
-```
-
-@category String
-*/
-export type NonEmptyString<T extends string> = '' extends T ? never : T;

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

@@ -1,21 +0,0 @@
-/**
-Matches any non-empty tuple.
-
-@example
-```
-import type {NonEmptyTuple} from 'type-fest';
-
-const sum = (...numbers: NonEmptyTuple<number>) => numbers.reduce((total, value) => total + value, 0);
-
-sum(1, 2, 3);
-//=> 6
-
-sum();
-//=> Error: Expected at least 1 arguments, but got 0.
-```
-
-@see {@link RequireAtLeastOne} for objects
-
-@category Array
-*/
-export type NonEmptyTuple<T = unknown> = readonly [T, ...T[]];

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

@@ -1,222 +0,0 @@
-import type {IsFloat} from './is-float';
-import type {IsInteger} from './is-integer';
-
-export type Numeric = number | bigint;
-
-export type Zero = 0 | 0n;
-
-/**
-Matches the hidden `Infinity` type.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
-
-@see NegativeInfinity
-
-@category Numeric
-*/
-// See https://github.com/microsoft/TypeScript/issues/31752
-// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-export type PositiveInfinity = 1e999;
-
-/**
-Matches the hidden `-Infinity` type.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
-
-@see PositiveInfinity
-
-@category Numeric
-*/
-// See https://github.com/microsoft/TypeScript/issues/31752
-// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-export type NegativeInfinity = -1e999;
-
-/**
-A finite `number`.
-You can't pass a `bigint` as they are already guaranteed to be finite.
-
-Use-case: Validating and documenting parameters.
-
-Note: This can't detect `NaN`, please upvote [this issue](https://github.com/microsoft/TypeScript/issues/28682) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-import type {Finite} from 'type-fest';
-
-declare function setScore<T extends number>(length: Finite<T>): void;
-```
-
-@category Numeric
-*/
-export type Finite<T extends number> = T extends PositiveInfinity | NegativeInfinity ? never : T;
-
-/**
-A `number` that is an integer.
-
-Use-case: Validating and documenting parameters.
-
-@example
-```
-type Integer = Integer<1>;
-//=> 1
-
-type IntegerWithDecimal = Integer<1.0>;
-//=> 1
-
-type NegativeInteger = Integer<-1>;
-//=> -1
-
-type Float = Integer<1.5>;
-//=> never
-
-// Supports non-decimal numbers
-
-type OctalInteger: Integer<0o10>;
-//=> 0o10
-
-type BinaryInteger: Integer<0b10>;
-//=> 0b10
-
-type HexadecimalInteger: Integer<0x10>;
-//=> 0x10
-```
-
-@example
-```
-import type {Integer} from 'type-fest';
-
-declare function setYear<T extends number>(length: Integer<T>): void;
-```
-
-@see NegativeInteger
-@see NonNegativeInteger
-
-@category Numeric
-*/
-// `${bigint}` is a type that matches a valid bigint literal without the `n` (ex. 1, 0b1, 0o1, 0x1)
-// Because T is a number and not a string we can effectively use this to filter out any numbers containing decimal points
-export type Integer<T> =
-	T extends unknown // To distributive type
-		? IsInteger<T> extends true ? T : never
-		: never; // Never happens
-
-/**
-A `number` that is not an integer.
-
-Use-case: Validating and documenting parameters.
-
-It does not accept `Infinity`.
-
-@example
-```
-import type {Float} from 'type-fest';
-
-declare function setPercentage<T extends number>(length: Float<T>): void;
-```
-
-@see Integer
-
-@category Numeric
-*/
-export type Float<T> =
-T extends unknown // To distributive type
-	? IsFloat<T> extends true ? T : never
-	: never; // Never happens
-
-/**
-A negative (`-∞ < x < 0`) `number` that is not an integer.
-Equivalent to `Negative<Float<T>>`.
-
-Use-case: Validating and documenting parameters.
-
-@see Negative
-@see Float
-
-@category Numeric
-*/
-export type NegativeFloat<T extends number> = Negative<Float<T>>;
-
-/**
-A negative `number`/`bigint` (`-∞ < x < 0`)
-
-Use-case: Validating and documenting parameters.
-
-@see NegativeInteger
-@see NonNegative
-
-@category Numeric
-*/
-export type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
-
-/**
-A negative (`-∞ < x < 0`) `number` that is an integer.
-Equivalent to `Negative<Integer<T>>`.
-
-You can't pass a `bigint` as they are already guaranteed to be integers, instead use `Negative<T>`.
-
-Use-case: Validating and documenting parameters.
-
-@see Negative
-@see Integer
-
-@category Numeric
-*/
-export type NegativeInteger<T extends number> = Negative<Integer<T>>;
-
-/**
-A non-negative `number`/`bigint` (`0 <= x < ∞`).
-
-Use-case: Validating and documenting parameters.
-
-@see NonNegativeInteger
-@see Negative
-
-@example
-```
-import type {NonNegative} from 'type-fest';
-
-declare function setLength<T extends number>(length: NonNegative<T>): void;
-```
-
-@category Numeric
-*/
-export type NonNegative<T extends Numeric> = T extends Zero ? T : Negative<T> extends never ? T : never;
-
-/**
-A non-negative (`0 <= x < ∞`) `number` that is an integer.
-Equivalent to `NonNegative<Integer<T>>`.
-
-You can't pass a `bigint` as they are already guaranteed to be integers, instead use `NonNegative<T>`.
-
-Use-case: Validating and documenting parameters.
-
-@see NonNegative
-@see Integer
-
-@example
-```
-import type {NonNegativeInteger} from 'type-fest';
-
-declare function setLength<T extends number>(length: NonNegativeInteger<T>): void;
-```
-
-@category Numeric
-*/
-export type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;
-
-/**
-Returns a boolean for whether the given number is a negative number.
-
-@see Negative
-
-@example
-```
-import type {IsNegative} from 'type-fest';
-
-type ShouldBeFalse = IsNegative<1>;
-type ShouldBeTrue = IsNegative<-1>;
-```
-
-@category Numeric
-*/
-export type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;

package/node_modules/ink/node_modules/type-fest/source/observable-like.d.ts

@@ -1,63 +0,0 @@
-declare global {
-	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
-	interface SymbolConstructor {
-		readonly observable: symbol;
-	}
-}
-
-/**
-@remarks
-The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
-As well, some guidance on making an `Observable` to not include `closed` property.
-@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
-@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
-@see https://github.com/benlesh/symbol-observable#making-an-object-observable
-
-@category Observable
-*/
-export type Unsubscribable = {
-	unsubscribe(): void;
-};
-
-/**
-@category Observable
-*/
-type OnNext<ValueType> = (value: ValueType) => void;
-/**
-@category Observable
-*/
-type OnError = (error: unknown) => void;
-/**
-@category Observable
-*/
-type OnComplete = () => void;
-
-/**
-@category Observable
-*/
-export type Observer<ValueType> = {
-	next: OnNext<ValueType>;
-	error: OnError;
-	complete: OnComplete;
-};
-
-/**
-Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
-
-@remarks
-The TC39 Observable proposal defines 2 forms of `subscribe()`:
-1. Three callback arguments: `subscribe(observer: OnNext<ValueType>, onError?: OnError, onComplete?: OnComplete): Unsubscribable;`
-2. A single `observer` argument: (as defined below)
-
-But `Observable` implementations have evolved to preferring case 2 and some implementations choose not to implement case 1. Therefore, an `ObservableLike` cannot be trusted to implement the first case. (xstream and hand built observerables often do not implement case 1)
-
-@see https://github.com/tc39/proposal-observable#observable
-@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L246-L259
-@see https://benlesh.com/posts/learning-observable-by-building-observable/
-
-@category Observable
-*/
-export type ObservableLike<ValueType = unknown> = {
-	subscribe(observer?: Partial<Observer<ValueType>>): Unsubscribable;
-	[Symbol.observable](): ObservableLike<ValueType>;
-};

package/node_modules/ink/node_modules/type-fest/source/omit-deep.d.ts

@@ -1,167 +0,0 @@
-import type {ArraySplice} from './array-splice';
-import type {ExactKey, IsArrayReadonly, NonRecursiveType, SetArrayAccess, ToString} from './internal';
-import type {IsEqual} from './is-equal';
-import type {IsNever} from './is-never';
-import type {LiteralUnion} from './literal-union';
-import type {Paths} from './paths';
-import type {SimplifyDeep} from './simplify-deep';
-import type {UnionToTuple} from './union-to-tuple';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Omit properties from a deeply-nested object.
-
-It supports recursing into arrays.
-
-It supports removing specific items from an array, replacing each removed item with unknown at the specified index.
-
-Use-case: Remove unneeded parts of complex objects.
-
-Use [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
-
-@example
-```
-import type {OmitDeep} from 'type-fest';
-
-type Info = {
-	userInfo: {
-		name: string;
-		uselessInfo: {
-			foo: string;
-		};
-	};
-};
-
-type UsefulInfo = OmitDeep<Info, 'userInfo.uselessInfo'>;
-// type UsefulInfo = {
-// 	userInfo: {
-// 		name: string;
-// 	};
-// };
-
-// Supports removing multiple paths
-type Info1 = {
-	userInfo: {
-		name: string;
-		uselessField: string;
-		uselessInfo: {
-			foo: string;
-		};
-	};
-};
-
-type UsefulInfo1 = OmitDeep<Info1, 'userInfo.uselessInfo' | 'userInfo.uselessField'>;
-// type UsefulInfo1 = {
-// 	userInfo: {
-// 		name: string;
-// 	};
-// };
-
-// Supports array
-type A = OmitDeep<[1, 'foo', 2], 1>;
-// type A = [1, unknown, 2];
-
-// Supports recursing into array
-
-type Info1 = {
-	address: [
-		{
-			street: string
-		},
-		{
-			street2: string,
-			foo: string
-		};
-	];
-}
-type AddressInfo = OmitDeep<Info1, 'address.1.foo'>;
-// type AddressInfo = {
-// 	address: [
-// 		{
-// 			street: string;
-// 		},
-// 		{
-// 			street2: string;
-// 		};
-// 	];
-// };
-```
-
-@category Object
-@category Array
-*/
-export type OmitDeep<T, PathUnion extends LiteralUnion<Paths<T>, string>> =
-	SimplifyDeep<
-	OmitDeepHelper<T, UnionToTuple<PathUnion>>,
-	UnknownArray>;
-
-/**
-Internal helper for {@link OmitDeep}.
-
-Recursively transforms `T` by applying {@link OmitDeepWithOnePath} for each path in `PathTuple`.
-*/
-type OmitDeepHelper<T, PathTuple extends UnknownArray> =
-	PathTuple extends [infer Path, ...infer RestPaths]
-		? OmitDeepHelper<OmitDeepWithOnePath<T, Path & (string | number)>, RestPaths>
-		: T;
-
-/**
-Omit one path from the given object/array.
-*/
-type OmitDeepWithOnePath<T, Path extends string | number> =
-T extends NonRecursiveType
-	? T
-	: T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>>
-		: T extends object ? OmitDeepObjectWithOnePath<T, Path>
-			: T;
-
-/**
-Omit one path from the given object.
-*/
-type OmitDeepObjectWithOnePath<ObjectT extends object, P extends string | number> =
-P extends `${infer RecordKeyInPath}.${infer SubPath}`
-	? {
-		[Key in keyof ObjectT]:
-		IsEqual<RecordKeyInPath, ToString<Key>> extends true
-			? ExactKey<ObjectT, Key> extends infer RealKey
-				? RealKey extends keyof ObjectT
-					? OmitDeepWithOnePath<ObjectT[RealKey], SubPath>
-					: ObjectT[Key]
-				: ObjectT[Key]
-			: ObjectT[Key]
-	}
-	: ExactKey<ObjectT, P> extends infer Key
-		? IsNever<Key> extends true
-			? ObjectT
-			: Key extends PropertyKey
-				? Omit<ObjectT, Key>
-				: ObjectT
-		: ObjectT;
-
-/**
-Omit one path from from the given array.
-
-It replaces the item to `unknown` at the given index.
-
-@example
-```
-type A = OmitDeepArrayWithOnePath<[10, 20, 30, 40], 2>;
-//=> type A = [10, 20, unknown, 40];
-```
-*/
-type OmitDeepArrayWithOnePath<ArrayType extends UnknownArray, P extends string | number> =
-	// Handle paths that are `${number}.${string}`
-	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
-		// If `ArrayIndex` is equal to `number`
-		? number extends ArrayIndex
-			? Array<OmitDeepWithOnePath<NonNullable<ArrayType[number]>, SubPath>>
-			// If `ArrayIndex` is a number literal
-			: ArraySplice<ArrayType, ArrayIndex, 1, [OmitDeepWithOnePath<NonNullable<ArrayType[ArrayIndex]>, SubPath>]>
-		// If the path is equal to `number`
-		: P extends `${infer ArrayIndex extends number}`
-			// If `ArrayIndex` is `number`
-			? number extends ArrayIndex
-				? []
-				// If `ArrayIndex` is a number literal
-				: ArraySplice<ArrayType, ArrayIndex, 1, [unknown]>
-			: ArrayType;

package/node_modules/ink/node_modules/type-fest/source/omit-index-signature.d.ts

@@ -1,95 +0,0 @@
-/**
-Omit any index signatures from the given object type, leaving only explicitly defined properties.
-
-This is the counterpart of `PickIndexSignature`.
-
-Use-cases:
-- Remove overly permissive signatures from third-party types.
-
-This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
-
-(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
-
-```
-const indexed: Record<string, unknown> = {}; // Allowed
-
-const keyed: Record<'foo', unknown> = {}; // Error
-// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
-```
-
-Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
-
-```
-type Indexed = {} extends Record<string, unknown>
-	? '✅ `{}` is assignable to `Record<string, unknown>`'
-	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
-// => '✅ `{}` is assignable to `Record<string, unknown>`'
-
-type Keyed = {} extends Record<'foo' | 'bar', unknown>
-	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
-	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
-// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
-```
-
-Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
-
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
-};
-```
-
-...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
-
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType
-		// Is `{}` assignable to `Record<KeyType, unknown>`?
-		as {} extends Record<KeyType, unknown>
-			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
-	]: ObjectType[KeyType];
-};
-```
-
-If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
-
-@example
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-interface Example {
-	// These index signatures will be removed.
-	[x: string]: any
-	[x: number]: any
-	[x: symbol]: any
-	[x: `head-${string}`]: string
-	[x: `${string}-tail`]: string
-	[x: `head-${string}-tail`]: string
-	[x: `${bigint}`]: string
-	[x: `embedded-${number}`]: string
-
-	// These explicitly defined keys will remain.
-	foo: 'bar';
-	qux?: 'baz';
-}
-
-type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
-// => { foo: 'bar'; qux?: 'baz' | undefined; }
-```
-
-@see PickIndexSignature
-@category Object
-*/
-export type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? never
-		: KeyType]: ObjectType[KeyType];
-};

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

@@ -1 +0,0 @@
-export * from './tagged';