@quantiya/codevibe-codex-plugin 2.0.4 → 2.0.6

package/node_modules/@quantiya/codevibe-core/node_modules/string-width/index.js

@@ -0,0 +1,203 @@
+import stripAnsi from 'strip-ansi';
+import {eastAsianWidth} from 'get-east-asian-width';
+
+/**
+Logic:
+- Segment graphemes to match how terminals render clusters.
+- Width rules:
+	1. Skip non-printing clusters (Default_Ignorable, Control, pure Mark, lone Surrogates). Tabs are ignored by design.
+	2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
+	3. Minimally-qualified/unqualified emoji clusters (ZWJ sequences with 2+ Extended_Pictographic, or keycap sequences) are double-width.
+	4. Hangul jamo collapse each standard modern Hangul L+V or L+V+T syllable piece to width 2.
+	   Unmatched repeated leading/vowel/trailing jamo stay additive because that matches how the terminals we target render them.
+	5. Otherwise use East Asian Width of the cluster's first visible code point, and add widths for trailing Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
+*/
+
+const segmenter = new Intl.Segmenter();
+
+// Whole-cluster zero-width
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})+$/v;
+
+// Pick the base scalar if the cluster starts with Prepend/Format/Marks
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+
+// RGI emoji sequences
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+
+// Detect minimally-qualified/unqualified emoji sequences (missing VS16 but still render as double-width)
+const unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+const extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
+
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+	// Real emoji clusters are < 30 chars; guard against pathological input
+	if (segment.length > 50) {
+		return false;
+	}
+
+	if (unqualifiedKeycapRegex.test(segment)) {
+		return true;
+	}
+
+	// ZWJ sequences with 2+ Extended_Pictographic
+	if (segment.includes('\u200D')) {
+		const pictographics = segment.match(extendedPictographicRegex);
+		return pictographics !== null && pictographics.length >= 2;
+	}
+
+	return false;
+}
+
+function baseVisible(segment) {
+	return segment.replace(leadingNonPrintingRegex, '');
+}
+
+function isZeroWidthCluster(segment) {
+	return zeroWidthClusterRegex.test(segment);
+}
+
+function isHangulLeadingJamo(codePoint) {
+	return (codePoint >= 0x11_00 && codePoint <= 0x11_5F)
+		|| (codePoint >= 0xA9_60 && codePoint <= 0xA9_7C);
+}
+
+function isHangulVowelJamo(codePoint) {
+	return (codePoint >= 0x11_60 && codePoint <= 0x11_A7)
+		|| (codePoint >= 0xD7_B0 && codePoint <= 0xD7_C6);
+}
+
+function isHangulTrailingJamo(codePoint) {
+	return (codePoint >= 0x11_A8 && codePoint <= 0x11_FF)
+		|| (codePoint >= 0xD7_CB && codePoint <= 0xD7_FB);
+}
+
+function isHangulJamo(codePoint) {
+	return isHangulLeadingJamo(codePoint)
+		|| isHangulVowelJamo(codePoint)
+		|| isHangulTrailingJamo(codePoint);
+}
+
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+	const codePoints = [];
+
+	for (const character of visibleSegment) {
+		if (zeroWidthClusterRegex.test(character)) {
+			continue;
+		}
+
+		codePoints.push(character.codePointAt(0));
+	}
+
+	if (codePoints.length === 0) {
+		return undefined;
+	}
+
+	let width = 0;
+
+	for (let index = 0; index < codePoints.length; index++) {
+		const codePoint = codePoints[index];
+		if (!isHangulJamo(codePoint)) {
+			if (width === 0) {
+				return undefined;
+			}
+
+			// Mixed cluster (e.g., L + precomposed syllable): use EAW for non-jamo remainder
+			for (let remaining = index; remaining < codePoints.length; remaining++) {
+				width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+			}
+
+			return width;
+		}
+
+		// Modern Hangul L+V(+T) shapes as one syllable block. Unmatched jamo stay additive:
+		// U+1100 U+1100 U+1161 => U+1100 + (U+1100 U+1161) => 2 + 2.
+		if (
+			isHangulLeadingJamo(codePoint)
+			&& isHangulVowelJamo(codePoints[index + 1])
+		) {
+			width += 2;
+			index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+			continue;
+		}
+
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+	}
+
+	return width;
+}
+
+function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+	let extra = 0;
+	let first = true;
+
+	for (const character of visibleSegment) {
+		if (first) {
+			first = false;
+			continue;
+		}
+
+		if (character >= '\uFF00' && character <= '\uFFEF') {
+			extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+		}
+	}
+
+	return extra;
+}
+
+export default function stringWidth(input, options = {}) {
+	if (typeof input !== 'string' || input.length === 0) {
+		return 0;
+	}
+
+	const {
+		ambiguousIsNarrow = true,
+		countAnsiEscapeCodes = false,
+	} = options;
+
+	let string = input;
+
+	// Avoid calling stripAnsi when there are no ANSI escape sequences (ESC = 0x1B, CSI = 0x9B)
+	if (!countAnsiEscapeCodes && (string.includes('\u001B') || string.includes('\u009B'))) {
+		string = stripAnsi(string);
+	}
+
+	if (string.length === 0) {
+		return 0;
+	}
+
+	// Fast path: printable ASCII (0x20–0x7E) needs no segmenter, regex, or EAW lookup — width equals length.
+	if (/^[\u0020-\u007E]*$/.test(string)) {
+		return string.length;
+	}
+
+	let width = 0;
+	const eastAsianWidthOptions = {ambiguousAsWide: !ambiguousIsNarrow};
+
+	for (const {segment} of segmenter.segment(string)) {
+		// Zero-width / non-printing clusters
+		if (isZeroWidthCluster(segment)) {
+			continue;
+		}
+
+		// Emoji width logic
+		if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+			width += 2;
+			continue;
+		}
+
+		const visibleSegment = baseVisible(segment);
+		const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+		if (hangulWidth !== undefined) {
+			width += hangulWidth;
+			continue;
+		}
+
+		// Everything else: EAW of the cluster’s first visible scalar
+		const codePoint = visibleSegment.codePointAt(0);
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+
+		// Add width for trailing Halfwidth and Fullwidth Forms (e.g., ﾞ, ﾟ, ｰ)
+		width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
+	}
+
+	return width;
+}

package/node_modules/@quantiya/codevibe-core/node_modules/string-width/package.json

@@ -0,0 +1,65 @@
+{
+	"name": "string-width",
+	"version": "8.2.1",
+	"description": "Get the visual width of a string - the number of columns required to display it",
+	"license": "MIT",
+	"repository": "sindresorhus/string-width",
+	"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 && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"string",
+		"character",
+		"unicode",
+		"width",
+		"visual",
+		"column",
+		"columns",
+		"fullwidth",
+		"full-width",
+		"wcwidth",
+		"wcswidth",
+		"full",
+		"ansi",
+		"escape",
+		"codes",
+		"cli",
+		"command-line",
+		"terminal",
+		"console",
+		"cjk",
+		"chinese",
+		"japanese",
+		"korean",
+		"fixed-width",
+		"east-asian-width"
+	],
+	"dependencies": {
+		"get-east-asian-width": "^1.5.0",
+		"strip-ansi": "^7.1.2"
+	},
+	"devDependencies": {
+		"ava": "^6.4.1",
+		"tsd": "^0.33.0",
+		"xo": "^1.2.3"
+	}
+}

package/node_modules/@quantiya/codevibe-core/node_modules/string-width/readme.md

@@ -0,0 +1,66 @@
+# string-width
+
+> Get the visual width of a string - the number of columns required to display it
+
+Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and do not affect the width.
+
+Useful to be able to measure the actual width of command-line output.
+
+## Install
+
+```sh
+npm install string-width
+```
+
+## Usage
+
+```js
+import stringWidth from 'string-width';
+
+stringWidth('a');
+//=> 1
+
+stringWidth('古');
+//=> 2
+
+stringWidth('\u001B[1m古\u001B[22m');
+//=> 2
+```
+
+## API
+
+### stringWidth(string, options?)
+
+#### string
+
+Type: `string`
+
+The string to be counted.
+
+#### options
+
+Type: `object`
+
+##### ambiguousIsNarrow
+
+Type: `boolean`\
+Default: `true`
+
+Count [ambiguous width characters](https://www.unicode.org/reports/tr11/#Ambiguous) as having narrow width (count of 1) instead of wide width (count of 2).
+
+> Ambiguous characters behave like wide or narrow characters depending on the context (language tag, script identification, associated font, source of data, or explicit markup; all can provide the context). **If the context cannot be established reliably, they should be treated as narrow characters by default.**
+> - http://www.unicode.org/reports/tr11/
+
+##### countAnsiEscapeCodes
+
+Type: `boolean`\
+Default: `false`
+
+Whether [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) should be counted.
+
+## Related
+
+- [string-width-cli](https://github.com/sindresorhus/string-width-cli) - CLI for this module
+- [string-length](https://github.com/sindresorhus/string-length) - Get the real length of a string
+- [widest-line](https://github.com/sindresorhus/widest-line) - Get the visual width of the widest line in a string
+- [get-east-asian-width](https://github.com/sindresorhus/get-east-asian-width) - Determine the East Asian Width of a Unicode character

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

@@ -0,0 +1,227 @@
+// Basic
+export type * from './source/primitive.d.ts';
+export type * from './source/typed-array.d.ts';
+export type * from './source/basic.d.ts';
+export type * from './source/json-value.d.ts';
+export type * from './source/characters.d.ts';
+
+// Utilities
+export type {KeysOfUnion} from './source/keys-of-union.d.ts';
+export type {DistributedOmit} from './source/distributed-omit.d.ts';
+export type {DistributedPick} from './source/distributed-pick.d.ts';
+export type {EmptyObject, IsEmptyObject} from './source/empty-object.d.ts';
+export type {IfEmptyObject} from './source/if-empty-object.d.ts';
+export type {NonEmptyObject} from './source/non-empty-object.d.ts';
+export type {NonEmptyString} from './source/non-empty-string.d.ts';
+export type {UnknownRecord} from './source/unknown-record.d.ts';
+export type {UnknownArray} from './source/unknown-array.d.ts';
+export type {UnknownSet} from './source/unknown-set.d.ts';
+export type {UnknownMap} from './source/unknown-map.d.ts';
+export type {Except, ExceptOptions} from './source/except.d.ts';
+export type {TaggedUnion} from './source/tagged-union.d.ts';
+export type {Writable} from './source/writable.d.ts';
+export type {WritableDeep} from './source/writable-deep.d.ts';
+export type {Merge} from './source/merge.d.ts';
+export type {ObjectMerge} from './source/object-merge.d.ts';
+export type {MergeDeep, MergeDeepOptions} from './source/merge-deep.d.ts';
+export type {MergeExclusive} from './source/merge-exclusive.d.ts';
+export type {RequireAtLeastOne} from './source/require-at-least-one.d.ts';
+export type {RequireExactlyOne} from './source/require-exactly-one.d.ts';
+export type {RequireAllOrNone} from './source/require-all-or-none.d.ts';
+export type {RequireOneOrNone} from './source/require-one-or-none.d.ts';
+export type {SingleKeyObject} from './source/single-key-object.d.ts';
+export type {OmitIndexSignature} from './source/omit-index-signature.d.ts';
+export type {PickIndexSignature} from './source/pick-index-signature.d.ts';
+export type {PartialDeep, PartialDeepOptions} from './source/partial-deep.d.ts';
+export type {UnwrapPartial} from './source/unwrap-partial.d.ts';
+export type {UnwrapRequired} from './source/unwrap-required.d.ts';
+export type {RequiredDeep} from './source/required-deep.d.ts';
+export type {PickDeep} from './source/pick-deep.d.ts';
+export type {OmitDeep} from './source/omit-deep.d.ts';
+export type {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep.d.ts';
+export type {UndefinedOnPartialDeep} from './source/undefined-on-partial-deep.d.ts';
+export type {ReadonlyDeep} from './source/readonly-deep.d.ts';
+export type {LiteralUnion} from './source/literal-union.d.ts';
+export type {Promisable} from './source/promisable.d.ts';
+export type {Arrayable} from './source/arrayable.d.ts';
+export type {Optional} from './source/optional.d.ts';
+export type {Opaque, UnwrapOpaque, Tagged, GetTagMetadata, UnwrapTagged} from './source/tagged.d.ts';
+export type {InvariantOf} from './source/invariant-of.d.ts';
+export type {SetOptional} from './source/set-optional.d.ts';
+export type {SetReadonly} from './source/set-readonly.d.ts';
+export type {SetRequired} from './source/set-required.d.ts';
+export type {SetRequiredDeep} from './source/set-required-deep.d.ts';
+export type {SetNonNullable} from './source/set-non-nullable.d.ts';
+export type {SetNonNullableDeep} from './source/set-non-nullable-deep.d.ts';
+export type {NonNullableDeep} from './source/non-nullable-deep.d.ts';
+export type {ValueOf} from './source/value-of.d.ts';
+export type {AsyncReturnType} from './source/async-return-type.d.ts';
+export type {ConditionalExcept} from './source/conditional-except.d.ts';
+export type {ConditionalKeys} from './source/conditional-keys.d.ts';
+export type {ConditionalPick} from './source/conditional-pick.d.ts';
+export type {ConditionalPickDeep, ConditionalPickDeepOptions} from './source/conditional-pick-deep.d.ts';
+export type {UnionToIntersection} from './source/union-to-intersection.d.ts';
+export type {Stringified} from './source/stringified.d.ts';
+export type {StringSlice} from './source/string-slice.d.ts';
+export type {FixedLengthArray} from './source/fixed-length-array.d.ts';
+export type {MultidimensionalArray} from './source/multidimensional-array.d.ts';
+export type {MultidimensionalReadonlyArray} from './source/multidimensional-readonly-array.d.ts';
+export type {IterableElement} from './source/iterable-element.d.ts';
+export type {Entry} from './source/entry.d.ts';
+export type {Entries} from './source/entries.d.ts';
+export type {SetReturnType} from './source/set-return-type.d.ts';
+export type {SetParameterType} from './source/set-parameter-type.d.ts';
+export type {Asyncify} from './source/asyncify.d.ts';
+export type {Simplify} from './source/simplify.d.ts';
+export type {SimplifyDeep} from './source/simplify-deep.d.ts';
+export type {Jsonify} from './source/jsonify.d.ts';
+export type {Jsonifiable} from './source/jsonifiable.d.ts';
+export type {StructuredCloneable} from './source/structured-cloneable.d.ts';
+export type {Schema, SchemaOptions} from './source/schema.d.ts';
+export type {LiteralToPrimitive} from './source/literal-to-primitive.d.ts';
+export type {LiteralToPrimitiveDeep} from './source/literal-to-primitive-deep.d.ts';
+export type {
+	PositiveInfinity,
+	NegativeInfinity,
+	Finite,
+	Integer,
+	Float,
+	NegativeFloat,
+	Negative,
+	NonNegative,
+	NegativeInteger,
+	NonNegativeInteger,
+	IsNegative,
+} from './source/numeric.d.ts';
+export type {GreaterThan} from './source/greater-than.d.ts';
+export type {GreaterThanOrEqual} from './source/greater-than-or-equal.d.ts';
+export type {LessThan} from './source/less-than.d.ts';
+export type {LessThanOrEqual} from './source/less-than-or-equal.d.ts';
+export type {Sum} from './source/sum.d.ts';
+export type {Subtract} from './source/subtract.d.ts';
+export type {KeyAsString} from './source/key-as-string.d.ts';
+export type {Exact} from './source/exact.d.ts';
+export type {ReadonlyTuple} from './source/readonly-tuple.d.ts';
+export type {OverrideProperties} from './source/override-properties.d.ts';
+export type {OptionalKeysOf} from './source/optional-keys-of.d.ts';
+export type {IsOptionalKeyOf} from './source/is-optional-key-of.d.ts';
+export type {HasOptionalKeys} from './source/has-optional-keys.d.ts';
+export type {RequiredKeysOf} from './source/required-keys-of.d.ts';
+export type {IsRequiredKeyOf} from './source/is-required-key-of.d.ts';
+export type {HasRequiredKeys} from './source/has-required-keys.d.ts';
+export type {ReadonlyKeysOf} from './source/readonly-keys-of.d.ts';
+export type {IsReadonlyKeyOf} from './source/is-readonly-key-of.d.ts';
+export type {HasReadonlyKeys} from './source/has-readonly-keys.d.ts';
+export type {WritableKeysOf} from './source/writable-keys-of.d.ts';
+export type {IsWritableKeyOf} from './source/is-writable-key-of.d.ts';
+export type {HasWritableKeys} from './source/has-writable-keys.d.ts';
+export type {Spread} from './source/spread.d.ts';
+export type {SplitOnRestElement} from './source/split-on-rest-element.d.ts';
+export type {ExtractRestElement} from './source/extract-rest-element.d.ts';
+export type {ExcludeRestElement} from './source/exclude-rest-element.d.ts';
+export type {IsInteger} from './source/is-integer.d.ts';
+export type {IsFloat} from './source/is-float.d.ts';
+export type {TupleToObject} from './source/tuple-to-object.d.ts';
+export type {TupleToUnion} from './source/tuple-to-union.d.ts';
+export type {UnionToTuple} from './source/union-to-tuple.d.ts';
+export type {IntRange} from './source/int-range.d.ts';
+export type {IntClosedRange} from './source/int-closed-range.d.ts';
+export type {IsEqual} from './source/is-equal.d.ts';
+export type {
+	IsLiteral,
+	IsStringLiteral,
+	IsNumericLiteral,
+	IsBooleanLiteral,
+	IsSymbolLiteral,
+} from './source/is-literal.d.ts';
+export type {IsAny} from './source/is-any.d.ts';
+export type {IfAny} from './source/if-any.d.ts';
+export type {IsNever} from './source/is-never.d.ts';
+export type {IfNever} from './source/if-never.d.ts';
+export type {IsUnknown} from './source/is-unknown.d.ts';
+export type {IfUnknown} from './source/if-unknown.d.ts';
+export type {IsTuple, IsTupleOptions} from './source/is-tuple.d.ts';
+export type {ArrayIndices} from './source/array-indices.d.ts';
+export type {ArrayValues} from './source/array-values.d.ts';
+export type {ArraySlice} from './source/array-slice.d.ts';
+export type {ArraySplice} from './source/array-splice.d.ts';
+export type {ArrayTail} from './source/array-tail.d.ts';
+export type {ArrayElement} from './source/array-element.d.ts';
+export type {ArrayLength} from './source/array-length.d.ts';
+export type {SetFieldType, SetFieldTypeOptions} from './source/set-field-type.d.ts';
+export type {Paths, PathsOptions} from './source/paths.d.ts';
+export type {AllUnionFields} from './source/all-union-fields.d.ts';
+export type {SharedUnionFields} from './source/shared-union-fields.d.ts';
+export type {SharedUnionFieldsDeep, SharedUnionFieldsDeepOptions} from './source/shared-union-fields-deep.d.ts';
+export type {IsNull} from './source/is-null.d.ts';
+export type {IfNull} from './source/if-null.d.ts';
+export type {IsUndefined} from './source/is-undefined.d.ts';
+export type {And} from './source/and.d.ts';
+export type {AndAll} from './source/and-all.d.ts';
+export type {Or} from './source/or.d.ts';
+export type {OrAll} from './source/or-all.d.ts';
+export type {Xor} from './source/xor.d.ts';
+export type {AllExtend, AllExtendOptions} from './source/all-extend.d.ts';
+export type {SomeExtend, SomeExtendOptions} from './source/some-extend.d.ts';
+export type {NonEmptyTuple} from './source/non-empty-tuple.d.ts';
+export type {FindGlobalInstanceType, FindGlobalType} from './source/find-global-type.d.ts';
+export type {If} from './source/if.d.ts';
+export type {IsUnion} from './source/is-union.d.ts';
+export type {IsLowercase} from './source/is-lowercase.d.ts';
+export type {IsUppercase} from './source/is-uppercase.d.ts';
+export type {IsOptional} from './source/is-optional.d.ts';
+export type {IsNullable} from './source/is-nullable.d.ts';
+export type {TupleOf} from './source/tuple-of.d.ts';
+export type {ExclusifyUnion} from './source/exclusify-union.d.ts';
+export type {ArrayReverse} from './source/array-reverse.d.ts';
+export type {UnionMember} from './source/union-member.d.ts';
+export type {Absolute} from './source/absolute.d.ts';
+export type {UnionLength} from './source/union-length.d.ts';
+export type {StringToNumber} from './source/string-to-number.d.ts';
+
+// Template literal types
+export type {CamelCase, CamelCaseOptions} from './source/camel-case.d.ts';
+export type {CamelCasedProperties} from './source/camel-cased-properties.d.ts';
+export type {CamelCasedPropertiesDeep} from './source/camel-cased-properties-deep.d.ts';
+export type {KebabCase} from './source/kebab-case.d.ts';
+export type {KebabCasedProperties} from './source/kebab-cased-properties.d.ts';
+export type {KebabCasedPropertiesDeep} from './source/kebab-cased-properties-deep.d.ts';
+export type {PascalCase} from './source/pascal-case.d.ts';
+export type {PascalCasedProperties} from './source/pascal-cased-properties.d.ts';
+export type {PascalCasedPropertiesDeep} from './source/pascal-cased-properties-deep.d.ts';
+export type {SnakeCase} from './source/snake-case.d.ts';
+export type {SnakeCasedProperties} from './source/snake-cased-properties.d.ts';
+export type {SnakeCasedPropertiesDeep} from './source/snake-cased-properties-deep.d.ts';
+export type {ScreamingSnakeCase} from './source/screaming-snake-case.d.ts';
+export type {DelimiterCase} from './source/delimiter-case.d.ts';
+export type {DelimiterCasedProperties} from './source/delimiter-cased-properties.d.ts';
+export type {DelimiterCasedPropertiesDeep} from './source/delimiter-cased-properties-deep.d.ts';
+export type {Join} from './source/join.d.ts';
+export type {Split, SplitOptions} from './source/split.d.ts';
+export type {Words, WordsOptions} from './source/words.d.ts';
+export type {Trim} from './source/trim.d.ts';
+export type {Replace, ReplaceOptions} from './source/replace.d.ts';
+export type {StringRepeat} from './source/string-repeat.d.ts';
+export type {Includes} from './source/includes.d.ts';
+export type {Get, GetOptions} from './source/get.d.ts';
+export type {LastArrayElement} from './source/last-array-element.d.ts';
+export type {ConditionalSimplify} from './source/conditional-simplify.d.ts';
+export type {ConditionalSimplifyDeep} from './source/conditional-simplify-deep.d.ts';
+export type {RemovePrefix, RemovePrefixOptions} from './source/remove-prefix.d.ts';
+export type {RemoveSuffix, RemoveSuffixOptions} from './source/remove-suffix.d.ts';
+export type {StringToArray, StringToArrayOptions} from './source/string-to-array.d.ts';
+export type {StringLength} from './source/string-length.d.ts';
+
+// Miscellaneous
+export type {GlobalThis} from './source/global-this.d.ts';
+export type {PackageJson} from './source/package-json.d.ts';
+export type {TsConfigJson} from './source/tsconfig-json.d.ts';
+
+// Improved built-in
+export type {ExtendsStrict, ExtendsStrictOptions} from './source/extends-strict.d.ts';
+export type {ExtractStrict} from './source/extract-strict.d.ts';
+export type {ExcludeStrict} from './source/exclude-strict.d.ts';
+export type {ExcludeExactly} from './source/exclude-exactly.d.ts';
+export type {ExtractExactly} from './source/extract-exactly.d.ts';
+
+export {};

package/node_modules/@quantiya/codevibe-core/node_modules/type-fest/package.json

@@ -0,0 +1,75 @@
+{
+	"name": "type-fest",
+	"version": "5.8.0",
+	"description": "A collection of essential TypeScript types",
+	"license": "(MIT OR CC0-1.0)",
+	"repository": "sindresorhus/type-fest",
+	"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"
+		},
+		"./globals": {
+			"types": "./source/globals/index.d.ts"
+		}
+	},
+	"types": "./index.d.ts",
+	"sideEffects": false,
+	"engines": {
+		"node": ">=20"
+	},
+	"scripts": {
+		"test:tsc": "node --max-old-space-size=6144 ./node_modules/.bin/tsc",
+		"test:tsd": "node --max-old-space-size=6144 ./node_modules/.bin/tsd",
+		"test:xo": "node --max-old-space-size=6144 ./node_modules/.bin/xo --ignores=lint-processors/fixtures/**/*.d.ts '**/*.{js,ts,md}'",
+		"test:linter": "node --test",
+		"test": "run-p test:*"
+	},
+	"files": [
+		"index.d.ts",
+		"source",
+		"license-mit",
+		"license-cc0"
+	],
+	"keywords": [
+		"typescript",
+		"ts",
+		"types",
+		"utility",
+		"util",
+		"utilities",
+		"omit",
+		"merge",
+		"json",
+		"generics"
+	],
+	"dependencies": {
+		"tagged-tag": "^1.0.0"
+	},
+	"devDependencies": {
+		"@eslint/markdown": "^8.0.1",
+		"@sindresorhus/tsconfig": "^8.0.1",
+		"@types/node": "^25.5.0",
+		"@typescript-eslint/parser": "^8.44.0",
+		"@typescript/vfs": "^1.6.1",
+		"dedent": "^1.7.0",
+		"eslint": "^10.1.0",
+		"expect-type": "^1.2.2",
+		"npm-run-all2": "^8.0.4",
+		"tsd": "^0.33.0",
+		"typescript": "^5.9.2",
+		"typescript-eslint": "^8.47.0",
+		"xo": "^2.0.2"
+	},
+	"tsd": {
+		"compilerOptions": {
+			"noUnusedLocals": false
+		}
+	}
+}