lay-sing 0.2.1 → 0.3.0

package/README.md

@@ -32,7 +32,7 @@ npm i -D lay-sing
 ```
 
 ```ts
-import { expect } from 'lay-sing/test-utils'
+import { expect } from 'lay-sing'
 ```
 
 </details>
@@ -47,7 +47,7 @@ deno add npm:lay-sing
 ```
 
 ```ts
-import { expect } from 'lay-sing/test-utils'
+import { expect } from 'lay-sing'
 ```
 
 ### From JSR
@@ -59,14 +59,14 @@ deno add @leawind/lay-sing
 ```
 
 ```ts
-import { expect } from '@leawind/lay-sing/test-utils'
+import { expect } from '@leawind/lay-sing'
 ```
 
 ### 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'
+import { expect } from 'https://raw.githubusercontent.com/Leawind/lay-sing/refs/heads/main/src/main/index.ts'
+import { Exact } from 'https://raw.githubusercontent.com/Leawind/lay-sing/refs/heads/main/src/utils/index.ts'
 ```
 
 </details>
@@ -75,13 +75,11 @@ import { Exact } from 'https://raw.githubusercontent.com/Leawind/lay-sing/refs/h
 
 ## Usage
 
-### Testing Utilities
-
 ```ts
-import { expect } from 'lay-sing/test-utils'
+import { expect } from 'lay-sing'
 ```
 
-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.
+The main 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/~/NOOP) value that safely supports almost any property access or method call.
 
 A typical type test statement follows this pattern:
 
@@ -148,15 +146,18 @@ await NOOP // Does not await (not thenable)
 
 ### Type Tools
 
-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.
+It provides some utility types organized into categories for common type-level programming tasks. These can be imported from the `lay-sing/utils` entry point.
 
 ```ts
-import type { Exact } from 'lay-sing'
+import type { Exact, Extends, Overlap } from 'lay-sing/utils'
 ```
 
 ### Examples
 
 ```typescript
+// Import the utility types
+import type { ConcatTuple, Exact, If, KeysOfBaseType } from '@leawind/lay-sing/utils'
+
 // Test if exactly the same
 type False = Exact<{ a: 1 }, { a?: 1 }> // false
 type Yes = Exact<boolean, true | false, 'yes', 'no'> // 'yes'
@@ -164,15 +165,10 @@ type Yes = Exact<boolean, true | false, 'yes', 'no'> // 'yes'
 // Conditional Types
 type Result = If<true, 'yes', 'no'> // 'yes'
 
-// Boolean Logic
-type IsTrue = And<true, true> // true
+type FailResult = If<Exact<number, string>, 'yes', 'no'> // 'no'
 
 // Tuple Manipulation
 type Combined = ConcatTuple<[1, 2], [3, 4]> // [1, 2, 3, 4]
 
-// Object Utilities
-type PartialObj = DeepPartial<{ a: string; nested: { b: number } }>
-// { a?: string; nested?: { b?: number } }
+type UniqueCombined = ConcatUniqueTuple<[1, 2], [2, 3]> // [1, 2, 3]
 ```
-
-[Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)

package/esm/{test-utils → main}/expect.d.ts

@@ -1,4 +1,4 @@
-import type { Exact, Extends, If, IfTupleIncludes, MutuallyAssignable, ProperExtend, SafePick } from '../main/index.js';
+import type { Exact, Extends, If, IfTupleIncludes, MutuallyAssignable, ProperExtend, SafePick } from '../utils/index.js';
 /**
  * Represents the result of a type assertion based on a boolean condition.
  *
@@ -32,7 +32,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      *
      * @example
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<any>().toBe<any>().success
      * expect<never>().toBe<never>().success
@@ -40,6 +40,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      * ```
      */
     toBe<U>(): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>;
+    toBe<U>(_: U): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>;
     /**
      * Tests if the current type is mutually assignable with the provided type U.
      *
@@ -53,13 +54,14 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      *
      * @example
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<{ a: 1; b: 2 }>().toEqual<{ a: 1 } & { b: 2 }>().success
      * expect<1>().toEqual<1 | 2>().fail
      * ```
      */
     toEqual<U>(): TypeAssertionResult<MutuallyAssignable<T, U>, ExpectType<T, H>>;
+    toEqual<U>(_: U): TypeAssertionResult<MutuallyAssignable<T, U>, ExpectType<T, H>>;
     /**
      * Tests if the current type T extends the provided type U.
      *
@@ -67,7 +69,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      *
      * @example
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<3.14>().toExtend<number>().success
      * expect<2>().toExtend<string>().fail
@@ -75,6 +77,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      * ```
      */
     toExtend<U>(): TypeAssertionResult<Extends<T, U>, ExpectType<T, H>>;
+    toExtend<U>(_: U): TypeAssertionResult<Extends<T, U>, ExpectType<T, H>>;
     /**
      * Tests if the current type T properly extends the provided type U (extends but is not the same).
      *
@@ -82,7 +85,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      *
      * @example
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<2>().toProperExtend<number>().success
      * expect<'a' | 'b'>().toProperExtend<string>().success
@@ -90,6 +93,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      * ```
      */
     toProperExtend<U>(): TypeAssertionResult<ProperExtend<T, U>, ExpectType<T, H>>;
+    toProperExtend<U>(_: U): TypeAssertionResult<ProperExtend<T, U>, ExpectType<T, H>>;
     /**
      * Tests if the current type `T` has a property with key `K`.
      *
@@ -103,7 +107,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      * ### Examples
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * type WithProp = { prop: string; another: number; may?: 5 }
      *
@@ -120,7 +124,18 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
         never,
         any
     ], K, never, TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>>;
+    toHaveKey<K extends PropertyKey>(_: K): IfTupleIncludes<[
+        never,
+        any
+    ], K, never, TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>>;
 };
+type ExpectFunction<T, H extends PropertyKey = never> = Exact<T, any> extends true ? unknown : Exact<T, never> extends true ? unknown : [T] extends [(...args: infer Args) => infer R] ? {
+    argsType(): ExpectType<Args, H>;
+    returnType(): ExpectType<R, H>;
+} : [T] extends [new (...args: infer Args) => infer R] ? {
+    argsType(): ExpectType<Args, H>;
+    returnType(): ExpectType<R, H>;
+} : unknown;
 /**
  * Type-level testing utility that allows checking various relationships between types.
  * Provides methods to test type equality, extension, properties, and more.
@@ -130,7 +145,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
  *
  * @example
  * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
+ * import { expect } from '@leawind/lay-sing'
  *
  * // Test if two types are identical
  * expect<number>().toBe<number>().success
@@ -142,7 +157,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
  * expect<{name: string}>().toHaveKey<'name'>().success
  * ```
  */
-export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMethods<T, H> & {
+export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMethods<T, H> & ExpectFunction<T, H> & {
     T: T;
     inspect: {
         [K in keyof T]: T[K];
@@ -154,7 +169,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      *
      * @example
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<3.14>().toExtendNumber
      * ```
@@ -166,7 +181,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      *
      * @example
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<'hello'>().toExtendString
      * ```
@@ -178,7 +193,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      *
      * @example
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<true>().toExtendBoolean
      * ```
@@ -189,7 +204,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = any`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<any>().toBeAny
      * expect<any>().toBe<any>().success
@@ -200,7 +215,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = never`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<never>().toBeNever
      * expect<never>().toBe<never>().success
@@ -211,7 +226,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = unknown`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<unknown>().toBeUnknown
      * expect<unknown>().toBe<unknown>().success
@@ -222,7 +237,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = void`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<void>().toBeVoid
      * expect<void>().toBe<void>().success
@@ -233,7 +248,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = null`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<null>().toBeNull
      * expect<null>().toBe<null>().success
@@ -244,7 +259,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = undefined`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<undefined>().toBeUndefined
      * expect<undefined>().toBe<undefined>().success
@@ -255,7 +270,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = true`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<true>().toBeTrue
      * expect<true>().toBe<true>().success
@@ -266,7 +281,7 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = false`
      *
      * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
+     * import { expect } from '@leawind/lay-sing'
      *
      * expect<false>().toBeFalse
      * expect<false>().toBe<false>().success

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

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

package/esm/main/expect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.js","sourceRoot":"","sources":["../../src/main/expect.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  Exact,\n  Extends,\n  If,\n  IfTupleIncludes,\n  MutuallyAssignable,\n  ProperExtend,\n  SafePick,\n} from '../utils/index.js'\n\n/**\n * Represents the result of a type assertion based on a boolean condition.\n *\n * - If `true`, the result has a `success` property;\n * - If `false`, the result has a `fail` property;\n * - Otherwise, the result is `never`\n *\n * @template B The boolean condition result (true or false)\n * @template R The type of the result value (default is void)\n */\nexport type TypeAssertionResult<B extends boolean, R = void> = Exact<B, never> extends true ? never\n  : [boolean] extends [B] ? never\n  : [B] extends [true] ? {\n      /**\n       * This field exist only when this type assertion succeed\n       *\n       * If you expect this assertion to fail, use `.fail`\n       */\n      success: R\n    }\n  : [B] extends [false] ? {\n      /**\n       * This field exist only when this type assertion failed\n       *\n       * If you expect this assertion to success, use `.success`\n       */\n      fail: R\n    }\n  : never\n\ntype ExpectTypeMethods<T, H extends PropertyKey = never> = {\n  /**\n   * Tests if the current type is exactly the same as the provided type U.\n   *\n   * @template U The type to compare with\n   *\n   * @example\n   * ```ts\n   * import { expect } from '@leawind/lay-sing'\n   *\n   * expect<any>().toBe<any>().success\n   * expect<never>().toBe<never>().success\n   * expect<false>().toBe<true>().fail\n   * ```\n   */\n  toBe<U>(): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>\n  toBe<U>(_: U): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>\n\n  /**\n   * Tests if the current type is mutually assignable with the provided type U.\n   *\n   * It's like:\n   *\n   * ```ts ignore\n   * [T] extends [U] ? [U] extends [T] ? Yes : No : No\n   * ```\n   *\n   * @template U The type to compare with\n   *\n   * @example\n   * ```ts\n   * import { expect } from '@leawind/lay-sing'\n   *\n   * expect<{ a: 1; b: 2 }>().toEqual<{ a: 1 } & { b: 2 }>().success\n   * expect<1>().toEqual<1 | 2>().fail\n   * ```\n   */\n  toEqual<U>(): TypeAssertionResult<MutuallyAssignable<T, U>, ExpectType<T, H>>\n  toEqual<U>(_: U): TypeAssertionResult<MutuallyAssignable<T, U>, ExpectType<T, H>>\n\n  /**\n   * Tests if the current type T extends the provided type U.\n   *\n   * @template U The type to check extension against\n   *\n   * @example\n   * ```ts\n   * import { expect } from '@leawind/lay-sing'\n   *\n   * expect<3.14>().toExtend<number>().success\n   * expect<2>().toExtend<string>().fail\n   * expect<'hello'>().toExtend<string>().success\n   * ```\n   */\n  toExtend<U>(): TypeAssertionResult<Extends<T, U>, ExpectType<T, H>>\n  toExtend<U>(_: U): TypeAssertionResult<Extends<T, U>, ExpectType<T, H>>\n\n  /**\n   * Tests if the current type T properly extends the provided type U (extends but is not the same).\n   *\n   * @template U The type to check proper extension against\n   *\n   * @example\n   * ```ts\n   * import { expect } from '@leawind/lay-sing'\n   *\n   * expect<2>().toProperExtend<number>().success\n   * expect<'a' | 'b'>().toProperExtend<string>().success\n   * expect<number>().toProperExtend<number>().fail\n   * ```\n   */\n  toProperExtend<U>(): TypeAssertionResult<ProperExtend<T, U>, ExpectType<T, H>>\n  toProperExtend<U>(_: U): TypeAssertionResult<ProperExtend<T, U>, ExpectType<T, H>>\n\n  /**\n   * Tests if the current type `T` has a property with key `K`.\n   *\n   * @template K The property key to check for\n   *\n   * ### Behavior\n   *\n   * - For single keys: succeeds if the key exists in `T`\n   * - For union types: succeeds only if **all** keys in the union exist in `T`\n   *\n   * ### Examples\n   *\n   * ```ts\n   * import { expect } from '@leawind/lay-sing'\n   *\n   * type WithProp = { prop: string; another: number; may?: 5 }\n   *\n   * // Single key checks\n   * expect<WithProp>().toHaveKey<'prop'>().success\n   * expect<WithProp>().toHaveKey<'missing'>().fail\n   *\n   * // Union type checks\n   * expect<WithProp>().toHaveKey<'prop' | 'another'>().success\n   * expect<WithProp>().toHaveKey<'may' | 'unexist'>().fail\n   * ```\n   */\n  toHaveKey<K extends PropertyKey>(): IfTupleIncludes<\n    [never, any],\n    K,\n    never,\n    TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>\n  >\n  toHaveKey<K extends PropertyKey>(_: K): IfTupleIncludes<\n    [never, any],\n    K,\n    never,\n    TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>\n  >\n}\n\ntype ExpectFunction<T, H extends PropertyKey = never> = Exact<T, any> extends true ? unknown\n  : Exact<T, never> extends true ? unknown\n  : [T] extends [(...args: infer Args) => infer R] ? {\n      argsType(): ExpectType<Args, H>\n      returnType(): ExpectType<R, H>\n    }\n  : [T] extends [new (...args: infer Args) => infer R] ? {\n      argsType(): ExpectType<Args, H>\n      returnType(): ExpectType<R, H>\n    }\n  : unknown\n\n/**\n * Type-level testing utility that allows checking various relationships between types.\n * Provides methods to test type equality, extension, properties, and more.\n *\n * @template T The type being tested\n * @template H Hidden property keys that are already used (internal tracking)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * // Test if two types are identical\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<2>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * // Test if type has a specific property\n * expect<{name: string}>().toHaveKey<'name'>().success\n * ```\n */\nexport type ExpectType<T, H extends PropertyKey = never> = Omit<\n  (\n    & ExpectTypeMethods<T, H>\n    & ExpectFunction<T, H>\n    & {\n      T: T\n      inspect: { [K in keyof T]: T[K] }\n    }\n    & SafePick<\n      {\n        /**\n         * Tests if the current type extends the Number primitive type.\n         * Available only if the current type extends number.\n         *\n         * @example\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<3.14>().toExtendNumber\n         * ```\n         */\n        toExtendNumber: ExpectType<T, H | 'toExtendNumber' | 'toExtend'>\n\n        /**\n         * Tests if the current type extends the String primitive type.\n         * Available only if the current type extends string.\n         *\n         * @example\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<'hello'>().toExtendString\n         * ```\n         */\n        toExtendString: ExpectType<T, H | 'toExtendString' | 'toExtend'>\n\n        /**\n         * Tests if the current type extends the Boolean primitive type.\n         * Available only if the current type extends boolean.\n         *\n         * @example\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<true>().toExtendBoolean\n         * ```\n         */\n        toExtendBoolean: ExpectType<T, H | 'toExtendBoolean' | 'toExtend'>\n      },\n      | If<Extends<T, number>, 'toExtendNumber'>\n      | If<Extends<T, string>, 'toExtendString'>\n      | If<Extends<T, boolean>, 'toExtendBoolean'>\n    >\n    & SafePick<\n      {\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = any`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<any>().toBeAny\n         * expect<any>().toBe<any>().success\n         * ```\n         */\n        toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>\n\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = never`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<never>().toBeNever\n         * expect<never>().toBe<never>().success\n         * ```\n         */\n        toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>\n\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = unknown`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<unknown>().toBeUnknown\n         * expect<unknown>().toBe<unknown>().success\n         * ```\n         */\n        toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>\n\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = void`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<void>().toBeVoid\n         * expect<void>().toBe<void>().success\n         * ```\n         */\n        toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>\n\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = null`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<null>().toBeNull\n         * expect<null>().toBe<null>().success\n         * ```\n         */\n        toBeNull: ExpectType<T, H | 'toBeNull' | 'toBe'>\n\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = undefined`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<undefined>().toBeUndefined\n         * expect<undefined>().toBe<undefined>().success\n         * ```\n         */\n        toBeUndefined: ExpectType<T, H | 'toBeUndefined' | 'toBe'>\n\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = true`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<true>().toBeTrue\n         * expect<true>().toBe<true>().success\n         * ```\n         */\n        toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>\n\n        /**\n         * Alias for {@link ExpectTypeMethods.toBe} where `U = false`\n         *\n         * ```ts\n         * import { expect } from '@leawind/lay-sing'\n         *\n         * expect<false>().toBeFalse\n         * expect<false>().toBe<false>().success\n         * ```\n         */\n        toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>\n      },\n      | If<Exact<T, any>, 'toBeAny'>\n      | If<Exact<T, never>, 'toBeNever'>\n      | If<Exact<T, unknown>, 'toBeUnknown'>\n      | If<Exact<T, void>, 'toBeVoid'>\n      | If<Exact<T, null>, 'toBeNull'>\n      | If<Exact<T, undefined>, 'toBeUndefined'>\n      | If<Exact<T, true>, 'toBeTrue'>\n      | If<Exact<T, false>, 'toBeFalse'>\n    >\n  ),\n  H\n>\n"]}

package/esm/main/index.d.ts

@@ -3,15 +3,28 @@
  *
  * @module
  */
-export * from './async.js';
-export * from './boolean.js';
-export * from './control.js';
-export * from './doc.js';
-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';
+import type { ExpectType } from './expect.js';
+export type { ExpectType } from './expect.js';
+export { NOOP } from './noop.js';
+/**
+ * Creates an instance of ExpectType to perform type-level assertions on the given type.
+ * This function enables testing various type relationships at compile time.
+ * NOTE: This function does nothing at runtime and is purely for type-level testing.
+ *
+ * @template T The type to be tested
+ *
+ * @returns An ExpectType instance with methods to test type relationships
+ *
+ * @example
+ * ```ts
+ * // Test exact type equality
+ * expect<number>().toBe<number>().success
+ * expect<number>().toBe<string>().fail
+ * // Test if one type extends another
+ * expect<3.14>().toExtend<number>().success
+ * expect<2>().toExtend<string>().fail
+ * ```
+ */
+export declare function expect<T>(): ExpectType<T>;
+export declare function expect<T>(_: T): ExpectType<T>;
 //# 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;;;;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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA;AAC1C,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA"}

package/esm/main/index.js

@@ -3,17 +3,9 @@
  *
  * @module
  */
-// Index start >>>>>>>>>>>>>>>>
-export * from './async.js';
-export * from './boolean.js';
-export * from './control.js';
-export * from './doc.js';
-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
+import { NOOP } from './noop.js';
+export { NOOP } from './noop.js';
+export function expect() {
+    return NOOP;
+}
 //# 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;;;;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"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAuBhC,MAAM,UAAU,MAAM;IACpB,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["/**\n * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)\n *\n * @module\n */\n\nimport type { ExpectType } from './expect.js'\nimport { NOOP } from './noop.js'\n\nexport type { ExpectType } from './expect.js'\nexport { NOOP } from './noop.js'\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * @example\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\n"]}

package/esm/main/noop.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A universal no-op placeholder implemented via `Proxy`.
+ *
+ * `NOOP` can be accessed, called, or chained indefinitely without throwing.
+ * Every operation returns itself, making it safe to use as a dummy fallback
+ * for APIs, optional hooks, or unimplemented interfaces.
+ *
+ * ### Special behaviors
+ *
+ * - Callable: invoking `NOOP()` returns `NOOP`
+ * - Property access: `NOOP.anything` returns `NOOP`
+ * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise
+ * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields
+ *   a stable string representation: `"[NOOP]"`
+ *
+ * This is useful in scenarios where a value is required syntactically but
+ * should perform no action and never fail at runtime.
+ *
+ * @example
+ * ```ts
+ * NOOP.foo.bar().baz.qux; // safe, returns NOOP
+ * String(NOOP); // "[NOOP]"
+ * await NOOP; // does not await (not thenable)
+ * ```
+ */
+export declare const NOOP: any;
+//# sourceMappingURL=noop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../../src/main/noop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,IAAI,EAAE,GA0BlB,CAAA"}

package/esm/{test-utils/index.js → main/noop.js}

@@ -1,8 +1,3 @@
-/**
- * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
- *
- * @module
- */
 /**
  * A universal no-op placeholder implemented via `Proxy`.
  *
@@ -52,10 +47,4 @@ export const NOOP = new Proxy(function () {
     has: () => true,
     ownKeys: () => ['prototype'],
 });
-export function compare() {
-    return NOOP;
-}
-export function expect() {
-    return NOOP;
-}
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=noop.js.map

package/esm/main/noop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.js","sourceRoot":"","sources":["../../src/main/noop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,IAAI,CAAA;AACb,CAAC,EACD;IACE,GAAG,CAAC,CAAC,EAAE,IAAI;QACT,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,OAAO,SAAS,CAAA;YAClB,KAAK,SAAS,CAAC;YACf,KAAK,UAAU,CAAC;YAChB,KAAK,MAAM,CAAC,WAAW;gBACrB,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAA;YACvB;gBACE,OAAO,IAAI,CAAA;QACf,CAAC;IACH,CAAC;IACD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,wBAAwB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC/B,YAAY,EAAE,IAAI;QAClB,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI;IAC1B,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW,CAAC;CAC7B,CACF,CAAA","sourcesContent":["/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * @example\n * ```ts\n * NOOP.foo.bar().baz.qux; // safe, returns NOOP\n * String(NOOP); // \"[NOOP]\"\n * await NOOP; // does not await (not thenable)\n * ```\n */\nexport const NOOP: any = new Proxy(\n  function () {\n    return NOOP\n  },\n  {\n    get(_, prop) {\n      switch (prop) {\n        case 'then':\n          return undefined\n        case 'valueOf':\n        case 'toString':\n        case Symbol.toPrimitive:\n          return () => '[NOOP]'\n        default:\n          return NOOP\n      }\n    },\n    set: () => true,\n    getOwnPropertyDescriptor: () => ({\n      configurable: true,\n      value: NOOP,\n    }),\n    getPrototypeOf: () => null,\n    has: () => true,\n    ownKeys: () => ['prototype'],\n  },\n)\n"]}

package/esm/utils/compare/assignable.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Checks whether two types are mutually assignable.
+ *
+ * This is equivalent to checking that:
+ * - `A` extends `B`
+ * - `B` extends `A`
+ *
+ * In other words, the two types describe the same set of values,
+ * even if they are written differently.
+ *
+ * @template A - The first type to check
+ * @template B - The second type to check
+ * @template Yes - The result if types are mutually assignable (defaults to `true`)
+ * @template No - The result if types are not mutually assignable (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` and `B` are mutually assignable
+ * - `No`: Otherwise
+ *
+ * @example
+ * ```ts
+ * type T1 = MutuallyAssignable<number, number> // true
+ * type T2 = MutuallyAssignable<1 | 2, 2 | 1> // true
+ * type F1 = MutuallyAssignable<string, number> // false
+ * type F2 = MutuallyAssignable<1, number> // false
+ * ```
+ */
+export type MutuallyAssignable<A, B, Yes = true, No = false> = [A] extends [B] ? [B] extends [A] ? Yes : No : No;
+//# sourceMappingURL=assignable.d.ts.map

package/esm/utils/compare/assignable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignable.d.ts","sourceRoot":"","sources":["../../../src/utils/compare/assignable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,kBAAkB,CAC5B,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAA"}

package/esm/utils/compare/assignable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=assignable.js.map

package/esm/utils/compare/assignable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignable.js","sourceRoot":"","sources":["../../../src/utils/compare/assignable.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Checks whether two types are mutually assignable.\n *\n * This is equivalent to checking that:\n * - `A` extends `B`\n * - `B` extends `A`\n *\n * In other words, the two types describe the same set of values,\n * even if they are written differently.\n *\n * @template A - The first type to check\n * @template B - The second type to check\n * @template Yes - The result if types are mutually assignable (defaults to `true`)\n * @template No - The result if types are not mutually assignable (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` are mutually assignable\n * - `No`: Otherwise\n *\n * @example\n * ```ts\n * type T1 = MutuallyAssignable<number, number> // true\n * type T2 = MutuallyAssignable<1 | 2, 2 | 1> // true\n * type F1 = MutuallyAssignable<string, number> // false\n * type F2 = MutuallyAssignable<1, number> // false\n * ```\n */\nexport type MutuallyAssignable<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? [B] extends [A] ? Yes : No : No\n"]}

package/esm/utils/compare/exact.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Checks whether two types are exactly the same.
+ *
+ * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it does not check each member separately.
+ *
+ * @template A - The first type to compare
+ * @template B - The second type to compare
+ * @template Yes - The result if types are exactly the same (defaults to `true`)
+ * @template No - The result if types are not exactly the same (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` and `B` are exactly the same
+ * - `No`: Otherwise
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * expect<Exact<string, string>>().toBeTrue
+ * expect<Exact<never, never>>().toBeTrue
+ * expect<Exact<any, any>>().toBeTrue
+ *
+ * expect<Exact<{ a: 3 }, { a?: 3 }>>().toBeFalse
+ * expect<Exact<1 | 2, 1>>().toBeFalse
+ * expect<Exact<1, number>>().toBeFalse
+ * expect<Exact<() => void, () => undefined>>().toBeFalse
+ * ```
+ */
+export type Exact<A, B, Yes = true, No = false> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Yes : No;
+/**
+ * Checks whether two types are not exactly the same.
+ *
+ * This is the logical negation of `Exact<A, B>`.
+ *
+ * @template A - The first type to compare
+ * @template B - The second type to compare
+ * @template Yes - The result if types are not exactly the same (defaults to `true`)
+ * @template No - The result if types are exactly the same (defaults to `false`)
+ *
+ * @example
+ * ```ts
+ * type T1 = NotExact<number, string> // true
+ * type T2 = NotExact<1, number> // true
+ * type F1 = NotExact<number, number> // false
+ * type F2 = NotExact<1, 1> // false
+ * ```
+ */
+export type NotExact<A, B, Yes = true, No = false> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? No : Yes;
+//# sourceMappingURL=exact.d.ts.map

package/esm/utils/compare/exact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exact.d.ts","sourceRoot":"","sources":["../../../src/utils/compare/exact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,KAAK,CACf,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAEpF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAA"}

package/esm/utils/compare/exact.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=exact.js.map

package/esm/utils/compare/exact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exact.js","sourceRoot":"","sources":["../../../src/utils/compare/exact.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Checks whether two types are exactly the same.\n *\n * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it does not check each member separately.\n *\n * @template A - The first type to compare\n * @template B - The second type to compare\n * @template Yes - The result if types are exactly the same (defaults to `true`)\n * @template No - The result if types are not exactly the same (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` are exactly the same\n * - `No`: Otherwise\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * expect<Exact<string, string>>().toBeTrue\n * expect<Exact<never, never>>().toBeTrue\n * expect<Exact<any, any>>().toBeTrue\n *\n * expect<Exact<{ a: 3 }, { a?: 3 }>>().toBeFalse\n * expect<Exact<1 | 2, 1>>().toBeFalse\n * expect<Exact<1, number>>().toBeFalse\n * expect<Exact<() => void, () => undefined>>().toBeFalse\n * ```\n */\nexport type Exact<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Yes : No\n\n/**\n * Checks whether two types are not exactly the same.\n *\n * This is the logical negation of `Exact<A, B>`.\n *\n * @template A - The first type to compare\n * @template B - The second type to compare\n * @template Yes - The result if types are not exactly the same (defaults to `true`)\n * @template No - The result if types are exactly the same (defaults to `false`)\n *\n * @example\n * ```ts\n * type T1 = NotExact<number, string> // true\n * type T2 = NotExact<1, number> // true\n * type F1 = NotExact<number, number> // false\n * type F2 = NotExact<1, 1> // false\n * ```\n */\nexport type NotExact<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? No : Yes\n"]}

package/esm/utils/compare/extends.d.ts

@@ -0,0 +1,46 @@
+import type { Exact } from '../index.js';
+/**
+ * Checks whether type `A` extends type `B`.
+ *
+ * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it treats them as a single entity.
+ *
+ * @template A - The type to check if it extends another type
+ * @template B - The type to check if `A` extends
+ * @template Yes - The result if `A` extends `B` (defaults to `true`)
+ * @template No - The result if `A` does not extend `B` (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` is assignable to `B`
+ * - `No`: Otherwise
+ */
+export type Extends<A, B, Yes = true, No = false> = [A] extends [B] ? Yes : No;
+/**
+ * Checks whether type `A` is a *proper* subtype of type `B`.
+ *
+ * A proper extension means:
+ * - `A` extends `B`
+ * - `A` is not exactly the same type as `B`
+ *
+ * @template A - The type to check if it is a proper subtype
+ * @template B - The type to check against
+ * @template Yes - The result if `A` is a proper subtype of `B` (defaults to `true`)
+ * @template No - The result if `A` is not a proper subtype of `B` (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` is a proper subtype of `B`
+ * - `No`: Otherwise
+ *
+ * **Note:** the result will never be `boolean`.
+ *
+ * @example
+ * ```ts
+ * type T1 = ProperExtend<true, boolean> // true
+ * type T2 = ProperExtend<1, number> // true
+ * type F1 = ProperExtend<boolean, boolean> // false
+ * type F2 = ProperExtend<number, string> // false
+ * ```
+ */
+export type ProperExtend<A, B, Yes = true, No = false> = [A] extends [B] ? Exact<A, B> extends false ? Yes : No : No;
+//# sourceMappingURL=extends.d.ts.map