@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

package/node_modules/ink/node_modules/type-fest/source/all-union-fields.d.ts

@@ -1,88 +0,0 @@
-import type {NonRecursiveType, ReadonlyKeysOfUnion, ValueOfUnion} from './internal';
-import type {KeysOfUnion} from './keys-of-union';
-import type {SharedUnionFields} from './shared-union-fields';
-import type {Simplify} from './simplify';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Create a type with all fields from a union of object types.
-
-Use-cases:
-- You want a safe object type where each key exists in the union object.
-
-@example
-```
-import type {AllUnionFields} from 'type-fest';
-
-type Cat = {
-	name: string;
-	type: 'cat';
-	catType: string;
-};
-
-type Dog = {
-	name: string;
-	type: 'dog';
-	dogType: string;
-};
-
-function displayPetInfo(petInfo: Cat | Dog) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat';
-	// 	catType: string;
-	// } | {
-	// 	name: string;
-	// 	type: 'dog';
-	// 	dogType: string;
-	// }
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-
-	// TypeScript complains about `catType` and `dogType` not existing on type `Cat | Dog`.
-	console.log('animal type: ', petInfo.catType ?? petInfo.dogType);
-}
-
-function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat' | 'dog';
-	// 	catType?: string;
-	// 	dogType?: string;
-	// }
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-
-	// No TypeScript error.
-	console.log('animal type: ', petInfo.catType ?? petInfo.dogType);
-}
-```
-
-@see SharedUnionFields
-
-@category Object
-@category Union
-*/
-export type AllUnionFields<Union> =
-Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
-	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
-		?
-		| SkippedMembers
-		| Simplify<
-		// Include fields that are common in all union members
-		SharedUnionFields<RelevantMembers> &
-		// Include readonly fields present in any union member
-		{
-			readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P & KeysOfUnion<RelevantMembers>>
-		} &
-		// Include remaining fields that are neither common nor readonly
-		{
-			[P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>
-		}
-		>
-		: never
-	: never;

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

@@ -1,25 +0,0 @@
-import type {IsEqual} from './is-equal';
-
-/**
-Returns a boolean for whether two given types are both true.
-
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
-
-@example
-```
-import type {And} from 'type-fest';
-
-And<true, true>;
-//=> true
-
-And<true, false>;
-//=> false
-```
-
-@see {@link Or}
-*/
-export type And<A extends boolean, B extends boolean> = [A, B][number] extends true
-	? true
-	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
-		? false
-		: never;

package/node_modules/ink/node_modules/type-fest/source/array-indices.d.ts

@@ -1,23 +0,0 @@
-/**
-Provides valid indices for a constant array or tuple.
-
-Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
-
-@example
-```
-import type {ArrayIndices, ArrayValues} from 'type-fest';
-
-const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
-
-type Weekday = ArrayIndices<typeof weekdays>;
-type WeekdayName = ArrayValues<typeof weekdays>;
-
-const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
-```
-
-@see {@link ArrayValues}
-
-@category Array
-*/
-export type ArrayIndices<Element extends readonly unknown[]> =
-	Exclude<Partial<Element>['length'], Element['length']>;

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

@@ -1,109 +0,0 @@
-import type {Sum} from './sum';
-import type {LessThanOrEqual} from './less-than-or-equal';
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-import type {GreaterThan} from './greater-than';
-import type {IsNegative} from './numeric';
-import type {Not, TupleMin} from './internal';
-import type {IsEqual} from './is-equal';
-import type {And} from './and';
-import type {ArraySplice} from './array-splice';
-
-/**
-Returns an array slice of a given range, just like `Array#slice()`.
-
-@example
-```
-import type {ArraySlice} from 'type-fest';
-
-type T0 = ArraySlice<[0, 1, 2, 3, 4]>;
-//=> [0, 1, 2, 3, 4]
-
-type T1 = ArraySlice<[0, 1, 2, 3, 4], 0, -1>;
-//=> [0, 1, 2, 3]
-
-type T2 = ArraySlice<[0, 1, 2, 3, 4], 1, -2>;
-//=> [1, 2]
-
-type T3 = ArraySlice<[0, 1, 2, 3, 4], -2, 4>;
-//=> [3]
-
-type T4 = ArraySlice<[0, 1, 2, 3, 4], -2, -1>;
-//=> [3]
-
-type T5 = ArraySlice<[0, 1, 2, 3, 4], 0, -999>;
-//=> []
-
-function arraySlice<
-	const Array_ extends readonly unknown[],
-	Start extends number = 0,
-	End extends number = Array_['length'],
->(array: Array_, start?: Start, end?: End) {
-	return array.slice(start, end) as ArraySlice<Array_, Start, End>;
-}
-
-const slice = arraySlice([1, '2', {a: 3}, [4, 5]], 0, -1);
-
-typeof slice;
-//=> [1, '2', { readonly a: 3; }]
-
-slice[2].a;
-//=> 3
-
-// @ts-expect-error -- TS2493: Tuple type '[1, "2", {readonly a: 3}]' of length '3' has no element at index '3'.
-slice[3];
-```
-
-@category Array
-*/
-export type ArraySlice<
-	Array_ extends readonly unknown[],
-	Start extends number = never,
-	End extends number = never,
-> = Array_ extends unknown // To distributive type
-	? And<IsEqual<Start, never>, IsEqual<End, never>> extends true
-		? Array_
-		: number extends Array_['length']
-			? VariableLengthArraySliceHelper<Array_, Start, End>
-			: ArraySliceHelper<Array_, IsEqual<Start, never> extends true ? 0 : Start, IsEqual<End, never> extends true ? Array_['length'] : End>
-	: never; // Never happens
-
-type VariableLengthArraySliceHelper<
-	Array_ extends readonly unknown[],
-	Start extends number,
-	End extends number,
-> = And<Not<IsNegative<Start>>, IsEqual<End, never>> extends true
-	? ArraySplice<Array_, 0, Start>
-	: And<
-	And<Not<IsNegative<Start>>, Not<IsNegative<End>>>,
-	IsEqual<GreaterThan<End, Start>, true>
-	> extends true
-		? ArraySliceByPositiveIndex<Array_, Start, End>
-		: [];
-
-type ArraySliceHelper<
-	Array_ extends readonly unknown[],
-	Start extends number = 0,
-	End extends number = Array_['length'],
-	TraversedElement extends Array<Array_[number]> = [],
-	Result extends Array<Array_[number]> = [],
-	ArrayLength extends number = Array_['length'],
-	PositiveS extends number = IsNegative<Start> extends true
-		? Sum<ArrayLength, Start> extends infer AddResult extends number
-			? number extends AddResult // (ArrayLength + Start) < 0
-				? 0
-				: GreaterThan<AddResult, 0> extends true ? AddResult : 0
-			: never
-		: Start,
-	PositiveE extends number = IsNegative<End> extends true ? Sum<ArrayLength, End> : End,
-> = true extends [IsNegative<PositiveS>, LessThanOrEqual<PositiveE, PositiveS>, GreaterThanOrEqual<PositiveS, ArrayLength>][number]
-	? []
-	: ArraySliceByPositiveIndex<Array_, TupleMin<[PositiveS, ArrayLength]>, TupleMin<[PositiveE, ArrayLength]>>;
-
-type ArraySliceByPositiveIndex<
-	Array_ extends readonly unknown[],
-	Start extends number,
-	End extends number,
-	Result extends Array<Array_[number]> = [],
-> = Start extends End
-	? Result
-	: ArraySliceByPositiveIndex<Array_, Sum<Start, 1>, End, [...Result, Array_[Start]]>;

package/node_modules/ink/node_modules/type-fest/source/array-splice.d.ts

@@ -1,99 +0,0 @@
-import type {BuildTuple, StaticPartOfArray, VariablePartOfArray} from './internal';
-import type {GreaterThanOrEqual} from './greater-than-or-equal';
-import type {Subtract} from './subtract';
-import type {UnknownArray} from './unknown-array';
-
-/**
-The implementation of `SplitArrayByIndex` for fixed length arrays.
-*/
-type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
-SplitIndex extends 0
-	? [[], T]
-	: T extends readonly [...BuildTuple<SplitIndex>, ...infer V]
-		? T extends readonly [...infer U, ...V]
-			? [U, V]
-			: [never, never]
-		: [never, never];
-
-/**
-The implementation of `SplitArrayByIndex` for variable length arrays.
-*/
-type SplitVariableArrayByIndex<T extends UnknownArray,
-	SplitIndex extends number,
-	T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>,
-	T2 = T1 extends number
-		? BuildTuple<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
-		: [],
-> =
-SplitIndex extends 0
-	? [[], T]
-	: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
-		? [
-			SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
-			[
-				...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
-				...VariablePartOfArray<T>,
-			],
-		]
-		: [
-			[
-				...StaticPartOfArray<T>,
-				...(T2 extends UnknownArray ? T2 : []),
-			],
-			VariablePartOfArray<T>,
-		];
-
-/**
-Split the given array `T` by the given `SplitIndex`.
-
-@example
-```
-type A = SplitArrayByIndex<[1, 2, 3, 4], 2>;
-// type A = [[1, 2], [3, 4]];
-
-type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
-// type B = [[], [1, 2, 3, 4]];
-```
-*/
-type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
-	SplitIndex extends 0
-		? [[], T]
-		: number extends T['length']
-			? SplitVariableArrayByIndex<T, SplitIndex>
-			: SplitFixedArrayByIndex<T, SplitIndex>;
-
-/**
-Creates a new array type by adding or removing elements at a specified index range in the original array.
-
-Use-case: Replace or insert items in an array type.
-
-Like [`Array#splice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) but for types.
-
-@example
-```
-type SomeMonths0 = ['January', 'April', 'June'];
-type Mouths0 = ArraySplice<SomeMonths0, 1, 0, ['Feb', 'March']>;
-//=> type Mouths0 = ['January', 'Feb', 'March', 'April', 'June'];
-
-type SomeMonths1 = ['January', 'April', 'June'];
-type Mouths1 = ArraySplice<SomeMonths1, 1, 1>;
-//=> type Mouths1 = ['January', 'June'];
-
-type SomeMonths2 = ['January', 'Foo', 'April'];
-type Mouths2 = ArraySplice<SomeMonths2, 1, 1, ['Feb', 'March']>;
-//=> type Mouths2 = ['January', 'Feb', 'March', 'April'];
-```
-
-@category Array
-*/
-export type ArraySplice<
-	T extends UnknownArray,
-	Start extends number,
-	DeleteCount extends number,
-	Items extends UnknownArray = [],
-> =
-	SplitArrayByIndex<T, Start> extends [infer U extends UnknownArray, infer V extends UnknownArray]
-		? SplitArrayByIndex<V, DeleteCount> extends [infer _Deleted extends UnknownArray, infer X extends UnknownArray]
-			? [...U, ...Items, ...X]
-			: never // Should never happen
-		: never; // Should never happen

package/node_modules/ink/node_modules/type-fest/source/array-tail.d.ts

@@ -1,76 +0,0 @@
-import type {ApplyDefaultOptions, IfArrayReadonly} from './internal';
-import type {UnknownArray} from './unknown-array';
-
-/**
-@see {@link ArrayTail}
-*/
-type ArrayTailOptions = {
-	/**
-	Return a readonly array if the input array is readonly.
-
-	@default false
-
-	@example
-	```
-	import type {ArrayTail} from 'type-fest';
-
-	type Example1 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: true}>;
-	//=> readonly [number, boolean]
-
-	type Example2 = ArrayTail<[string, number, boolean], {preserveReadonly: true}>;
-	//=> [number, boolean]
-
-	type Example3 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: false}>;
-	//=> [number, boolean]
-
-	type Example4 = ArrayTail<[string, number, boolean], {preserveReadonly: false}>;
-	//=> [number, boolean]
-	```
-	*/
-	preserveReadonly?: boolean;
-};
-
-type DefaultArrayTailOptions = {
-	preserveReadonly: false;
-};
-
-/**
-Extracts the type of an array or tuple minus the first element.
-
-@example
-```
-import type {ArrayTail} from 'type-fest';
-
-declare const curry: <Arguments extends unknown[], Return>(
-	function_: (...arguments_: Arguments) => Return,
-	...arguments_: ArrayTail<Arguments>
-) => (...arguments_: ArrayTail<Arguments>) => Return;
-
-const add = (a: number, b: number) => a + b;
-
-const add3 = curry(add, 3);
-
-add3(4);
-//=> 7
-```
-
-@see {@link ArrayTailOptions}
-
-@category Array
-*/
-export type ArrayTail<TArray extends UnknownArray, Options extends ArrayTailOptions = {}> =
-	ApplyDefaultOptions<ArrayTailOptions, DefaultArrayTailOptions, Options> extends infer ResolvedOptions extends Required<ArrayTailOptions>
-		? TArray extends UnknownArray // For distributing `TArray`
-			? _ArrayTail<TArray> extends infer Result
-				? ResolvedOptions['preserveReadonly'] extends true
-					? IfArrayReadonly<TArray, Readonly<Result>, Result>
-					: Result
-				: never // Should never happen
-			: never // Should never happen
-		: never; // Should never happen
-
-type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?, ...infer Tail]
-	? keyof TArray & `${number}` extends never
-		? []
-		: Tail
-	: [];

package/node_modules/ink/node_modules/type-fest/source/array-values.d.ts

@@ -1,22 +0,0 @@
-/**
-Provides all values for a constant array or tuple.
-
-Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
-
-@example
-```
-import type {ArrayValues, ArrayIndices} from 'type-fest';
-
-const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
-
-type WeekdayName = ArrayValues<typeof weekdays>;
-type Weekday = ArrayIndices<typeof weekdays>;
-
-const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
-```
-
-@see {@link ArrayIndices}
-
-@category Array
-*/
-export type ArrayValues<T extends readonly unknown[]> = T[number];

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

@@ -1,29 +0,0 @@
-/**
-Create a type that represents either the value or an array of the value.
-
-@see Promisable
-
-@example
-```
-import type {Arrayable} from 'type-fest';
-
-function bundle(input: string, output: Arrayable<string>) {
-	const outputList = Array.isArray(output) ? output : [output];
-
-	// …
-
-	for (const output of outputList) {
-		console.log(`write to: ${output}`);
-	}
-}
-
-bundle('src/index.js', 'dist/index.js');
-bundle('src/index.js', ['dist/index.cjs', 'dist/index.mjs']);
-```
-
-@category Array
-*/
-export type Arrayable<T> =
-T
-// TODO: Use `readonly T[]` when this issue is resolved: https://github.com/microsoft/TypeScript/issues/17002
-| T[];

package/node_modules/ink/node_modules/type-fest/source/async-return-type.d.ts

@@ -1,23 +0,0 @@
-type AsyncFunction = (...arguments_: any[]) => PromiseLike<unknown>;
-
-/**
-Unwrap the return type of a function that returns a `Promise`.
-
-There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
-
-@example
-```ts
-import type {AsyncReturnType} from 'type-fest';
-import {asyncFunction} from 'api';
-
-// This type resolves to the unwrapped return type of `asyncFunction`.
-type Value = AsyncReturnType<typeof asyncFunction>;
-
-async function doSomething(value: Value) {}
-
-asyncFunction().then(value => doSomething(value));
-```
-
-@category Async
-*/
-export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;

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

@@ -1,32 +0,0 @@
-import type {SetReturnType} from './set-return-type';
-
-/**
-Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
-
-Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
-
-@example
-```
-import type {Asyncify} from 'type-fest';
-
-// Synchronous function.
-function getFooSync(someArg: SomeType): Foo {
-	// …
-}
-
-type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
-//=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
-
-// Same as `getFooSync` but asynchronous.
-const getFooAsync: AsyncifiedFooGetter = (someArg) => {
-	// TypeScript now knows that `someArg` is `SomeType` automatically.
-	// It also knows that this function must return `Promise<Foo>`.
-	// If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
-
-	// …
-}
-```
-
-@category Async
-*/
-export type Asyncify<Function_ extends (...arguments_: any[]) => any> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;

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

@@ -1,68 +0,0 @@
-/**
-Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
-
-@category Class
-*/
-export type Class<T, Arguments extends unknown[] = any[]> = {
-	prototype: Pick<T, keyof T>;
-	new(...arguments_: Arguments): T;
-};
-
-/**
-Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
-
-@category Class
-*/
-export type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;
-
-/**
-Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
-
-@category Class
-
-@privateRemarks
-We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)
-*/
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
-	prototype: Pick<T, keyof T>;
-}
-
-/**
-Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.
-
-@category Class
-*/
-export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new(...arguments_: Arguments) => T;
-
-/**
-Matches a JSON object.
-
-This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
-
-@category JSON
-*/
-export type JsonObject = {[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined};
-
-/**
-Matches a JSON array.
-
-@category JSON
-*/
-export type JsonArray = JsonValue[] | readonly JsonValue[];
-
-/**
-Matches any valid JSON primitive value.
-
-@category JSON
-*/
-export type JsonPrimitive = string | number | boolean | null;
-
-/**
-Matches any valid JSON value.
-
-@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
-
-@category JSON
-*/
-export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

package/node_modules/ink/node_modules/type-fest/source/camel-case.d.ts

@@ -1,89 +0,0 @@
-import type {ApplyDefaultOptions} from './internal';
-import type {Words} from './words';
-
-/**
-CamelCase options.
-
-@see {@link CamelCase}
-*/
-export type CamelCaseOptions = {
-	/**
-	Whether to preserved consecutive uppercase letter.
-
-	@default true
-	*/
-	preserveConsecutiveUppercase?: boolean;
-};
-
-export type DefaultCamelCaseOptions = {
-	preserveConsecutiveUppercase: true;
-};
-
-/**
-Convert an array of words to camel-case.
-*/
-type CamelCaseFromArray<
-	Words extends string[],
-	Options extends Required<CamelCaseOptions>,
-	OutputString extends string = '',
-> = Words extends [
-	infer FirstWord extends string,
-	...infer RemainingWords extends string[],
-]
-	? Options['preserveConsecutiveUppercase'] extends true
-		? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}`
-		: `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}`
-	: OutputString;
-
-/**
-Convert a string literal to camel-case.
-
-This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
-
-By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
-
-@example
-```
-import type {CamelCase} from 'type-fest';
-
-// Simple
-
-const someVariable: CamelCase<'foo-bar'> = 'fooBar';
-const preserveConsecutiveUppercase: CamelCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'fooBARBaz';
-
-// Advanced
-
-type CamelCasedProperties<T> = {
-	[K in keyof T as CamelCase<K>]: T[K]
-};
-
-interface RawOptions {
-	'dry-run': boolean;
-	'full_family_name': string;
-	foo: number;
-	BAR: string;
-	QUZ_QUX: number;
-	'OTHER-FIELD': boolean;
-}
-
-const dbResult: CamelCasedProperties<RawOptions> = {
-	dryRun: true,
-	fullFamilyName: 'bar.js',
-	foo: 123,
-	bar: 'foo',
-	quzQux: 6,
-	otherField: false
-};
-```
-
-@category Change case
-@category Template literal
-*/
-export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extends string
-	? string extends Type
-		? Type
-		: Uncapitalize<CamelCaseFromArray<
-		Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
-		ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, Options>
-		>>
-	: Type;