@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

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

@@ -1,149 +0,0 @@
-import type {BuildObject, BuildTuple, NonRecursiveType, ObjectValue} from './internal';
-import type {IsNever} from './is-never';
-import type {Paths} from './paths';
-import type {Simplify} from './simplify.d';
-import type {UnionToIntersection} from './union-to-intersection.d';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Pick properties from a deeply-nested object.
-
-It supports recursing into arrays.
-
-Use-case: Distill complex objects down to the components you need to target.
-
-@example
-```
-import type {PickDeep, PartialDeep} from 'type-fest';
-
-type Configuration = {
-	userConfig: {
-		name: string;
-		age: number;
-		address: [
-			{
-				city1: string;
-				street1: string;
-			},
-			{
-				city2: string;
-				street2: string;
-			}
-		]
-	};
-	otherConfig: any;
-};
-
-type NameConfig = PickDeep<Configuration, 'userConfig.name'>;
-// type NameConfig = {
-// 	userConfig: {
-// 		name: string;
-// 	}
-// };
-
-// Supports optional properties
-type User = PickDeep<PartialDeep<Configuration>, 'userConfig.name' | 'userConfig.age'>;
-// type User = {
-// 	userConfig?: {
-// 		name?: string;
-// 		age?: number;
-// 	};
-// };
-
-// Supports array
-type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
-// type AddressConfig = {
-// 	userConfig: {
-// 		address: [{
-// 			city1: string;
-// 			street1: string;
-// 		}];
-// 	};
-// }
-
-// Supports recurse into array
-type Street = PickDeep<Configuration, 'userConfig.address.1.street2'>;
-// type Street = {
-// 	userConfig: {
-// 		address: [
-// 			unknown,
-// 			{street2: string}
-// 		];
-// 	};
-// }
-```
-
-@category Object
-@category Array
-*/
-export type PickDeep<T, PathUnion extends Paths<T>> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray
-			? UnionToIntersection<{
-				[P in PathUnion]: InternalPickDeep<T, P>;
-			}[PathUnion]
-			>
-			: T extends object
-				? Simplify<UnionToIntersection<{
-					[P in PathUnion]: InternalPickDeep<T, P>;
-				}[PathUnion]>>
-				: never;
-
-/**
-Pick an object/array from the given object/array by one path.
-*/
-type InternalPickDeep<T, Path extends string | number> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray ? PickDeepArray<T, Path>
-			: T extends object ? Simplify<PickDeepObject<T, Path>>
-				: never;
-
-/**
-Pick an object from the given object by one path.
-*/
-type PickDeepObject<RecordType extends object, P extends string | number> =
-	P extends `${infer RecordKeyInPath}.${infer SubPath}`
-		? ObjectValue<RecordType, RecordKeyInPath> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<RecordKeyInPath, InternalPickDeep<NonNullable<ObjectV>, SubPath>, RecordType>
-				: never
-			: never
-		: ObjectValue<RecordType, P> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<P, ObjectV, RecordType>
-				: never
-			: never;
-
-/**
-Pick an array from the given array by one path.
-*/
-type PickDeepArray<ArrayType extends UnknownArray, P extends string | number> =
-	// Handle paths that are `${number}.${string}`
-	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
-		// When `ArrayIndex` is equal to `number`
-		? number extends ArrayIndex
-			? ArrayType extends unknown[]
-				? Array<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-				: ArrayType extends readonly unknown[]
-					? ReadonlyArray<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-					: never
-			// When `ArrayIndex` is a number literal
-			: ArrayType extends unknown[]
-				? [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-				: ArrayType extends readonly unknown[]
-					? readonly [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-					: never
-		// When the path is equal to `number`
-		: P extends `${infer ArrayIndex extends number}`
-			// When `ArrayIndex` is `number`
-			? number extends ArrayIndex
-				? ArrayType
-				// When `ArrayIndex` is a number literal
-				: ArrayType extends unknown[]
-					? [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
-					: ArrayType extends readonly unknown[]
-						? readonly [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
-						: never
-			: never;

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

@@ -1,50 +0,0 @@
-/**
-Pick only index signatures from the given object type, leaving out all explicitly defined properties.
-
-This is the counterpart of `OmitIndexSignature`.
-
-@example
-```
-import type {PickIndexSignature} from 'type-fest';
-
-declare const symbolKey: unique symbol;
-
-type Example = {
-	// These index signatures will remain.
-	[x: string]: unknown;
-	[x: number]: unknown;
-	[x: symbol]: unknown;
-	[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 be removed.
-	['kebab-case-key']: string;
-	[symbolKey]: string;
-	foo: 'bar';
-	qux?: 'baz';
-};
-
-type ExampleIndexSignature = PickIndexSignature<Example>;
-// {
-// 	[x: string]: unknown;
-// 	[x: number]: unknown;
-// 	[x: symbol]: unknown;
-// 	[x: `head-${string}`]: string;
-// 	[x: `${string}-tail`]: string;
-// 	[x: `head-${string}-tail`]: string;
-// 	[x: `${bigint}`]: string;
-// 	[x: `embedded-${number}`]: string;
-// }
-```
-
-@see OmitIndexSignature
-@category Object
-*/
-export type PickIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? KeyType
-		: never]: ObjectType[KeyType];
-};

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

@@ -1,13 +0,0 @@
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-export type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;

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

@@ -1,25 +0,0 @@
-/**
-Create a type that represents either the value or the value wrapped in `PromiseLike`.
-
-Use-cases:
-- A function accepts a callback that may either return a value synchronously or may return a promised value.
-- This type could be the return type of `Promise#then()`, `Promise#catch()`, and `Promise#finally()` callbacks.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-import type {Promisable} from 'type-fest';
-
-async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
-	const entry = await getLogEntry();
-	console.log(entry);
-}
-
-logger(() => 'foo');
-logger(() => Promise.resolve('bar'));
-```
-
-@category Async
-*/
-export type Promisable<T> = T | PromiseLike<T>;

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

@@ -1,81 +0,0 @@
-import type {BuiltIns, HasMultipleCallSignatures} from './internal';
-
-/**
-Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
-
-This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-// data.json
-{
-	"foo": ["bar"]
-}
-
-// main.ts
-import type {ReadonlyDeep} from 'type-fest';
-import dataJson = require('./data.json');
-
-const data: ReadonlyDeep<typeof dataJson> = dataJson;
-
-export default data;
-
-// test.ts
-import data from './main';
-
-data.foo.push('bar');
-//=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
-```
-
-Note that types containing overloaded functions are not made deeply readonly due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
-
-@category Object
-@category Array
-@category Set
-@category Map
-*/
-export type ReadonlyDeep<T> = T extends BuiltIns
-	? T
-	: T extends new (...arguments_: any[]) => unknown
-		? T // Skip class constructors
-		: T extends (...arguments_: any[]) => unknown
-			? {} extends ReadonlyObjectDeep<T>
-				? T
-				: HasMultipleCallSignatures<T> extends true
-					? T
-					: ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
-			: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
-				? ReadonlyMapDeep<KeyType, ValueType>
-				: T extends Readonly<ReadonlySet<infer ItemType>>
-					? ReadonlySetDeep<ItemType>
-					: // Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
-					T extends readonly [] | readonly [...never[]]
-						? readonly []
-						: T extends readonly [infer U, ...infer V]
-							? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>]
-							: T extends readonly [...infer U, infer V]
-								? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>]
-								: T extends ReadonlyArray<infer ItemType>
-									? ReadonlyArray<ReadonlyDeep<ItemType>>
-									: T extends object
-										? ReadonlyObjectDeep<T>
-										: unknown;
-
-/**
-Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
-*/
-type ReadonlyMapDeep<KeyType, ValueType> = {} & Readonly<ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>>>;
-
-/**
-Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
-*/
-type ReadonlySetDeep<ItemType> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType>>>;
-
-/**
-Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
-*/
-type ReadonlyObjectDeep<ObjectType extends object> = {
-	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
-};

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

@@ -1,30 +0,0 @@
-import type {WritableKeysOf} from './writable-keys-of';
-
-/**
-Extract all readonly keys from the given type.
-
-This is useful when you want to create a new type that contains readonly keys only.
-
-@example
-```
-import type {ReadonlyKeysOf} from 'type-fest';
-
-interface User {
-	name: string;
-	surname: string;
-	readonly id: number;
-}
-
-type UpdateResponse<Entity extends object> = Pick<Entity, ReadonlyKeysOf<Entity>>;
-
-const update1: UpdateResponse<User> = {
-    id: 123,
-};
-```
-
-@category Utilities
-*/
-export type ReadonlyKeysOf<T> =
-	T extends unknown // For distributing `T`
-		? Exclude<keyof T, WritableKeysOf<T>>
-		: never; // Should never happen

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

@@ -1,41 +0,0 @@
-/**
-Creates a read-only tuple of type `Element` and with the length of `Length`.
-
-@private
-@see `ReadonlyTuple` which is safer because it tests if `Length` is a specific finite number.
-*/
-type BuildTupleHelper<Element, Length extends number, Rest extends Element[]> =
-	Rest['length'] extends Length ?
-		readonly [...Rest] : // Terminate with readonly array (aka tuple)
-		BuildTupleHelper<Element, Length, [Element, ...Rest]>;
-
-/**
-Create a type that represents a read-only tuple of the given type and length.
-
-Use-cases:
-- Declaring fixed-length tuples with a large number of items.
-- Creating a range union (for example, `0 | 1 | 2 | 3 | 4` from the keys of such a type) without having to resort to recursive types.
-- Creating a tuple of coordinates with a static length, for example, length of 3 for a 3D vector.
-
-@example
-```
-import {ReadonlyTuple} from 'type-fest';
-
-type FencingTeam = ReadonlyTuple<string, 3>;
-
-const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert'];
-
-const homeFencingTeam: FencingTeam = ['George', 'John'];
-//=> error TS2322: Type string[] is not assignable to type 'FencingTeam'
-
-guestFencingTeam.push('Sam');
-//=> error TS2339: Property 'push' does not exist on type 'FencingTeam'
-```
-
-@category Utilities
-*/
-export type ReadonlyTuple<Element, Length extends number> =
-	number extends Length
-		// Because `Length extends number` and `number extends Length`, then `Length` is not a specific finite number.
-		? readonly Element[] // It's not fixed length.
-		: BuildTupleHelper<Element, Length, []>; // Otherwise it is a fixed length tuple.

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

@@ -1,85 +0,0 @@
-import type {ApplyDefaultOptions} from './internal';
-
-type ReplaceOptions = {
-	all?: boolean;
-};
-
-type DefaultReplaceOptions = {
-	all: false;
-};
-
-/**
-Represents a string with some or all matches replaced by a replacement.
-
-Use-case:
-- `kebab-case-path` to `dotted.path.notation`
-- Changing date/time format: `01-08-2042` → `01/08/2042`
-- Manipulation of type properties, for example, removal of prefixes
-
-@example
-```
-import {Replace} from 'type-fest';
-
-declare function replace<
-	Input extends string,
-	Search extends string,
-	Replacement extends string
->(
-	input: Input,
-	search: Search,
-	replacement: Replacement
-): Replace<Input, Search, Replacement>;
-
-declare function replaceAll<
-	Input extends string,
-	Search extends string,
-	Replacement extends string
->(
-	input: Input,
-	search: Search,
-	replacement: Replacement
-): Replace<Input, Search, Replacement, {all: true}>;
-
-// The return type is the exact string literal, not just `string`.
-
-replace('hello ?', '?', '🦄');
-//=> 'hello 🦄'
-
-replace('hello ??', '?', '❓');
-//=> 'hello ❓?'
-
-replaceAll('10:42:00', ':', '-');
-//=> '10-42-00'
-
-replaceAll('__userName__', '__', '');
-//=> 'userName'
-
-replaceAll('My Cool Title', ' ', '');
-//=> 'MyCoolTitle'
-```
-
-@category String
-@category Template literal
-*/
-export type Replace<
-	Input extends string,
-	Search extends string,
-	Replacement extends string,
-	Options extends ReplaceOptions = {},
-> = _Replace<Input, Search, Replacement, ApplyDefaultOptions<ReplaceOptions, DefaultReplaceOptions, Options>>;
-
-type _Replace<
-	Input extends string,
-	Search extends string,
-	Replacement extends string,
-	Options extends Required<ReplaceOptions>,
-	Accumulator extends string = '',
-> = Search extends string // For distributing `Search`
-	? Replacement extends string // For distributing `Replacement`
-		? Input extends `${infer Head}${Search}${infer Tail}`
-			? Options['all'] extends true
-				? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`>
-				: `${Head}${Replacement}${Tail}`
-			: `${Accumulator}${Input}`
-		: never
-	: never;

package/node_modules/ink/node_modules/type-fest/source/require-all-or-none.d.ts

@@ -1,51 +0,0 @@
-import type {IfAny} from './if-any';
-import type {IfNever} from './if-never';
-import type {IfNotAnyOrNever, RequireNone} from './internal';
-
-/**
-Requires all of the keys in the given object.
-*/
-type RequireAll<ObjectType, KeysType extends keyof ObjectType> = Required<Pick<ObjectType, KeysType>>;
-
-/**
-Create a type that requires all of the given keys or none of the given keys. The remaining keys are kept as is.
-
-Use-cases:
-- Creating interfaces for components with mutually-inclusive keys.
-
-The caveat with `RequireAllOrNone` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireAllOrNone` can't do anything to prevent extra keys it doesn't know about.
-
-@example
-```
-import type {RequireAllOrNone} from 'type-fest';
-
-type Responder = {
-	text?: () => string;
-	json?: () => string;
-	secure: boolean;
-};
-
-const responder1: RequireAllOrNone<Responder, 'text' | 'json'> = {
-	secure: true
-};
-
-const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
-	text: () => '{"message": "hi"}',
-	json: () => '{"message": "ok"}',
-	secure: true
-};
-```
-
-@category Object
-*/
-export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-	IfNever<KeysType,
-	ObjectType,
-	_RequireAllOrNone<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
-	>>;
-
-type _RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType> = (
-	| RequireAll<ObjectType, KeysType>
-	| RequireNone<KeysType>
-) & Omit<ObjectType, KeysType>; // The rest of the keys.

package/node_modules/ink/node_modules/type-fest/source/require-at-least-one.d.ts

@@ -1,47 +0,0 @@
-import type {Except} from './except';
-import type {IfAny} from './if-any';
-import type {IfNever} from './if-never';
-import type {IfNotAnyOrNever} from './internal';
-
-/**
-Create a type that requires at least one of the given keys. The remaining keys are kept as is.
-
-@example
-```
-import type {RequireAtLeastOne} from 'type-fest';
-
-type Responder = {
-	text?: () => string;
-	json?: () => string;
-	secure?: boolean;
-};
-
-const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
-	json: () => '{"message": "ok"}',
-	secure: true
-};
-```
-
-@category Object
-*/
-export type RequireAtLeastOne<
-	ObjectType,
-	KeysType extends keyof ObjectType = keyof ObjectType,
-> =
-	IfNotAnyOrNever<ObjectType,
-	IfNever<KeysType,
-	never,
-	_RequireAtLeastOne<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
-	>>;
-
-type _RequireAtLeastOne<
-	ObjectType,
-	KeysType extends keyof ObjectType,
-> = {
-	// For each `Key` in `KeysType` make a mapped type:
-	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
-	// 2. Make all other keys in `KeysType` optional
-	Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
-}[KeysType] &
-// 3. Add the remaining keys not in `KeysType`
-Except<ObjectType, KeysType>;

package/node_modules/ink/node_modules/type-fest/source/require-exactly-one.d.ts

@@ -1,45 +0,0 @@
-import type {IfAny} from './if-any';
-import type {IfNever} from './if-never';
-import type {IfNotAnyOrNever} from './internal';
-
-/**
-Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
-
-Use-cases:
-- Creating interfaces for components that only need one of the keys to display properly.
-- Declaring generic keys in a single place for a single use-case that gets narrowed down via `RequireExactlyOne`.
-
-The caveat with `RequireExactlyOne` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireExactlyOne` can't do anything to prevent extra keys it doesn't know about.
-
-@example
-```
-import type {RequireExactlyOne} from 'type-fest';
-
-type Responder = {
-	text: () => string;
-	json: () => string;
-	secure: boolean;
-};
-
-const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
-	// Adding a `text` key here would cause a compile error.
-
-	json: () => '{"message": "ok"}',
-	secure: true
-};
-```
-
-@category Object
-*/
-export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-	IfNever<KeysType,
-	never,
-	_RequireExactlyOne<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
-	>>;
-
-type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> =
-	{[Key in KeysType]: (
-		Required<Pick<ObjectType, Key>> &
-		Partial<Record<Exclude<KeysType, Key>, never>>
-	)}[KeysType] & Omit<ObjectType, KeysType>;

package/node_modules/ink/node_modules/type-fest/source/require-one-or-none.d.ts

@@ -1,46 +0,0 @@
-import type {RequireExactlyOne} from './require-exactly-one';
-import type {IfNotAnyOrNever, RequireNone} from './internal';
-import type {IfNever} from './if-never';
-import type {IfAny} from './if-any';
-
-/**
-Create a type that requires exactly one of the given keys and disallows more, or none of the given keys. The remaining keys are kept as is.
-
-@example
-```
-import type {RequireOneOrNone} from 'type-fest';
-
-type Responder = RequireOneOrNone<{
-	text: () => string;
-	json: () => string;
-	secure: boolean;
-}, 'text' | 'json'>;
-
-const responder1: Responder = {
-	secure: true
-};
-
-const responder2: Responder = {
-	text: () => '{"message": "hi"}',
-	secure: true
-};
-
-const responder3: Responder = {
-	json: () => '{"message": "ok"}',
-	secure: true
-};
-```
-
-@category Object
-*/
-export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-	IfNever<KeysType,
-	ObjectType,
-	_RequireOneOrNone<ObjectType, IfAny<KeysType, keyof ObjectType, KeysType>>
-	>>;
-
-type _RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType> = (
-	| RequireExactlyOne<ObjectType, KeysType>
-	| RequireNone<KeysType>
-) & Omit<ObjectType, KeysType>; // Ignore unspecified keys.