lay-sing 0.2.0 → 0.2.1

package/esm/main/key.d.ts

@@ -9,22 +9,23 @@ import type { Exact } from './type/index.js';
  * @template ValueType - The base type to match against property values (ignoring undefined from optional properties).
  *
  * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
  * // Basic usage: match base type (non-optional property)
  * type A = { a: 1; b: 2; c: 1 };
- * type MatchedKeys = KeysOfBaseType<A, 1>; // 'a' | 'c'
+ * expect<KeysOfBaseType<A, 1>>().toBe<'a' | 'c'>().success
  *
- * @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)
+ * expect<KeysOfBaseType<B, string>>().toBe<'a' | 'b'>().success // matches base type of both
+ * expect<KeysOfBaseType<B, string | undefined>>().toBe<never>().success // 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'
+ * expect<KeysOfBaseType<C, never>>().toBe<'a'>().success
+ * expect<KeysOfBaseType<C, any>>().toBe<'b'>().success
+ * expect<KeysOfBaseType<C, unknown>>().toBe<'c'>().success
+ * ```
  */
 export type KeysOfBaseType<Obj, ValueType> = Exclude<{
     [K in keyof Obj]: Exact<Required<Obj>[K], ValueType> extends true ? K : never;
@@ -39,22 +40,23 @@ export type KeysOfBaseType<Obj, ValueType> = Exclude<{
  * @template ValueType - The exact type to match against property values (including undefined for optional properties).
  *
  * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
  * // Basic usage: match exact type (non-optional property)
  * type A = { a: 1; b: 2; c: 1 };
- * type MatchedKeys = KeysOfExactType<A, 1>; // 'a' | 'c'
+ * expect<KeysOfExactType<A, 1>>().toBe<'a' | 'c'>().success
  *
- * @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)
+ * expect<KeysOfExactType<B, string | undefined>>().toBe<'a'>().success // matches complete type
+ * expect<KeysOfExactType<B, string>>().toBe<never>().success // does not match complete type
  *
- * @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'
+ * expect<KeysOfExactType<C, never>>().toBe<'a'>().success
+ * expect<KeysOfExactType<C, any>>().toBe<'b'>().success
+ * expect<KeysOfExactType<C, unknown>>().toBe<'c'>().success
+ * ```
  */
 export type KeysOfExactType<Obj, ValueType> = Exclude<{
     [K in keyof Obj]: Exact<Obj[K], ValueType> extends true ? K : never;

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,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"}
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;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 { 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"]}
+{"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 * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * // Basic usage: match base type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * expect<KeysOfBaseType<A, 1>>().toBe<'a' | 'c'>().success\n *\n * // Key difference: optional property matching (ignores undefined)\n * type B = { a?: string; b: string };\n * expect<KeysOfBaseType<B, string>>().toBe<'a' | 'b'>().success // matches base type of both\n * expect<KeysOfBaseType<B, string | undefined>>().toBe<never>().success // base type does not include undefined\n *\n * type C = { a: never; b: any; c: unknown };\n * expect<KeysOfBaseType<C, never>>().toBe<'a'>().success\n * expect<KeysOfBaseType<C, any>>().toBe<'b'>().success\n * expect<KeysOfBaseType<C, unknown>>().toBe<'c'>().success\n * ```\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 * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * // Basic usage: match exact type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * expect<KeysOfExactType<A, 1>>().toBe<'a' | 'c'>().success\n *\n * // Key difference: optional property matching (requires undefined in `ValueType`)\n * type B = { a?: string };\n * expect<KeysOfExactType<B, string | undefined>>().toBe<'a'>().success // matches complete type\n * expect<KeysOfExactType<B, string>>().toBe<never>().success // does not match complete type\n *\n * type C = { a: never; b: any; c: unknown };\n * expect<KeysOfExactType<C, never>>().toBe<'a'>().success\n * expect<KeysOfExactType<C, any>>().toBe<'b'>().success\n * expect<KeysOfExactType<C, unknown>>().toBe<'c'>().success\n * ```\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"]}

package/esm/main/object.d.ts

@@ -1,20 +1,39 @@
 import type { KeysOfExactType } from './key.js';
 /**
- * Access a property with key `K` in object `T`, with a fallback `E` if the property doesn't exist
+ * Get property type from object, with fallback for missing keys.
+ *
+ * @template Obj - The object type to access
+ * @template K - The key to access in the object
+ * @template E - The fallback type if the key doesn't exist (defaults to `never`)
+ *
+ * @returns `Obj[K]` if key exists, otherwise `E`.
  *
  * @example
  * ```ts
- * type Result = Access<{ a: string }, 'a'> // string
- * type Missing = Access<{ a: string }, 'x', 'default'> // 'default'
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * type User = { name: string; age?: number };
+ *
+ * expect<Access<User, 'name'>>().toBe<string>().success
+ * expect<Access<User, 'age'>>().toBe<number | undefined>().success
+ * expect<Access<User, 'email', 'none'>>().toBe<'none'>().success
  * ```
  */
 export type Access<Obj, K extends PropertyKey, E = never> = K extends keyof Obj ? Obj[K] : E;
 /**
- * Inverse of `Access`
+ * Inverse of `Access` - gets keys from an object that have values of a specific type
+ *
+ * @template T - The object type to inspect
+ * @template V - The value type to match against
+ * @template E - The fallback type if no keys match (defaults to `never`)
  *
  * @example
  * ```ts
- * type Result = InverseAccess<{ a: string }, string> // 'a'
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<InverseAccess<{ a: string }, string>>().toBe<'a'>().success
+ * expect<InverseAccess<{ a: string; b: string }, string>>().toBe<'a' | 'b'>().success
+ * expect<InverseAccess<{ a: string }, number>>().toBe<never>().success
  * ```
  */
 export type InverseAccess<T, V, E = never> = {
@@ -23,9 +42,14 @@ export type InverseAccess<T, V, E = never> = {
 /**
  * Recursively makes all properties of `T` optional
  *
+ * @template T - The object type to make deep partial
+ *
  * @example
  * ```ts
- * type Result = DeepPartial<{ a: string; nested: { b: number } }> // { a?: string; nested?: { b?: number } }
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * type Result = DeepPartial<{ a: string; nested: { b: number } }>
+ * expect<Result>().toBe<{ a?: string; nested?: { b?: number } }>().success
  * ```
  */
 export type DeepPartial<T> = {
@@ -34,22 +58,20 @@ export type DeepPartial<T> = {
 /**
  * Recursively makes all properties of `T` required
  *
+ * @template T - The object type to make deep required
+ *
  * @example
  * ```ts
- * type Result = DeepRequire<{ a?: string; nested?: { b?: number } }>
- * // { a: string; nested: { b: number } }
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<DeepRequire<{ _?: { _?: 1 } }>>().toBe<{ _: { _: 1 } }>().success
  * ```
  */
 export type DeepRequire<T> = {
-    [P in keyof T]-?: T[P] extends object ? DeepRequire<T[P]> : T[P];
+    [K in keyof T]-?: T[K] extends object | undefined ? DeepRequire<NonNullable<T[K]>> : T[K];
 };
 /**
- * A non-distributive conditional type that checks if the entire type `T`
- * (treated as a single entity) is assignable to type `U`.
- *
- * Unlike the built-in distributive version (`Extract<T, U>`), this type wraps `T` and `U` in tuples to
- * prevent distribution over union types. The entire type `T` must satisfy
- * the constraint `U` for the check to pass.
+ * **⚠️Important:** parameter `T` and `U` are not distributive. When they are union type, it treats them as a single entity.
  *
  * @template T - The type to test (not distributed over unions)
  * @template U - The constraint type to test against
@@ -57,38 +79,41 @@ export type DeepRequire<T> = {
  * @example
  *
  * ```ts
- * // Non-distributive check - entire type must satisfy constraint
- * type T1 = string | number;
- * type Test1 = AssertExtends<T1, string | number>; // string | number
- * type Test2 = AssertExtends<T1, string>; // never
- *
- * // Compare distributive vs non-distributive behavior
- * type Union1 = 'a' | 'b'
- * type Dist = Extract<Union1, string> // 'a' | 'b'
- * type NonDist = AssertExtends<Union1, string> // 'a' | 'b'
- *
- * type Union2 = 'a' | 1
- * type Dist2 = Extract<Union2, string> // 'a'
- * type NonDist2 = AssertExtends<Union2, string> // never
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<AssertExtends<string, number>>().toBeNever
+ * expect<AssertExtends<1 | 2, 1>>().toBeNever
+ * expect<AssertExtends<1, 1 | 2>>().toBe<1>().success
  * ```
  */
 export type AssertExtends<T, U> = [T] extends [U] ? T : never;
 /**
- * Safely picks keys `K` from type T, excluding non-existent keys
+ * Safely picks keys `Key` from type `Obj`, excluding non-existent keys
+ *
+ * @template Obj - The object type to pick keys from
+ * @template Key - The keys to pick from the object
  *
  * @example
  * ```ts
- * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'> // { a: string }
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'>
+ * expect<Result>().toBe<{ a: string }>().success
  * ```
  */
 export type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>;
 /**
- * Picks properties from `T` that have values of type U
+ * Picks properties from `T` that have values of type `U`
+ *
+ * @template T - The object type to pick properties from
+ * @template U - The value type to match against
  *
  * @example
  * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
  * type A = { a: string; b: number; c: string }
- * type Strings = PropsOfType<A, string> // { a: string; c: string }
+ * type Strings = PropsOfBaseType<A, string> // { a: string; c: string }
+ * expect<PropsOfBaseType<A, string>>().toBe<{ a: string; c: string }>()
  * ```
  */
 export type PropsOfBaseType<T, U> = Pick<T, KeysOfExactType<Required<T>, U>>;

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

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/main/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,CAAC,GAAG,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AAE5F;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC;CAAE,CAAC,MAAM,CAAC,CAAC,CAAA;AAEhG;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAChE,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACjE,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE7D;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,CAAC,CAAA;AAE3D;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/main/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,MAAM,CAAC,GAAG,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AAE5F;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC;CAAE,CAAC,MAAM,CAAC,CAAC,CAAA;AAEhG;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAChE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,SAAS,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1F,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE7D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,CAAC,CAAA;AAE3D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}

package/esm/main/object.js.map

@@ -1 +1 @@
-{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/main/object.ts"],"names":[],"mappings":"","sourcesContent":["import type { KeysOfExactType } from './key.js'\n\n/**\n * Access a property with key `K` in object `T`, with a fallback `E` if the property doesn't exist\n *\n * @example\n * ```ts\n * type Result = Access<{ a: string }, 'a'> // string\n * type Missing = Access<{ a: string }, 'x', 'default'> // 'default'\n * ```\n */\nexport type Access<Obj, K extends PropertyKey, E = never> = K extends keyof Obj ? Obj[K] : E\n\n/**\n * Inverse of `Access`\n *\n * @example\n * ```ts\n * type Result = InverseAccess<{ a: string }, string> // 'a'\n * ```\n */\nexport type InverseAccess<T, V, E = never> = { [K in keyof T]: T[K] extends V ? K : E }[keyof T]\n\n/**\n * Recursively makes all properties of `T` optional\n *\n * @example\n * ```ts\n * type Result = DeepPartial<{ a: string; nested: { b: number } }> // { a?: string; nested?: { b?: number } }\n * ```\n */\nexport type DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]\n}\n\n/**\n * Recursively makes all properties of `T` required\n *\n * @example\n * ```ts\n * type Result = DeepRequire<{ a?: string; nested?: { b?: number } }>\n * // { a: string; nested: { b: number } }\n * ```\n */\nexport type DeepRequire<T> = {\n  [P in keyof T]-?: T[P] extends object ? DeepRequire<T[P]> : T[P]\n}\n\n/**\n * A non-distributive conditional type that checks if the entire type `T`\n * (treated as a single entity) is assignable to type `U`.\n *\n * Unlike the built-in distributive version (`Extract<T, U>`), this type wraps `T` and `U` in tuples to\n * prevent distribution over union types. The entire type `T` must satisfy\n * the constraint `U` for the check to pass.\n *\n * @template T - The type to test (not distributed over unions)\n * @template U - The constraint type to test against\n *\n * @example\n *\n * ```ts\n * // Non-distributive check - entire type must satisfy constraint\n * type T1 = string | number;\n * type Test1 = AssertExtends<T1, string | number>; // string | number\n * type Test2 = AssertExtends<T1, string>; // never\n *\n * // Compare distributive vs non-distributive behavior\n * type Union1 = 'a' | 'b'\n * type Dist = Extract<Union1, string> // 'a' | 'b'\n * type NonDist = AssertExtends<Union1, string> // 'a' | 'b'\n *\n * type Union2 = 'a' | 1\n * type Dist2 = Extract<Union2, string> // 'a'\n * type NonDist2 = AssertExtends<Union2, string> // never\n * ```\n */\nexport type AssertExtends<T, U> = [T] extends [U] ? T : never\n\n/**\n * Safely picks keys `K` from type T, excluding non-existent keys\n *\n * @example\n * ```ts\n * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'> // { a: string }\n * ```\n */\nexport type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>\n\n/**\n * Picks properties from `T` that have values of type U\n *\n * @example\n * ```ts\n * type A = { a: string; b: number; c: string }\n * type Strings = PropsOfType<A, string> // { a: string; c: string }\n * ```\n */\nexport type PropsOfBaseType<T, U> = Pick<T, KeysOfExactType<Required<T>, U>>\n"]}
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/main/object.ts"],"names":[],"mappings":"","sourcesContent":["import type { KeysOfExactType } from './key.js'\n\n/**\n * Get property type from object, with fallback for missing keys.\n *\n * @template Obj - The object type to access\n * @template K - The key to access in the object\n * @template E - The fallback type if the key doesn't exist (defaults to `never`)\n *\n * @returns `Obj[K]` if key exists, otherwise `E`.\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * type User = { name: string; age?: number };\n *\n * expect<Access<User, 'name'>>().toBe<string>().success\n * expect<Access<User, 'age'>>().toBe<number | undefined>().success\n * expect<Access<User, 'email', 'none'>>().toBe<'none'>().success\n * ```\n */\nexport type Access<Obj, K extends PropertyKey, E = never> = K extends keyof Obj ? Obj[K] : E\n\n/**\n * Inverse of `Access` - gets keys from an object that have values of a specific type\n *\n * @template T - The object type to inspect\n * @template V - The value type to match against\n * @template E - The fallback type if no keys match (defaults to `never`)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<InverseAccess<{ a: string }, string>>().toBe<'a'>().success\n * expect<InverseAccess<{ a: string; b: string }, string>>().toBe<'a' | 'b'>().success\n * expect<InverseAccess<{ a: string }, number>>().toBe<never>().success\n * ```\n */\nexport type InverseAccess<T, V, E = never> = { [K in keyof T]: T[K] extends V ? K : E }[keyof T]\n\n/**\n * Recursively makes all properties of `T` optional\n *\n * @template T - The object type to make deep partial\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * type Result = DeepPartial<{ a: string; nested: { b: number } }>\n * expect<Result>().toBe<{ a?: string; nested?: { b?: number } }>().success\n * ```\n */\nexport type DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]\n}\n\n/**\n * Recursively makes all properties of `T` required\n *\n * @template T - The object type to make deep required\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<DeepRequire<{ _?: { _?: 1 } }>>().toBe<{ _: { _: 1 } }>().success\n * ```\n */\nexport type DeepRequire<T> = {\n  [K in keyof T]-?: T[K] extends object | undefined ? DeepRequire<NonNullable<T[K]>> : T[K]\n}\n\n/**\n * **⚠️Important:** parameter `T` and `U` are not distributive. When they are union type, it treats them as a single entity.\n *\n * @template T - The type to test (not distributed over unions)\n * @template U - The constraint type to test against\n *\n * @example\n *\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<AssertExtends<string, number>>().toBeNever\n * expect<AssertExtends<1 | 2, 1>>().toBeNever\n * expect<AssertExtends<1, 1 | 2>>().toBe<1>().success\n * ```\n */\nexport type AssertExtends<T, U> = [T] extends [U] ? T : never\n\n/**\n * Safely picks keys `Key` from type `Obj`, excluding non-existent keys\n *\n * @template Obj - The object type to pick keys from\n * @template Key - The keys to pick from the object\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'>\n * expect<Result>().toBe<{ a: string }>().success\n * ```\n */\nexport type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>\n\n/**\n * Picks properties from `T` that have values of type `U`\n *\n * @template T - The object type to pick properties from\n * @template U - The value type to match against\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n * type A = { a: string; b: number; c: string }\n * type Strings = PropsOfBaseType<A, string> // { a: string; c: string }\n * expect<PropsOfBaseType<A, string>>().toBe<{ a: string; c: string }>()\n * ```\n */\nexport type PropsOfBaseType<T, U> = Pick<T, KeysOfExactType<Required<T>, U>>\n"]}

package/esm/main/tuple.d.ts

@@ -2,38 +2,62 @@ import type { Exact } from './type/compare.js';
 /**
  * Concatenates two tuples into a single tuple type
  *
+ * @template Left - The first tuple type to concatenate
+ * @template Right - The second tuple type to concatenate
+ *
  * @example
  * ```ts
- * type Result = ConcatTuple<[1, 2], [3, 4]> // [1, 2, 3, 4]
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<ConcatTuple<[1, 2], [3, 4]>>().toBe<[1, 2, 3, 4]>().success
  * ```
  */
 export type ConcatTuple<Left extends readonly unknown[], Right extends readonly unknown[]> = Left extends readonly unknown[] ? (Right extends readonly unknown[] ? [...Left, ...Right] : never) : never;
 /**
  * Checks whether a tuple includes a specific element type
  *
+ * @template Tuple - The tuple type to check
+ * @template Element - The element type to look for
+ * @template Yes - The result if the element is found (defaults to `true`)
+ * @template No - The result if the element is not found (defaults to `false`)
+ *
  * @example
  * ```ts
- * type HasTwo = IfTupleIncludes<[1, 2, 3], 2> // true
- * type HasFour = IfTupleIncludes<[1, 2, 3], 4> // false
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<IfTupleIncludes<[1, 2, 3], 2>>().toBeTrue
+ * expect<IfTupleIncludes<[1, 2, 3], 4>>().toBeFalse
+ * expect<IfTupleIncludes<[1, 2, 1], 1>>().toBeTrue
  * ```
  */
 export type IfTupleIncludes<Tuple extends readonly unknown[], Element, Yes = true, No = false> = Exact<Tuple, any> extends true ? never : Tuple extends readonly [infer First, ...infer Rest] ? (Exact<Element, First> extends true ? Yes : IfTupleIncludes<Rest, Element, Yes, No>) : No;
 /**
  * Appends an element to a tuple only if it doesn't already exist in the tuple
  *
+ * @template Tuple - The tuple type to append to
+ * @template Element - The element type to append
+ *
  * @example
  * ```ts
- * type Result1 = AppendUnique<[1, 2, 3], 4> // [1, 2, 3, 4]
- * type Result2 = AppendUnique<[1, 2, 3], 2> // [1, 2, 3]
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<AppendUnique<[1, 2, 3], 4>>().toBe<[1, 2, 3, 4]>().success
+ * expect<AppendUnique<[1, 2, 3], 2>>().toBe<[1, 2, 3]>().success
  * ```
  */
 export type AppendUnique<Tuple extends readonly unknown[], Element> = IfTupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element];
 /**
  * Concatenates two tuples while ensuring uniqueness of elements
  *
+ * @template Left - The first tuple type to concatenate
+ * @template Right - The second tuple type to concatenate
+ * @template R - The intermediate result tuple type (defaults to `Left`)
+ *
  * @example
  * ```ts
- * type Result = ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]> // [1, 2, 3, 4]
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * expect<ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]>>().toBe<[1, 2, 3, 4]>().success
  * ```
  */
 export type ConcatUniqueTuple<Left extends readonly unknown[], Right extends readonly unknown[], R extends readonly unknown[] = Left> = Right extends readonly [infer First, ...infer Rest] ? ConcatUniqueTuple<Left, Rest, AppendUnique<R, First>> : R;

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

@@ -1 +1 @@
-{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../src/main/tuple.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CACrB,IAAI,SAAS,SAAS,OAAO,EAAE,EAC/B,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,IAAI,SAAS,SAAS,OAAO,EAAE,GAAG,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,CAAA;AAE9G;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,CACzB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,EACP,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,IAAI,GAAG,KAAK,GACtC,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GACjD,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,IAAI,GAAG,GAAG,GAAG,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,GACtF,EAAE,CAAA;AAEN;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CACtB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,CAAA;AAE9E;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,CAC3B,IAAI,SAAS,SAAS,OAAO,EAAE,EAC/B,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,IAAI,IACjC,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAA"}
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../src/main/tuple.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CACrB,IAAI,SAAS,SAAS,OAAO,EAAE,EAC/B,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,IAAI,SAAS,SAAS,OAAO,EAAE,GAAG,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,CAAA;AAE9G;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,eAAe,CACzB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,EACP,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,IAAI,GAAG,KAAK,GACtC,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GACjD,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,IAAI,GAAG,GAAG,GAAG,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,GACtF,EAAE,CAAA;AAEN;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,CACtB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,CAAA;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,CAC3B,IAAI,SAAS,SAAS,OAAO,EAAE,EAC/B,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,IAAI,IACjC,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAA"}

package/esm/main/tuple.js.map

@@ -1 +1 @@
-{"version":3,"file":"tuple.js","sourceRoot":"","sources":["../../src/main/tuple.ts"],"names":[],"mappings":"","sourcesContent":["// deno-lint-ignore-file no-explicit-any\nimport type { Exact } from './type/compare.js'\n\n/**\n * Concatenates two tuples into a single tuple type\n *\n * @example\n * ```ts\n * type Result = ConcatTuple<[1, 2], [3, 4]> // [1, 2, 3, 4]\n * ```\n */\nexport type ConcatTuple<\n  Left extends readonly unknown[],\n  Right extends readonly unknown[],\n> = Left extends readonly unknown[] ? (Right extends readonly unknown[] ? [...Left, ...Right] : never) : never\n\n/**\n * Checks whether a tuple includes a specific element type\n *\n * @example\n * ```ts\n * type HasTwo = IfTupleIncludes<[1, 2, 3], 2> // true\n * type HasFour = IfTupleIncludes<[1, 2, 3], 4> // false\n * ```\n */\nexport type IfTupleIncludes<\n  Tuple extends readonly unknown[],\n  Element,\n  Yes = true,\n  No = false,\n> = Exact<Tuple, any> extends true ? never\n  : Tuple extends readonly [infer First, ...infer Rest]\n    ? (Exact<Element, First> extends true ? Yes : IfTupleIncludes<Rest, Element, Yes, No>)\n  : No\n\n/**\n * Appends an element to a tuple only if it doesn't already exist in the tuple\n *\n * @example\n * ```ts\n * type Result1 = AppendUnique<[1, 2, 3], 4> // [1, 2, 3, 4]\n * type Result2 = AppendUnique<[1, 2, 3], 2> // [1, 2, 3]\n * ```\n */\nexport type AppendUnique<\n  Tuple extends readonly unknown[],\n  Element,\n> = IfTupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element]\n\n/**\n * Concatenates two tuples while ensuring uniqueness of elements\n *\n * @example\n * ```ts\n * type Result = ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]> // [1, 2, 3, 4]\n * ```\n */\nexport type ConcatUniqueTuple<\n  Left extends readonly unknown[],\n  Right extends readonly unknown[],\n  R extends readonly unknown[] = Left,\n> = Right extends readonly [infer First, ...infer Rest] ? ConcatUniqueTuple<Left, Rest, AppendUnique<R, First>> : R\n"]}
+{"version":3,"file":"tuple.js","sourceRoot":"","sources":["../../src/main/tuple.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from './type/compare.js'\n\n/**\n * Concatenates two tuples into a single tuple type\n *\n * @template Left - The first tuple type to concatenate\n * @template Right - The second tuple type to concatenate\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<ConcatTuple<[1, 2], [3, 4]>>().toBe<[1, 2, 3, 4]>().success\n * ```\n */\nexport type ConcatTuple<\n  Left extends readonly unknown[],\n  Right extends readonly unknown[],\n> = Left extends readonly unknown[] ? (Right extends readonly unknown[] ? [...Left, ...Right] : never) : never\n\n/**\n * Checks whether a tuple includes a specific element type\n *\n * @template Tuple - The tuple type to check\n * @template Element - The element type to look for\n * @template Yes - The result if the element is found (defaults to `true`)\n * @template No - The result if the element is not found (defaults to `false`)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<IfTupleIncludes<[1, 2, 3], 2>>().toBeTrue\n * expect<IfTupleIncludes<[1, 2, 3], 4>>().toBeFalse\n * expect<IfTupleIncludes<[1, 2, 1], 1>>().toBeTrue\n * ```\n */\nexport type IfTupleIncludes<\n  Tuple extends readonly unknown[],\n  Element,\n  Yes = true,\n  No = false,\n> = Exact<Tuple, any> extends true ? never\n  : Tuple extends readonly [infer First, ...infer Rest]\n    ? (Exact<Element, First> extends true ? Yes : IfTupleIncludes<Rest, Element, Yes, No>)\n  : No\n\n/**\n * Appends an element to a tuple only if it doesn't already exist in the tuple\n *\n * @template Tuple - The tuple type to append to\n * @template Element - The element type to append\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<AppendUnique<[1, 2, 3], 4>>().toBe<[1, 2, 3, 4]>().success\n * expect<AppendUnique<[1, 2, 3], 2>>().toBe<[1, 2, 3]>().success\n * ```\n */\nexport type AppendUnique<\n  Tuple extends readonly unknown[],\n  Element,\n> = IfTupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element]\n\n/**\n * Concatenates two tuples while ensuring uniqueness of elements\n *\n * @template Left - The first tuple type to concatenate\n * @template Right - The second tuple type to concatenate\n * @template R - The intermediate result tuple type (defaults to `Left`)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]>>().toBe<[1, 2, 3, 4]>().success\n * ```\n */\nexport type ConcatUniqueTuple<\n  Left extends readonly unknown[],\n  Right extends readonly unknown[],\n  R extends readonly unknown[] = Left,\n> = Right extends readonly [infer First, ...infer Rest] ? ConcatUniqueTuple<Left, Rest, AppendUnique<R, First>> : R\n"]}

package/esm/main/type/compare.d.ts

@@ -1,13 +1,31 @@
 /**
  * Checks whether two types are exactly the same.
  *
- * This performs a structural equality comparison between `A` and `B`,
- * rather than a one-way assignability check.
+ * **⚠️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
  *
- * - `true`: `A` and `B` are identical types
- * - `false`: Otherwise
+ * - `Yes`: `A` and `B` are exactly the same
+ * - `No`: Otherwise
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing/test-utils'
+ *
+ * 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;
 /**
@@ -15,24 +33,34 @@ export type Exact<A, B, Yes = true, No = false> = (<T>() => T extends A ? 1 : 2)
  *
  * This is the logical negation of `Exact<A, B>`.
  *
- * ### Result
- *
- * - `true`: `A` and `B` are not identical
- * - `false`: `A` and `B` are exactly the same type
+ * @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;
 /**
  * Checks whether type `A` extends type `B`.
  *
- * This is a non-distributive version of `extends`, ensuring
- * the result is always a concrete boolean literal.
+ * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it treats them as a single entity.
  *
- * ### Result
+ * @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`)
  *
- * - `true`: `A` is assignable to `B`
- * - `false`: Otherwise
+ * ### Result
  *
- * **Note:** the result will never be `boolean`.
+ * - `Yes`: `A` is assignable to `B`
+ * - `No`: Otherwise
  */
 export type Extends<A, B, Yes = true, No = false> = [A] extends [B] ? Yes : No;
 /**
@@ -42,16 +70,47 @@ export type Extends<A, B, Yes = true, No = false> = [A] extends [B] ? Yes : No;
  * - `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;
 /**
  * Checks whether two types have any overlapping members.
  *
+ * @template A - The first type to check for overlap
+ * @template B - The second type to check for overlap
+ * @template Yes - The result if types overlap (defaults to `true`)
+ * @template No - The result if types do not overlap (defaults to `false`)
+ *
  * ### Result
  *
- * - `true`: `A` and `B` share at least one common type
- * - `false`: `A` and `B` are completely disjoint
+ * - `Yes`: `A` and `B` share at least one common type
+ * - `No`: `A` and `B` are completely disjoint
+ *
+ * @example
+ * ```ts
+ * type T1 = Overlap<1 | 2, 2 | 3> // true
+ * type T2 = Overlap<string, 'hello'> // true
+ * type F1 = Overlap<string, number> // false
+ * type F2 = Overlap<1, 'one'> // false
+ * ```
  */
 export type Overlap<A, B, Yes = true, No = false> = [A & B] extends [never] ? No : Yes;
 /**
@@ -59,10 +118,23 @@ export type Overlap<A, B, Yes = true, No = false> = [A & B] extends [never] ? No
  *
  * This is the logical negation of `Overlap<A, B>`.
  *
+ * @template A - The first type to check for disjointness
+ * @template B - The second type to check for disjointness
+ * @template Yes - The result if types are disjoint (defaults to `true`)
+ * @template No - The result if types are not disjoint (defaults to `false`)
+ *
  * ### Result
  *
- * - `true`: `A` and `B` have no overlap
- * - `false`: `A` and `B` share at least one common type
+ * - `Yes`: `A` and `B` have no overlap
+ * - `No`: `A` and `B` share at least one common type
+ *
+ * @example
+ * ```ts
+ * type T1 = Disjoint<string, number> // true
+ * type T2 = Disjoint<1, 'one'> // true
+ * type F1 = Disjoint<1 | 2, 2 | 3> // false
+ * type F2 = Disjoint<string, 'hello'> // false
+ * ```
  */
 export type Disjoint<A, B, Yes = true, No = false> = [A & B] extends [never] ? Yes : No;
 /**
@@ -74,6 +146,24 @@ export type Disjoint<A, B, Yes = true, No = false> = [A & B] extends [never] ? Y
  *
  * 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=compare.d.ts.map

package/esm/main/type/compare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/main/type/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;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;;;;;;;;;GASG;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;AAEpF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAE9B;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,KAAK,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAA;AAE/D;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,CAAA;AAEtC;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAEtC;;;;;;;;;GASG;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"}
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/main/type/compare.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;AAEpF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,KAAK,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;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/main/type/compare.js.map

@@ -1 +1 @@
-{"version":3,"file":"compare.js","sourceRoot":"","sources":["../../../src/main/type/compare.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Checks whether two types are exactly the same.\n *\n * This performs a structural equality comparison between `A` and `B`,\n * rather than a one-way assignability check.\n *\n * ### Result\n *\n * - `true`: `A` and `B` are identical types\n * - `false`: Otherwise\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 * ### Result\n *\n * - `true`: `A` and `B` are not identical\n * - `false`: `A` and `B` are exactly the same type\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\n/**\n * Checks whether type `A` extends type `B`.\n *\n * This is a non-distributive version of `extends`, ensuring\n * the result is always a concrete boolean literal.\n *\n * ### Result\n *\n * - `true`: `A` is assignable to `B`\n * - `false`: Otherwise\n *\n * **Note:** the result will never be `boolean`.\n */\nexport type Extends<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Yes : No\n\n/**\n * Checks whether type `A` is a *proper* subtype of type `B`.\n *\n * A proper extension means:\n * - `A` extends `B`\n * - `A` is not exactly the same type as `B`\n *\n * **Note:** the result will never be `boolean`.\n */\nexport type ProperExtend<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Exact<A, B> extends false ? Yes : No : No\n\n/**\n * Checks whether two types have any overlapping members.\n *\n * ### Result\n *\n * - `true`: `A` and `B` share at least one common type\n * - `false`: `A` and `B` are completely disjoint\n */\nexport type Overlap<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? No : Yes\n\n/**\n * Checks whether two types are disjoint.\n *\n * This is the logical negation of `Overlap<A, B>`.\n *\n * ### Result\n *\n * - `true`: `A` and `B` have no overlap\n * - `false`: `A` and `B` share at least one common type\n */\nexport type Disjoint<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? Yes : No\n\n/**\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 */\nexport type MutuallyAssignable<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? [B] extends [A] ? Yes : No : No\n"]}
+{"version":3,"file":"compare.js","sourceRoot":"","sources":["../../../src/main/type/compare.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/test-utils'\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\n/**\n * Checks whether type `A` extends type `B`.\n *\n * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it treats them as a single entity.\n *\n * @template A - The type to check if it extends another type\n * @template B - The type to check if `A` extends\n * @template Yes - The result if `A` extends `B` (defaults to `true`)\n * @template No - The result if `A` does not extend `B` (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` is assignable to `B`\n * - `No`: Otherwise\n */\nexport type Extends<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Yes : No\n\n/**\n * Checks whether type `A` is a *proper* subtype of type `B`.\n *\n * A proper extension means:\n * - `A` extends `B`\n * - `A` is not exactly the same type as `B`\n *\n * @template A - The type to check if it is a proper subtype\n * @template B - The type to check against\n * @template Yes - The result if `A` is a proper subtype of `B` (defaults to `true`)\n * @template No - The result if `A` is not a proper subtype of `B` (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` is a proper subtype of `B`\n * - `No`: Otherwise\n *\n * **Note:** the result will never be `boolean`.\n *\n * @example\n * ```ts\n * type T1 = ProperExtend<true, boolean> // true\n * type T2 = ProperExtend<1, number> // true\n * type F1 = ProperExtend<boolean, boolean> // false\n * type F2 = ProperExtend<number, string> // false\n * ```\n */\nexport type ProperExtend<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Exact<A, B> extends false ? Yes : No : No\n\n/**\n * Checks whether two types have any overlapping members.\n *\n * @template A - The first type to check for overlap\n * @template B - The second type to check for overlap\n * @template Yes - The result if types overlap (defaults to `true`)\n * @template No - The result if types do not overlap (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` share at least one common type\n * - `No`: `A` and `B` are completely disjoint\n *\n * @example\n * ```ts\n * type T1 = Overlap<1 | 2, 2 | 3> // true\n * type T2 = Overlap<string, 'hello'> // true\n * type F1 = Overlap<string, number> // false\n * type F2 = Overlap<1, 'one'> // false\n * ```\n */\nexport type Overlap<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? No : Yes\n\n/**\n * Checks whether two types are disjoint.\n *\n * This is the logical negation of `Overlap<A, B>`.\n *\n * @template A - The first type to check for disjointness\n * @template B - The second type to check for disjointness\n * @template Yes - The result if types are disjoint (defaults to `true`)\n * @template No - The result if types are not disjoint (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` have no overlap\n * - `No`: `A` and `B` share at least one common type\n *\n * @example\n * ```ts\n * type T1 = Disjoint<string, number> // true\n * type T2 = Disjoint<1, 'one'> // true\n * type F1 = Disjoint<1 | 2, 2 | 3> // false\n * type F2 = Disjoint<string, 'hello'> // false\n * ```\n */\nexport type Disjoint<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? Yes : No\n\n/**\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"]}