@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

package/node_modules/ink/node_modules/type-fest/source/snake-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 snake case recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see SnakeCase
-@see SnakeCasedProperties
-
-@example
-```
-import type {SnakeCasedPropertiesDeep} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-interface UserWithFriends {
-	userInfo: User;
-	userFriends: User[];
-}
-
-const result: SnakeCasedPropertiesDeep<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: SnakeCasedPropertiesDeep<{line1: { line2: [{ line3: string }] }}, {splitOnNumbers: true}> = {
-	line_1: {
-		line_2: [
-			{
-				line_3: 'string',
-			},
-		],
-	},
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type SnakeCasedPropertiesDeep<
-	Value,
-	Options extends WordsOptions = {},
-> = DelimiterCasedPropertiesDeep<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

package/node_modules/ink/node_modules/type-fest/source/snake-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 snake case but not recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see SnakeCase
-@see SnakeCasedPropertiesDeep
-
-@example
-```
-import type {SnakeCasedProperties} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-const result: SnakeCasedProperties<User> = {
-	user_id: 1,
-	user_name: 'Tom',
-};
-
-const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
-	'line_1': 'string',
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type SnakeCasedProperties<
-	Value,
-	Options extends WordsOptions = {},
-> = DelimiterCasedProperties<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

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

@@ -1,88 +0,0 @@
-import type {And} from './and';
-import type {ApplyDefaultOptions, Not} from './internal';
-import type {IsStringLiteral} from './is-literal';
-import type {Or} from './or';
-
-/**
-Split options.
-
-@see {@link Split}
-*/
-type SplitOptions = {
-	/**
-	When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
-
-	Note: In the future, this option might be enabled by default, so if you currently rely on this being disabled, you should consider explicitly enabling it.
-
-	@default false
-
-	@example
-	```ts
-	type Example1 = Split<`foo.${string}.bar`, '.', {strictLiteralChecks: false}>;
-	//=> ['foo', string, 'bar']
-
-	type Example2 = Split<`foo.${string}`, '.', {strictLiteralChecks: true}>;
-	//=> string[]
-
-	type Example3 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: false}>;
-	//=> ['foo', 'r', 'z']
-
-	type Example4 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: true}>;
-	//=> string[]
-	```
-	*/
-	strictLiteralChecks?: boolean;
-};
-
-type DefaultSplitOptions = {
-	strictLiteralChecks: false;
-};
-
-/**
-Represents an array of strings split using a given character or character set.
-
-Use-case: Defining the return type of a method like `String.prototype.split`.
-
-@example
-```
-import type {Split} from 'type-fest';
-
-declare function split<S extends string, D extends string>(string: S, separator: D): Split<S, D>;
-
-type Item = 'foo' | 'bar' | 'baz' | 'waldo';
-const items = 'foo,bar,baz,waldo';
-let array: Item[];
-
-array = split(items, ',');
-```
-
-@see {@link SplitOptions}
-
-@category String
-@category Template literal
-*/
-export type Split<
-	S extends string,
-	Delimiter extends string,
-	Options extends SplitOptions = {},
-> =
-	SplitHelper<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
-
-type SplitHelper<
-	S extends string,
-	Delimiter extends string,
-	Options extends Required<SplitOptions>,
-	Accumulator extends string[] = [],
-> = S extends string // For distributing `S`
-	? Delimiter extends string // For distributing `Delimeter`
-		// If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
-		? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true
-			? S extends `${infer Head}${Delimiter}${infer Tail}`
-				? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]>
-				: Delimiter extends ''
-					? Accumulator
-					: [...Accumulator, S]
-			// Otherwise, return `string[]`
-			: string[]
-		: never // Should never happen
-	: never; // Should never happen

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

@@ -1,84 +0,0 @@
-import type {RequiredKeysOf} from './required-keys-of';
-import type {Simplify} from './simplify';
-
-type SpreadObject<FirstType extends object, SecondType extends object> = {
-	[Key in keyof FirstType]: Key extends keyof SecondType
-		? FirstType[Key] | Required<SecondType>[Key]
-		: FirstType[Key];
-} & Pick<
-SecondType,
-RequiredKeysOf<SecondType> | Exclude<keyof SecondType, keyof FirstType>
->;
-
-type TupleOrArray = readonly [...unknown[]];
-
-type SpreadTupleOrArray<
-	FirstType extends TupleOrArray,
-	SecondType extends TupleOrArray,
-> = Array<FirstType[number] | SecondType[number]>;
-
-type Spreadable = object | TupleOrArray;
-
-/**
-Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
-
-@example
-```
-import type {Spread} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b?: string;
-};
-
-type Bar = {
-	b?: number;
-	c: boolean;
-};
-
-const foo = {a: 1, b: '2'};
-const bar = {c: false};
-const fooBar = {...foo, ...bar};
-
-type FooBar = Spread<Foo, Bar>;
-// type FooBar = {
-// 	a: number;
-// 	b?: string | number | undefined;
-// 	c: boolean;
-// }
-
-const baz = (argument: FooBar) => {
-	// Do something
-}
-
-baz(fooBar);
-```
-
-@example
-```
-import type {Spread} from 'type-fest';
-
-const foo = [1, 2, 3];
-const bar = ['4', '5', '6'];
-
-const fooBar = [...foo, ...bar];
-type FooBar = Spread<typeof foo, typeof bar>;
-// FooBar = (string | number)[]
-
-const baz = (argument: FooBar) => {
-	// Do something
-};
-
-baz(fooBar);
-```
-
-@category Object
-*/
-export type Spread<
-	FirstType extends Spreadable,
-	SecondType extends Spreadable,
-> = FirstType extends TupleOrArray
-	? SecondType extends TupleOrArray
-		? SpreadTupleOrArray<FirstType, SecondType>
-		: Simplify<SpreadObject<FirstType, SecondType>>
-	: Simplify<SpreadObject<FirstType, SecondType>>;

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

@@ -1,25 +0,0 @@
-/**
-Get keys of the given type as strings.
-
-Number keys are converted to strings.
-
-Use-cases:
-- Get string keys from a type which may have number keys.
-- Makes it possible to index using strings retrieved from template types.
-
-@example
-```
-import type {StringKeyOf} from 'type-fest';
-
-type Foo = {
-	1: number,
-	stringKey: string,
-};
-
-type StringKeysOfFoo = StringKeyOf<Foo>;
-//=> '1' | 'stringKey'
-```
-
-@category Object
-*/
-export type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;

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

@@ -1,47 +0,0 @@
-import type {IsNumericLiteral} from './is-literal';
-import type {IsNegative} from './numeric';
-
-/**
-Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
-
-@example
-```
-import {StringRepeat} from 'type-fest';
-
-declare function stringRepeat<
-	Input extends string,
-	Count extends number
->(input: Input, count: Count): StringRepeat<Input, Count>;
-
-// The return type is the exact string literal, not just `string`.
-
-stringRepeat('foo', 2);
-//=> 'foofoo'
-
-stringRepeat('=', 3);
-//=> '==='
-```
-
-@category String
-@category Template literal
-*/
-export type StringRepeat<
-	Input extends string,
-	Count extends number,
-> = StringRepeatHelper<Input, Count>;
-
-type StringRepeatHelper<
-	Input extends string,
-	Count extends number,
-	Counter extends never[] = [],
-	Accumulator extends string = '',
-> =
-	IsNegative<Count> extends true
-		? never
-		: Input extends ''
-			? ''
-			: Count extends Counter['length']
-				? Accumulator
-				: IsNumericLiteral<Count> extends false
-					? string
-					: StringRepeatHelper<Input, Count, [...Counter, never], `${Accumulator}${Input}`>;

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

@@ -1,37 +0,0 @@
-import type {Join} from './join';
-import type {ArraySlice} from './array-slice';
-import type {StringToArray} from './internal';
-
-/**
-Returns a string slice of a given range, just like `String#slice()`.
-
-@see {ArraySlice}
-
-@example
-```
-import type {StringSlice} from 'type-fest';
-
-StringSlice<'abcde', 0, 2>;
-//=> 'ab'
-
-StringSlice<'abcde', 1>;
-//=> 'bcde'
-
-StringSlice<'abcde', 0, -1>;
-//=> 'abcd'
-
-StringSlice<'abcde', -2, -1>;
-//=> 'd'
-```
-
-@category String
-*/
-export type StringSlice<
-	S extends string,
-	Start extends number = 0,
-	End extends number = StringToArray<S>['length'],
-> = string extends S
-	? string
-	: ArraySlice<StringToArray<S>, Start, End> extends infer R extends readonly string[]
-		? Join<R, ''>
-		: never;

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

@@ -1,23 +0,0 @@
-/**
-Create a type with the keys of the given type changed to `string` type.
-
-Use-case: Changing interface values to strings in order to use them in a form model.
-
-@example
-```
-import type {Stringified} from 'type-fest';
-
-type Car = {
-	model: string;
-	speed: number;
-}
-
-const carForm: Stringified<Car> = {
-	model: 'Foo',
-	speed: '101'
-};
-```
-
-@category Object
-*/
-export type Stringified<ObjectType> = {[KeyType in keyof ObjectType]: string};

package/node_modules/ink/node_modules/type-fest/source/structured-cloneable.d.ts

@@ -1,92 +0,0 @@
-import type {TypedArray} from './typed-array';
-import type {FindGlobalInstanceType} from './find-global-type';
-
-type StructuredCloneablePrimitive =
-	| string
-	| number
-	| bigint
-	| boolean
-	| null
-	| undefined
-	| Boolean
-	| Number
-	| String;
-
-type StructuredCloneableData =
-	| ArrayBuffer
-	| DataView
-	| Date
-	| Error
-	| RegExp
-	| TypedArray
-	| FindGlobalInstanceType<
-	// DOM or Node types
-	| 'Blob'
-	| 'File'
-	// DOM exclusive types
-	| 'AudioData'
-	| 'CropTarget'
-	| 'CryptoKey'
-	| 'DOMException'
-	| 'DOMMatrix'
-	| 'DOMMatrixReadOnly'
-	| 'DOMPoint'
-	| 'DOMPointReadOnly'
-	| 'DOMQuad'
-	| 'DOMRect'
-	| 'DOMRectReadOnly'
-	| 'FileList'
-	| 'FileSystemDirectoryHandle'
-	| 'FileSystemFileHandle'
-	| 'FileSystemHandle'
-	| 'GPUCompilationInfo'
-	| 'GPUCompilationMessage'
-	| 'ImageBitmap'
-	| 'ImageData'
-	| 'RTCCertificate'
-	| 'VideoFrame'
-	>;
-
-type StructuredCloneableCollection =
-	| readonly StructuredCloneable[]
-	| {readonly [key: string]: StructuredCloneable; readonly [key: number]: StructuredCloneable}
-	| ReadonlyMap<StructuredCloneable, StructuredCloneable>
-	| ReadonlySet<StructuredCloneable>;
-
-/**
-Matches a value that can be losslessly cloned using `structuredClone`.
-
-Note:
-- Custom error types will be cloned as the base `Error` type
-
-@see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
-
-@example
-```
-import type {StructuredCloneable} from 'type-fest';
-
-class CustomClass {}
-
-// @ts-expect-error
-const error: StructuredCloneable = {
-    custom: new CustomClass(),
-};
-
-structuredClone(error);
-//=> {custom: {}}
-
-const good: StructuredCloneable = {
-    number: 3,
-    date: new Date(),
-    map: new Map<string, number>(),
-}
-
-good.map.set('key', 1);
-
-structuredClone(good);
-//=> {number: 3, date: Date(2022-10-17 22:22:35.920), map: Map {'key' -> 1}}
-```
-
-@category Structured clone
-*/
-export type StructuredCloneable = StructuredCloneablePrimitive | StructuredCloneableData | StructuredCloneableCollection;

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

@@ -1,83 +0,0 @@
-import type {NumberAbsolute, BuildTuple, ReverseSign} from './internal';
-import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
-import type {LessThan} from './less-than';
-
-/**
-Returns the difference between two numbers.
-
-Note:
-- A or B can only support `-999` ~ `999`.
-
-@example
-```
-import type {Subtract} from 'type-fest';
-
-Subtract<333, 222>;
-//=> 111
-
-Subtract<111, -222>;
-//=> 333
-
-Subtract<-111, 222>;
-//=> -333
-
-Subtract<18, 96>;
-//=> -78
-
-Subtract<PositiveInfinity, 9999>;
-//=> PositiveInfinity
-
-Subtract<PositiveInfinity, PositiveInfinity>;
-//=> number
-```
-
-@category Numeric
-*/
-// TODO: Support big integer.
-export type Subtract<A extends number, B extends number> =
-	// Handle cases when A or B is the actual "number" type
-	number extends A | B ? number
-		// Handle cases when A and B are both +/- infinity
-		: A extends B & (PositiveInfinity | NegativeInfinity) ? number
-			// Handle cases when A is - infinity or B is + infinity
-			: A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity
-				// Handle cases when A is + infinity or B is - infinity
-				: A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity
-					// Handle case when numbers are equal to each other
-					: A extends B ? 0
-						// Handle cases when A or B is 0
-						: A extends 0 ? ReverseSign<B> : B extends 0 ? A
-							// Handle remaining regular cases
-							: SubtractPostChecks<A, B>;
-
-/**
-Subtracts two numbers A and B, such that they are not equal and neither of them are 0, +/- infinity or the `number` type
-*/
-type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
-	AreNegative extends [false, false]
-		? SubtractPositives<A, B>
-		: AreNegative extends [true, true]
-			// When both numbers are negative we subtract the absolute values and then reverse the sign
-			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
-			// When the signs are different we can add the absolute values and then reverse the sign if A < B
-			: [...BuildTuple<NumberAbsolute<A>>, ...BuildTuple<NumberAbsolute<B>>] extends infer R extends unknown[]
-				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
-				: never;
-
-/**
-Subtracts two positive numbers.
-*/
-type SubtractPositives<A extends number, B extends number> =
-	LessThan<A, B> extends true
-		// When A < B we can reverse the result of B - A
-		? ReverseSign<SubtractIfAGreaterThanB<B, A>>
-		: SubtractIfAGreaterThanB<A, B>;
-
-/**
-Subtracts two positive numbers A and B such that A > B.
-*/
-type SubtractIfAGreaterThanB<A extends number, B extends number> =
-	// This is where we always want to end up and do the actual subtraction
-	BuildTuple<A> extends [...BuildTuple<B>, ...infer R]
-		? R['length']
-		: never;

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

@@ -1,78 +0,0 @@
-import type {NumberAbsolute, BuildTuple, TupleMax, ReverseSign} from './internal';
-import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
-import type {Subtract} from './subtract';
-
-/**
-Returns the sum of two numbers.
-
-Note:
-- A or B can only support `-999` ~ `999`.
-
-@example
-```
-import type {Sum} from 'type-fest';
-
-Sum<111, 222>;
-//=> 333
-
-Sum<-111, 222>;
-//=> 111
-
-Sum<111, -222>;
-//=> -111
-
-Sum<PositiveInfinity, -9999>;
-//=> PositiveInfinity
-
-Sum<PositiveInfinity, NegativeInfinity>;
-//=> number
-```
-
-@category Numeric
-*/
-// TODO: Support big integer.
-export type Sum<A extends number, B extends number> =
-	// Handle cases when A or B is the actual "number" type
-	number extends A | B ? number
-		// Handle cases when A and B are both +/- infinity
-		: A extends B & (PositiveInfinity | NegativeInfinity) ? A // A or B could be used here as they are equal
-			// Handle cases when A and B are opposite infinities
-			: A | B extends PositiveInfinity | NegativeInfinity ? number
-				// Handle cases when A is +/- infinity
-				: A extends PositiveInfinity | NegativeInfinity ? A
-					// Handle cases when B is +/- infinity
-					: B extends PositiveInfinity | NegativeInfinity ? B
-						// Handle cases when A or B is 0 or it's the same number with different signs
-						: A extends 0 ? B : B extends 0 ? A : A extends ReverseSign<B> ? 0
-							// Handle remaining regular cases
-							: SumPostChecks<A, B>;
-
-/**
-Adds two numbers A and B, such that they are not equal with different signs and neither of them are 0, +/- infinity or the `number` type
-*/
-type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
-	AreNegative extends [false, false]
-		// When both numbers are positive we can add them together
-		? SumPositives<A, B>
-		: AreNegative extends [true, true]
-			// When both numbers are negative we add the absolute values and then reverse the sign
-			? ReverseSign<SumPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
-			// When the signs are different we can subtract the absolute values, remove the sign
-			// and then reverse the sign if the larger absolute value is negative
-			: NumberAbsolute<Subtract<NumberAbsolute<A>, NumberAbsolute<B>>> extends infer Result extends number
-				? TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_ extends number
-					? Max_ extends A | B
-						// The larger absolute value is positive, so the result is positive
-						? Result
-						// The larger absolute value is negative, so the result is negative
-						: ReverseSign<Result>
-					: never
-				: never;
-
-/**
-Adds two positive numbers.
-*/
-type SumPositives<A extends number, B extends number> =
-	[...BuildTuple<A>, ...BuildTuple<B>]['length'] extends infer Result extends number
-		? Result
-		: never;