@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.5

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

@@ -1,52 +0,0 @@
-import type {IsNull} from './is-null';
-
-/**
-Returns a boolean for whether the given type is `unknown`.
-
-@link https://github.com/dsherret/conditional-type-checks/pull/16
-
-Useful in type utilities, such as when dealing with unknown data from API calls.
-
-@example
-```
-import type {IsUnknown} from 'type-fest';
-
-// https://github.com/pajecawav/tiny-global-store/blob/master/src/index.ts
-type Action<TState, TPayload = void> =
-	IsUnknown<TPayload> extends true
-		? (state: TState) => TState,
-		: (state: TState, payload: TPayload) => TState;
-
-class Store<TState> {
-	constructor(private state: TState) {}
-
-	execute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {
-		this.state = action(this.state, payload);
-		return this.state;
-	}
-
-	// ... other methods
-}
-
-const store = new Store({value: 1});
-declare const someExternalData: unknown;
-
-store.execute(state => ({value: state.value + 1}));
-//=> `TPayload` is `void`
-
-store.execute((state, payload) => ({value: state.value + payload}), 5);
-//=> `TPayload` is `5`
-
-store.execute((state, payload) => ({value: state.value + payload}), someExternalData);
-//=> Errors: `action` is `(state: TState) => TState`
-```
-
-@category Utilities
-*/
-export type IsUnknown<T> = (
-	unknown extends T // `T` can be `unknown` or `any`
-		? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
-			? true
-			: false
-		: false
-);

package/node_modules/ink/node_modules/type-fest/source/iterable-element.d.ts

@@ -1,64 +0,0 @@
-/**
-Get the element type of an `Iterable`/`AsyncIterable`. For example, `Array`, `Set`, `Map`, generator, stream, etc.
-
-This can be useful, for example, if you want to get the type that is yielded in a generator function. Often the return type of those functions are not specified.
-
-This type works with both `Iterable`s and `AsyncIterable`s, so it can be use with synchronous and asynchronous generators.
-
-Here is an example of `IterableElement` in action with a generator function:
-
-@example
-```
-import type {IterableElement} from 'type-fest';
-
-function * iAmGenerator() {
-	yield 1;
-	yield 2;
-}
-
-type MeNumber = IterableElement<ReturnType<typeof iAmGenerator>>
-```
-
-And here is an example with an async generator:
-
-@example
-```
-import type {IterableElement} from 'type-fest';
-
-async function * iAmGeneratorAsync() {
-	yield 'hi';
-	yield true;
-}
-
-type MeStringOrBoolean = IterableElement<ReturnType<typeof iAmGeneratorAsync>>
-```
-
-Many types in JavaScript/TypeScript are iterables. This type works on all types that implement those interfaces.
-
-An example with an array of strings:
-
-@example
-```
-import type {IterableElement} from 'type-fest';
-
-type MeString = IterableElement<string[]>
-```
-
-@example
-```
-import type {IterableElement} from 'type-fest';
-
-const fruits = new Set(['🍎', '🍌', '🍉'] as const);
-
-type Fruit = IterableElement<typeof fruits>;
-//=> '🍎' | '🍌' | '🍉'
-```
-
-@category Iterable
-*/
-export type IterableElement<TargetIterable> =
-	TargetIterable extends Iterable<infer ElementType> ?
-		ElementType :
-		TargetIterable extends AsyncIterable<infer ElementType> ?
-			ElementType :
-			never;

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

@@ -1,68 +0,0 @@
-// The builtin `join` method supports all these natively in the same way that typescript handles them so we can safely accept all of them.
-type JoinableItem = string | number | bigint | boolean | undefined | null;
-
-// `null` and `undefined` are treated uniquely in the built-in join method, in a way that differs from the default `toString` that would result in the type `${undefined}`. That's why we need to handle it specifically with this helper.
-// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join#description
-type NullishCoalesce<
-	Value extends JoinableItem,
-	Fallback extends string,
-> = Value extends undefined | null ? NonNullable<Value> | Fallback : Value;
-
-/**
-Join an array of strings and/or numbers using the given string as a delimiter.
-
-Use-case: Defining key paths in a nested object. For example, for dot-notation fields in MongoDB queries.
-
-@example
-```
-import type {Join} from 'type-fest';
-
-// Mixed (strings & numbers) items; result is: 'foo.0.baz'
-const path: Join<['foo', 0, 'baz'], '.'> = ['foo', 0, 'baz'].join('.');
-
-// Only string items; result is: 'foo.bar.baz'
-const path: Join<['foo', 'bar', 'baz'], '.'> = ['foo', 'bar', 'baz'].join('.');
-
-// Only number items; result is: '1.2.3'
-const path: Join<[1, 2, 3], '.'> = [1, 2, 3].join('.');
-
-// Only bigint items; result is '1.2.3'
-const path: Join<[1n, 2n, 3n], '.'> = [1n, 2n, 3n].join('.');
-
-// Only boolean items; result is: 'true.false.true'
-const path: Join<[true, false, true], '.'> = [true, false, true].join('.');
-
-// Contains nullish items; result is: 'foo..baz..xyz'
-const path: Join<['foo', undefined, 'baz', null, 'xyz'], '.'> = ['foo', undefined, 'baz', null, 'xyz'].join('.');
-
-// Partial tuple shapes (rest param last); result is: `prefix.${string}`
-const path: Join<['prefix', ...string[]], '.'> = ['prefix'].join('.');
-
-// Partial tuple shapes (rest param first); result is: `${string}.suffix`
-const path: Join<[...string[], 'suffix'], '.'> = ['suffix'].join('.');
-
-// Tuples items with nullish unions; result is '.' | 'hello.' | '.world' | 'hello.world'
-const path: Join<['hello' | undefined, 'world' | null], '.'> = ['hello', 'world'].join('.');
-```
-
-@category Array
-@category Template literal
-*/
-export type Join<
-	Items extends readonly JoinableItem[],
-	Delimiter extends string,
-> = Items extends readonly []
-	? ''
-	: Items extends readonly [JoinableItem?]
-		? `${NullishCoalesce<Items[0], ''>}`
-		: Items extends readonly [
-			infer First extends JoinableItem,
-			...infer Tail extends readonly JoinableItem[],
-		]
-			? `${NullishCoalesce<First, ''>}${Delimiter}${Join<Tail, Delimiter>}`
-			: Items extends readonly [
-				...infer Head extends readonly JoinableItem[],
-				infer Last extends JoinableItem,
-			]
-				? `${Join<Head, Delimiter>}${Delimiter}${NullishCoalesce<Last, ''>}`
-				: string;

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

@@ -1,37 +0,0 @@
-import type {JsonPrimitive} from './basic';
-
-type JsonifiableObject = {[Key in string]?: Jsonifiable} | {toJSON: () => Jsonifiable};
-type JsonifiableArray = readonly Jsonifiable[];
-
-/**
-Matches a value that can be losslessly converted to JSON.
-
-Can be used to type values that you expect to pass to `JSON.stringify`.
-
-`undefined` is allowed in object fields (for example, `{a?: number}`) as a special case even though `JSON.stringify({a: undefined})` is `{}` because it makes this class more widely useful and checking for undefined-but-present values is likely an anti-pattern.
-
-@example
-```
-import type {Jsonifiable} from 'type-fest';
-
-// @ts-expect-error
-const error: Jsonifiable = {
-    map: new Map([['a', 1]]),
-};
-
-JSON.stringify(error);
-//=> {"map": {}}
-
-const good: Jsonifiable = {
-    number: 3,
-    date: new Date(),
-    missing: undefined,
-}
-
-JSON.stringify(good);
-//=> {"number": 3, "date": "2022-10-17T22:22:35.920Z"}
-```
-
-@category JSON
-*/
-export type Jsonifiable = JsonPrimitive | JsonifiableObject | JsonifiableArray;

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

@@ -1,122 +0,0 @@
-import type {JsonPrimitive, JsonValue} from './basic';
-import type {EmptyObject} from './empty-object';
-import type {UndefinedToOptional} from './internal';
-import type {IsAny} from './is-any';
-import type {IsNever} from './is-never';
-import type {IsUnknown} from './is-unknown';
-import type {NegativeInfinity, PositiveInfinity} from './numeric';
-import type {TypedArray} from './typed-array';
-import type {UnknownArray} from './unknown-array';
-
-// Note: The return value has to be `any` and not `unknown` so it can match `void`.
-type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
-
-type NeverToNull<T> = IsNever<T> extends true ? null : T;
-type UndefinedToNull<T> = T extends undefined ? null : T;
-
-// Handles tuples and arrays
-type JsonifyList<T extends UnknownArray> = T extends readonly []
-	? []
-	: T extends readonly [infer F, ...infer R]
-		? [NeverToNull<Jsonify<F>>, ...JsonifyList<R>]
-		: IsUnknown<T[number]> extends true
-			? []
-			: Array<T[number] extends NotJsonable ? null : Jsonify<UndefinedToNull<T[number]>>>;
-
-type FilterJsonableKeys<T extends object> = {
-	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
-}[keyof T];
-
-/**
-JSON serialize objects (not including arrays) and classes.
-*/
-type JsonifyObject<T extends object> = {
-	[Key in keyof Pick<T, FilterJsonableKeys<T>>]: Jsonify<T[Key]>;
-};
-
-/**
-Transform a type to one that is assignable to the `JsonValue` type.
-
-This includes:
-1. Transforming JSON `interface` to a `type` that is assignable to `JsonValue`.
-2. Transforming non-JSON value that is *jsonable* to a type that is assignable to `JsonValue`, where *jsonable* means the non-JSON value implements the `.toJSON()` method that returns a value that is assignable to `JsonValue`.
-
-@remarks
-
-An interface cannot be structurally compared to `JsonValue` because an interface can be re-opened to add properties that may not be satisfy `JsonValue`.
-
-@example
-```
-import type {Jsonify, JsonValue} from 'type-fest';
-
-interface Geometry {
-	type: 'Point' | 'Polygon';
-	coordinates: [number, number];
-}
-
-const point: Geometry = {
-	type: 'Point',
-	coordinates: [1, 1]
-};
-
-const problemFn = (data: JsonValue) => {
-	// Does something with data
-};
-
-problemFn(point); // Error: type Geometry is not assignable to parameter of type JsonValue because it is an interface
-
-const fixedFn = <T>(data: Jsonify<T>) => {
-	// Does something with data
-};
-
-fixedFn(point); // Good: point is assignable. Jsonify<T> transforms Geometry into value assignable to JsonValue
-fixedFn(new Date()); // Error: As expected, Date is not assignable. Jsonify<T> cannot transforms Date into value assignable to JsonValue
-```
-
-Non-JSON values such as `Date` implement `.toJSON()`, so they can be transformed to a value assignable to `JsonValue`:
-
-@example
-```
-import type {Jsonify} from 'type-fest';
-
-const time = {
-	timeValue: new Date()
-};
-
-// `Jsonify<typeof time>` is equivalent to `{timeValue: string}`
-const timeJson = JSON.parse(JSON.stringify(time)) as Jsonify<typeof time>;
-```
-
-@link https://github.com/Microsoft/TypeScript/issues/1897#issuecomment-710744173
-
-@category JSON
-*/
-export type Jsonify<T> = IsAny<T> extends true
-	? any
-	: T extends PositiveInfinity | NegativeInfinity
-		? null
-		: T extends JsonPrimitive
-			? T
-			: // Any object with toJSON is special case
-			T extends {toJSON(): infer J}
-				? (() => J) extends () => JsonValue // Is J assignable to JsonValue?
-					? J // Then T is Jsonable and its Jsonable value is J
-					: Jsonify<J> // Maybe if we look a level deeper we'll find a JsonValue
-				: // Instanced primitives are objects
-				T extends Number
-					? number
-					: T extends String
-						? string
-						: T extends Boolean
-							? boolean
-							: T extends Map<any, any> | Set<any>
-								? EmptyObject
-								: T extends TypedArray
-									? Record<string, number>
-									: T extends NotJsonable
-										? never // Non-JSONable type union was found not empty
-										: T extends UnknownArray
-											? JsonifyList<T>
-											: T extends object
-												? JsonifyObject<UndefinedToOptional<T>> // JsonifyObject recursive call for its children
-												: never; // Otherwise any other non-object is removed

package/node_modules/ink/node_modules/type-fest/source/kebab-case.d.ts

@@ -1,44 +0,0 @@
-import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
-
-/**
-Convert a string literal to kebab-case.
-
-This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
-
-@example
-```
-import type {KebabCase} from 'type-fest';
-
-// Simple
-
-const someVariable: KebabCase<'fooBar'> = 'foo-bar';
-const someVariableNoSplitOnNumbers: KebabCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p-network';
-
-// Advanced
-
-type KebabCasedProperties<T> = {
-	[K in keyof T as KebabCase<K>]: T[K]
-};
-
-interface CliOptions {
-	dryRun: boolean;
-	includeFile: string;
-	foo: number;
-}
-
-const rawCliOptions: KebabCasedProperties<CliOptions> = {
-	'dry-run': true,
-	'include-file': 'bar.js',
-	foo: 123
-};
-```
-
-@category Change case
-@category Template literal
-*/
-export type KebabCase<
-	Value,
-	Options extends WordsOptions = {},
-> = DelimiterCase<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

package/node_modules/ink/node_modules/type-fest/source/kebab-cased-properties-deep.d.ts

@@ -1,63 +0,0 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case';
-import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
-
-/**
-Convert object properties to kebab case recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see KebabCase
-@see KebabCasedProperties
-
-@example
-```
-import type [KebabCasedPropertiesDeep] from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-interface UserWithFriends {
-	userInfo: User;
-	userFriends: User[];
-}
-
-const result: KebabCasedPropertiesDeep<UserWithFriends> = {
-	'user-info': {
-		'user-id': 1,
-		'user-name': 'Tom',
-	},
-	'user-friends': [
-		{
-			'user-id': 2,
-			'user-name': 'Jerry',
-		},
-		{
-			'user-id': 3,
-			'user-name': 'Spike',
-		},
-	],
-};
-
-const splitOnNumbers: KebabCasedPropertiesDeep<{line1: { line2: [{ line3: string }] }}, {splitOnNumbers: true}> = {
-	'line-1': {
-		'line-2': [
-			{
-				'line-3': 'string',
-			},
-		],
-	},
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type KebabCasedPropertiesDeep<
-	Value,
-	Options extends WordsOptions = {},
-> = DelimiterCasedPropertiesDeep<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

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

@@ -1,40 +0,0 @@
-import type {DefaultDelimiterCaseOptions} from './delimiter-case';
-import type {DelimiterCasedProperties} from './delimiter-cased-properties';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
-
-/**
-Convert object properties to kebab case but not recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see KebabCase
-@see KebabCasedPropertiesDeep
-
-@example
-```
-import type {KebabCasedProperties} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-const result: KebabCasedProperties<User> = {
-	'user-id': 1,
-	'user-name': 'Tom',
-};
-
-const splitOnNumbers: KebabCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
-	'line-1': 'string',
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type KebabCasedProperties<
-	Value,
-	Options extends WordsOptions = {},
-> = DelimiterCasedProperties<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

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

@@ -1,42 +0,0 @@
-import type {UnionToIntersection} from './union-to-intersection';
-
-/**
-Create a union of all keys from a given type, even those exclusive to specific union members.
-
-Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
-
-@link https://stackoverflow.com/a/49402091
-
-@example
-```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-	common: string;
-	a: number;
-};
-
-type B = {
-	common: string;
-	b: string;
-};
-
-type C = {
-	common: string;
-	c: boolean;
-};
-
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
-```
-
-@category Object
-*/
-export type KeysOfUnion<ObjectType> =
-  // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
-  keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;

package/node_modules/ink/node_modules/type-fest/source/last-array-element.d.ts

@@ -1,38 +0,0 @@
-/**
-Extracts the type of the last element of an array.
-
-Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
-
-@example
-```
-import type {LastArrayElement} from 'type-fest';
-
-declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
-
-const array = ['foo', 2];
-
-typeof lastOf(array);
-//=> number
-
-const array = ['foo', 2] as const;
-
-typeof lastOf(array);
-//=> 2
-```
-
-@category Array
-@category Template literal
-*/
-export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> =
-	// If the last element of an array is a spread element, the `LastArrayElement` result should be `'the type of the element before the spread element' | 'the type of the spread element'`.
-	Elements extends readonly []
-		? ElementBeforeTailingSpreadElement
-		: Elements extends readonly [...infer U, infer V]
-			? V
-			: Elements extends readonly [infer U, ...infer V]
-				// If we return `V[number] | U` directly, it would be wrong for `[[string, boolean, object, ...number[]]`.
-				// So we need to recurse type `V` and carry over the type of the element before the spread element.
-				? LastArrayElement<V, U>
-				: Elements extends ReadonlyArray<infer U>
-					? U | ElementBeforeTailingSpreadElement
-					: never;

package/node_modules/ink/node_modules/type-fest/source/less-than-or-equal.d.ts

@@ -1,22 +0,0 @@
-import type {GreaterThan} from './greater-than';
-
-/**
- Returns a boolean for whether a given number is less than or equal to another number.
-
-@example
-```
-import type {LessThanOrEqual} from 'type-fest';
-
-LessThanOrEqual<1, -5>;
-//=> false
-
-LessThanOrEqual<1, 1>;
-//=> true
-
-LessThanOrEqual<1, 5>;
-//=> true
-```
-*/
-export type LessThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThan<A, B> extends true ? false : true;

package/node_modules/ink/node_modules/type-fest/source/less-than.d.ts

@@ -1,26 +0,0 @@
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-
-/**
-Returns a boolean for whether a given number is less than another number.
-
-@example
-```
-import type {LessThan} from 'type-fest';
-
-LessThan<1, -5>;
-//=> false
-
-LessThan<1, 1>;
-//=> false
-
-LessThan<1, 5>;
-//=> true
-```
-*/
-export type LessThan<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThanOrEqual<A, B> extends infer Result
-		? Result extends true
-			? false
-			: true
-		: never; // Should never happen

package/node_modules/ink/node_modules/type-fest/source/literal-to-primitive-deep.d.ts

@@ -1,36 +0,0 @@
-import type {LiteralToPrimitive} from './literal-to-primitive';
-import type {OmitIndexSignature} from './omit-index-signature';
-
-/**
-Like `LiteralToPrimitive` except it converts literal types inside an object or array deeply.
-
-For example, given a constant object, it returns a new object type with the same keys but with all the values converted to primitives.
-
-@see LiteralToPrimitive
-
-Use-case: Deal with data that is imported from a JSON file.
-
-@example
-```
-import type {LiteralToPrimitiveDeep, TsConfigJson} from 'type-fest';
-import tsconfig from 'path/to/tsconfig.json';
-
-function doSomethingWithTSConfig(config: LiteralToPrimitiveDeep<TsConfigJson>) { ... }
-
-// No casting is needed to pass the type check
-doSomethingWithTSConfig(tsconfig);
-
-// If LiteralToPrimitiveDeep is not used, you need to cast the imported data like this:
-doSomethingWithTSConfig(tsconfig as TsConfigJson);
-```
-
-@category Type
-@category Object
-*/
-export type LiteralToPrimitiveDeep<T> = T extends object
-	? T extends Array<infer U>
-		? Array<LiteralToPrimitiveDeep<U>>
-		: {
-			[K in keyof OmitIndexSignature<T>]: LiteralToPrimitiveDeep<T[K]>;
-		}
-	: LiteralToPrimitive<T>;