@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

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

@@ -0,0 +1,24 @@
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+import type {ValueOf} from 'type-fest';
+
+type A = ValueOf<{id: number; name: string; active: boolean}>;
+//=> string | number | boolean
+
+type B = ValueOf<{id: number; name: string; active: boolean}, 'name'>;
+//=> string
+
+type C = ValueOf<{id: number; name: string; active: boolean}, 'id' | 'name'>;
+//=> string | number
+```
+
+@category Object
+*/
+export type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
+
+export {};

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

@@ -0,0 +1,148 @@
+import type {
+	ApplyDefaultOptions,
+	AsciiPunctuation,
+	IsNumeric,
+	WordSeparators,
+} from './internal/index.d.ts';
+import type {IsLowercase} from './is-lowercase.d.ts';
+import type {IsUppercase} from './is-uppercase.d.ts';
+
+type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
+
+type RemoveLastCharacter<
+	Sentence extends string,
+	Character extends string,
+> = Sentence extends `${infer LeftSide}${Character}`
+	? SkipEmptyWord<LeftSide>
+	: never;
+
+/**
+Words options.
+
+@see {@link Words}
+*/
+export type WordsOptions = {
+	/**
+	Split on numeric sequence.
+
+	@default true
+
+	@example
+	```
+	import type {Words} from 'type-fest';
+
+	type Example1 = Words<'p2pNetwork', {splitOnNumbers: true}>;
+	//=> ['p', '2', 'p', 'Network']
+
+	type Example2 = Words<'p2pNetwork', {splitOnNumbers: false}>;
+	//=> ['p2p', 'Network']
+	```
+	*/
+	splitOnNumbers?: boolean;
+	/**
+	Split on {@link AsciiPunctuation | punctuation characters} (e.g., `#`, `&`, `*`, `:`, `?`, `@`, `~`).
+
+	@example
+	```
+	import type {Words} from 'type-fest';
+
+	type Example1 = Words<'hello:world', {splitOnPunctuation: true}>;
+	//=> ['hello', 'world']
+
+	type Example2 = Words<'hello:world', {splitOnPunctuation: false}>;
+	//=> ['hello', ':world']
+	```
+	*/
+	splitOnPunctuation?: boolean;
+};
+
+export type _DefaultWordsOptions = {
+	splitOnNumbers: true;
+	splitOnPunctuation: false;
+};
+
+/**
+Split a string similar to Lodash's `_.words()` function.
+
+- Split on each word that begins with a capital letter.
+- Split on each {@link WordSeparators}.
+- Split on each {@link AsciiPunctuation} (if {@link WordsOptions.splitOnPunctuation} is enabled).
+- Split on numeric sequence.
+
+@example
+```
+import type {Words} from 'type-fest';
+
+type Words0 = Words<'helloWorld'>;
+//=> ['hello', 'World']
+
+type Words1 = Words<'helloWORLD'>;
+//=> ['hello', 'WORLD']
+
+type Words2 = Words<'hello-world'>;
+//=> ['hello', 'world']
+
+type Words3 = Words<'--hello the_world'>;
+//=> ['hello', 'the', 'world']
+
+type Words4 = Words<'lifeIs42'>;
+//=> ['life', 'Is', '42']
+
+type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
+//=> ['p2p', 'Network']
+
+type Words6 = Words<'hello:world', {splitOnPunctuation: true}>;
+//=> ['hello', 'world']
+
+type Words7 = Words<'hello:world', {splitOnPunctuation: false}>;
+//=> ['hello', ':world']
+
+type Words8 = Words<'hello::world', {splitOnPunctuation: true}>;
+//=> ['hello', 'world']
+```
+
+@category Change case
+@category Template literal
+*/
+export type Words<Sentence extends string, Options extends WordsOptions = {}> = WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>>;
+
+type WordsImplementation<
+	Sentence extends string,
+	Options extends Required<WordsOptions>,
+	LastCharacter extends string = '',
+	CurrentWord extends string = '',
+> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}`
+	? FirstCharacter extends WordSeparators | (Options['splitOnPunctuation'] extends true ? AsciiPunctuation : never)
+		// Skip word separator
+		? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>]
+		: LastCharacter extends ''
+			// Fist char of word
+			? WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>
+			// Case change: non-numeric to numeric
+			: [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
+				? Options['splitOnNumbers'] extends true
+					// Split on number: push word
+					? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
+					// No split on number: concat word
+					: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+				// Case change: numeric to non-numeric
+				: [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
+					? Options['splitOnNumbers'] extends true
+						// Split on number: push word
+						? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
+						// No split on number: concat word
+						: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+					// No case change: concat word
+					: [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
+						? WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+					// Case change: lower to upper, push word
+						: [true, true] extends [IsLowercase<LastCharacter>, IsUppercase<FirstCharacter>]
+							? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
+						// Case change: upper to lower, brings back the last character, push word
+							: [true, true] extends [IsUppercase<LastCharacter>, IsLowercase<FirstCharacter>]
+								? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${LastCharacter}${FirstCharacter}`>]
+							// No case change: concat word
+								: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+	: [...SkipEmptyWord<CurrentWord>];
+
+export {};

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

@@ -0,0 +1,84 @@
+import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
+
+/**
+Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.
+
+This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
+
+@example
+```
+import type {WritableDeep} from 'type-fest';
+
+type Foo = {
+	readonly a: number;
+	readonly b: readonly string[]; // To show that mutability is deeply affected.
+	readonly c: boolean;
+};
+
+const writableDeepFoo: WritableDeep<Foo> = {a: 1, b: ['2'], c: true};
+writableDeepFoo.a = 3;
+writableDeepFoo.b[0] = 'new value';
+writableDeepFoo.b = ['something'];
+```
+
+Note that types containing overloaded functions are not made deeply writable due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@see {@link Writable}
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type WritableDeep<T> = T extends BuiltIns
+	? T
+	: T extends (...arguments_: any[]) => unknown
+		? {} extends _WritableObjectDeep<T>
+			? T
+			: HasMultipleCallSignatures<T> extends true
+				? T
+				: ((...arguments_: Parameters<T>) => ReturnType<T>) & _WritableObjectDeep<T>
+		: T extends ReadonlyMap<unknown, unknown>
+			? WritableMapDeep<T>
+			: T extends ReadonlySet<unknown>
+				? WritableSetDeep<T>
+				: T extends readonly unknown[]
+					? WritableArrayDeep<T>
+					: T extends object
+						? _WritableObjectDeep<T>
+						: unknown;
+
+/**
+Same as `WritableDeep`, but accepts only `Map`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableMapDeep<MapType extends ReadonlyMap<unknown, unknown>> =
+	MapType extends ReadonlyMap<infer KeyType, infer ValueType>
+		? Map<WritableDeep<KeyType>, WritableDeep<ValueType>>
+		: MapType; // Should not heppen
+
+/**
+Same as `WritableDeep`, but accepts only `Set`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableSetDeep<SetType extends ReadonlySet<unknown>> =
+	SetType extends ReadonlySet<infer ItemType>
+		? Set<WritableDeep<ItemType>>
+		: SetType; // Should not heppen
+
+/**
+Same as `WritableDeep`, but accepts only `object`s as inputs. Internal helper for `WritableDeep`.
+*/
+export type _WritableObjectDeep<ObjectType extends object> = {
+	-readonly [KeyType in keyof ObjectType]: WritableDeep<ObjectType[KeyType]>
+};
+
+/**
+Same as `WritableDeep`, but accepts only `Array`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableArrayDeep<ArrayType extends readonly unknown[]> =
+	ArrayType extends readonly [] ? []
+		: ArrayType extends readonly [...infer U, infer V] ? [...WritableArrayDeep<U>, WritableDeep<V>]
+			: ArrayType extends readonly [infer U, ...infer V] ? [WritableDeep<U>, ...WritableArrayDeep<V>]
+				: ArrayType extends ReadonlyArray<infer U> ? Array<WritableDeep<U>>
+					: ArrayType extends Array<infer U> ? Array<WritableDeep<U>>
+						: ArrayType;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/source/writable-keys-of.d.ts

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

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

@@ -0,0 +1,68 @@
+import type {Except} from './except.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+/**
+Create a writable version of the given array type.
+*/
+type WritableArray<ArrayType extends readonly unknown[]> =
+	ArrayType extends readonly [] ? []
+		: ArrayType extends readonly [...infer U, infer V] ? [...U, V]
+			: ArrayType extends readonly [infer U, ...infer V] ? [U, ...V]
+				: ArrayType extends ReadonlyArray<infer U> ? U[]
+					: ArrayType;
+
+/**
+Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
+
+The 2nd argument will be ignored if the input type is not an object.
+
+Note: This type can make readonly `Set` and `Map` writable. This behavior is different from `Readonly<T>` (as of TypeScript 5.2.2). See: https://github.com/microsoft/TypeScript/issues/29655
+
+This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
+
+@example
+```
+import type {Writable} from 'type-fest';
+
+type Foo = {
+	readonly a: number;
+	readonly b: readonly string[]; // To show that only the mutability status of the properties, not their values, are affected.
+	readonly c: boolean;
+};
+
+const writableFoo: Writable<Foo> = {a: 1, b: ['2'], c: true};
+writableFoo.a = 3;
+// @ts-expect-error
+writableFoo.b[0] = 'new value'; // Will still fail as the value of property "b" is still a readonly type.
+writableFoo.b = ['something']; // Will work as the "b" property itself is no longer readonly.
+
+type SomeWritable = Writable<Foo, 'b' | 'c'>;
+//=> {readonly a: number; b: readonly string[]; c: boolean}
+
+// Also supports array
+const readonlyArray: readonly number[] = [1, 2, 3];
+// @ts-expect-error
+readonlyArray.push(4); // Will fail as the array itself is readonly.
+const writableArray: Writable<typeof readonlyArray> = readonlyArray as Writable<typeof readonlyArray>;
+writableArray.push(4); // Will work as the array itself is now writable.
+```
+
+@category Object
+*/
+export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
+	BaseType extends ReadonlyMap<infer KeyType, infer ValueType>
+		? Map<KeyType, ValueType>
+		: BaseType extends ReadonlySet<infer ItemType>
+			? Set<ItemType>
+			: BaseType extends readonly unknown[]
+				// Handle array
+				? WritableArray<BaseType>
+				// Handle object
+				: Simplify<
+					// Pick just the keys that are not writable from the base type.
+					Except<BaseType, Keys>
+					// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
+					& {-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
+				>;
+
+export {};

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

@@ -0,0 +1,83 @@
+import type {Not} from './internal/type.d.ts';
+import type {And} from './and.d.ts';
+import type {Or} from './or.d.ts';
+
+/**
+Returns a boolean for whether only one of two given types is `true`.
+
+Use-case: Constructing complex conditional types where one single condition must be satisfied.
+
+@example
+```
+import type {Xor} from 'type-fest';
+
+type TT = Xor<true, true>;
+//=> false
+
+type TF = Xor<true, false>;
+//=> true
+
+type FT = Xor<false, true>;
+//=> true
+
+type FF = Xor<false, false>;
+//=> false
+```
+
+Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `Xor<false, boolean>` expands to `Xor<false, true> | Xor<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {Xor} from 'type-fest';
+
+type A = Xor<false, boolean>;
+//=> boolean
+
+type B = Xor<boolean, false>;
+//=> boolean
+
+type C = Xor<true, boolean>;
+//=> boolean
+
+type D = Xor<boolean, true>;
+//=> boolean
+
+type E = Xor<boolean, boolean>;
+//=> boolean
+```
+
+Note: If `never` is passed as an argument, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {Xor} from 'type-fest';
+
+type A = Xor<true, never>;
+//=> true
+
+type B = Xor<never, true>;
+//=> true
+
+type C = Xor<false, never>;
+//=> false
+
+type D = Xor<never, false>;
+//=> false
+
+type E = Xor<boolean, never>;
+//=> boolean
+
+type F = Xor<never, boolean>;
+//=> boolean
+
+type G = Xor<never, never>;
+//=> false
+```
+
+@see {@link And}
+@see {@link Or}
+*/
+export type Xor<A extends boolean, B extends boolean> = And<Or<A, B>, Not<And<A, B>>>;
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/widest-line/package.json

@@ -0,0 +1,60 @@
+{
+	"name": "widest-line",
+	"version": "6.0.0",
+	"description": "Get the visual width of the widest line in a string - the number of columns required to display it",
+	"license": "MIT",
+	"repository": "sindresorhus/widest-line",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"type": "module",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=20"
+	},
+	"scripts": {
+		"test": "xo && ava"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"string",
+		"character",
+		"unicode",
+		"width",
+		"visual",
+		"column",
+		"columns",
+		"fullwidth",
+		"full-width",
+		"full",
+		"ansi",
+		"escape",
+		"codes",
+		"cli",
+		"command-line",
+		"terminal",
+		"console",
+		"cjk",
+		"chinese",
+		"japanese",
+		"korean",
+		"fixed-width"
+	],
+	"dependencies": {
+		"string-width": "^8.1.0"
+	},
+	"devDependencies": {
+		"ava": "^6.4.1",
+		"xo": "^1.2.3"
+	}
+}

package/node_modules/@quantiya/codevibe-core/node_modules/wrap-ansi/index.d.ts

@@ -0,0 +1,41 @@
+export type Options = {
+	/**
+	By default the wrap is soft, meaning long words may extend past the column width. Setting this to `true` will make it hard wrap at the column width.
+
+	@default false
+	*/
+	readonly hard?: boolean;
+
+	/**
+	By default, an attempt is made to split words at spaces, ensuring that they don't extend past the configured columns. If wordWrap is `false`, each column will instead be completely filled splitting words as necessary.
+
+	@default true
+	*/
+	readonly wordWrap?: boolean;
+
+	/**
+	Whitespace on all lines is removed by default. Set this option to `false` if you don't want to trim.
+
+	@default true
+	*/
+	readonly trim?: boolean;
+};
+
+/**
+Wrap words to the specified column width.
+
+@param string - A string with ANSI escape codes, like one styled by [`chalk`](https://github.com/chalk/chalk). Newline characters will be normalized to `\n`. Tab characters are expanded to spaces using 8-column tab stops before wrapping.
+@param columns - The number of columns to wrap the text to.
+
+@example
+```
+import chalk from 'chalk';
+import wrapAnsi from 'wrap-ansi';
+
+const input = 'The quick brown ' + chalk.red('fox jumped over ') +
+	'the lazy ' + chalk.green('dog and then ran away with the unicorn.');
+
+console.log(wrapAnsi(input, 20));
+```
+*/
+export default function wrapAnsi(string: string, columns: number, options?: Options): string;