@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.5

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

@@ -1,219 +0,0 @@
-import type {ApplyDefaultOptions, StringDigit, ToString} from './internal';
-import type {LiteralStringUnion} from './literal-union';
-import type {Paths} from './paths';
-import type {Split} from './split';
-import type {StringKeyOf} from './string-key-of';
-
-type GetOptions = {
-	/**
-	Include `undefined` in the return type when accessing properties.
-
-	Setting this to `false` is not recommended.
-
-	@default true
-	*/
-	strict?: boolean;
-};
-
-type DefaultGetOptions = {
-	strict: true;
-};
-
-/**
-Like the `Get` type but receives an array of strings as a path parameter.
-*/
-type GetWithPath<BaseType, Keys, Options extends Required<GetOptions>> =
-	Keys extends readonly []
-		? BaseType
-		: Keys extends readonly [infer Head, ...infer Tail]
-			? GetWithPath<
-			PropertyOf<BaseType, Extract<Head, string>, Options>,
-			Extract<Tail, string[]>,
-			Options
-			>
-			: never;
-
-/**
-Adds `undefined` to `Type` if `strict` is enabled.
-*/
-type Strictify<Type, Options extends Required<GetOptions>> =
-	Options['strict'] extends false ? Type : (Type | undefined);
-
-/**
-If `Options['strict']` is `true`, includes `undefined` in the returned type when accessing properties on `Record<string, any>`.
-
-Known limitations:
-- Does not include `undefined` in the type on object types with an index signature (for example, `{a: string; [key: string]: string}`).
-*/
-type StrictPropertyOf<BaseType, Key extends keyof BaseType, Options extends Required<GetOptions>> =
-	Record<string, any> extends BaseType
-		? string extends keyof BaseType
-			? Strictify<BaseType[Key], Options> // Record<string, any>
-			: BaseType[Key] // Record<'a' | 'b', any> (Records with a string union as keys have required properties)
-		: BaseType[Key];
-
-/**
-Splits a dot-prop style path into a tuple comprised of the properties in the path. Handles square-bracket notation.
-
-@example
-```
-ToPath<'foo.bar.baz'>
-//=> ['foo', 'bar', 'baz']
-
-ToPath<'foo[0].bar.baz'>
-//=> ['foo', '0', 'bar', 'baz']
-```
-*/
-type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
-
-/**
-Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`.
-*/
-type FixPathSquareBrackets<Path extends string> =
-	Path extends `[${infer Head}]${infer Tail}`
-		? Tail extends `[${string}`
-			? `${Head}.${FixPathSquareBrackets<Tail>}`
-			: `${Head}${FixPathSquareBrackets<Tail>}`
-		: Path extends `${infer Head}[${infer Middle}]${infer Tail}`
-			? `${Head}.${FixPathSquareBrackets<`[${Middle}]${Tail}`>}`
-			: Path;
-
-/**
-Returns true if `LongString` is made up out of `Substring` repeated 0 or more times.
-
-@example
-```
-ConsistsOnlyOf<'aaa', 'a'> //=> true
-ConsistsOnlyOf<'ababab', 'ab'> //=> true
-ConsistsOnlyOf<'aBa', 'a'> //=> false
-ConsistsOnlyOf<'', 'a'> //=> true
-```
-*/
-type ConsistsOnlyOf<LongString extends string, Substring extends string> =
-	LongString extends ''
-		? true
-		: LongString extends `${Substring}${infer Tail}`
-			? ConsistsOnlyOf<Tail, Substring>
-			: false;
-
-/**
-Convert a type which may have number keys to one with string keys, making it possible to index using strings retrieved from template types.
-
-@example
-```
-type WithNumbers = {foo: string; 0: boolean};
-type WithStrings = WithStringKeys<WithNumbers>;
-
-type WithNumbersKeys = keyof WithNumbers;
-//=> 'foo' | 0
-type WithStringsKeys = keyof WithStrings;
-//=> 'foo' | '0'
-```
-*/
-type WithStringKeys<BaseType> = {
-	[Key in StringKeyOf<BaseType>]: UncheckedIndex<BaseType, Key>
-};
-
-/**
-Perform a `T[U]` operation if `T` supports indexing.
-*/
-type UncheckedIndex<T, U extends string | number> = [T] extends [Record<string | number, any>] ? T[U] : never;
-
-/**
-Get a property of an object or array. Works when indexing arrays using number-literal-strings, for example, `PropertyOf<number[], '0'> = number`, and when indexing objects with number keys.
-
-Note:
-- Returns `unknown` if `Key` is not a property of `BaseType`, since TypeScript uses structural typing, and it cannot be guaranteed that extra properties unknown to the type system will exist at runtime.
-- Returns `undefined` from nullish values, to match the behaviour of most deep-key libraries like `lodash`, `dot-prop`, etc.
-*/
-type PropertyOf<BaseType, Key extends string, Options extends Required<GetOptions>> =
-	BaseType extends null | undefined
-		? undefined
-		: Key extends keyof BaseType
-			? StrictPropertyOf<BaseType, Key, Options>
-			// Handle arrays and tuples
-			: BaseType extends readonly unknown[]
-				? Key extends `${number}`
-					// For arrays with unknown length (regular arrays)
-					? number extends BaseType['length']
-						? Strictify<BaseType[number], Options>
-						// For tuples: check if the index is valid
-						: Key extends keyof BaseType
-							? Strictify<BaseType[Key & keyof BaseType], Options>
-							// Out-of-bounds access for tuples
-							: unknown
-					// Non-numeric string key for arrays/tuples
-					: unknown
-				// Handle array-like objects
-				: BaseType extends {
-					[n: number]: infer Item;
-					length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
-				}
-					? (
-						ConsistsOnlyOf<Key, StringDigit> extends true
-							? Strictify<Item, Options>
-							: unknown
-					)
-					: Key extends keyof WithStringKeys<BaseType>
-						? StrictPropertyOf<WithStringKeys<BaseType>, Key, Options>
-						: unknown;
-
-// This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
-/**
-Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
-
-Use-case: Retrieve a property from deep inside an API response or some other complex object.
-
-@example
-```
-import type {Get} from 'type-fest';
-import * as lodash from 'lodash';
-
-const get = <BaseType, Path extends string | readonly string[]>(object: BaseType, path: Path): Get<BaseType, Path> =>
-	lodash.get(object, path);
-
-interface ApiResponse {
-	hits: {
-		hits: Array<{
-			_id: string
-			_source: {
-				name: Array<{
-					given: string[]
-					family: string
-				}>
-				birthDate: string
-			}
-		}>
-	}
-}
-
-const getName = (apiResponse: ApiResponse) =>
-	get(apiResponse, 'hits.hits[0]._source.name');
-	//=> Array<{given: string[]; family: string}> | undefined
-
-// Path also supports a readonly array of strings
-const getNameWithPathArray = (apiResponse: ApiResponse) =>
-	get(apiResponse, ['hits','hits', '0', '_source', 'name'] as const);
-	//=> Array<{given: string[]; family: string}> | undefined
-
-// Non-strict mode:
-Get<string[], '3', {strict: false}> //=> string
-Get<Record<string, string>, 'foo', {strict: true}> // => string
-```
-
-@category Object
-@category Array
-@category Template literal
-*/
-export type Get<
-	BaseType,
-	Path extends
-	| readonly string[]
-	| LiteralStringUnion<ToString<Paths<BaseType, {bracketNotation: false; maxRecursionDepth: 2}> | Paths<BaseType, {bracketNotation: true; maxRecursionDepth: 2}>>>,
-	Options extends GetOptions = {},
-> =
-	GetWithPath<
-	BaseType,
-	Path extends string ? ToPath<Path> : Path,
-	ApplyDefaultOptions<GetOptions, DefaultGetOptions, Options>
-	>;

package/node_modules/ink/node_modules/type-fest/source/global-this.d.ts

@@ -1,21 +0,0 @@
-/**
-Declare locally scoped properties on `globalThis`.
-
-When defining a global variable in a declaration file is inappropriate, it can be helpful to define a `type` or `interface` (say `ExtraGlobals`) with the global variable and then cast `globalThis` via code like `globalThis as unknown as ExtraGlobals`.
-
-Instead of casting through `unknown`, you can update your `type` or `interface` to extend `GlobalThis` and then directly cast `globalThis`.
-
-@example
-```
-import type {GlobalThis} from 'type-fest';
-
-type ExtraGlobals = GlobalThis & {
-	readonly GLOBAL_TOKEN: string;
-};
-
-(globalThis as ExtraGlobals).GLOBAL_TOKEN;
-```
-
-@category Type
-*/
-export type GlobalThis = typeof globalThis;

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

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

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

@@ -1,56 +0,0 @@
-import type {NumberAbsolute, PositiveNumericStringGt} from './internal';
-import type {IsEqual} from './is-equal';
-import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
-import type {And} from './and';
-import type {Or} from './or';
-
-/**
-Returns a boolean for whether a given number is greater than another number.
-
-@example
-```
-import type {GreaterThan} from 'type-fest';
-
-GreaterThan<1, -5>;
-//=> true
-
-GreaterThan<1, 1>;
-//=> false
-
-GreaterThan<1, 5>;
-//=> false
-```
-*/
-export type GreaterThan<A extends number, B extends number> =
-	A extends number // For distributing `A`
-		? B extends number // For distributing `B`
-			? number extends A | B
-				? never
-				: [
-					IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-					IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-				] extends infer R extends [boolean, boolean, boolean, boolean]
-					? Or<
-					And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-					And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-					> extends true
-						? true
-						: Or<
-						And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-						And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-						> extends true
-							? false
-							: true extends R[number]
-								? false
-								: [IsNegative<A>, IsNegative<B>] extends infer R extends [boolean, boolean]
-									? [true, false] extends R
-										? false
-										: [false, true] extends R
-											? true
-											: [false, false] extends R
-												? PositiveNumericStringGt<`${A}`, `${B}`>
-												: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
-									: never
-					: never
-			: never // Should never happen
-		: never; // Should never happen

package/node_modules/ink/node_modules/type-fest/source/has-optional-keys.d.ts

@@ -1,21 +0,0 @@
-import type {OptionalKeysOf} from './optional-keys-of';
-
-/**
-Creates a type that represents `true` or `false` depending on whether the given type has any optional fields.
-
-This is useful when you want to create an API whose behavior depends on the presence or absence of optional fields.
-
-@example
-```
-import type {HasOptionalKeys, OptionalKeysOf} from 'type-fest';
-
-type UpdateService<Entity extends object> = {
-	removeField: HasOptionalKeys<Entity> extends true
-		? (field: OptionalKeysOf<Entity>) => Promise<void>
-		: never
-}
-```
-
-@category Utilities
-*/
-export type HasOptionalKeys<BaseType extends object> = OptionalKeysOf<BaseType> extends never ? false : true;

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

@@ -1,21 +0,0 @@
-import type {ReadonlyKeysOf} from './readonly-keys-of';
-
-/**
-Creates a type that represents `true` or `false` depending on whether the given type has any readonly fields.
-
-This is useful when you want to create an API whose behavior depends on the presence or absence of readonly fields.
-
-@example
-```
-import type {HasReadonlyKeys, ReadonlyKeysOf} from 'type-fest';
-
-type UpdateService<Entity extends object> = {
-	removeField: HasReadonlyKeys<Entity> extends true
-		? (field: ReadonlyKeysOf<Entity>) => Promise<void>
-		: never
-}
-```
-
-@category Utilities
-*/
-export type HasReadonlyKeys<BaseType extends object> = ReadonlyKeysOf<BaseType> extends never ? false : true;

package/node_modules/ink/node_modules/type-fest/source/has-required-keys.d.ts

@@ -1,59 +0,0 @@
-import type {RequiredKeysOf} from './required-keys-of';
-
-/**
-Creates a type that represents `true` or `false` depending on whether the given type has any required fields.
-
-This is useful when you want to create an API whose behavior depends on the presence or absence of required fields.
-
-@example
-```
-import type {HasRequiredKeys} from 'type-fest';
-
-type GeneratorOptions<Template extends object> = {
-	prop1: number;
-	prop2: string;
-} & (HasRequiredKeys<Template> extends true
-	? {template: Template}
-	: {template?: Template});
-
-interface Template1 {
-	optionalSubParam?: string;
-}
-
-interface Template2 {
-	requiredSubParam: string;
-}
-
-type Options1 = GeneratorOptions<Template1>;
-type Options2 = GeneratorOptions<Template2>;
-
-const optA: Options1 = {
-	prop1: 0,
-	prop2: 'hi'
-};
-const optB: Options1 = {
-	prop1: 0,
-	prop2: 'hi',
-	template: {}
-};
-const optC: Options1 = {
-	prop1: 0,
-	prop2: 'hi',
-	template: {
-		optionalSubParam: 'optional value'
-	}
-};
-
-const optD: Options2 = {
-	prop1: 0,
-	prop2: 'hi',
-	template: {
-		requiredSubParam: 'required value'
-	}
-};
-
-```
-
-@category Utilities
-*/
-export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;

package/node_modules/ink/node_modules/type-fest/source/has-writable-keys.d.ts

@@ -1,21 +0,0 @@
-import type {WritableKeysOf} from './writable-keys-of';
-
-/**
-Creates a type that represents `true` or `false` depending on whether the given type has any writable fields.
-
-This is useful when you want to create an API whose behavior depends on the presence or absence of writable fields.
-
-@example
-```
-import type {HasWritableKeys, WritableKeysOf} from 'type-fest';
-
-type UpdateService<Entity extends object> = {
-	removeField: HasWritableKeys<Entity> extends true
-		? (field: WritableKeysOf<Entity>) => Promise<void>
-		: never
-}
-```
-
-@category Utilities
-*/
-export type HasWritableKeys<BaseType extends object> = WritableKeysOf<BaseType> extends never ? false : true;

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

@@ -1,24 +0,0 @@
-import type {IsAny} from './is-any';
-
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (
-	IsAny<T> extends true ? TypeIfAny : TypeIfNotAny
-);

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

@@ -1,26 +0,0 @@
-import type {IsEmptyObject} from './empty-object';
-
-/**
-An if-else-like type that resolves depending on whether the given type is `{}`.
-
-@see {@link IsEmptyObject}
-
-@example
-```
-import type {IfEmptyObject} from 'type-fest';
-
-type ShouldBeTrue = IfEmptyObject<{}>;
-//=> true
-
-type ShouldBeBar = IfEmptyObject<{key: any}, 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IfEmptyObject<
-	T,
-	TypeIfEmptyObject = true,
-	TypeIfNotEmptyObject = false,
-> = IsEmptyObject<T> extends true ? TypeIfEmptyObject : TypeIfNotEmptyObject;

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

@@ -1,24 +0,0 @@
-import type {IsNever} from './is-never';
-
-/**
-An if-else-like type that resolves depending on whether the given type is `never`.
-
-@see {@link IsNever}
-
-@example
-```
-import type {IfNever} from 'type-fest';
-
-type ShouldBeTrue = IfNever<never>;
-//=> true
-
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
-	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
-);

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

@@ -1,24 +0,0 @@
-import type {IsNull} from './is-null';
-
-/**
-An if-else-like type that resolves depending on whether the given type is `null`.
-
-@see {@link IsNull}
-
-@example
-```
-import type {IfNull} from 'type-fest';
-
-type ShouldBeTrue = IfNull<null>;
-//=> true
-
-type ShouldBeBar = IfNull<'not null', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IfNull<T, TypeIfNull = true, TypeIfNotNull = false> = (
-	IsNull<T> extends true ? TypeIfNull : TypeIfNotNull
-);

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

@@ -1,24 +0,0 @@
-import type {IsUnknown} from './is-unknown';
-
-/**
-An if-else-like type that resolves depending on whether the given type is `unknown`.
-
-@see {@link IsUnknown}
-
-@example
-```
-import type {IfUnknown} from 'type-fest';
-
-type ShouldBeTrue = IfUnknown<unknown>;
-//=> true
-
-type ShouldBeBar = IfUnknown<'not unknown', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IfUnknown<T, TypeIfUnknown = true, TypeIfNotUnknown = false> = (
-	IsUnknown<T> extends true ? TypeIfUnknown : TypeIfNotUnknown
-);

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

@@ -1,22 +0,0 @@
-import type {IsEqual} from './is-equal';
-
-/**
-Returns a boolean for whether the given array includes the given item.
-
-This can be useful if another type wants to make a decision based on whether the array includes that item.
-
-@example
-```
-import type {Includes} from 'type-fest';
-
-type hasRed<array extends any[]> = Includes<array, 'red'>;
-```
-
-@category Array
-*/
-export 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;

package/node_modules/ink/node_modules/type-fest/source/int-closed-range.d.ts

@@ -1,35 +0,0 @@
-import type {IntRange} from './int-range';
-import type {Sum} from './sum';
-
-/**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (inclusive) parameter.
-
-You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntClosedRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8 | 10`.
-
-Note: `Start` or `End` must be non-negative and smaller than `999`.
-
-Use-cases:
-1. This can be used to define a set of valid input/output values. for example:
-	```
-	type Age = IntClosedRange<0, 120>; //=> 0 | 1 | 2 | ... | 119 | 120
-	type FontSize = IntClosedRange<10, 20>; //=> 10 | 11 | ... | 19 | 20
-	type EvenNumber = IntClosedRange<0, 10, 2>; //=> 0 | 2 | 4 | 6 | 8 | 10
-	```
-2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntClosedRange<0, 100>;`
-
-@example
-```
-import type {IntClosedRange} from 'type-fest';
-
-// Create union type `0 | 1 | ... | 9`
-type ZeroToNine = IntClosedRange<0, 9>;
-
-// Create union type `100 | 200 | 300 | ... | 900`
-type Hundreds = IntClosedRange<100, 900, 100>;
-```
-
-@see IntRange
-*/
-export type IntClosedRange<Start extends number, End extends number, Skip extends number = 1> = IntRange<Start, Sum<End, 1>, Skip>;