lay-sing 0.1.2 → 0.2.0

package/README.md

@@ -1,18 +1,16 @@
-| English | [简体中文](./README-zh.md) |
-| ------- | -------------------------- |
+[![GitHub License](https://img.shields.io/github/license/Leawind/lay-sing)](https://github.com/Leawind/lay-sing?tab=MIT-1-ov-file)
+[![NPM Version](https://img.shields.io/npm/v/lay-sing?style=flat&logo=npm)](https://www.npmjs.com/package/lay-sing)
+[![JSR Version](https://jsr.io/badges/@leawind/lay-sing)](https://jsr.io/@leawind/lay-sing)
+[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Leawind/lay-sing/verify.yaml?branch=main&logo=github-actions&label=test)](https://github.com/Leawind/lay-sing/actions/workflows/verify.yaml)
 
-# `lay-sing`
+# Lay-Sing
 
 TypeScript utilities for compile-time type testing and utility types
 
-## What is it
-
-1. **Testing Utilities**
-
 ```ts
 // They do nothing at runtime
 expect<never>().toBe<never>().success
-expect<never>().toBeNever // alias for above
+expect<never>().toBeNever // alias for the above
 expect<never>().toBe<'should fail'>().fail
 
 // Type Error: Property 'success' does not exist on type '{ fail: void; }'.
@@ -20,49 +18,24 @@ expect<never>().toBe<'should fail'>().success
 //                                    ^^^^^^^
 ```
 
-1. **Type Manipulation Tools**
-
-```ts
-// Result is 'Bob'
-type Result = Switch<2, [
-  Case<1, 'Alice'>,
-  Case<2, 'Bob'>,
-  Case<3, 'Charlie'>,
-], DefaultCase<'Unknown'>>
-```
+> [!TIP]
+>
+> I know this library is quite simple and serves a specific purpose, so one of its API design principles is to minimize the cognitive load for users. You just need to remember to **start with an `expect<>()` call** and **end with some property access**. Leave the rest to editor suggestions and inline documentation.
 
 ## Install
 
-> This lib is published to both [NPM](https://www.npmjs.com/package/lay-sing) and [JSR](https://jsr.io/@leawind/lay-sing)
-
-### NPM
+### [NPM](https://www.npmjs.com/package/lay-sing)
 
 ```sh
 npm i -D lay-sing
 ```
 
 ```ts
-import type { Same } from 'lay-sing'
+import type { Exact } from 'lay-sing'
 import { expect } from 'lay-sing/test-utils'
 ```
 
-### Deno (JSR)
-
-```sh
-deno add jsr:@leawind/lay-sing
-```
-
-```ts
-import type { Same } from '@leawind/lay-sing'
-import { expect } from '@leawind/lay-sing/test-utils'
-```
-
-Or Import directly:
-
-```ts
-import type { Same } from 'jsr:@leawind/lay-sing@^0.1'
-import { expect } from 'jsr:@leawind/lay-sing@^0.1/test-utils'
-```
+> This library is also published to [JSR (`@leawind/lay-sing`)](https://jsr.io/@leawind/lay-sing)
 
 ---
 
@@ -74,7 +47,7 @@ import { expect } from 'jsr:@leawind/lay-sing@^0.1/test-utils'
 import { compare, expect, NOOP } from 'lay-sing/test-utils'
 ```
 
-The `test-utils` module provides utilities for **compile-time** type validation. These utilities have **no runtime effect** — they always return a special [`NOOP`](https://jsr.io/@leawind/lay-sing/doc/test-utils/~/NOOP) value that safely supports almost any property access or method call.
+The `test-utils` module provides utilities for **compile-time** type validation. These utilities have **no runtime impact** — they always return a special [`NOOP`](https://jsr.io/@leawind/lay-sing/doc/test-utils/~/NOOP) value that safely supports almost any property access or method call.
 
 A typical type test statement follows this pattern:
 
@@ -84,8 +57,18 @@ expect<ActualType>().toBe<ExpectedType>().success
 
 - It starts with a function call like `expect<T>()` or `compare<T, U>()`
 - It ends with a property like `.success` or `.fail`
-- A **type error occurs only if the assertion fails**, helping you catch incorrect types at compile time
-- At runtime, the function always returns the actual value `NOOP`, which performs **no operation**. It can be accessed, called, or chained indefinitely without throwing
+- Type error occurs only if the assertion fails
+
+> [!CAUTION]
+>
+> Only statements ending with property access are type assertions. Without property access, type error may never occur:
+>
+> ```diff
+> - expect<true>().toBe<false>()         // Type error never occur
+> + expect<true>().toBe<false>().success // Type Error: Property 'success' does not exist on type '{ fail: void; }'.
+> ```
+
+At runtime, the function always returns the `NOOP` object, which performs **no operation**. It can be accessed, called, or chained indefinitely without throwing errors.
 
 #### Common Usage
 
@@ -97,7 +80,7 @@ expect<A>().toBe<B>().success // Passes only if A and B are identical
 expect<A>().toExtend<B>().success // Passes if A extends B
 
 // Property existence
-expect<{ name: string }>().toHaveProperty<'name'>().success
+expect<{ name: string }>().toHaveKey<'name'>().success
 
 // Primitive checks
 expect<true>().toBeTrue.success
@@ -108,39 +91,37 @@ compare<A, B>().same // Available only if A ≡ B
 compare<A, B>().different // Available only if A ≠ B
 ```
 
-> [!TIP]
->
-> There's no need to memorize the full API.
->
-> Your editor will show inline documentation and auto-completion for all available methods and properties
-
 #### NOOP
 
-A `Proxy`-based no-op object:
+A `Proxy`-based no-op object with the following behavior:
 
-- Most accesses return itself.
-- `toString()` returns `"[NOOP]"`.
+- Most property/method accesses return the NOOP object itself.
+- `.toString()`, `.valueOf()` returns string `"[NOOP]"`.
 - Not thenable (`then` is `undefined`).
 
+It's used as returned value of `expect()` and `compare()`.
+
 ```ts
-NOOP.foo.bar().baz.qux // safe, returns NOOP
+expect().foo.bar().baz.qux // Safe, returns NOOP
 String(NOOP) // "[NOOP]"
-await NOOP // does not await (not thenable)
+await NOOP // Does not await (not thenable)
 ```
 
 ### Type Tools
 
-The main entry point provides a collection of utility types for common type-level programming tasks. All types are flat-exported from the main entry point — you don’t need to import from deep paths.
+The main entry point provides some utility types for common type-level programming tasks. All types are flat-exported from the main entry point — no need to import from nested paths.
 
 ```ts
-import type { Same } from 'lay-sing'
+import type { Exact } from 'lay-sing'
 ```
 
-> All types are documented — your editor will show inline documentation on hover
-
 ### Examples
 
 ```typescript
+// Test if exactly the same
+type False = Exact<{ a: 1 }, { a?: 1 }> // false
+type Yes = Exact<boolean, true | false, 'yes', 'no'> // 'yes'
+
 // Conditional Types
 type Result = If<true, 'yes', 'no'> // 'yes'
 
@@ -155,12 +136,4 @@ type PartialObj = DeepPartial<{ a: string; nested: { b: number } }>
 // { a?: string; nested?: { b?: number } }
 ```
 
-> [!NOTE]
->
-> [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
-
----
-
-> ## _Pronunciation of lay-sing_
->
-> _"lay-sing" mimics Mandarin "lèi xíng" ("type") — Say "LAY-sing" with a sharp "LAY" (like a command) followed by a rising "sing" (like a question)._
+[Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)

package/esm/main/boolean.d.ts

@@ -6,8 +6,7 @@
  * - `false`: if `T` is `true`
  * - `true`: if `T` is `false`
  *
- * ### Examples
- *
+ * @example
  * | `T`       | `Not<T>`  |
  * | --------- | --------- |
  * | `never`   | `never`    |

package/esm/main/boolean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,OAAO,IAAI,CAAC,SAAS,IAAI,GAAG,KAAK,GACvD,CAAC,SAAS,KAAK,GAAG,IAAI,GACtB,OAAO,CAAA;AAEX;;;;;GAKG;AACH,MAAM,MAAM,GAAG,CACb,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,IACf,CAAC,SAAS,KAAK,GAAG,KAAK,GACvB,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;AAE9D;;;;;;;GAOG;AACH,MAAM,MAAM,EAAE,CACZ,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,IACf,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,GAC/B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,GAC/B,IAAI,SAAS,CAAC,GAAG,IAAI,GACrB,IAAI,SAAS,CAAC,GAAG,IAAI,GACrB,KAAK,CAAA"}
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,OAAO,IAAI,CAAC,SAAS,IAAI,GAAG,KAAK,GACvD,CAAC,SAAS,KAAK,GAAG,IAAI,GACtB,OAAO,CAAA;AAEX;;;;;GAKG;AACH,MAAM,MAAM,GAAG,CACb,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,IACf,CAAC,SAAS,KAAK,GAAG,KAAK,GACvB,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;AAE9D;;;;;;;GAOG;AACH,MAAM,MAAM,EAAE,CACZ,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,IACf,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,GAC/B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,GAC/B,IAAI,SAAS,CAAC,GAAG,IAAI,GACrB,IAAI,SAAS,CAAC,GAAG,IAAI,GACrB,KAAK,CAAA"}

package/esm/main/boolean.js.map

@@ -1 +1 @@
-{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * ### Result\n *\n * - `never`: if `T` is `never`\n * - `boolean`: if `T` is `boolean` or `any`\n * - `false`: if `T` is `true`\n * - `true`: if `T` is `false`\n *\n * ### Examples\n *\n * | `T`       | `Not<T>`  |\n * | --------- | --------- |\n * | `never`   | `never`    |\n * | `true`    | `false`   |\n * | `false`   | `true`    |\n * | `boolean` | `boolean` |\n * | `any`     | `boolean` |\n */\nexport type Not<T extends boolean> = T extends true ? false\n  : T extends false ? true\n  : boolean\n\n/**\n * - `never`: if anyone of A,B is `never`\n * - `boolean`: if anyone of A,B is `boolean` or `any`\n * - `true`: if both A,B are `true`\n * - `false`: otherwise\n */\nexport type And<\n  A extends boolean,\n  B extends boolean,\n> = A extends never ? never\n  : [B] extends [never] ? never\n  : (A extends true ? (B extends true ? true : false) : false)\n\n/**\n * ### Result\n *\n * - `never`: if anyone of A,B is `never`\n * - `boolean`: if anyone of A,B is `boolean` or `any`\n * - `false`: if both A,B are `false`\n * - `true`: otherwise\n */\nexport type Or<\n  A extends boolean,\n  B extends boolean,\n> = [A] extends [never] ? never\n  : [B] extends [never] ? never\n  : [boolean] extends [A] ? boolean\n  : [boolean] extends [B] ? boolean\n  : true extends A ? true\n  : true extends B ? true\n  : false\n"]}
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * ### Result\n *\n * - `never`: if `T` is `never`\n * - `boolean`: if `T` is `boolean` or `any`\n * - `false`: if `T` is `true`\n * - `true`: if `T` is `false`\n *\n * @example\n * | `T`       | `Not<T>`  |\n * | --------- | --------- |\n * | `never`   | `never`    |\n * | `true`    | `false`   |\n * | `false`   | `true`    |\n * | `boolean` | `boolean` |\n * | `any`     | `boolean` |\n */\nexport type Not<T extends boolean> = T extends true ? false\n  : T extends false ? true\n  : boolean\n\n/**\n * - `never`: if anyone of A,B is `never`\n * - `boolean`: if anyone of A,B is `boolean` or `any`\n * - `true`: if both A,B are `true`\n * - `false`: otherwise\n */\nexport type And<\n  A extends boolean,\n  B extends boolean,\n> = A extends never ? never\n  : [B] extends [never] ? never\n  : (A extends true ? (B extends true ? true : false) : false)\n\n/**\n * ### Result\n *\n * - `never`: if anyone of A,B is `never`\n * - `boolean`: if anyone of A,B is `boolean` or `any`\n * - `false`: if both A,B are `false`\n * - `true`: otherwise\n */\nexport type Or<\n  A extends boolean,\n  B extends boolean,\n> = [A] extends [never] ? never\n  : [B] extends [never] ? never\n  : [boolean] extends [A] ? boolean\n  : [boolean] extends [B] ? boolean\n  : true extends A ? true\n  : true extends B ? true\n  : false\n"]}

package/esm/main/control.d.ts

@@ -1,54 +1,51 @@
-import type { Same } from './type/compare.js';
+import type { Exact } from './type/compare.js';
 /**
  * Conditional type - returns `T` if condition `C` is true, otherwise returns `F`
  *
  * ### Result
  *
  * - `never`: if `C` is `never`
- * - `T`: if `C` is `true`
- * - `F`: if `C` is `false`
- *
- * ### Examples
+ * - `Yes`: if `C` is `true`
+ * - `No`: if `C` is `false`
  *
+ * @example
  * ```ts
  * type Result = If<true, 'yes', 'no'> // 'yes'
  * type Result2 = If<false, 'yes', 'no'> // 'no'
  * type NeverResult = If<never, 'yes', 'no'> // never
  * ```
  */
-export type If<C extends boolean, T, F = never> = [C] extends [never] ? never : C extends true ? T : F;
+export type If<Condition extends boolean, Yes, No = never> = [Condition] extends [never] ? never : Condition extends true ? Yes : No;
 /**
  * Conditional type - returns `T` if condition `C` is false, otherwise returns `F`
  *
  * ### Result
  *
  * - `never`: if `C` is `never`
- * - `T`: if `C` is `false`
- * - `F`: if `C` is `true`
- *
- * ### Examples
+ * - `Yes`: if `C` is `false`
+ * - `No`: if `C` is `true`
  *
+ * @example
  * ```ts
  * type Result = IfFalse<false, 'yes', 'no'> // 'yes'
  * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'
  * type NeverResult = IfFalse<never, 'yes', 'no'> // never
  * ```
  */
-export type IfFalse<C extends boolean, T, F = never> = [C] extends [never] ? never : C extends false ? T : F;
+export type IfFalse<Condition extends boolean, Yes, No = never> = [Condition] extends [never] ? never : Condition extends false ? Yes : No;
 /**
  * Used with:
  * - {@link Switch}
  * - {@link SwitchExtends}
  */
-export type Case<T = unknown, Return = unknown> = [T, Return];
+export type Case<T = unknown, Result = unknown> = [T, Result];
 /**
  * Used with:
  *
  * - {@link Switch}
  * - {@link SwitchExtends}
  *
- * ### Examples
- *
+ * @example
  * ```ts
  * type NameMap<id> = Switch<id, [
  *   Case<1, 'Alice'>,
@@ -59,8 +56,7 @@ export type Case<T = unknown, Return = unknown> = [T, Return];
  */
 export type DefaultCase<T> = T;
 /**
- * ### Examples
- *
+ * @example
  * ```ts
  * type Result = Switch<2, [
  *   Case<1, 'Alice'>,
@@ -71,12 +67,11 @@ export type DefaultCase<T> = T;
  * // Result: 'Bob'
  * ```
  */
-export type Switch<T, Cases extends readonly Case[], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer C, infer R] ? (Same<T, C> extends true ? R : (Switch<T, Rest extends readonly Case[] ? Rest : never, Default>)) : (never)) : Default;
+export type Switch<T, Cases extends readonly Case[], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer Condition, infer Result] ? (Exact<T, Condition> extends true ? Result : (Switch<T, Rest extends readonly Case[] ? Rest : never, Default>)) : (never)) : Default;
 /**
- * Switch type that uses 'extends' logic instead of 'Same' logic
+ * Switch type that uses 'extends' logic instead of 'Exact' logic
  *
- * ### Examples
- * ```ts
+ * @example ```ts
  * type Result = SwitchExtends<string | number, [
  *   Case<string, 'string type'>,
  *   Case<number, 'number type'>,

package/esm/main/control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,EAAE,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GACzE,CAAC,SAAS,IAAI,GAAG,CAAC,GAClB,CAAC,CAAA;AAEL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC9E,CAAC,SAAS,KAAK,GAAG,CAAC,GACnB,CAAC,CAAA;AAEL;;;;GAIG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAC7D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAA;AAE9B;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EACD,KAAK,SAAS,SAAS,IAAI,EAAE,EAC7B,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAC5B,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GACjG,CAAC,KAAK,CAAC,CACZ,GACC,OAAO,CAAA;AAEX;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,EACD,KAAK,SAAS,SAAS,IAAI,EAAE,EAC7B,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAC5B,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,GAC9F,KAAK,CACV,GACC,OAAO,CAAA"}
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,EAAE,CACZ,SAAS,SAAS,OAAO,EACzB,GAAG,EACH,EAAE,GAAG,KAAK,IACR,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GACnC,SAAS,SAAS,IAAI,GAAG,GAAG,GAC5B,EAAE,CAAA;AAEN;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,OAAO,CACjB,SAAS,SAAS,OAAO,EACzB,GAAG,EACH,EAAE,GAAG,KAAK,IACR,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GACnC,SAAS,SAAS,KAAK,GAAG,GAAG,GAC7B,EAAE,CAAA;AAEN;;;;GAIG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAE7D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAA;AAE9B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EACD,KAAK,SAAS,SAAS,IAAI,EAAE,EAC7B,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,SAAS,EAAE,MAAM,MAAM,CAAC,GACzC,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAC/G,CAAC,KAAK,CAAC,CACZ,GACC,OAAO,CAAA;AAEX;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,EACD,KAAK,SAAS,SAAS,IAAI,EAAE,EAC7B,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAC5B,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,GAC9F,KAAK,CACV,GACC,OAAO,CAAA"}

package/esm/main/control.js.map

@@ -1 +1 @@
-{"version":3,"file":"control.js","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"","sourcesContent":["import type { Same } from './type/compare.js'\n\n/**\n * Conditional type - returns `T` if condition `C` is true, otherwise returns `F`\n *\n * ### Result\n *\n * - `never`: if `C` is `never`\n * - `T`: if `C` is `true`\n * - `F`: if `C` is `false`\n *\n * ### Examples\n *\n * ```ts\n * type Result = If<true, 'yes', 'no'> // 'yes'\n * type Result2 = If<false, 'yes', 'no'> // 'no'\n * type NeverResult = If<never, 'yes', 'no'> // never\n * ```\n */\nexport type If<C extends boolean, T, F = never> = [C] extends [never] ? never\n  : C extends true ? T\n  : F\n\n/**\n * Conditional type - returns `T` if condition `C` is false, otherwise returns `F`\n *\n * ### Result\n *\n * - `never`: if `C` is `never`\n * - `T`: if `C` is `false`\n * - `F`: if `C` is `true`\n *\n * ### Examples\n *\n * ```ts\n * type Result = IfFalse<false, 'yes', 'no'> // 'yes'\n * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'\n * type NeverResult = IfFalse<never, 'yes', 'no'> // never\n * ```\n */\nexport type IfFalse<C extends boolean, T, F = never> = [C] extends [never] ? never\n  : C extends false ? T\n  : F\n\n/**\n * Used with:\n * - {@link Switch}\n * - {@link SwitchExtends}\n */\nexport type Case<T = unknown, Return = unknown> = [T, Return]\n/**\n * Used with:\n *\n * - {@link Switch}\n * - {@link SwitchExtends}\n *\n * ### Examples\n *\n * ```ts\n * type NameMap<id> = Switch<id, [\n *   Case<1, 'Alice'>,\n *   Case<2, 'Bob'>,\n *   Case<3, 'Charlie'>,\n * ], DefaultCase<'Steve'>>\n * ```\n */\nexport type DefaultCase<T> = T\n\n/**\n * ### Examples\n *\n * ```ts\n * type Result = Switch<2, [\n *   Case<1, 'Alice'>,\n *   Case<2, 'Bob'>,\n *   Case<3, 'Charlie'>,\n * ], DefaultCase<'Steve'>>\n *\n * // Result: 'Bob'\n * ```\n */\nexport type Switch<\n  T,\n  Cases extends readonly Case[],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer C, infer R]\n      ? (Same<T, C> extends true ? R : (Switch<T, Rest extends readonly Case[] ? Rest : never, Default>))\n      : (never)\n  )\n  : Default\n\n/**\n * Switch type that uses 'extends' logic instead of 'Same' logic\n *\n * ### Examples\n * ```ts\n * type Result = SwitchExtends<string | number, [\n *   Case<string, 'string type'>,\n *   Case<number, 'number type'>,\n * ], 'other'>\n * // Result: 'string type' | 'number type'\n * ```\n */\nexport type SwitchExtends<\n  T,\n  Cases extends readonly Case[],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer C, infer R]\n      ? ([T] extends [C] ? R : SwitchExtends<T, Rest extends readonly Case[] ? Rest : never, Default>)\n      : never\n  )\n  : Default\n"]}
+{"version":3,"file":"control.js","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from './type/compare.js'\n\n/**\n * Conditional type - returns `T` if condition `C` is true, otherwise returns `F`\n *\n * ### Result\n *\n * - `never`: if `C` is `never`\n * - `Yes`: if `C` is `true`\n * - `No`: if `C` is `false`\n *\n * @example\n * ```ts\n * type Result = If<true, 'yes', 'no'> // 'yes'\n * type Result2 = If<false, 'yes', 'no'> // 'no'\n * type NeverResult = If<never, 'yes', 'no'> // never\n * ```\n */\nexport type If<\n  Condition extends boolean,\n  Yes,\n  No = never,\n> = [Condition] extends [never] ? never\n  : Condition extends true ? Yes\n  : No\n\n/**\n * Conditional type - returns `T` if condition `C` is false, otherwise returns `F`\n *\n * ### Result\n *\n * - `never`: if `C` is `never`\n * - `Yes`: if `C` is `false`\n * - `No`: if `C` is `true`\n *\n * @example\n * ```ts\n * type Result = IfFalse<false, 'yes', 'no'> // 'yes'\n * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'\n * type NeverResult = IfFalse<never, 'yes', 'no'> // never\n * ```\n */\nexport type IfFalse<\n  Condition extends boolean,\n  Yes,\n  No = never,\n> = [Condition] extends [never] ? never\n  : Condition extends false ? Yes\n  : No\n\n/**\n * Used with:\n * - {@link Switch}\n * - {@link SwitchExtends}\n */\nexport type Case<T = unknown, Result = unknown> = [T, Result]\n\n/**\n * Used with:\n *\n * - {@link Switch}\n * - {@link SwitchExtends}\n *\n * @example\n * ```ts\n * type NameMap<id> = Switch<id, [\n *   Case<1, 'Alice'>,\n *   Case<2, 'Bob'>,\n *   Case<3, 'Charlie'>,\n * ], DefaultCase<'Steve'>>\n * ```\n */\nexport type DefaultCase<T> = T\n\n/**\n * @example\n * ```ts\n * type Result = Switch<2, [\n *   Case<1, 'Alice'>,\n *   Case<2, 'Bob'>,\n *   Case<3, 'Charlie'>,\n * ], DefaultCase<'Steve'>>\n *\n * // Result: 'Bob'\n * ```\n */\nexport type Switch<\n  T,\n  Cases extends readonly Case[],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer Condition, infer Result]\n      ? (Exact<T, Condition> extends true ? Result : (Switch<T, Rest extends readonly Case[] ? Rest : never, Default>))\n      : (never)\n  )\n  : Default\n\n/**\n * Switch type that uses 'extends' logic instead of 'Exact' logic\n *\n * @example ```ts\n * type Result = SwitchExtends<string | number, [\n *   Case<string, 'string type'>,\n *   Case<number, 'number type'>,\n * ], 'other'>\n * // Result: 'string type' | 'number type'\n * ```\n */\nexport type SwitchExtends<\n  T,\n  Cases extends readonly Case[],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer C, infer R]\n      ? ([T] extends [C] ? R : SwitchExtends<T, Rest extends readonly Case[] ? Rest : never, Default>)\n      : never\n  )\n  : Default\n"]}

package/esm/main/function.d.ts

@@ -1,8 +1,7 @@
 /**
  * Represents a function with any parameters and a specific return type
  *
- * ### Examples
- *
+ * @example
  * ```ts
  * type _ = AnyFunction<string, [number]> // (arg: number) => string
  * ```
@@ -11,8 +10,7 @@ export type AnyFunction<Return = any, Params extends any[] = any[]> = (...args:
 /**
  * Represents a constructor with any parameters and a specific return type
  *
- * ### Examples
- *
+ * @example
  * ```ts
  * type _ = Constructor<string, [number]> // new (arg: number) => string
  * ```

package/esm/main/function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,CAAC,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;AAE/B;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,KAAK,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA"}
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,CAAC,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;AAE/B;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,KAAK,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA"}

package/esm/main/function.js.map

@@ -1 +1 @@
-{"version":3,"file":"function.js","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAAA,wCAAwC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\n\n/**\n * Represents a function with any parameters and a specific return type\n *\n * ### Examples\n *\n * ```ts\n * type _ = AnyFunction<string, [number]> // (arg: number) => string\n * ```\n */\nexport type AnyFunction<\n  Return = any,\n  Params extends any[] = any[],\n> = (...args: Params) => Return\n\n/**\n * Represents a constructor with any parameters and a specific return type\n *\n * ### Examples\n *\n * ```ts\n * type _ = Constructor<string, [number]> // new (arg: number) => string\n * ```\n */\nexport type Constructor<\n  Return = any,\n  Params extends any[] = any[],\n> = new (...args: Params) => Return\n"]}
+{"version":3,"file":"function.js","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAAA,wCAAwC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\n\n/**\n * Represents a function with any parameters and a specific return type\n *\n * @example\n * ```ts\n * type _ = AnyFunction<string, [number]> // (arg: number) => string\n * ```\n */\nexport type AnyFunction<\n  Return = any,\n  Params extends any[] = any[],\n> = (...args: Params) => Return\n\n/**\n * Represents a constructor with any parameters and a specific return type\n *\n * @example\n * ```ts\n * type _ = Constructor<string, [number]> // new (arg: number) => string\n * ```\n */\nexport type Constructor<\n  Return = any,\n  Params extends any[] = any[],\n> = new (...args: Params) => Return\n"]}

package/esm/main/index.d.ts

@@ -1,4 +1,3 @@
-export * from './array.js';
 export * from './async.js';
 export * from './boolean.js';
 export * from './control.js';
@@ -7,6 +6,7 @@ export * from './function.js';
 export * from './json.js';
 export * from './key.js';
 export * from './object.js';
+export * from './tuple.js';
 export * from './type/index.js';
 export * from './typed-array.js';
 //# sourceMappingURL=index.d.ts.map

package/esm/main/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}

package/esm/main/index.js

@@ -1,4 +1,4 @@
-export * from './array.js';
+// Index start >>>>>>>>>>>>>>>>
 export * from './async.js';
 export * from './boolean.js';
 export * from './control.js';
@@ -7,6 +7,8 @@ export * from './function.js';
 export * from './json.js';
 export * from './key.js';
 export * from './object.js';
+export * from './tuple.js';
 export * from './type/index.js';
 export * from './typed-array.js';
+// <<<<<<<<<<<<<<<<   Index end
 //# sourceMappingURL=index.js.map

package/esm/main/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA","sourcesContent":["export * from './array.js'\nexport * from './async.js'\nexport * from './boolean.js'\nexport * from './control.js'\nexport * from './doc.js'\nexport * from './function.js'\nexport * from './json.js'\nexport * from './key.js'\nexport * from './object.js'\nexport * from './type/index.js'\nexport * from './typed-array.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,+BAA+B","sourcesContent":["// Index start >>>>>>>>>>>>>>>>\nexport * from './async.js'\nexport * from './boolean.js'\nexport * from './control.js'\nexport * from './doc.js'\nexport * from './function.js'\nexport * from './json.js'\nexport * from './key.js'\nexport * from './object.js'\nexport * from './tuple.js'\nexport * from './type/index.js'\nexport * from './typed-array.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}

package/esm/main/key.d.ts

@@ -1,26 +1,62 @@
-import type { Same } from './type/index.js';
+import type { Exact } from './type/index.js';
 /**
- * Extracts the keys of type T that have values of type U
+ * Extracts the keys of an object whose **base value type** matches the specified `ValueType` (ignoring undefined from optional properties).
  *
- * ### Examples
+ * This utility matches the underlying/base type of each property (stripping `undefined` added by optional modifiers `?`).
+ * For optional properties (e.g., `a?: string`), the type is treated as `string` – no need to include `undefined` in `ValueType` to match.
  *
- * ```ts
- * type A = { a: 1; b: 2; c: 1 }
- * type Keys = KeysOfType<A, 1> // 'a' | 'c'
- * ```
+ * @template Obj - The target object type to extract keys from.
+ * @template ValueType - The base type to match against property values (ignoring undefined from optional properties).
+ *
+ * @example
+ * // Basic usage: match base type (non-optional property)
+ * type A = { a: 1; b: 2; c: 1 };
+ * type MatchedKeys = KeysOfBaseType<A, 1>; // 'a' | 'c'
+ *
+ * @example
+ * // Key difference: optional property matching (ignores undefined)
+ * type B = { a?: string; b: string };
+ * type MatchBaseString = KeysOfBaseType<B, string>; // 'a' | 'b' (matches base type of both)
+ * type MatchWithUndefined = KeysOfBaseType<B, string | undefined>; // never (base type does not include undefined)
+ *
+ * @example
+ * // Edge cases: never/any/unknown
+ * type C = { a: never; b: any; c: unknown };
+ * type MatchNever = KeysOfBaseType<C, never>; // 'a'
+ * type MatchAny = KeysOfBaseType<C, any>; // 'b'
+ * type MatchUnknown = KeysOfBaseType<C, unknown>; // 'c'
  */
-export type KeysOfType<T, U> = Exclude<{
-    [K in keyof T]: Same<T[K], U> extends true ? K : never;
-}[keyof T], undefined>;
+export type KeysOfBaseType<Obj, ValueType> = Exclude<{
+    [K in keyof Obj]: Exact<Required<Obj>[K], ValueType> extends true ? K : never;
+}[keyof Obj], undefined>;
 /**
- * Extracts the keys of type T that do not have values of type U
+ * Extracts the keys of an object whose **complete value type** exactly matches the specified `ValueType` (including undefined for optional properties).
+ *
+ * This utility strictly matches the full type of each property (including `undefined` added by optional modifiers `?`).
+ * For optional properties (e.g., `a?: string`), the type is treated as `string | undefined` – to match, `ValueType` must include `undefined`.
+ *
+ * @template Obj - The target object type to extract keys from.
+ * @template ValueType - The exact type to match against property values (including undefined for optional properties).
+ *
+ * @example
+ * // Basic usage: match exact type (non-optional property)
+ * type A = { a: 1; b: 2; c: 1 };
+ * type MatchedKeys = KeysOfExactType<A, 1>; // 'a' | 'c'
  *
- * ### Examples
+ * @example
+ * // Key difference: optional property matching (requires undefined in `ValueType`)
+ * type B = { a?: string };
+ * type MatchWithUndefined = KeysOfExactType<B, string | undefined>; // 'a' (matches complete type)
+ * type MatchWithoutUndefined = KeysOfExactType<B, string>; // never (does not match complete type)
  *
- * ```ts
- * type A = { a: 1; b: 2; c: 1 }
- * type Keys = KeysOfOtherType<A, 1> // 'b'
- * ```
+ * @example
+ * // Edge cases: never/any/unknown
+ * type C = { a: never; b: any; c: unknown };
+ * type MatchNever = KeysOfExactType<C, never>; // 'a'
+ * type MatchAny = KeysOfExactType<C, any>; // 'b'
+ * type MatchUnknown = KeysOfExactType<C, unknown>; // 'c'
  */
-export type KeysOfOtherType<T, U> = Exclude<keyof T, KeysOfType<T, U>>;
+export type KeysOfExactType<Obj, ValueType> = Exclude<{
+    [K in keyof Obj]: Exact<Obj[K], ValueType> extends true ? K : never;
+}[keyof Obj], undefined>;
 //# sourceMappingURL=key.d.ts.map

package/esm/main/key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;AAEtH;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,cAAc,CAAC,GAAG,EAAE,SAAS,IAAI,OAAO,CAClD;KACG,CAAC,IAAI,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK;CAC9E,CAAC,MAAM,GAAG,CAAC,EACZ,SAAS,CACV,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,eAAe,CAAC,GAAG,EAAE,SAAS,IAAI,OAAO,CACnD;KAAG,CAAC,IAAI,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,MAAM,GAAG,CAAC,EAClF,SAAS,CACV,CAAA"}

package/esm/main/key.js.map

@@ -1 +1 @@
-{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"","sourcesContent":["import type { Same } from './type/index.js'\n\n/**\n * Extracts the keys of type T that have values of type U\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: 1; b: 2; c: 1 }\n * type Keys = KeysOfType<A, 1> // 'a' | 'c'\n * ```\n */\nexport type KeysOfType<T, U> = Exclude<{ [K in keyof T]: Same<T[K], U> extends true ? K : never }[keyof T], undefined>\n\n/**\n * Extracts the keys of type T that do not have values of type U\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: 1; b: 2; c: 1 }\n * type Keys = KeysOfOtherType<A, 1> // 'b'\n * ```\n */\nexport type KeysOfOtherType<T, U> = Exclude<keyof T, KeysOfType<T, U>>\n"]}
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from './type/index.js'\n\n/**\n * Extracts the keys of an object whose **base value type** matches the specified `ValueType` (ignoring undefined from optional properties).\n *\n * This utility matches the underlying/base type of each property (stripping `undefined` added by optional modifiers `?`).\n * For optional properties (e.g., `a?: string`), the type is treated as `string` – no need to include `undefined` in `ValueType` to match.\n *\n * @template Obj - The target object type to extract keys from.\n * @template ValueType - The base type to match against property values (ignoring undefined from optional properties).\n *\n * @example\n * // Basic usage: match base type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * type MatchedKeys = KeysOfBaseType<A, 1>; // 'a' | 'c'\n *\n * @example\n * // Key difference: optional property matching (ignores undefined)\n * type B = { a?: string; b: string };\n * type MatchBaseString = KeysOfBaseType<B, string>; // 'a' | 'b' (matches base type of both)\n * type MatchWithUndefined = KeysOfBaseType<B, string | undefined>; // never (base type does not include undefined)\n *\n * @example\n * // Edge cases: never/any/unknown\n * type C = { a: never; b: any; c: unknown };\n * type MatchNever = KeysOfBaseType<C, never>; // 'a'\n * type MatchAny = KeysOfBaseType<C, any>; // 'b'\n * type MatchUnknown = KeysOfBaseType<C, unknown>; // 'c'\n */\nexport type KeysOfBaseType<Obj, ValueType> = Exclude<\n  {\n    [K in keyof Obj]: Exact<Required<Obj>[K], ValueType> extends true ? K : never\n  }[keyof Obj],\n  undefined\n>\n\n/**\n * Extracts the keys of an object whose **complete value type** exactly matches the specified `ValueType` (including undefined for optional properties).\n *\n * This utility strictly matches the full type of each property (including `undefined` added by optional modifiers `?`).\n * For optional properties (e.g., `a?: string`), the type is treated as `string | undefined` – to match, `ValueType` must include `undefined`.\n *\n * @template Obj - The target object type to extract keys from.\n * @template ValueType - The exact type to match against property values (including undefined for optional properties).\n *\n * @example\n * // Basic usage: match exact type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * type MatchedKeys = KeysOfExactType<A, 1>; // 'a' | 'c'\n *\n * @example\n * // Key difference: optional property matching (requires undefined in `ValueType`)\n * type B = { a?: string };\n * type MatchWithUndefined = KeysOfExactType<B, string | undefined>; // 'a' (matches complete type)\n * type MatchWithoutUndefined = KeysOfExactType<B, string>; // never (does not match complete type)\n *\n * @example\n * // Edge cases: never/any/unknown\n * type C = { a: never; b: any; c: unknown };\n * type MatchNever = KeysOfExactType<C, never>; // 'a'\n * type MatchAny = KeysOfExactType<C, any>; // 'b'\n * type MatchUnknown = KeysOfExactType<C, unknown>; // 'c'\n */\nexport type KeysOfExactType<Obj, ValueType> = Exclude<\n  { [K in keyof Obj]: Exact<Obj[K], ValueType> extends true ? K : never }[keyof Obj],\n  undefined\n>\n"]}