@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/split.d.ts

@@ -0,0 +1,90 @@
+import type {And} from './and.d.ts';
+import type {ApplyDefaultOptions, Not} from './internal/index.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
+import type {Or} from './or.d.ts';
+
+/**
+Split options.
+
+@see {@link Split}
+*/
+export 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.
+
+	@default true
+
+	@example
+	```ts
+	import type {Split} from 'type-fest';
+
+	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: true;
+};
+
+/**
+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';
+const array: Item[] = 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 `Delimiter`
+		// 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 ''
+					? S extends ''
+						? Accumulator
+						: [...Accumulator, S]
+					: [...Accumulator, S]
+			// Otherwise, return `string[]`
+			: string[]
+		: never // Should never happen
+	: never; // Should never happen
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/spread.d.ts

@@ -0,0 +1,78 @@
+import type {RequiredKeysOf} from './required-keys-of.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+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>;
+//=> {a: number; b?: string | number; c: boolean}
+
+declare function baz(argument: FooBar): void;
+
+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)[]
+
+declare function baz(argument: FooBar): void;
+
+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>>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/string-length.d.ts

@@ -0,0 +1,38 @@
+import type {StringToArray} from './string-to-array.d.ts';
+
+/**
+Returns the length of the given string.
+
+@example
+```
+import type {StringLength} from 'type-fest';
+
+type A = StringLength<'abcde'>;
+//=> 5
+
+type B = StringLength<'abcde' | 'fgh'>;
+//=> 3 | 5
+```
+
+For non-literal strings, the result is `number` because the length of a non-literal string can be any number.
+
+@example
+```
+import type {StringLength} from 'type-fest';
+
+type A = StringLength<string>;
+//=> number
+
+type B = StringLength<Uppercase<string>>;
+//=> number
+
+type C = StringLength<`${string}abc`>;
+//=> number
+```
+
+@category String
+@category Template literal
+*/
+export type StringLength<S extends string> = StringToArray<S>['length'];
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/string-repeat.d.ts

@@ -0,0 +1,76 @@
+import type {IsNumericLiteral} from './is-literal.d.ts';
+import type {IsNegative} from './numeric.d.ts';
+import type {DigitCharacter} from './characters.d.ts';
+
+/**
+Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
+
+@example
+```
+import type {StringRepeat} from 'type-fest';
+
+declare function stringRepeat<
+	S extends string,
+	Count extends number,
+>(input: S, count: Count): StringRepeat<S, Count>;
+
+// The return type is the exact string literal, not just `string`.
+
+stringRepeat('foo', 2);
+//=> 'foofoo'
+
+stringRepeat('=', 3);
+//=> '==='
+```
+
+Note: If the specified count has a decimal part, the decimal part will be ignored.
+
+@example
+```
+import type {StringRepeat} from 'type-fest';
+
+type DecimalCount = StringRepeat<'foo', 2.5>;
+//=> 'foofoo'
+```
+
+@category String
+@category Template literal
+*/
+export type StringRepeat<S extends string, Count extends number> =
+	Count extends unknown // To distribute `Count`
+		? IsNegative<Count> extends true
+			? never
+			: S extends ''
+				? ''
+				: IsNumericLiteral<Count> extends false
+					? string
+					: `${Count}` extends `${string}e${string}`
+						? string
+						: BuildStringDigitByDigit<S, `${Count}`>
+		: never;
+
+type BuildStringDigitByDigit<S extends string, Count extends string, Accumulator extends string = ''> =
+	Count extends `${infer First extends DigitCharacter}${infer Rest}`
+		? BuildStringDigitByDigit<
+			S,
+			Rest,
+			`${RepeatStringTenTimes<Accumulator>}${DigitStringRepeat<S, First>}`
+		>
+		: Accumulator;
+
+type RepeatStringTenTimes<S extends string> = `${S}${S}${S}${S}${S}${S}${S}${S}${S}${S}`;
+
+type DigitStringRepeat<S extends string, Digit extends DigitCharacter> = [
+	'',
+	`${S}`,
+	`${S}${S}`,
+	`${S}${S}${S}`,
+	`${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}${S}${S}`,
+][Digit];
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/string-slice.d.ts

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

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/string-to-array.d.ts

@@ -0,0 +1,97 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
+import type {Or} from './or.d.ts';
+
+/**
+@see {@link StringToArray}
+*/
+export type StringToArrayOptions = {
+	/**
+	When enabled, non-literal parts of the string (e.g., `string`, `Uppercase<string>`) are mapped as single elements instead of being mapped as a rest element.
+
+	Note: Enabling this option can produce misleading results that might not reflect the actual runtime behavior.
+	For example, `StringToArray<string, {mapNonLiteralsDirectly: true}>` returns `[string]`, but at runtime, the string could be `'abc'` (which satisfies `string`), and converting it to an array would result in `['a', 'b', 'c']`, which doesn't satisfy `[string]`.
+
+	So, it is recommended to not enable this option unless you are aware of the implications.
+
+	@default false
+
+	@example
+	```
+	import type {StringToArray} from 'type-fest';
+
+	type A = StringToArray<string, {mapNonLiteralsDirectly: false}>;
+	//=> string[]
+
+	type B = StringToArray<string, {mapNonLiteralsDirectly: true}>;
+	//=> [string]
+
+	type C = StringToArray<`on${string}`, {mapNonLiteralsDirectly: false}>;
+	//=> ['o', 'n', ...string[]]
+
+	type D = StringToArray<`on${string}`, {mapNonLiteralsDirectly: true}>;
+	//=> ['o', 'n', string]
+
+	type E = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: false}>;
+	//=> [...string[], 'x', 'y', 'z']
+
+	type F = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: true}>;
+	//=> [string, 'x', 'y', 'z']
+	```
+	*/
+	mapNonLiteralsDirectly?: boolean;
+};
+
+type DefaultStringToArrayOptions = {
+	mapNonLiteralsDirectly: false;
+};
+
+/**
+Returns an array of the characters of the specified string.
+
+@example
+```
+import type {StringToArray} from 'type-fest';
+
+type A = StringToArray<'abcde'>;
+//=> ['a', 'b', 'c', 'd', 'e']
+
+type B = StringToArray<''>;
+//=> []
+
+type C = StringToArray<string>;
+//=> string[]
+
+type D = StringToArray<`foo${string}bar`>;
+//=> ['f', 'o', 'o', ...string[], 'b', 'a', 'r']
+
+type E = StringToArray<`foo${string}bar`, {mapNonLiteralsDirectly: true}>;
+//=> ['f', 'o', 'o', string, 'b', 'a', 'r']
+```
+
+@see {@link StringToArrayOptions}
+
+@category String
+*/
+export type StringToArray<S extends string, Options extends StringToArrayOptions = {}> =
+	IfNotAnyOrNever<
+		S,
+		{
+			ifNot: _StringToArray<S, ApplyDefaultOptions<StringToArrayOptions, DefaultStringToArrayOptions, Options>>;
+			ifAny: unknown[];
+		}
+	>;
+
+type _StringToArray<S extends string, Options extends Required<StringToArrayOptions>, Accumulator extends string[] = []> =
+	S extends `${infer First}${infer Rest}`
+		? Or<IsStringLiteral<First>, Options['mapNonLiteralsDirectly']> extends true
+			? _StringToArray<Rest, Options, [...Accumulator, First]>
+			: _StringToArray<Rest, Options, [...Accumulator, ...First[]]>
+		: S extends ''
+			? Accumulator
+			: Options['mapNonLiteralsDirectly'] extends true
+				? [...Accumulator, S]
+				: [...Accumulator, ...S[]];
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/string-to-number.d.ts

@@ -0,0 +1,67 @@
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from './numeric.d.ts';
+
+/**
+Converts a numeric string to a number.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type PositiveInteger = StringToNumber<'1234'>;
+//=> 1234
+
+type NegativeInteger = StringToNumber<'-1234'>;
+//=> -1234
+
+type PositiveFloat = StringToNumber<'1234.56'>;
+//=> 1234.56
+
+type NegativeFloat = StringToNumber<'-1234.56'>;
+//=> -1234.56
+
+type PositiveInfinity = StringToNumber<'Infinity'>;
+//=> Infinity
+
+type NegativeInfinity = StringToNumber<'-Infinity'>;
+//=> -Infinity
+```
+
+Note: Some strings, such as `'1.50'`, `'0b10'`, or `'12_345'`, may look like they can be converted to numbers, but they don't actually have corresponding numeric literals. So, in such cases, this type produces `never`. See [type-fest#1446](https://github.com/sindresorhus/type-fest/pull/1446) for more details.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type FractionalsEndingInZero = StringToNumber<'1.50'>;
+//=> never
+
+type NonDecimalBases = StringToNumber<'0b10' | '0o10' | '0x10'>;
+//=> never
+
+type NumericSeparators = StringToNumber<'12_345'>;
+//=> never
+```
+
+@category String
+@category Numeric
+@category Template literal
+*/
+export type StringToNumber<S extends string> = IfNotAnyOrNever<S, {ifNot: _StringToNumber<S>; ifAny: number}>;
+
+type _StringToNumber<S extends string> =
+	S extends `${infer N extends number}`
+		? number extends N
+			? `${number}` extends S
+				? N
+				: never
+			: N
+		: string extends S
+			? number
+			: S extends 'Infinity'
+				? PositiveInfinity
+				: S extends '-Infinity'
+					? NegativeInfinity
+					: never;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/stringified.d.ts

@@ -0,0 +1,25 @@
+/**
+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};
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/structured-cloneable.d.ts

@@ -0,0 +1,89 @@
+import type {TypedArray} from './typed-array.d.ts';
+import type {FindGlobalInstanceType} from './find-global-type.d.ts';
+
+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 {}
+
+const error = {
+	custom: new CustomClass(),
+	// @ts-expect-error
+} satisfies StructuredCloneable;
+
+const good = {
+	number: 3,
+	date: new Date(),
+	map: new Map<string, number>(),
+} satisfies StructuredCloneable;
+
+const clonedGood = structuredClone(good);
+//=> {number: number; date: Date; map: Map<string, number>}
+```
+
+@category Structured clone
+*/
+export type StructuredCloneable = StructuredCloneablePrimitive | StructuredCloneableData | StructuredCloneableCollection;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/subtract.d.ts

@@ -0,0 +1,87 @@
+import type {ReverseSign} from './internal/index.d.ts';
+import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
+import type {LessThan} from './less-than.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
+import type {Absolute} from './absolute.d.ts';
+
+/**
+Returns the difference between two numbers.
+
+Note:
+- A or B can only support `-999` ~ `999`.
+
+@example
+```
+import type {Subtract, PositiveInfinity} from 'type-fest';
+
+type A = Subtract<333, 222>;
+//=> 111
+
+type B = Subtract<111, -222>;
+//=> 333
+
+type C = Subtract<-111, 222>;
+//=> -333
+
+type D = Subtract<18, 96>;
+//=> -78
+
+type E = Subtract<PositiveInfinity, 9999>;
+//=> Infinity
+
+type F = 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<Absolute<A>, Absolute<B>>>
+			// When the signs are different we can add the absolute values and then reverse the sign if A < B
+			: [...TupleOf<Absolute<A>>, ...TupleOf<Absolute<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
+	TupleOf<A> extends [...TupleOf<B>, ...infer R]
+		? R['length']
+		: never;
+
+export {};