lay-sing 0.3.0 → 0.4.1

package/README.md

@@ -9,12 +9,12 @@ TypeScript utilities for compile-time type testing and utility types
 
 ```ts
 // They do nothing at runtime
-expect<never>().toBe<never>().success
-expect<never>().toBeNever // alias for the above
-expect<never>().toBe<'should fail'>().fail
+expect<never>().to.be<never>().pass
+expect<never>().to.be.never // alias for the above
+expect<never>().to.be<'should fail'>().fail
 
-// Type Error: Property 'success' does not exist on type '{ fail: void; }'.
-expect<never>().toBe<'should fail'>().success
+// Type Error: Property 'pass' does not exist on type '{ fail: void; }'.
+expect<never>().to.be<'should fail'>().pass
 //                                    ^^^^^^^
 ```
 
@@ -84,11 +84,11 @@ The main module provides utilities for **compile-time** type validation. These u
 A typical type test statement follows this pattern:
 
 ```ts
-expect<ActualType>().toBe<ExpectedType>().success
+expect<ActualType>().to.be<ExpectedType>().pass
 ```
 
 - It starts with a function call like `expect<T>()` or `compare<T, U>()`
-- It ends with a property like `.success` or `.fail`
+- It ends with a property like `.pass` or `.fail`
 - Type error occurs only if the assertion fails
 
 > [!CAUTION]
@@ -96,8 +96,8 @@ expect<ActualType>().toBe<ExpectedType>().success
 > Only statements ending with property access are type assertions. Without property access, type error may never occur:
 >
 > ```diff
-> - expect<true>().toBe<false>()         // Type error never occur
-> + expect<true>().toBe<false>().success // Type Error: Property 'success' does not exist on type '{ fail: void; }'.
+> - expect<true>().to.be<false>()         // Type error never occur
+> + expect<true>().to.be<false>().pass // Type Error: Property 'pass' does not exist on type '{ fail: void; }'.
 > ```
 
 At runtime, the function always returns the `NOOP` object, which performs **no operation**. It can be accessed, called, or chained indefinitely without throwing errors.
@@ -106,26 +106,26 @@ At runtime, the function always returns the `NOOP` object, which performs **no o
 
 ```ts
 // Passes only if A and B are identical
-expect<keyof { a: 2 }>().toBe<'a'>().success
+expect<keyof { a: 2 }>().to.be<'a'>().pass
 
 // Passes if A extends B
-expect<12138>().toExtend<number>().success
+expect<12138>().to.extend<number>().pass
 
 // Passes if mutually assignable
-expect<{ a: 1; b: 2 }>().toEqual<{ a: 1 } & { b: 2 }>().success
+expect<{ a: 1; b: 2 }>().to.equal<{ a: 1 } & { b: 2 }>().pass
 
 // Test property existence
-expect<{ name: string }>().toHaveKey<'name'>().success
+expect<{ name: string }>().to.haveKey<'name'>().pass
 ```
 
 Aliases:
 
 ```ts
-expect<never>().toBe<never>().success
-expect<never>().toBeNever
+expect<never>().to.be<never>().pass
+expect<never>().to.be.never
 
-expect<'hello'>().toExtend<string>().success
-expect<'hello'>().toExtendString
+expect<'hello'>().to.extend<string>().pass
+expect<'hello'>().to.extend.string
 ```
 
 #### NOOP

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

@@ -0,0 +1,30 @@
+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<T, B extends boolean, R = ExpectType<T>> = [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/esm/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,EAAE,EAAE,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,mBAAmB,CAC7B,CAAC,EACD,CAAC,SAAS,OAAO,EACjB,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,IACf,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG;IACrB;;;;OAIG;IACH,IAAI,EAAE,CAAC,CAAA;CACR,GACC,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/esm/main/expect/index.js

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

package/esm/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 { 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<\n  T,\n  B extends boolean,\n  R = ExpectType<T>,\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/esm/main/expect/to/be.d.ts

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

package/esm/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,GAAG,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,SAAS,OAAO,GAAG,KAAK,IACzC;IACA,CAAC,CAAC,KAAK,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;CACzD,GACC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAC9C,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAClD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACtD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAChD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAChD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAC1D,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GAChD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,CAAA"}

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

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

package/esm/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, Xor } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type Be<T, Inv extends boolean = false> =\n  & {\n    <U>(): TypeAssertionResult<T, Xor<Inv, Exact<T, U>>>\n    <U>(_: U): TypeAssertionResult<T, Xor<Inv, Exact<T, U>>>\n  }\n  & If<Xor<Inv, Exact<T, any>>, { any: void }, {}>\n  & If<Xor<Inv, Exact<T, never>>, { never: void }, {}>\n  & If<Xor<Inv, Exact<T, unknown>>, { unknown: void }, {}>\n  & If<Xor<Inv, Exact<T, void>>, { void: void }, {}>\n  & If<Xor<Inv, Exact<T, null>>, { null: void }, {}>\n  & If<Xor<Inv, Exact<T, undefined>>, { undefined: void }, {}>\n  & If<Xor<Inv, Exact<T, true>>, { true: void }, {}>\n  & If<Xor<Inv, Exact<T, false>>, { false: void }, {}>\n"]}

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

@@ -0,0 +1,26 @@
+import type { MutuallyAssignable, Xor } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+export type Equal<T, Inv extends boolean = false> = {
+    /**
+     * 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<T, Xor<Inv, MutuallyAssignable<T, U>>>;
+    <U>(_: U): TypeAssertionResult<T, Xor<Inv, MutuallyAssignable<T, U>>>;
+};
+//# sourceMappingURL=equal.d.ts.map

package/esm/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,GAAG,EAAE,MAAM,yBAAyB,CAAA;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,GAAG,SAAS,OAAO,GAAG,KAAK,IAAI;IAClD;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,CAAC,KAAK,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;IACjE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;CACtE,CAAA"}

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

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

package/esm/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, Xor } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type Equal<T, Inv extends boolean = false> = {\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<T, Xor<Inv, MutuallyAssignable<T, U>>>\n  <U>(_: U): TypeAssertionResult<T, Xor<Inv, MutuallyAssignable<T, U>>>\n}\n"]}

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

@@ -0,0 +1,31 @@
+import type { Extends, If, Xor } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+export type Extend<T, Inv extends boolean = false> = {
+    /**
+     * 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<T, Xor<Inv, Extends<T, U>>>;
+    <U>(_: U): TypeAssertionResult<T, Xor<Inv, Extends<T, U>>>;
+} & If<Xor<Inv, Extends<T, number>>, {
+    number: void;
+}, {}> & If<Xor<Inv, Extends<T, bigint>>, {
+    bigint: void;
+}, {}> & If<Xor<Inv, Extends<T, string>>, {
+    string: void;
+}, {}> & If<Xor<Inv, Extends<T, boolean>>, {
+    boolean: void;
+}, {}> & If<Xor<Inv, Extends<T, symbol>>, {
+    symbol: void;
+}, {}>;
+//# sourceMappingURL=extend.d.ts.map

package/esm/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,GAAG,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,GAAG,SAAS,OAAO,GAAG,KAAK,IAC7C;IACA;;;;;;;;;;;;;OAaG;IACH,CAAC,CAAC,KAAK,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;IACtD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;CAC3D,GACC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACtD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACtD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACtD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,GACxD,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,EAAE,CAAC,CAAA"}

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

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

package/esm/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, Xor } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type Extend<T, Inv extends boolean = false> =\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<T, Xor<Inv, Extends<T, U>>>\n    <U>(_: U): TypeAssertionResult<T, Xor<Inv, Extends<T, U>>>\n  }\n  & If<Xor<Inv, Extends<T, number>>, { number: void }, {}>\n  & If<Xor<Inv, Extends<T, bigint>>, { bigint: void }, {}>\n  & If<Xor<Inv, Extends<T, string>>, { string: void }, {}>\n  & If<Xor<Inv, Extends<T, boolean>>, { boolean: void }, {}>\n  & If<Xor<Inv, Extends<T, symbol>>, { symbol: void }, {}>\n"]}

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

@@ -0,0 +1,38 @@
+import type { Extends, IfTupleIncludes, Xor } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+type Result<T, K extends PropertyKey, Inv extends boolean = false> = IfTupleIncludes<[
+    never,
+    any
+], K, never, TypeAssertionResult<T, Xor<Inv, Extends<K, keyof T>>>>;
+export type HaveKey<T, Inv extends boolean = false> = {
+    /**
+     * 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, Inv>;
+    <K extends PropertyKey>(_: K): Result<T, K, Inv>;
+};
+export {};
+//# sourceMappingURL=have-key.d.ts.map

package/esm/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,GAAG,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,GAAG,SAAS,OAAO,GAAG,KAAK,IAAI,eAAe,CAClF;IAAC,KAAK;IAAE,GAAG;CAAC,EACZ,CAAC,EACD,KAAK,EACL,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CACtD,CAAA;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,GAAG,SAAS,OAAO,GAAG,KAAK,IAAI;IACpD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,CAAC,CAAC,SAAS,WAAW,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAA;IAC5C,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAA;CACjD,CAAA"}

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

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

package/esm/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, Xor } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\ntype Result<T, K extends PropertyKey, Inv extends boolean = false> = IfTupleIncludes<\n  [never, any],\n  K,\n  never,\n  TypeAssertionResult<T, Xor<Inv, Extends<K, keyof T>>>\n>\n\nexport type HaveKey<T, Inv extends boolean = false> = {\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, Inv>\n  <K extends PropertyKey>(_: K): Result<T, K, Inv>\n}\n"]}

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

@@ -0,0 +1,15 @@
+import type { Not } from '../../../utils/logic/boolean.js';
+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, Inv extends boolean = false> = {
+    not: To<T, Not<Inv>>;
+    be: Be<T, Inv>;
+    equal: Equal<T, Inv>;
+    extend: Extend<T, Inv>;
+    properExtend: ProperExtends<T, Inv>;
+    haveKey: HaveKey<T, Inv>;
+};
+//# sourceMappingURL=index.d.ts.map

package/esm/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,GAAG,EAAE,MAAM,iCAAiC,CAAA;AAC1D,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,EAAE,GAAG,SAAS,OAAO,GAAG,KAAK,IAAI;IAC/C,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;IACpB,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IACd,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IACpB,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IACtB,YAAY,EAAE,aAAa,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IACnC,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;CACzB,CAAA"}

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

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

package/esm/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 { Not } from '../../../utils/logic/boolean.js'\nimport 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, Inv extends boolean = false> = {\n  not: To<T, Not<Inv>>\n  be: Be<T, Inv>\n  equal: Equal<T, Inv>\n  extend: Extend<T, Inv>\n  properExtend: ProperExtends<T, Inv>\n  haveKey: HaveKey<T, Inv>\n}\n"]}

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

@@ -0,0 +1,21 @@
+import type { ProperExtend, Xor } from '../../../utils/index.js';
+import type { TypeAssertionResult } from '../index.js';
+export type ProperExtends<T, Inv extends boolean = false> = {
+    /**
+     * 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<T, Xor<Inv, ProperExtend<T, U>>>;
+    <U>(_: U): TypeAssertionResult<T, Xor<Inv, ProperExtend<T, U>>>;
+};
+//# sourceMappingURL=proper-extends.d.ts.map

package/esm/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,GAAG,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,GAAG,SAAS,OAAO,GAAG,KAAK,IAAI;IAC1D;;;;;;;;;;;;;OAaG;IACH,CAAC,CAAC,KAAK,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;IAC3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;CAChE,CAAA"}

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

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

package/esm/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, Xor } from '../../../utils/index.js'\nimport type { TypeAssertionResult } from '../index.js'\n\nexport type ProperExtends<T, Inv extends boolean = false> = {\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<T, Xor<Inv, ProperExtend<T, U>>>\n  <U>(_: U): TypeAssertionResult<T, Xor<Inv, ProperExtend<T, U>>>\n}\n"]}

package/esm/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/esm/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/esm/main/index.js

@@ -5,7 +5,24 @@
  */
 import { NOOP } from './noop.js';
 export { NOOP } from './noop.js';
-export function expect() {
-    return 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
+ * ```
+ */
+export const expect = NOOP;
 //# sourceMappingURL=index.js.map

package/esm/main/index.js.map

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

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

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

package/esm/utils/index.d.ts

@@ -5,6 +5,7 @@
  */
 export * from './compare/index.js';
 export * from './logic/index.js';
+export * from './misc.js';
 export * from './object/index.js';
 export * from './tuple/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA"}

package/esm/utils/index.js

@@ -6,6 +6,7 @@
 // Index start >>>>>>>>>>>>>>>>
 export * from './compare/index.js';
 export * from './logic/index.js';
+export * from './misc.js';
 export * from './object/index.js';
 export * from './tuple/index.js';
 // <<<<<<<<<<<<<<<<   Index end

package/esm/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,+BAA+B;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,+BAA+B","sourcesContent":["/**\n * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)\n *\n * @module\n */\n\n// Index start >>>>>>>>>>>>>>>>\nexport * from './compare/index.js'\nexport * from './logic/index.js'\nexport * from './object/index.js'\nexport * from './tuple/index.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,+BAA+B;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,+BAA+B","sourcesContent":["/**\n * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)\n *\n * @module\n */\n\n// Index start >>>>>>>>>>>>>>>>\nexport * from './compare/index.js'\nexport * from './logic/index.js'\nexport * from './misc.js'\nexport * from './object/index.js'\nexport * from './tuple/index.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}

package/esm/utils/logic/assert.d.ts

@@ -9,9 +9,9 @@
  * ```ts
  * import { expect } from '@leawind/lay-sing'
  *
- * expect<AssertExtends<string, number>>().toBeNever
- * expect<AssertExtends<1 | 2, 1>>().toBeNever
- * expect<AssertExtends<1, 1 | 2>>().toBe<1>().success
+ * expect<AssertExtends<string, number>>().to.be.never
+ * expect<AssertExtends<1 | 2, 1>>().to.be.never
+ * expect<AssertExtends<1, 1 | 2>>().to.be<1>().pass
  * ```
  */
 export type AssertExtends<T, U> = [T] extends [U] ? T : never;

package/esm/utils/logic/assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"assert.js","sourceRoot":"","sources":["../../../src/utils/logic/assert.ts"],"names":[],"mappings":"","sourcesContent":["/**\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'\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"]}
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../../../src/utils/logic/assert.ts"],"names":[],"mappings":"","sourcesContent":["/**\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'\n *\n * expect<AssertExtends<string, number>>().to.be.never\n * expect<AssertExtends<1 | 2, 1>>().to.be.never\n * expect<AssertExtends<1, 1 | 2>>().to.be<1>().pass\n * ```\n */\nexport type AssertExtends<T, U> = [T] extends [U] ? T : never\n"]}

package/esm/utils/logic/boolean.d.ts

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

package/esm/utils/logic/boolean.d.ts.map

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

package/esm/utils/logic/boolean.js

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