@quantiya/codevibe-claude-plugin 2.0.26 → 2.0.27

package/node_modules/es-toolkit/dist/object/merge.mjs

@@ -2,46 +2,6 @@ import { isPlainObject } from "../predicate/isPlainObject.mjs";
 import { isMergeableValue } from "../_internal/isMergeableValue.mjs";
 import { isUnsafeProperty } from "../_internal/isUnsafeProperty.mjs";
 //#region src/object/merge.ts
-/**
-* Merges the properties of the source object into the target object.
-*
-* This function performs a deep merge, meaning nested objects and arrays are merged recursively.
-* If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged.
-* If a property in the source object is undefined, it will not overwrite a defined property in the target object.
-*
-* Note that this function mutates the target object.
-*
-* @param target - The target object into which the source object properties will be merged. This object is modified in place.
-* @param source - The source object whose properties will be merged into the target object.
-* @returns The updated target object with properties from the source object merged in.
-*
-* @template T - Type of the target object.
-* @template S - Type of the source object.
-*
-* @example
-* const target = { a: 1, b: { x: 1, y: 2 } };
-* const source = { b: { y: 3, z: 4 }, c: 5 };
-*
-* const result = merge(target, source);
-* console.log(result);
-* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
-*
-* @example
-* const target = { a: [1, 2], b: { x: 1 } };
-* const source = { a: [3], b: { y: 2 } };
-*
-* const result = merge(target, source);
-* console.log(result);
-* // Output: { a: [3, 2], b: { x: 1, y: 2 } }
-*
-* @example
-* const target = { a: null };
-* const source = { a: [1, 2, 3] };
-*
-* const result = merge(target, source);
-* console.log(result);
-* // Output: { a: [1, 2, 3] }
-*/
 function merge(target, source) {
 	const sourceKeys = Object.keys(source);
 	for (let i = 0; i < sourceKeys.length; i++) {

package/node_modules/es-toolkit/dist/object/omitBy.d.mts

@@ -1,3 +1,5 @@
+import { ObjectKeys } from "../types/ObjectKeys.mjs";
+
 //#region src/object/omitBy.d.ts
 /**
  * Creates a new object composed of the properties that do not satisfy the predicate function.
@@ -9,7 +11,7 @@
  * @param obj - The object to omit properties from.
  * @param shouldOmit - A predicate function that determines
  * whether a property should be omitted. It takes the property's key and value as arguments and returns `true`
- * if the property should be omitted, and `false` otherwise.
+ * if the property should be omitted, and `false` otherwise. Numeric keys are passed as strings.
  * @returns A new object with the properties that do not satisfy the predicate function.
  *
  * @example
@@ -18,6 +20,6 @@
  * const result = omitBy(obj, shouldOmit);
  * // result will be { a: 1, c: 3 }
  */
-declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: ObjectKeys<T>) => boolean): Partial<T>;
 //#endregion
 export { omitBy };

package/node_modules/es-toolkit/dist/object/omitBy.d.ts

@@ -1,3 +1,5 @@
+import { ObjectKeys } from "../types/ObjectKeys.js";
+
 //#region src/object/omitBy.d.ts
 /**
  * Creates a new object composed of the properties that do not satisfy the predicate function.
@@ -9,7 +11,7 @@
  * @param obj - The object to omit properties from.
  * @param shouldOmit - A predicate function that determines
  * whether a property should be omitted. It takes the property's key and value as arguments and returns `true`
- * if the property should be omitted, and `false` otherwise.
+ * if the property should be omitted, and `false` otherwise. Numeric keys are passed as strings.
  * @returns A new object with the properties that do not satisfy the predicate function.
  *
  * @example
@@ -18,6 +20,6 @@
  * const result = omitBy(obj, shouldOmit);
  * // result will be { a: 1, c: 3 }
  */
-declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: ObjectKeys<T>) => boolean): Partial<T>;
 //#endregion
 export { omitBy };

package/node_modules/es-toolkit/dist/object/omitBy.js

@@ -9,7 +9,7 @@
 * @param obj - The object to omit properties from.
 * @param shouldOmit - A predicate function that determines
 * whether a property should be omitted. It takes the property's key and value as arguments and returns `true`
-* if the property should be omitted, and `false` otherwise.
+* if the property should be omitted, and `false` otherwise. Numeric keys are passed as strings.
 * @returns A new object with the properties that do not satisfy the predicate function.
 *
 * @example
@@ -23,8 +23,9 @@ function omitBy(obj, shouldOmit) {
 	const keys = Object.keys(obj);
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
-		const value = obj[key];
-		if (!shouldOmit(value, key)) result[key] = value;
+		const objectKey = key;
+		const value = obj[objectKey];
+		if (!shouldOmit(value, key)) result[objectKey] = value;
 	}
 	return result;
 }

package/node_modules/es-toolkit/dist/object/omitBy.mjs

@@ -9,7 +9,7 @@
 * @param obj - The object to omit properties from.
 * @param shouldOmit - A predicate function that determines
 * whether a property should be omitted. It takes the property's key and value as arguments and returns `true`
-* if the property should be omitted, and `false` otherwise.
+* if the property should be omitted, and `false` otherwise. Numeric keys are passed as strings.
 * @returns A new object with the properties that do not satisfy the predicate function.
 *
 * @example
@@ -23,8 +23,9 @@ function omitBy(obj, shouldOmit) {
 	const keys = Object.keys(obj);
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
-		const value = obj[key];
-		if (!shouldOmit(value, key)) result[key] = value;
+		const objectKey = key;
+		const value = obj[objectKey];
+		if (!shouldOmit(value, key)) result[objectKey] = value;
 	}
 	return result;
 }

package/node_modules/es-toolkit/dist/object/pickBy.d.mts

@@ -1,3 +1,5 @@
+import { ObjectKeys } from "../types/ObjectKeys.mjs";
+
 //#region src/object/pickBy.d.ts
 /**
  * Creates a new object composed of the properties that satisfy the predicate function.
@@ -9,7 +11,7 @@
  * @param obj - The object to pick properties from.
  * @param shouldPick - A predicate function that determines
  * whether a property should be picked. It takes the property's key and value as arguments and returns `true`
- * if the property should be picked, and `false` otherwise.
+ * if the property should be picked, and `false` otherwise. Numeric keys are passed as strings.
  * @returns A new object with the properties that satisfy the predicate function.
  *
  * @example
@@ -18,6 +20,6 @@
  * const result = pickBy(obj, shouldPick);
  * // result will be { b: 'pick' }
  */
-declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: ObjectKeys<T>) => boolean): Partial<T>;
 //#endregion
 export { pickBy };

package/node_modules/es-toolkit/dist/object/pickBy.d.ts

@@ -1,3 +1,5 @@
+import { ObjectKeys } from "../types/ObjectKeys.js";
+
 //#region src/object/pickBy.d.ts
 /**
  * Creates a new object composed of the properties that satisfy the predicate function.
@@ -9,7 +11,7 @@
  * @param obj - The object to pick properties from.
  * @param shouldPick - A predicate function that determines
  * whether a property should be picked. It takes the property's key and value as arguments and returns `true`
- * if the property should be picked, and `false` otherwise.
+ * if the property should be picked, and `false` otherwise. Numeric keys are passed as strings.
  * @returns A new object with the properties that satisfy the predicate function.
  *
  * @example
@@ -18,6 +20,6 @@
  * const result = pickBy(obj, shouldPick);
  * // result will be { b: 'pick' }
  */
-declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: ObjectKeys<T>) => boolean): Partial<T>;
 //#endregion
 export { pickBy };

package/node_modules/es-toolkit/dist/object/pickBy.js

@@ -9,7 +9,7 @@
 * @param obj - The object to pick properties from.
 * @param shouldPick - A predicate function that determines
 * whether a property should be picked. It takes the property's key and value as arguments and returns `true`
-* if the property should be picked, and `false` otherwise.
+* if the property should be picked, and `false` otherwise. Numeric keys are passed as strings.
 * @returns A new object with the properties that satisfy the predicate function.
 *
 * @example
@@ -23,8 +23,9 @@ function pickBy(obj, shouldPick) {
 	const keys = Object.keys(obj);
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
-		const value = obj[key];
-		if (shouldPick(value, key)) result[key] = value;
+		const objectKey = key;
+		const value = obj[objectKey];
+		if (shouldPick(value, key)) result[objectKey] = value;
 	}
 	return result;
 }

package/node_modules/es-toolkit/dist/object/pickBy.mjs

@@ -9,7 +9,7 @@
 * @param obj - The object to pick properties from.
 * @param shouldPick - A predicate function that determines
 * whether a property should be picked. It takes the property's key and value as arguments and returns `true`
-* if the property should be picked, and `false` otherwise.
+* if the property should be picked, and `false` otherwise. Numeric keys are passed as strings.
 * @returns A new object with the properties that satisfy the predicate function.
 *
 * @example
@@ -23,8 +23,9 @@ function pickBy(obj, shouldPick) {
 	const keys = Object.keys(obj);
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
-		const value = obj[key];
-		if (shouldPick(value, key)) result[key] = value;
+		const objectKey = key;
+		const value = obj[objectKey];
+		if (shouldPick(value, key)) result[objectKey] = value;
 	}
 	return result;
 }

package/node_modules/es-toolkit/dist/types/EmptyObject.d.mts

@@ -0,0 +1,21 @@
+//#region src/types/EmptyObject.d.ts
+/**
+ * An object with no properties.
+ *
+ * Pairs with the `isEmptyObject` guard. Assigning an object that has any property
+ * fails, because every value would have to be `never`.
+ *
+ * @example
+ * const a: EmptyObject = {}; // ok
+ * const b: EmptyObject = { a: 1 }; // error
+ *
+ * @example
+ * // Useful for a step that carries no data.
+ * interface StepContext {
+ *   intro: EmptyObject;
+ *   form: { amount: number };
+ * }
+ */
+type EmptyObject = Record<PropertyKey, never>;
+//#endregion
+export { EmptyObject };

package/node_modules/es-toolkit/dist/types/EmptyObject.d.ts

@@ -0,0 +1,21 @@
+//#region src/types/EmptyObject.d.ts
+/**
+ * An object with no properties.
+ *
+ * Pairs with the `isEmptyObject` guard. Assigning an object that has any property
+ * fails, because every value would have to be `never`.
+ *
+ * @example
+ * const a: EmptyObject = {}; // ok
+ * const b: EmptyObject = { a: 1 }; // error
+ *
+ * @example
+ * // Useful for a step that carries no data.
+ * interface StepContext {
+ *   intro: EmptyObject;
+ *   form: { amount: number };
+ * }
+ */
+type EmptyObject = Record<PropertyKey, never>;
+//#endregion
+export { EmptyObject };

package/node_modules/es-toolkit/dist/types/IsEqual.d.mts

@@ -0,0 +1,18 @@
+//#region src/types/IsEqual.d.ts
+/**
+ * Resolves to `true` when `A` and `B` are exactly the same type, `false` otherwise.
+ *
+ * Unlike a plain conditional type, this tells `any` apart from every other type,
+ * which makes it useful for catching an accidental `any` in type-level tests.
+ *
+ * @template A - The first type to compare.
+ * @template B - The second type to compare.
+ *
+ * @example
+ * type A = IsEqual<{ a: string }, { a: string }>; // true
+ * type B = IsEqual<string, 'literal'>;            // false
+ * type C = IsEqual<unknown, any>;                 // false
+ */
+type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
+//#endregion
+export { IsEqual };

package/node_modules/es-toolkit/dist/types/IsEqual.d.ts

@@ -0,0 +1,18 @@
+//#region src/types/IsEqual.d.ts
+/**
+ * Resolves to `true` when `A` and `B` are exactly the same type, `false` otherwise.
+ *
+ * Unlike a plain conditional type, this tells `any` apart from every other type,
+ * which makes it useful for catching an accidental `any` in type-level tests.
+ *
+ * @template A - The first type to compare.
+ * @template B - The second type to compare.
+ *
+ * @example
+ * type A = IsEqual<{ a: string }, { a: string }>; // true
+ * type B = IsEqual<string, 'literal'>;            // false
+ * type C = IsEqual<unknown, any>;                 // false
+ */
+type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
+//#endregion
+export { IsEqual };

package/node_modules/es-toolkit/dist/types/JSONValue.d.mts

@@ -0,0 +1,24 @@
+//#region src/types/JSONValue.d.ts
+/**
+ * Any value that `JSON.parse` can produce.
+ *
+ * Functions, `Date`, `undefined`, and class instances are excluded, because they
+ * do not survive a JSON round trip.
+ *
+ * @example
+ * declare function parse(text: string): JSONValue;
+ *
+ * const value = parse('{"a":[1,null]}');
+ * if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+ *   const a = value.a; // JSONValue
+ * }
+ *
+ * @example
+ * // Use `Record` when you want to accept a JSON object specifically.
+ * declare function send(body: Record<string, JSONValue>): void;
+ */
+type JSONValue = string | number | boolean | null | JSONValue[] | {
+  [key: string]: JSONValue;
+};
+//#endregion
+export { JSONValue };

package/node_modules/es-toolkit/dist/types/JSONValue.d.ts

@@ -0,0 +1,24 @@
+//#region src/types/JSONValue.d.ts
+/**
+ * Any value that `JSON.parse` can produce.
+ *
+ * Functions, `Date`, `undefined`, and class instances are excluded, because they
+ * do not survive a JSON round trip.
+ *
+ * @example
+ * declare function parse(text: string): JSONValue;
+ *
+ * const value = parse('{"a":[1,null]}');
+ * if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+ *   const a = value.a; // JSONValue
+ * }
+ *
+ * @example
+ * // Use `Record` when you want to accept a JSON object specifically.
+ * declare function send(body: Record<string, JSONValue>): void;
+ */
+type JSONValue = string | number | boolean | null | JSONValue[] | {
+  [key: string]: JSONValue;
+};
+//#endregion
+export { JSONValue };

package/node_modules/es-toolkit/dist/types/Merge.d.mts

@@ -0,0 +1,37 @@
+import { Simplify } from "./Simplify.mjs";
+
+//#region src/types/Merge.d.ts
+/**
+ * The result of deeply merging the source type `S` into the target type `T`,
+ * matching what `merge(target, source)` returns at runtime.
+ *
+ * Keys present on only one side are kept as-is. When both sides have a plain
+ * object at the same key, the merge recurses; tuples merge index by index, and
+ * other arrays merge into an array of both element types. If the source value
+ * can be `undefined`, the target type is kept because `merge` skips
+ * `undefined` source values. Values that are not plain objects or arrays
+ * (functions, `Date`, `RegExp`, `Map`, `Set`, etc.) are not merged into;
+ * the source value replaces the target value. When an array meets a plain
+ * object, `merge` keeps the target and assigns the source's properties onto
+ * it, so both property sets are kept (`T & S`).
+ *
+ * @template T - Type of the target object.
+ * @template S - Type of the source object.
+ *
+ * @example
+ * type Target = { a: number; b: { x: number; y: number } };
+ * type Source = { b: { y: string; z: boolean }; c: string };
+ * type Result = Merge<Target, Source>;
+ * // => { a: number; b: { x: number; y: string; z: boolean }; c: string }
+ */
+type Merge<T, S> = undefined extends S ? T | MergeDefined<T, Exclude<S, undefined>> : MergeDefined<T, S>;
+/**
+ * Values `merge` does not merge into: everything that is not a plain object
+ * or an array. The source value replaces the target value instead.
+ */
+type NonMergeable = ((...args: any[]) => unknown) | Date | RegExp | Error | Promise<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | WeakMap<object, unknown> | WeakSet<object>;
+type MergeDefined<T, S> = S extends readonly unknown[] ? (T extends readonly unknown[] ? MergeArrays<T, S> : T extends NonMergeable ? S : T extends object ? T & S : S) : S extends NonMergeable ? S : S extends object ? (T extends readonly unknown[] ? T & S : T extends NonMergeable ? S : T extends object ? MergeRecords<T, S> : S) : S;
+type MergeArrays<T extends readonly unknown[], S extends readonly unknown[]> = T extends readonly [] ? S : S extends readonly [] ? T : T extends readonly [infer TH, ...infer TR] ? S extends readonly [infer SH, ...infer SR] ? [Merge<TH, SH>, ...MergeArrays<TR, SR>] : Array<T[number] | S[number]> : Array<T[number] | S[number]>;
+type MergeRecords<T extends object, S extends object> = Simplify<Omit<T, keyof S> & Omit<S, keyof T> & { [K in keyof T & keyof S]: Merge<T[K], S[K]> }>;
+//#endregion
+export { Merge };

package/node_modules/es-toolkit/dist/types/Merge.d.ts

@@ -0,0 +1,37 @@
+import { Simplify } from "./Simplify.js";
+
+//#region src/types/Merge.d.ts
+/**
+ * The result of deeply merging the source type `S` into the target type `T`,
+ * matching what `merge(target, source)` returns at runtime.
+ *
+ * Keys present on only one side are kept as-is. When both sides have a plain
+ * object at the same key, the merge recurses; tuples merge index by index, and
+ * other arrays merge into an array of both element types. If the source value
+ * can be `undefined`, the target type is kept because `merge` skips
+ * `undefined` source values. Values that are not plain objects or arrays
+ * (functions, `Date`, `RegExp`, `Map`, `Set`, etc.) are not merged into;
+ * the source value replaces the target value. When an array meets a plain
+ * object, `merge` keeps the target and assigns the source's properties onto
+ * it, so both property sets are kept (`T & S`).
+ *
+ * @template T - Type of the target object.
+ * @template S - Type of the source object.
+ *
+ * @example
+ * type Target = { a: number; b: { x: number; y: number } };
+ * type Source = { b: { y: string; z: boolean }; c: string };
+ * type Result = Merge<Target, Source>;
+ * // => { a: number; b: { x: number; y: string; z: boolean }; c: string }
+ */
+type Merge<T, S> = undefined extends S ? T | MergeDefined<T, Exclude<S, undefined>> : MergeDefined<T, S>;
+/**
+ * Values `merge` does not merge into: everything that is not a plain object
+ * or an array. The source value replaces the target value instead.
+ */
+type NonMergeable = ((...args: any[]) => unknown) | Date | RegExp | Error | Promise<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | WeakMap<object, unknown> | WeakSet<object>;
+type MergeDefined<T, S> = S extends readonly unknown[] ? (T extends readonly unknown[] ? MergeArrays<T, S> : T extends NonMergeable ? S : T extends object ? T & S : S) : S extends NonMergeable ? S : S extends object ? (T extends readonly unknown[] ? T & S : T extends NonMergeable ? S : T extends object ? MergeRecords<T, S> : S) : S;
+type MergeArrays<T extends readonly unknown[], S extends readonly unknown[]> = T extends readonly [] ? S : S extends readonly [] ? T : T extends readonly [infer TH, ...infer TR] ? S extends readonly [infer SH, ...infer SR] ? [Merge<TH, SH>, ...MergeArrays<TR, SR>] : Array<T[number] | S[number]> : Array<T[number] | S[number]>;
+type MergeRecords<T extends object, S extends object> = Simplify<Omit<T, keyof S> & Omit<S, keyof T> & { [K in keyof T & keyof S]: Merge<T[K], S[K]> }>;
+//#endregion
+export { Merge };

package/node_modules/es-toolkit/dist/types/ObjectKeys.d.mts

@@ -0,0 +1,19 @@
+//#region src/types/ObjectKeys.d.ts
+/**
+ * Creates a union of the keys of `T` as they are returned by `Object.keys`:
+ * numeric keys are converted to strings and symbol keys are excluded. The key-side
+ * counterpart to `ValueOf`.
+ *
+ * @template T - The object type to read keys from.
+ *
+ * @example
+ * type Keys = ObjectKeys<{ a: number; 1: string }>;
+ * // => 'a' | '1'
+ *
+ * const obj = { a: 1, b: 2 };
+ * const keys = Object.keys(obj) as Array<ObjectKeys<typeof obj>>;
+ * // => Array<'a' | 'b'>
+ */
+type ObjectKeys<T> = `${Exclude<keyof T, symbol>}`;
+//#endregion
+export { ObjectKeys };

package/node_modules/es-toolkit/dist/types/ObjectKeys.d.ts

@@ -0,0 +1,19 @@
+//#region src/types/ObjectKeys.d.ts
+/**
+ * Creates a union of the keys of `T` as they are returned by `Object.keys`:
+ * numeric keys are converted to strings and symbol keys are excluded. The key-side
+ * counterpart to `ValueOf`.
+ *
+ * @template T - The object type to read keys from.
+ *
+ * @example
+ * type Keys = ObjectKeys<{ a: number; 1: string }>;
+ * // => 'a' | '1'
+ *
+ * const obj = { a: 1, b: 2 };
+ * const keys = Object.keys(obj) as Array<ObjectKeys<typeof obj>>;
+ * // => Array<'a' | 'b'>
+ */
+type ObjectKeys<T> = `${Exclude<keyof T, symbol>}`;
+//#endregion
+export { ObjectKeys };

package/node_modules/es-toolkit/dist/types/Primitive.d.mts

@@ -0,0 +1,14 @@
+//#region src/types/Primitive.d.ts
+/**
+ * Every primitive value in JavaScript. Anything that is not a primitive is an object.
+ *
+ * Writing this union by hand usually misses `bigint` or `symbol`.
+ *
+ * @example
+ * function isPrimitive(value: unknown): value is Primitive {
+ *   return value === null || (typeof value !== 'object' && typeof value !== 'function');
+ * }
+ */
+type Primitive = string | number | bigint | boolean | symbol | null | undefined;
+//#endregion
+export { Primitive };

package/node_modules/es-toolkit/dist/types/Primitive.d.ts

@@ -0,0 +1,14 @@
+//#region src/types/Primitive.d.ts
+/**
+ * Every primitive value in JavaScript. Anything that is not a primitive is an object.
+ *
+ * Writing this union by hand usually misses `bigint` or `symbol`.
+ *
+ * @example
+ * function isPrimitive(value: unknown): value is Primitive {
+ *   return value === null || (typeof value !== 'object' && typeof value !== 'function');
+ * }
+ */
+type Primitive = string | number | bigint | boolean | symbol | null | undefined;
+//#endregion
+export { Primitive };

package/node_modules/es-toolkit/dist/types/SetOptional.d.mts

@@ -0,0 +1,20 @@
+import { Simplify } from "./Simplify.mjs";
+
+//#region src/types/SetOptional.d.ts
+/**
+ * Makes the given keys `K` of `T` optional, leaving the rest unchanged.
+ * Like the built-in `Partial`, but scoped to specific keys.
+ *
+ * Distributes over unions, so a union stays a union.
+ *
+ * @template T - The object type to transform.
+ * @template K - The keys to make optional.
+ *
+ * @example
+ * type User = { id: number; name: string; email: string };
+ * type UserDraft = SetOptional<User, 'email'>;
+ * // => { id: number; name: string; email?: string }
+ */
+type SetOptional<T, K extends keyof T> = T extends unknown ? Simplify<Omit<T, K> & Partial<Pick<T, K>>> : never;
+//#endregion
+export { SetOptional };

package/node_modules/es-toolkit/dist/types/SetOptional.d.ts

@@ -0,0 +1,20 @@
+import { Simplify } from "./Simplify.js";
+
+//#region src/types/SetOptional.d.ts
+/**
+ * Makes the given keys `K` of `T` optional, leaving the rest unchanged.
+ * Like the built-in `Partial`, but scoped to specific keys.
+ *
+ * Distributes over unions, so a union stays a union.
+ *
+ * @template T - The object type to transform.
+ * @template K - The keys to make optional.
+ *
+ * @example
+ * type User = { id: number; name: string; email: string };
+ * type UserDraft = SetOptional<User, 'email'>;
+ * // => { id: number; name: string; email?: string }
+ */
+type SetOptional<T, K extends keyof T> = T extends unknown ? Simplify<Omit<T, K> & Partial<Pick<T, K>>> : never;
+//#endregion
+export { SetOptional };

package/node_modules/es-toolkit/dist/types/SetRequired.d.mts

@@ -0,0 +1,20 @@
+import { Simplify } from "./Simplify.mjs";
+
+//#region src/types/SetRequired.d.ts
+/**
+ * Makes the given keys `K` of `T` required, leaving the rest unchanged.
+ * Like the built-in `Required`, but scoped to specific keys.
+ *
+ * Distributes over unions, so a union stays a union.
+ *
+ * @template T - The object type to transform.
+ * @template K - The keys to make required.
+ *
+ * @example
+ * type User = { id: number; name: string; avatar?: string };
+ * type ProfileUser = SetRequired<User, 'avatar'>;
+ * // => { id: number; name: string; avatar: string }
+ */
+type SetRequired<T, K extends keyof T> = T extends unknown ? Simplify<T & Required<Pick<T, K>>> : never;
+//#endregion
+export { SetRequired };

package/node_modules/es-toolkit/dist/types/SetRequired.d.ts

@@ -0,0 +1,20 @@
+import { Simplify } from "./Simplify.js";
+
+//#region src/types/SetRequired.d.ts
+/**
+ * Makes the given keys `K` of `T` required, leaving the rest unchanged.
+ * Like the built-in `Required`, but scoped to specific keys.
+ *
+ * Distributes over unions, so a union stays a union.
+ *
+ * @template T - The object type to transform.
+ * @template K - The keys to make required.
+ *
+ * @example
+ * type User = { id: number; name: string; avatar?: string };
+ * type ProfileUser = SetRequired<User, 'avatar'>;
+ * // => { id: number; name: string; avatar: string }
+ */
+type SetRequired<T, K extends keyof T> = T extends unknown ? Simplify<T & Required<Pick<T, K>>> : never;
+//#endregion
+export { SetRequired };

package/node_modules/es-toolkit/dist/types/UnknownRecord.d.mts

@@ -0,0 +1,24 @@
+//#region src/types/UnknownRecord.d.ts
+/**
+ * An object with unknown keys and unknown values.
+ *
+ * Use it instead of `{}`, which accepts every non-nullish value including numbers
+ * and strings. Values are `unknown`, so reading one forces a check first.
+ *
+ * Only types with an index signature are assignable. An `interface` declares its
+ * keys one by one and is rejected, so accept `object` when the caller may pass
+ * one, or spread it at the call site.
+ *
+ * @example
+ * function log(data: UnknownRecord) {
+ *   if (typeof data.id === 'string') {
+ *     console.log(data.id);
+ *   }
+ * }
+ *
+ * log({ id: '1' }); // ok
+ * log(42); // error, while `{}` would have allowed it
+ */
+type UnknownRecord = Record<PropertyKey, unknown>;
+//#endregion
+export { UnknownRecord };

package/node_modules/es-toolkit/dist/types/UnknownRecord.d.ts

@@ -0,0 +1,24 @@
+//#region src/types/UnknownRecord.d.ts
+/**
+ * An object with unknown keys and unknown values.
+ *
+ * Use it instead of `{}`, which accepts every non-nullish value including numbers
+ * and strings. Values are `unknown`, so reading one forces a check first.
+ *
+ * Only types with an index signature are assignable. An `interface` declares its
+ * keys one by one and is rejected, so accept `object` when the caller may pass
+ * one, or spread it at the call site.
+ *
+ * @example
+ * function log(data: UnknownRecord) {
+ *   if (typeof data.id === 'string') {
+ *     console.log(data.id);
+ *   }
+ * }
+ *
+ * log({ id: '1' }); // ok
+ * log(42); // error, while `{}` would have allowed it
+ */
+type UnknownRecord = Record<PropertyKey, unknown>;
+//#endregion
+export { UnknownRecord };