lay-sing 0.2.0 → 0.2.1

package/README.md

@@ -22,20 +22,54 @@ expect<never>().toBe<'should fail'>().success
 >
 > 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
+## Install & Import
 
-### [NPM](https://www.npmjs.com/package/lay-sing)
+<details>
+<summary>NPM</summary>
 
 ```sh
 npm i -D lay-sing
 ```
 
 ```ts
-import type { Exact } from 'lay-sing'
 import { expect } from 'lay-sing/test-utils'
 ```
 
-> This library is also published to [JSR (`@leawind/lay-sing`)](https://jsr.io/@leawind/lay-sing)
+</details>
+
+<details>
+<summary>Deno</summary>
+
+### From NPM
+
+```sh
+deno add npm:lay-sing
+```
+
+```ts
+import { expect } from 'lay-sing/test-utils'
+```
+
+### From JSR
+
+This library is also published to [JSR (`@leawind/lay-sing`)](https://jsr.io/@leawind/lay-sing)
+
+```sh
+deno add @leawind/lay-sing
+```
+
+```ts
+import { expect } from '@leawind/lay-sing/test-utils'
+```
+
+### From Latest commit
+
+```ts
+import { expect } from 'https://raw.githubusercontent.com/Leawind/lay-sing/refs/heads/main/src/test-utils/index.ts'
+import { Exact } from 'https://raw.githubusercontent.com/Leawind/lay-sing/refs/heads/main/src/main/index.ts'
+```
+
+</details>
 
 ---
 
@@ -44,7 +78,7 @@ import { expect } from 'lay-sing/test-utils'
 ### Testing Utilities
 
 ```ts
-import { compare, expect, NOOP } from 'lay-sing/test-utils'
+import { expect } from 'lay-sing/test-utils'
 ```
 
 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.
@@ -73,22 +107,27 @@ At runtime, the function always returns the `NOOP` object, which performs **no o
 #### Common Usage
 
 ```ts
-// Exact equality
-expect<A>().toBe<B>().success // Passes only if A and B are identical
+// Passes only if A and B are identical
+expect<keyof { a: 2 }>().toBe<'a'>().success
 
-// Subtype check
-expect<A>().toExtend<B>().success // Passes if A extends B
+// Passes if A extends B
+expect<12138>().toExtend<number>().success
 
-// Property existence
+// Passes if mutually assignable
+expect<{ a: 1; b: 2 }>().toEqual<{ a: 1 } & { b: 2 }>().success
+
+// Test property existence
 expect<{ name: string }>().toHaveKey<'name'>().success
+```
 
-// Primitive checks
-expect<true>().toBeTrue.success
-expect<'hello'>().toExtendString.success
+Aliases:
+
+```ts
+expect<never>().toBe<never>().success
+expect<never>().toBeNever
 
-// Type comparison
-compare<A, B>().same // Available only if A ≡ B
-compare<A, B>().different // Available only if A ≠ B
+expect<'hello'>().toExtend<string>().success
+expect<'hello'>().toExtendString
 ```
 
 #### NOOP

package/esm/main/async.d.ts

@@ -1,5 +1,13 @@
 /**
- * Represents a value that can be either T or a Promise of T
+ * Represents a value that can be either `T` or a Promise of `T`
+ *
+ * @template T - The underlying type that may or may not be wrapped in a Promise
+ *
+ * @example
+ * ```ts
+ * type StringOrPromise = Awaitable<string>
+ * // Equivalent to: string | Promise<string>
+ * ```
  */
 export type Awaitable<T> = Promise<T> | T;
 //# sourceMappingURL=async.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/main/async.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA"}
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/main/async.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA"}

package/esm/main/async.js.map

@@ -1 +1 @@
-{"version":3,"file":"async.js","sourceRoot":"","sources":["../../src/main/async.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents a value that can be either T or a Promise of T\n */\nexport type Awaitable<T> = Promise<T> | T\n"]}
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../src/main/async.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents a value that can be either `T` or a Promise of `T`\n *\n * @template T - The underlying type that may or may not be wrapped in a Promise\n *\n * @example\n * ```ts\n * type StringOrPromise = Awaitable<string>\n * // Equivalent to: string | Promise<string>\n * ```\n */\nexport type Awaitable<T> = Promise<T> | T\n"]}

package/esm/main/boolean.d.ts

@@ -1,35 +1,59 @@
 /**
- * ### Result
+ * Negates a boolean type
  *
- * - `never`: if `T` is `never`
- * - `boolean`: if `T` is `boolean` or `any`
- * - `false`: if `T` is `true`
- * - `true`: if `T` is `false`
+ * @template T - The boolean type to negate
  *
  * @example
- * | `T`       | `Not<T>`  |
- * | --------- | --------- |
- * | `never`   | `never`    |
- * | `true`    | `false`   |
- * | `false`   | `true`    |
- * | `boolean` | `boolean` |
- * | `any`     | `boolean` |
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<Not<true>>().toBeFalse
+ * expect<Not<false>>().toBeTrue
+ * expect<Not<boolean>>().toBe<boolean>().success
+ * ```
  */
 export type Not<T extends boolean> = T extends true ? false : T extends false ? true : boolean;
 /**
- * - `never`: if anyone of A,B is `never`
- * - `boolean`: if anyone of A,B is `boolean` or `any`
- * - `true`: if both A,B are `true`
- * - `false`: otherwise
+ * Logical AND operation on two boolean types
+ *
+ * @template A - The first boolean type to compare
+ * @template B - The second boolean type to compare
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<And<true, true>>().toBeTrue
+ * expect<And<true, false>>().toBeFalse
+ * expect<And<false, true>>().toBeFalse
+ * expect<And<false, false>>().toBeFalse
+ * expect<And<boolean, boolean>>().toBe<boolean>().success
+ * ```
  */
 export type And<A extends boolean, B extends boolean> = A extends never ? never : [B] extends [never] ? never : (A extends true ? (B extends true ? true : false) : false);
 /**
+ * Logical OR operation on two boolean types
+ *
+ * @template A - The first boolean type to compare
+ * @template B - The second boolean type to compare
+ *
  * ### Result
  *
- * - `never`: if anyone of A,B is `never`
- * - `boolean`: if anyone of A,B is `boolean` or `any`
- * - `false`: if both A,B are `false`
+ * - `never`: if either `A` or `B` is `never`
+ * - `boolean`: if either `A` or `B` is `boolean` or `any`
+ * - `false`: if both `A` and `B` are `false`
  * - `true`: otherwise
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<Or<true, true>>().toBeTrue
+ * expect<Or<true, false>>().toBeTrue
+ * expect<Or<false, true>>().toBeTrue
+ * expect<Or<false, false>>().toBeFalse
+ * expect<Or<boolean, false>>().toBe<boolean>().success
+ * ```
  */
 export type Or<A extends boolean, B extends boolean> = [A] extends [never] ? never : [B] extends [never] ? never : [boolean] extends [A] ? boolean : [boolean] extends [B] ? boolean : true extends A ? true : true extends B ? true : false;
 //# sourceMappingURL=boolean.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,OAAO,IAAI,CAAC,SAAS,IAAI,GAAG,KAAK,GACvD,CAAC,SAAS,KAAK,GAAG,IAAI,GACtB,OAAO,CAAA;AAEX;;;;;;;;;;;;;;;;GAgBG;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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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 * @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"]}
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Negates a boolean type\n *\n * @template T - The boolean type to negate\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<Not<true>>().toBeFalse\n * expect<Not<false>>().toBeTrue\n * expect<Not<boolean>>().toBe<boolean>().success\n * ```\n */\nexport type Not<T extends boolean> = T extends true ? false\n  : T extends false ? true\n  : boolean\n\n/**\n * Logical AND operation on two boolean types\n *\n * @template A - The first boolean type to compare\n * @template B - The second boolean type to compare\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<And<true, true>>().toBeTrue\n * expect<And<true, false>>().toBeFalse\n * expect<And<false, true>>().toBeFalse\n * expect<And<false, false>>().toBeFalse\n * expect<And<boolean, boolean>>().toBe<boolean>().success\n * ```\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 * Logical OR operation on two boolean types\n *\n * @template A - The first boolean type to compare\n * @template B - The second boolean type to compare\n *\n * ### Result\n *\n * - `never`: if either `A` or `B` is `never`\n * - `boolean`: if either `A` or `B` is `boolean` or `any`\n * - `false`: if both `A` and `B` are `false`\n * - `true`: otherwise\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<Or<true, true>>().toBeTrue\n * expect<Or<true, false>>().toBeTrue\n * expect<Or<false, true>>().toBeTrue\n * expect<Or<false, false>>().toBeFalse\n * expect<Or<boolean, false>>().toBe<boolean>().success\n * ```\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,83 +1,112 @@
 import type { Exact } from './type/compare.js';
 /**
- * Conditional type - returns `T` if condition `C` is true, otherwise returns `F`
+ * Conditional type - returns `Yes` if condition `Condition` is true, otherwise returns `No`
  *
- * ### Result
- *
- * - `never`: if `C` is `never`
- * - `Yes`: if `C` is `true`
- * - `No`: if `C` is `false`
+ * @template Condition - The boolean condition to check
+ * @template Yes - The type to return if condition is true
+ * @template No - The type to return if condition is false (defaults to `never`)
  *
  * @example
  * ```ts
  * type Result = If<true, 'yes', 'no'> // 'yes'
  * type Result2 = If<false, 'yes', 'no'> // 'no'
- * type NeverResult = If<never, 'yes', 'no'> // never
+ * type BoolResult = If<boolean, 'yes', 'no'> // boolean
  * ```
  */
-export type If<Condition extends boolean, Yes, No = never> = [Condition] extends [never] ? never : Condition extends true ? Yes : No;
+export type If<Condition extends boolean, Yes, No = never> = Condition extends true ? Yes : No;
 /**
- * Conditional type - returns `T` if condition `C` is false, otherwise returns `F`
+ * Conditional type - returns `Yes` if condition `Condition` is false, otherwise returns `No`
+ *
+ * @template Condition - The boolean condition to check
+ * @template Yes - The type to return if condition is false
+ * @template No - The type to return if condition is true (defaults to `never`)
  *
  * ### Result
  *
- * - `never`: if `C` is `never`
- * - `Yes`: if `C` is `false`
- * - `No`: if `C` is `true`
+ * - `never`: if `Condition` is `never`
+ * - `Yes`: if `Condition` is `false`
+ * - `No`: if `Condition` 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
+ * type BoolResult = IfFalse<boolean, 'yes', 'no'> // boolean
  * ```
  */
-export type IfFalse<Condition extends boolean, Yes, No = never> = [Condition] extends [never] ? never : Condition extends false ? Yes : No;
+export type IfFalse<Condition extends boolean, Yes, No = never> = Condition extends false ? Yes : No;
 /**
- * Used with:
- * - {@link Switch}
- * - {@link SwitchExtends}
+ * Case tuple type used with `SwitchExact` and `SwitchExtends`
+ *
+ * @template T - The condition type to match against
+ * @template Result - The result type to return if match is found
+ *
+ * @example
+ * ```ts
+ * type MyCase = Case<1, 'one'>
+ * // Equivalent to: [1, 'one']
+ * ```
+ *
+ * @see SwitchExact
  */
 export type Case<T = unknown, Result = unknown> = [T, Result];
 /**
- * Used with:
+ * Default case type used with `SwitchExact` and `SwitchExtends`
  *
- * - {@link Switch}
- * - {@link SwitchExtends}
+ * @template T - The default result type
  *
  * @example
  * ```ts
- * type NameMap<id> = Switch<id, [
- *   Case<1, 'Alice'>,
- *   Case<2, 'Bob'>,
- *   Case<3, 'Charlie'>,
+ * type NameMap<id> = SwitchExact<id, [
+ *   [1, 'Alice'],
+ *   [2, 'Bob'],
  * ], DefaultCase<'Steve'>>
  * ```
+ *
+ * @see SwitchExact
  */
 export type DefaultCase<T> = T;
 /**
+ * Switch type that uses exact matching logic
+ *
+ * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.
+ *
+ * @template T - The type to match against cases
+ * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]
+ * @template Default - Default result if no exact match is found (defaults to `never`)
+ *
  * @example
  * ```ts
- * type Result = Switch<2, [
- *   Case<1, 'Alice'>,
- *   Case<2, 'Bob'>,
- *   Case<3, 'Charlie'>,
+ * type Result = SwitchExact<2, [
+ *   [1, 'Alice'],
+ *   [2, 'Bob'],
+ *   [3, 'Charlie'],
  * ], DefaultCase<'Steve'>>
  *
  * // Result: 'Bob'
  * ```
  */
-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;
+export type SwitchExact<T, Cases extends readonly [unknown, unknown][], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer Condition, infer Result] ? (Exact<T, Condition> extends true ? Result : (SwitchExact<T, Rest extends readonly [unknown, unknown][] ? Rest : never, Default>)) : (never)) : Default;
 /**
  * Switch type that uses 'extends' logic instead of 'Exact' logic
  *
- * @example ```ts
- * type Result = SwitchExtends<string | number, [
- *   Case<string, 'string type'>,
- *   Case<number, 'number type'>,
- * ], 'other'>
- * // Result: 'string type' | 'number type'
+ * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.
+ *
+ * @template T - The type to match against cases
+ * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]
+ * @template Default - Default result if no match is found (defaults to `never`)
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<
+ *   SwitchExtends<string, [
+ *     [number, boolean],
+ *     [string, boolean],
+ *   ], Error>
+ * >().toBe<boolean>().success
  * ```
  */
-export type SwitchExtends<T, Cases extends readonly Case[], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer C, infer R] ? ([T] extends [C] ? R : SwitchExtends<T, Rest extends readonly Case[] ? Rest : never, Default>) : never) : Default;
+export type SwitchExtends<T, Cases extends readonly [unknown, unknown][], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer C, infer R] ? ([T] extends [C] ? R : SwitchExtends<T, Rest extends readonly [unknown, unknown][] ? Rest : never, Default>) : never) : Default;
 //# sourceMappingURL=control.d.ts.map

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,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"}
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,KAAK,IAAI,SAAS,SAAS,IAAI,GAAG,GAAG,GAAG,EAAE,CAAA;AAE9F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,OAAO,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,KAAK,IAAI,SAAS,SAAS,KAAK,GAAG,GAAG,GAAG,EAAE,CAAA;AAEpG;;;;;;;;;;;;;GAaG;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;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,EACD,KAAK,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAC3C,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,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,MAAM,GACpF,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GACvF,CAAC,KAAK,CAAC,CACZ,GACC,OAAO,CAAA;AAEX;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,EACD,KAAK,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAC3C,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,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,GAC5G,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 { 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"]}
+{"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 `Yes` if condition `Condition` is true, otherwise returns `No`\n *\n * @template Condition - The boolean condition to check\n * @template Yes - The type to return if condition is true\n * @template No - The type to return if condition is false (defaults to `never`)\n *\n * @example\n * ```ts\n * type Result = If<true, 'yes', 'no'> // 'yes'\n * type Result2 = If<false, 'yes', 'no'> // 'no'\n * type BoolResult = If<boolean, 'yes', 'no'> // boolean\n * ```\n */\nexport type If<Condition extends boolean, Yes, No = never> = Condition extends true ? Yes : No\n\n/**\n * Conditional type - returns `Yes` if condition `Condition` is false, otherwise returns `No`\n *\n * @template Condition - The boolean condition to check\n * @template Yes - The type to return if condition is false\n * @template No - The type to return if condition is true (defaults to `never`)\n *\n * ### Result\n *\n * - `never`: if `Condition` is `never`\n * - `Yes`: if `Condition` is `false`\n * - `No`: if `Condition` 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 BoolResult = IfFalse<boolean, 'yes', 'no'> // boolean\n * ```\n */\nexport type IfFalse<Condition extends boolean, Yes, No = never> = Condition extends false ? Yes : No\n\n/**\n * Case tuple type used with `SwitchExact` and `SwitchExtends`\n *\n * @template T - The condition type to match against\n * @template Result - The result type to return if match is found\n *\n * @example\n * ```ts\n * type MyCase = Case<1, 'one'>\n * // Equivalent to: [1, 'one']\n * ```\n *\n * @see SwitchExact\n */\nexport type Case<T = unknown, Result = unknown> = [T, Result]\n\n/**\n * Default case type used with `SwitchExact` and `SwitchExtends`\n *\n * @template T - The default result type\n *\n * @example\n * ```ts\n * type NameMap<id> = SwitchExact<id, [\n *   [1, 'Alice'],\n *   [2, 'Bob'],\n * ], DefaultCase<'Steve'>>\n * ```\n *\n * @see SwitchExact\n */\nexport type DefaultCase<T> = T\n\n/**\n * Switch type that uses exact matching logic\n *\n * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.\n *\n * @template T - The type to match against cases\n * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]\n * @template Default - Default result if no exact match is found (defaults to `never`)\n *\n * @example\n * ```ts\n * type Result = SwitchExact<2, [\n *   [1, 'Alice'],\n *   [2, 'Bob'],\n *   [3, 'Charlie'],\n * ], DefaultCase<'Steve'>>\n *\n * // Result: 'Bob'\n * ```\n */\nexport type SwitchExact<\n  T,\n  Cases extends readonly [unknown, unknown][],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer Condition, infer Result] ? (Exact<T, Condition> extends true ? Result\n        : (SwitchExact<T, Rest extends readonly [unknown, unknown][] ? Rest : never, Default>))\n      : (never)\n  )\n  : Default\n\n/**\n * Switch type that uses 'extends' logic instead of 'Exact' logic\n *\n * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.\n *\n * @template T - The type to match against cases\n * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]\n * @template Default - Default result if no match is found (defaults to `never`)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<\n *   SwitchExtends<string, [\n *     [number, boolean],\n *     [string, boolean],\n *   ], Error>\n * >().toBe<boolean>().success\n * ```\n */\nexport type SwitchExtends<\n  T,\n  Cases extends readonly [unknown, unknown][],\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 [unknown, unknown][] ? Rest : never, Default>)\n      : never\n  )\n  : Default\n"]}

package/esm/main/doc.d.ts

@@ -1,30 +1,56 @@
 /**
- * Append documentation or auxiliary metadata to type `A`
+ * Append documentation or auxiliary metadata to type `T`
  * without changing its shape.
  *
- * This type intersects `Doc` onto `A`, but only keeps the keys
- * originally defined in `A`. As a result:
+ * This type intersects `Doc` onto `T`, but only keeps the keys
+ * originally defined in `T`. As a result:
  *
  * - `Doc` cannot introduce new properties
- * - Existing properties in `A` are preserved
+ * - Existing properties in `T` are preserved
  * - `Doc` may further constrain or annotate existing properties
  *
  * This is typically used to attach JSDoc comments, branding,
  * or editor-only metadata to an existing type while keeping
  * its public structure intact.
+ *
+ * @template T - The target type to append documentation to
+ * @template Doc - The documentation or metadata type to append
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * type User = { name: string; age: number }
+ * type UserWithDoc = AppendDoc<User, { name: string }>
+ *
+ * expect<UserWithDoc>().toBe<User>().success
+ * ```
  */
 export type AppendDoc<T, Doc> = Pick<T & Doc, keyof T>;
 /**
- * Prepend documentation or auxiliary metadata to type `A`
+ * Prepend documentation or auxiliary metadata to type `T`
  * without changing its shape.
  *
  * This is similar to {@link AppendDoc}, but the intersection order
- * is reversed (`Doc & A`), which can affect how property types,
+ * is reversed (`Doc & T`), which can affect how property types,
  * documentation, and hover information are presented by tooling.
  *
  * In practice, this allows `Doc` to act as a non-invasive,
- * descriptive layer while ensuring `A` remains the authoritative
+ * descriptive layer while ensuring `T` remains the authoritative
  * source of truth for property types.
+ *
+ * @template T - The target type to prepend documentation to
+ * @template Doc - The documentation or metadata type to prepend
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * type User = { name: string; age: number }
+ * type UserWithDoc = PrependDoc<User, { age: number }>
+ *
+ * expect<UserWithDoc>().toBe<User>().success
+ * ```
  */
 export type PrependDoc<T, Doc> = Pick<Doc & T, keyof T>;
 //# sourceMappingURL=doc.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/main/doc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,GAAG,IAAI,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,CAAC,CAAC,CAAA;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA"}
+{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/main/doc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,GAAG,IAAI,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,CAAC,CAAC,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA"}

package/esm/main/doc.js.map

@@ -1 +1 @@
-{"version":3,"file":"doc.js","sourceRoot":"","sources":["../../src/main/doc.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Append documentation or auxiliary metadata to type `A`\n * without changing its shape.\n *\n * This type intersects `Doc` onto `A`, but only keeps the keys\n * originally defined in `A`. As a result:\n *\n * - `Doc` cannot introduce new properties\n * - Existing properties in `A` are preserved\n * - `Doc` may further constrain or annotate existing properties\n *\n * This is typically used to attach JSDoc comments, branding,\n * or editor-only metadata to an existing type while keeping\n * its public structure intact.\n */\nexport type AppendDoc<T, Doc> = Pick<T & Doc, keyof T>\n\n/**\n * Prepend documentation or auxiliary metadata to type `A`\n * without changing its shape.\n *\n * This is similar to {@link AppendDoc}, but the intersection order\n * is reversed (`Doc & A`), which can affect how property types,\n * documentation, and hover information are presented by tooling.\n *\n * In practice, this allows `Doc` to act as a non-invasive,\n * descriptive layer while ensuring `A` remains the authoritative\n * source of truth for property types.\n */\nexport type PrependDoc<T, Doc> = Pick<Doc & T, keyof T>\n"]}
+{"version":3,"file":"doc.js","sourceRoot":"","sources":["../../src/main/doc.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Append documentation or auxiliary metadata to type `T`\n * without changing its shape.\n *\n * This type intersects `Doc` onto `T`, but only keeps the keys\n * originally defined in `T`. As a result:\n *\n * - `Doc` cannot introduce new properties\n * - Existing properties in `T` are preserved\n * - `Doc` may further constrain or annotate existing properties\n *\n * This is typically used to attach JSDoc comments, branding,\n * or editor-only metadata to an existing type while keeping\n * its public structure intact.\n *\n * @template T - The target type to append documentation to\n * @template Doc - The documentation or metadata type to append\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * type User = { name: string; age: number }\n * type UserWithDoc = AppendDoc<User, { name: string }>\n *\n * expect<UserWithDoc>().toBe<User>().success\n * ```\n */\nexport type AppendDoc<T, Doc> = Pick<T & Doc, keyof T>\n\n/**\n * Prepend documentation or auxiliary metadata to type `T`\n * without changing its shape.\n *\n * This is similar to {@link AppendDoc}, but the intersection order\n * is reversed (`Doc & T`), which can affect how property types,\n * documentation, and hover information are presented by tooling.\n *\n * In practice, this allows `Doc` to act as a non-invasive,\n * descriptive layer while ensuring `T` remains the authoritative\n * source of truth for property types.\n *\n * @template T - The target type to prepend documentation to\n * @template Doc - The documentation or metadata type to prepend\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * type User = { name: string; age: number }\n * type UserWithDoc = PrependDoc<User, { age: number }>\n *\n * expect<UserWithDoc>().toBe<User>().success\n * ```\n */\nexport type PrependDoc<T, Doc> = Pick<Doc & T, keyof T>\n"]}

package/esm/main/function.d.ts

@@ -1,18 +1,26 @@
 /**
  * Represents a function with any parameters and a specific return type
  *
+ * @template Return - The return type of the function
+ * @template Params - The parameters of the function as a tuple type
+ *
  * @example
  * ```ts
- * type _ = AnyFunction<string, [number]> // (arg: number) => string
+ * type NumberToStringFn = AnyFunction<string, [number]>
+ * // Equivalent to: (arg: number) => string
  * ```
  */
 export type AnyFunction<Return = any, Params extends any[] = any[]> = (...args: Params) => Return;
 /**
- * Represents a constructor with any parameters and a specific return type
+ * Represents a constructor function with any parameters and a specific return type
+ *
+ * @template Return - The type returned by the constructor function
+ * @template Params - The parameters of the constructor function as a tuple type
  *
  * @example
  * ```ts
- * type _ = Constructor<string, [number]> // new (arg: number) => string
+ * type StringConstructor = Constructor<string, [number]>
+ * // Equivalent to: new (arg: number) => string
  * ```
  */
 export type Constructor<Return = any, Params extends any[] = any[]> = new (...args: Params) => Return;

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;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;;;;;;;;;;;GAWG;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

@@ -1,3 +1,2 @@
-// deno-lint-ignore-file no-explicit-any
 export {};
 //# sourceMappingURL=function.js.map

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 * @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"]}
+{"version":3,"file":"function.js","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents a function with any parameters and a specific return type\n *\n * @template Return - The return type of the function\n * @template Params - The parameters of the function as a tuple type\n *\n * @example\n * ```ts\n * type NumberToStringFn = AnyFunction<string, [number]>\n * // Equivalent to: (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 function with any parameters and a specific return type\n *\n * @template Return - The type returned by the constructor function\n * @template Params - The parameters of the constructor function as a tuple type\n *\n * @example\n * ```ts\n * type StringConstructor = Constructor<string, [number]>\n * // Equivalent to: 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,3 +1,8 @@
+/**
+ * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
+ *
+ * @module
+ */
 export * from './async.js';
 export * from './boolean.js';
 export * from './control.js';

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,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,3 +1,8 @@
+/**
+ * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
+ *
+ * @module
+ */
 // Index start >>>>>>>>>>>>>>>>
 export * from './async.js';
 export * from './boolean.js';

package/esm/main/index.js.map

@@ -1 +1 @@
-{"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"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,+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":["/**\n * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)\n *\n * @module\n */\n\n// 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"]}