lay-sing 0.3.0 → 0.4.0

package/esm/utils/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Creates an intersection of all types in the provided tuple\n *\n * ## `IntersectionOf<[A, B, ... T]>` = `A & B & ... & T`\n *\n * @template Types - A tuple of types to create an intersection from\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * type Result = IntersectionOf<[{ a: string }, { b: number }, { c: boolean }]>\n * expect<Result>().to.extend<{ a: string } & { b: number } & { c: boolean }>().pass\n * expect<Result>().to.extend<{ a: string; b: number; c: boolean }>().pass\n * ```\n */\nexport type IntersectionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]\n  ? First & IntersectionOf<Rest>\n  : unknown\n\n/**\n * Creates a union of all types in the provided tuple\n *\n * ## `UnionOf<[A, B, ... T]>` = `A | B | ... | T`\n *\n * @template Types - A tuple of types to create a union from\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * type Result = UnionOf<[string, number, boolean]>\n * expect<Result>().to.be<string | number | boolean>().pass\n * ```\n */\nexport type UnionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]\n  ? First | UnionOf<Rest>\n  : never\n"]}

package/esm/utils/object/keys.d.ts

@@ -14,17 +14,17 @@ import type { Exact } from '../index.js';
  *
  * // Basic usage: match exact type (non-optional property)
  * type A = { a: 1; b: 2; c: 1 };
- * expect<KeysOfExactType<A, 1>>().toBe<'a' | 'c'>().success
+ * expect<KeysOfExactType<A, 1>>().to.be<'a' | 'c'>().pass
  *
  * // Key difference: optional property matching (requires undefined in `ValueType`)
  * type B = { a?: string };
- * expect<KeysOfExactType<B, string | undefined>>().toBe<'a'>().success // matches complete type
- * expect<KeysOfExactType<B, string>>().toBe<never>().success // does not match complete type
+ * expect<KeysOfExactType<B, string | undefined>>().to.be<'a'>().pass // matches complete type
+ * expect<KeysOfExactType<B, string>>().to.be<never>().pass // does not match complete type
  *
  * type C = { a: never; b: any; c: unknown };
- * expect<KeysOfExactType<C, never>>().toBe<'a'>().success
- * expect<KeysOfExactType<C, any>>().toBe<'b'>().success
- * expect<KeysOfExactType<C, unknown>>().toBe<'c'>().success
+ * expect<KeysOfExactType<C, never>>().to.be<'a'>().pass
+ * expect<KeysOfExactType<C, any>>().to.be<'b'>().pass
+ * expect<KeysOfExactType<C, unknown>>().to.be<'c'>().pass
  * ```
  */
 export type KeysOfExactType<Obj, ValueType> = Exclude<{
@@ -45,17 +45,17 @@ export type KeysOfExactType<Obj, ValueType> = Exclude<{
  *
  * // Basic usage: match base type (non-optional property)
  * type A = { a: 1; b: 2; c: 1 };
- * expect<KeysOfBaseType<A, 1>>().toBe<'a' | 'c'>().success
+ * expect<KeysOfBaseType<A, 1>>().to.be<'a' | 'c'>().pass
  *
  * // Key difference: optional property matching (ignores undefined)
  * type B = { a?: string; b: string };
- * 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
+ * expect<KeysOfBaseType<B, string>>().to.be<'a' | 'b'>().pass // matches base type of both
+ * expect<KeysOfBaseType<B, string | undefined>>().to.be<never>().pass // base type does not include undefined
  *
  * type C = { a: never; b: any; c: unknown };
- * expect<KeysOfBaseType<C, never>>().toBe<'a'>().success
- * expect<KeysOfBaseType<C, any>>().toBe<'b'>().success
- * expect<KeysOfBaseType<C, unknown>>().toBe<'c'>().success
+ * expect<KeysOfBaseType<C, never>>().to.be<'a'>().pass
+ * expect<KeysOfBaseType<C, any>>().to.be<'b'>().pass
+ * expect<KeysOfBaseType<C, unknown>>().to.be<'c'>().pass
  * ```
  */
 export type KeysOfBaseType<Obj, ValueType> = Exclude<{

package/esm/utils/object/keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../../src/utils/object/keys.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from '../index.js'\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'\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\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'\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"]}
+{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../../src/utils/object/keys.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from '../index.js'\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'\n *\n * // Basic usage: match exact type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * expect<KeysOfExactType<A, 1>>().to.be<'a' | 'c'>().pass\n *\n * // Key difference: optional property matching (requires undefined in `ValueType`)\n * type B = { a?: string };\n * expect<KeysOfExactType<B, string | undefined>>().to.be<'a'>().pass // matches complete type\n * expect<KeysOfExactType<B, string>>().to.be<never>().pass // does not match complete type\n *\n * type C = { a: never; b: any; c: unknown };\n * expect<KeysOfExactType<C, never>>().to.be<'a'>().pass\n * expect<KeysOfExactType<C, any>>().to.be<'b'>().pass\n * expect<KeysOfExactType<C, unknown>>().to.be<'c'>().pass\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\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'\n *\n * // Basic usage: match base type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * expect<KeysOfBaseType<A, 1>>().to.be<'a' | 'c'>().pass\n *\n * // Key difference: optional property matching (ignores undefined)\n * type B = { a?: string; b: string };\n * expect<KeysOfBaseType<B, string>>().to.be<'a' | 'b'>().pass // matches base type of both\n * expect<KeysOfBaseType<B, string | undefined>>().to.be<never>().pass // base type does not include undefined\n *\n * type C = { a: never; b: any; c: unknown };\n * expect<KeysOfBaseType<C, never>>().to.be<'a'>().pass\n * expect<KeysOfBaseType<C, any>>().to.be<'b'>().pass\n * expect<KeysOfBaseType<C, unknown>>().to.be<'c'>().pass\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"]}

package/esm/utils/object/pick.d.ts

@@ -9,7 +9,7 @@
  * import { expect } from '@leawind/lay-sing'
  *
  * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'>
- * expect<Result>().toBe<{ a: string }>().success
+ * expect<Result>().to.be<{ a: string }>().pass
  * ```
  */
 export type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>;

package/esm/utils/object/pick.js.map

@@ -1 +1 @@
-{"version":3,"file":"pick.js","sourceRoot":"","sources":["../../../src/utils/object/pick.ts"],"names":[],"mappings":"","sourcesContent":["/**\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'\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"]}
+{"version":3,"file":"pick.js","sourceRoot":"","sources":["../../../src/utils/object/pick.ts"],"names":[],"mappings":"","sourcesContent":["/**\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'\n *\n * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'>\n * expect<Result>().to.be<{ a: string }>().pass\n * ```\n */\nexport type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>\n"]}

package/esm/utils/object/props.d.ts

@@ -10,7 +10,7 @@ import type { KeysOfBaseType } from '../index.js';
  * import { expect } from '@leawind/lay-sing'
  * type A = { a: string; b: number; c: string }
  * type Strings = PropsOfBaseType<A, string> // { a: string; c: string }
- * expect<PropsOfBaseType<A, string>>().toBe<{ a: string; c: string }>()
+ * expect<PropsOfBaseType<A, string>>().to.be<{ a: string; c: string }>()
  * ```
  */
 export type PropsOfBaseType<T, U> = Pick<T, KeysOfBaseType<Required<T>, U>>;

package/esm/utils/object/props.js.map

@@ -1 +1 @@
-{"version":3,"file":"props.js","sourceRoot":"","sources":["../../../src/utils/object/props.ts"],"names":[],"mappings":"","sourcesContent":["import type { KeysOfBaseType } from '../index.js'\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'\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, KeysOfBaseType<Required<T>, U>>\n"]}
+{"version":3,"file":"props.js","sourceRoot":"","sources":["../../../src/utils/object/props.ts"],"names":[],"mappings":"","sourcesContent":["import type { KeysOfBaseType } from '../index.js'\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'\n * type A = { a: string; b: number; c: string }\n * type Strings = PropsOfBaseType<A, string> // { a: string; c: string }\n * expect<PropsOfBaseType<A, string>>().to.be<{ a: string; c: string }>()\n * ```\n */\nexport type PropsOfBaseType<T, U> = Pick<T, KeysOfBaseType<Required<T>, U>>\n"]}

package/esm/utils/tuple/append.d.ts

@@ -9,8 +9,8 @@ import type { IfTupleIncludes } from '../index.js';
  * ```ts
  * import { expect } from '@leawind/lay-sing'
  *
- * expect<AppendUnique<[1, 2, 3], 4>>().toBe<[1, 2, 3, 4]>().success
- * expect<AppendUnique<[1, 2, 3], 2>>().toBe<[1, 2, 3]>().success
+ * expect<AppendUnique<[1, 2, 3], 4>>().to.be<[1, 2, 3, 4]>().pass
+ * expect<AppendUnique<[1, 2, 3], 2>>().to.be<[1, 2, 3]>().pass
  * ```
  */
 export type AppendUnique<Tuple extends readonly unknown[], Element> = IfTupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element];

package/esm/utils/tuple/append.js.map

@@ -1 +1 @@
-{"version":3,"file":"append.js","sourceRoot":"","sources":["../../../src/utils/tuple/append.ts"],"names":[],"mappings":"","sourcesContent":["import type { IfTupleIncludes } from '../index.js'\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'\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"]}
+{"version":3,"file":"append.js","sourceRoot":"","sources":["../../../src/utils/tuple/append.ts"],"names":[],"mappings":"","sourcesContent":["import type { IfTupleIncludes } from '../index.js'\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'\n *\n * expect<AppendUnique<[1, 2, 3], 4>>().to.be<[1, 2, 3, 4]>().pass\n * expect<AppendUnique<[1, 2, 3], 2>>().to.be<[1, 2, 3]>().pass\n * ```\n */\nexport type AppendUnique<\n  Tuple extends readonly unknown[],\n  Element,\n> = IfTupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element]\n"]}

package/esm/utils/tuple/concat.d.ts

@@ -9,7 +9,7 @@ import type { AppendUnique } from '../index.js';
  * ```ts
  * import { expect } from '@leawind/lay-sing'
  *
- * expect<ConcatTuple<[1, 2], [3, 4]>>().toBe<[1, 2, 3, 4]>().success
+ * expect<ConcatTuple<[1, 2], [3, 4]>>().to.be<[1, 2, 3, 4]>().pass
  * ```
  */
 export type ConcatTuple<Left extends readonly unknown[], Right extends readonly unknown[]> = Left extends readonly unknown[] ? (Right extends readonly unknown[] ? [...Left, ...Right] : never) : never;
@@ -24,7 +24,7 @@ export type ConcatTuple<Left extends readonly unknown[], Right extends readonly
  * ```ts
  * import { expect } from '@leawind/lay-sing'
  *
- * expect<ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]>>().toBe<[1, 2, 3, 4]>().success
+ * expect<ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]>>().to.be<[1, 2, 3, 4]>().pass
  * ```
  */
 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/utils/tuple/concat.js.map

@@ -1 +1 @@
-{"version":3,"file":"concat.js","sourceRoot":"","sources":["../../../src/utils/tuple/concat.ts"],"names":[],"mappings":"","sourcesContent":["// Import needed for ConcatUniqueTuple\nimport type { AppendUnique } from '../index.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'\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 * 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'\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"]}
+{"version":3,"file":"concat.js","sourceRoot":"","sources":["../../../src/utils/tuple/concat.ts"],"names":[],"mappings":"","sourcesContent":["// Import needed for ConcatUniqueTuple\nimport type { AppendUnique } from '../index.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'\n *\n * expect<ConcatTuple<[1, 2], [3, 4]>>().to.be<[1, 2, 3, 4]>().pass\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 * 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'\n *\n * expect<ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]>>().to.be<[1, 2, 3, 4]>().pass\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/utils/tuple/includes.d.ts

@@ -11,9 +11,9 @@ import type { Exact } from '../index.js';
  * ```ts
  * import { expect } from '@leawind/lay-sing'
  *
- * expect<IfTupleIncludes<[1, 2, 3], 2>>().toBeTrue
- * expect<IfTupleIncludes<[1, 2, 3], 4>>().toBeFalse
- * expect<IfTupleIncludes<[1, 2, 1], 1>>().toBeTrue
+ * expect<IfTupleIncludes<[1, 2, 3], 2>>().to.be.true
+ * expect<IfTupleIncludes<[1, 2, 3], 4>>().to.be.false
+ * expect<IfTupleIncludes<[1, 2, 1], 1>>().to.be.true
  * ```
  */
 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;

package/esm/utils/tuple/includes.js.map

@@ -1 +1 @@
-{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../../src/utils/tuple/includes.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from '../index.js'\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'\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"]}
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../../src/utils/tuple/includes.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from '../index.js'\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'\n *\n * expect<IfTupleIncludes<[1, 2, 3], 2>>().to.be.true\n * expect<IfTupleIncludes<[1, 2, 3], 4>>().to.be.false\n * expect<IfTupleIncludes<[1, 2, 1], 1>>().to.be.true\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"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lay-sing",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Utilities for compile-time type testing",
   "repository": {
     "type": "git",

package/script/main/expect/index.d.ts

@@ -0,0 +1,31 @@
+import type { Exact } from '../../utils/index.js';
+import type { To } from './to/index.js';
+/**
+ * Represents the result of a type assertion based on a boolean condition.
+ *
+ * - If `true`, the result has a `pass` property;
+ * - If `false`, the result has a `fail` property;
+ * - Otherwise, the result is `never`
+ *
+ * @template B The boolean condition result (true or false)
+ * @template R The type of the result value (default is void)
+ */
+export type TypeAssertionResult<B extends boolean, R = void> = Exact<B, never> extends true ? never : [boolean] extends [B] ? never : [B] extends [true] ? {
+    /**
+     * This field exist only when this type assertion succeed
+     *
+     * If you expect this assertion to fail, use `.fail`
+     */
+    pass: R;
+} : [B] extends [false] ? {
+    /**
+     * This field exist only when this type assertion failed
+     *
+     * If you expect this assertion to pass, use `.pass`
+     */
+    fail: R;
+} : never;
+export type ExpectType<T> = {
+    to: To<T>;
+};
+//# sourceMappingURL=index.d.ts.map

package/script/main/expect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/main/expect/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,IAAI,GAAG,KAAK,GAC/F,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,GAC7B,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG;IACnB;;;;OAIG;IACH,IAAI,EAAE,CAAC,CAAA;CACR,GACD,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG;IACpB;;;;OAIG;IACH,IAAI,EAAE,CAAC,CAAA;CACR,GACD,KAAK,CAAA;AAET,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAA;CACV,CAAA"}

package/script/main/{expect.js → expect/index.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=expect.js.map
+//# sourceMappingURL=index.js.map

package/script/main/expect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/main/expect/index.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from '../../utils/index.js'\nimport type { To } from './to/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 `pass` 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      pass: 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 pass, use `.pass`\n       */\n      fail: R\n    }\n  : never\n\nexport type ExpectType<T> = {\n  to: To<T>\n}\n"]}

package/script/main/expect/to/be.d.ts

@@ -0,0 +1,23 @@
+import type { Exact, If } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+export type Be<T> = {
+    <U>(): TypeAssertionResult<Exact<T, U>>;
+    <U>(_: U): TypeAssertionResult<Exact<T, U>>;
+} & If<Exact<T, any>, {
+    any: void;
+}, {}> & If<Exact<T, never>, {
+    never: void;
+}, {}> & If<Exact<T, unknown>, {
+    unknown: void;
+}, {}> & If<Exact<T, void>, {
+    void: void;
+}, {}> & If<Exact<T, null>, {
+    null: void;
+}, {}> & If<Exact<T, undefined>, {
+    undefined: void;
+}, {}> & If<Exact<T, true>, {
+    true: void;
+}, {}> & If<Exact<T, false>, {
+    false: void;
+}, {}>;
+//# sourceMappingURL=be.d.ts.map

package/script/main/expect/to/be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"be.d.ts","sourceRoot":"","sources":["../../../../src/main/expect/to/be.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,EAAE,CAAC,CAAC,IACZ;IACA,CAAC,CAAC,KAAK,mBAAmB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACvC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CAC5C,GACC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACpC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACxC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAC5C,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACtC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACtC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAChD,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACtC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,CAAA"}

package/script/main/expect/to/be.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=be.js.map

package/script/main/expect/to/be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"be.js","sourceRoot":"","sources":["../../../../src/main/expect/to/be.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact, If } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type Be<T> =\n  & {\n    <U>(): TypeAssertionResult<Exact<T, U>>\n    <U>(_: U): TypeAssertionResult<Exact<T, U>>\n  }\n  & If<Exact<T, any>, { any: void }, {}>\n  & If<Exact<T, never>, { never: void }, {}>\n  & If<Exact<T, unknown>, { unknown: void }, {}>\n  & If<Exact<T, void>, { void: void }, {}>\n  & If<Exact<T, null>, { null: void }, {}>\n  & If<Exact<T, undefined>, { undefined: void }, {}>\n  & If<Exact<T, true>, { true: void }, {}>\n  & If<Exact<T, false>, { false: void }, {}>\n"]}

package/script/main/expect/to/equal.d.ts

@@ -0,0 +1,26 @@
+import type { MutuallyAssignable } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+export type Equal<T> = {
+    /**
+     * Tests if the current type is mutually assignable with the provided type U.
+     *
+     * It's like:
+     *
+     * ```ts ignore
+     * [T] extends [U] ? [U] extends [T] ? Yes : No : No
+     * ```
+     *
+     * @template U The type to compare with
+     *
+     * @example
+     * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
+     * expect<{ a: 1; b: 2 }>().to.equal<{ a: 1 } & { b: 2 }>().pass
+     * expect<1>().to.equal<1 | 2>().fail
+     * ```
+     */
+    <U>(): TypeAssertionResult<MutuallyAssignable<T, U>>;
+    <U>(_: U): TypeAssertionResult<MutuallyAssignable<T, U>>;
+};
+//# sourceMappingURL=equal.d.ts.map

package/script/main/expect/to/equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../src/main/expect/to/equal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI;IACrB;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,CAAC,KAAK,mBAAmB,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CACzD,CAAA"}

package/script/main/expect/to/equal.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=equal.js.map

package/script/main/expect/to/equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.js","sourceRoot":"","sources":["../../../../src/main/expect/to/equal.ts"],"names":[],"mappings":"","sourcesContent":["import type { MutuallyAssignable } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type Equal<T> = {\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 }>().to.equal<{ a: 1 } & { b: 2 }>().pass\n   * expect<1>().to.equal<1 | 2>().fail\n   * ```\n   */\n  <U>(): TypeAssertionResult<MutuallyAssignable<T, U>>\n  <U>(_: U): TypeAssertionResult<MutuallyAssignable<T, U>>\n}\n"]}

package/script/main/expect/to/extend.d.ts

@@ -0,0 +1,31 @@
+import type { Extends, If } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+export type Extend<T> = {
+    /**
+     * Tests if the current type T extends the provided type U.
+     *
+     * @template U The type to check extension against
+     *
+     * @example
+     * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
+     * expect<3.14>().to.extend<number>().pass
+     * expect<2>().to.extend<string>().fail
+     * expect<'hello'>().to.extend<string>().pass
+     * ```
+     */
+    <U>(): TypeAssertionResult<Extends<T, U>>;
+    <U>(_: U): TypeAssertionResult<Extends<T, U>>;
+} & If<Extends<T, number>, {
+    number: void;
+}, {}> & If<Extends<T, bigint>, {
+    bigint: void;
+}, {}> & If<Extends<T, string>, {
+    string: void;
+}, {}> & If<Extends<T, boolean>, {
+    boolean: void;
+}, {}> & If<Extends<T, symbol>, {
+    symbol: void;
+}, {}>;
+//# sourceMappingURL=extend.d.ts.map

package/script/main/expect/to/extend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend.d.ts","sourceRoot":"","sources":["../../../../src/main/expect/to/extend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,MAAM,CAAC,CAAC,IAChB;IACA;;;;;;;;;;;;;OAaG;IACH,CAAC,CAAC,KAAK,mBAAmB,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACzC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CAC9C,GACC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAC5C,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAC5C,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAC5C,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAC9C,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,CAAA"}

package/script/main/expect/to/extend.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=extend.js.map

package/script/main/expect/to/extend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend.js","sourceRoot":"","sources":["../../../../src/main/expect/to/extend.ts"],"names":[],"mappings":"","sourcesContent":["import type { Extends, If } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type Extend<T> =\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>().to.extend<number>().pass\n     * expect<2>().to.extend<string>().fail\n     * expect<'hello'>().to.extend<string>().pass\n     * ```\n     */\n    <U>(): TypeAssertionResult<Extends<T, U>>\n    <U>(_: U): TypeAssertionResult<Extends<T, U>>\n  }\n  & If<Extends<T, number>, { number: void }, {}>\n  & If<Extends<T, bigint>, { bigint: void }, {}>\n  & If<Extends<T, string>, { string: void }, {}>\n  & If<Extends<T, boolean>, { boolean: void }, {}>\n  & If<Extends<T, symbol>, { symbol: void }, {}>\n"]}

package/script/main/expect/to/have-key.d.ts

@@ -0,0 +1,38 @@
+import type { Extends, IfTupleIncludes } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+type Result<T, K extends PropertyKey> = IfTupleIncludes<[
+    never,
+    any
+], K, never, TypeAssertionResult<Extends<K, keyof T>>>;
+export type HaveKey<T> = {
+    /**
+     * Tests if the current type `T` has a property with key `K`.
+     *
+     * @template K The property key to check for
+     *
+     * ### Behavior
+     *
+     * - For single keys: succeeds if the key exists in `T`
+     * - For union types: succeeds only if **all** keys in the union exist in `T`
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
+     * type WithProp = { prop: string; another: number; may?: 5 }
+     *
+     * // Single key checks
+     * expect<WithProp>().to.haveKey<'prop'>().pass
+     * expect<WithProp>().to.haveKey<'missing'>().fail
+     *
+     * // Union type checks
+     * expect<WithProp>().to.haveKey<'prop' | 'another'>().pass
+     * expect<WithProp>().to.haveKey<'may' | 'unexist'>().fail
+     * ```
+     */
+    <K extends PropertyKey>(): Result<T, K>;
+    <K extends PropertyKey>(_: K): Result<T, K>;
+};
+export {};
+//# sourceMappingURL=have-key.d.ts.map

package/script/main/expect/to/have-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"have-key.d.ts","sourceRoot":"","sources":["../../../../src/main/expect/to/have-key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,IAAI,eAAe,CACrD;IAAC,KAAK;IAAE,GAAG;CAAC,EACZ,CAAC,EACD,KAAK,EACL,mBAAmB,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CACzC,CAAA;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,CAAC,CAAC,SAAS,WAAW,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IACvC,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CAC5C,CAAA"}

package/script/main/expect/to/have-key.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=have-key.js.map

package/script/main/expect/to/have-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"have-key.js","sourceRoot":"","sources":["../../../../src/main/expect/to/have-key.ts"],"names":[],"mappings":"","sourcesContent":["import type { Extends, IfTupleIncludes } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\ntype Result<T, K extends PropertyKey> = IfTupleIncludes<\n  [never, any],\n  K,\n  never,\n  TypeAssertionResult<Extends<K, keyof T>>\n>\n\nexport type HaveKey<T> = {\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>().to.haveKey<'prop'>().pass\n   * expect<WithProp>().to.haveKey<'missing'>().fail\n   *\n   * // Union type checks\n   * expect<WithProp>().to.haveKey<'prop' | 'another'>().pass\n   * expect<WithProp>().to.haveKey<'may' | 'unexist'>().fail\n   * ```\n   */\n  <K extends PropertyKey>(): Result<T, K>\n  <K extends PropertyKey>(_: K): Result<T, K>\n}\n"]}

package/script/main/expect/to/index.d.ts

@@ -0,0 +1,13 @@
+import type { Be } from './be.js';
+import type { Equal } from './equal.js';
+import type { Extend } from './extend.js';
+import type { ProperExtends } from './proper-extends.js';
+import type { HaveKey } from './have-key.js';
+export type To<T> = {
+    be: Be<T>;
+    equal: Equal<T>;
+    extend: Extend<T>;
+    properExtend: ProperExtends<T>;
+    haveKey: HaveKey<T>;
+};
+//# sourceMappingURL=index.d.ts.map

package/script/main/expect/to/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/main/expect/to/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AACjC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,MAAM,MAAM,EAAE,CAAC,CAAC,IAAI;IAClB,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAA;IACT,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IACf,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IACjB,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;IAC9B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CACpB,CAAA"}

package/script/main/expect/to/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/script/main/expect/to/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/main/expect/to/index.ts"],"names":[],"mappings":"","sourcesContent":["import type { Be } from './be.js'\nimport type { Equal } from './equal.js'\nimport type { Extend } from './extend.js'\nimport type { ProperExtends } from './proper-extends.js'\nimport type { HaveKey } from './have-key.js'\n\nexport type To<T> = {\n  be: Be<T>\n  equal: Equal<T>\n  extend: Extend<T>\n  properExtend: ProperExtends<T>\n  haveKey: HaveKey<T>\n}\n"]}

package/script/main/expect/to/proper-extends.d.ts

@@ -0,0 +1,21 @@
+import type { ProperExtend } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+export type ProperExtends<T> = {
+    /**
+     * Tests if the current type T properly extends the provided type U (extends but is not the same).
+     *
+     * @template U The type to check proper extension against
+     *
+     * @example
+     * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
+     * expect<2>().to.properExtend<number>().pass
+     * expect<'a' | 'b'>().to.properExtend<string>().pass
+     * expect<number>().to.properExtend<number>().fail
+     * ```
+     */
+    <U>(): TypeAssertionResult<ProperExtend<T, U>>;
+    <U>(_: U): TypeAssertionResult<ProperExtend<T, U>>;
+};
+//# sourceMappingURL=proper-extends.d.ts.map

package/script/main/expect/to/proper-extends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proper-extends.d.ts","sourceRoot":"","sources":["../../../../src/main/expect/to/proper-extends.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAC7B;;;;;;;;;;;;;OAaG;IACH,CAAC,CAAC,KAAK,mBAAmB,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAC9C,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CACnD,CAAA"}

package/script/main/expect/to/proper-extends.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=proper-extends.js.map

package/script/main/expect/to/proper-extends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proper-extends.js","sourceRoot":"","sources":["../../../../src/main/expect/to/proper-extends.ts"],"names":[],"mappings":"","sourcesContent":["import type { ProperExtend } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type ProperExtends<T> = {\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>().to.properExtend<number>().pass\n   * expect<'a' | 'b'>().to.properExtend<string>().pass\n   * expect<number>().to.properExtend<number>().fail\n   * ```\n   */\n  <U>(): TypeAssertionResult<ProperExtend<T, U>>\n  <U>(_: U): TypeAssertionResult<ProperExtend<T, U>>\n}\n"]}

package/script/main/index.d.ts

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import type { ExpectType } from './expect.js';
-export type { ExpectType } from './expect.js';
+import type { ExpectType } from './expect/index.js';
+export type { ExpectType } from './expect/index.js';
 export { NOOP } from './noop.js';
 /**
  * Creates an instance of ExpectType to perform type-level assertions on the given type.
@@ -18,13 +18,15 @@ export { NOOP } from './noop.js';
  * @example
  * ```ts
  * // Test exact type equality
- * expect<number>().toBe<number>().success
- * expect<number>().toBe<string>().fail
+ * expect<number>().to.be<number>().pass
+ * expect<number>().to.be<string>().fail
  * // Test if one type extends another
- * expect<3.14>().toExtend<number>().success
- * expect<2>().toExtend<string>().fail
+ * expect<3.14>().to.extend<number>().pass
+ * expect<2>().to.extend<string>().fail
  * ```
  */
-export declare function expect<T>(): ExpectType<T>;
-export declare function expect<T>(_: T): ExpectType<T>;
+export declare const expect: {
+    <T>(): ExpectType<T>;
+    <T>(_: T): ExpectType<T>;
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAGnD,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA;IACpB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA;CAClB,CAAA"}

package/script/main/index.js

@@ -5,12 +5,28 @@
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NOOP = void 0;
-exports.expect = expect;
+exports.expect = exports.NOOP = void 0;
 const noop_js_1 = require("./noop.js");
 var noop_js_2 = require("./noop.js");
 Object.defineProperty(exports, "NOOP", { enumerable: true, get: function () { return noop_js_2.NOOP; } });
-function expect() {
-    return noop_js_1.NOOP;
-}
+/**
+ * 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>().to.be<number>().pass
+ * expect<number>().to.be<string>().fail
+ * // Test if one type extends another
+ * expect<3.14>().to.extend<number>().pass
+ * expect<2>().to.extend<string>().fail
+ * ```
+ */
+exports.expect = noop_js_1.NOOP;
 //# sourceMappingURL=index.js.map

package/script/main/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AA6BH,wBAEC;AA5BD,uCAAgC;AAGhC,qCAAgC;AAAvB,+FAAA,IAAI,OAAA;AAuBb,SAAgB,MAAM;IACpB,OAAO,cAAI,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"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAGH,uCAAgC;AAGhC,qCAAgC;AAAvB,+FAAA,IAAI,OAAA;AAEb;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,MAAM,GAGf,cAAI,CAAA","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/index.js'\nimport { NOOP } from './noop.js'\n\nexport type { ExpectType } from './expect/index.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>().to.be<number>().pass\n * expect<number>().to.be<string>().fail\n * // Test if one type extends another\n * expect<3.14>().to.extend<number>().pass\n * expect<2>().to.extend<string>().fail\n * ```\n */\nexport const expect: {\n  <T>(): ExpectType<T>\n  <T>(_: T): ExpectType<T>\n} = NOOP\n"]}

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

@@ -17,14 +17,14 @@
  * ```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
+ * expect<Exact<string, string>>().to.be.true
+ * expect<Exact<never, never>>().to.be.true
+ * expect<Exact<any, any>>().to.be.true
+ *
+ * expect<Exact<{ a: 3 }, { a?: 3 }>>().to.be.false
+ * expect<Exact<1 | 2, 1>>().to.be.false
+ * expect<Exact<1, number>>().to.be.false
+ * expect<Exact<() => void, () => undefined>>().to.be.false
  * ```
  */
 export type Exact<A, B, Yes = true, No = false> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Yes : No;