lay-sing 0.2.1 → 0.4.0

package/esm/test-utils/expect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/test-utils/expect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,eAAe,EAAE,kBAAkB,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEvH;;;;;;;;;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,OAAO,EAAE,CAAC,CAAA;CACX,GACD,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG;IACpB;;;;OAIG;IACH,IAAI,EAAE,CAAC,CAAA;CACR,GACD,KAAK,CAAA;AAET,KAAK,iBAAiB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,KAAK,IAAI;IACzD;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,CAAC,KAAK,mBAAmB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAE7D;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,CAAC,KAAK,mBAAmB,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAE7E;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,CAAC,KAAK,mBAAmB,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAEnE;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,CAAC,KAAK,mBAAmB,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAE9E;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,SAAS,CAAC,CAAC,SAAS,WAAW,KAAK,eAAe,CACjD;QAAC,KAAK;QAAE,GAAG;KAAC,EACZ,CAAC,EACD,KAAK,EACL,mBAAmB,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAC3D,CAAA;CACF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,KAAK,IAAI,IAAI,CAC7D,CACI,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB;IACA,CAAC,EAAE,CAAC,CAAA;IACJ,OAAO,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAAE,CAAA;CAClC,GACC,QAAQ,CACR;IACE;;;;;;;;;;OAUG;IACH,cAAc,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,gBAAgB,GAAG,UAAU,CAAC,CAAA;IAEhE;;;;;;;;;;OAUG;IACH,cAAc,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,gBAAgB,GAAG,UAAU,CAAC,CAAA;IAEhE;;;;;;;;;;OAUG;IACH,eAAe,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,iBAAiB,GAAG,UAAU,CAAC,CAAA;CACnE,EACC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,gBAAgB,CAAC,GACxC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,gBAAgB,CAAC,GACxC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,CAC7C,GACC,QAAQ,CACR;IACE;;;;;;;;;OASG;IACH,OAAO,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,GAAG,MAAM,CAAC,CAAA;IAE9C;;;;;;;;;OASG;IACH,SAAS,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,MAAM,CAAC,CAAA;IAElD;;;;;;;;;OASG;IACH,WAAW,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,aAAa,GAAG,MAAM,CAAC,CAAA;IAEtD;;;;;;;;;OASG;IACH,QAAQ,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,GAAG,MAAM,CAAC,CAAA;IAEhD;;;;;;;;;OASG;IACH,QAAQ,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,GAAG,MAAM,CAAC,CAAA;IAEhD;;;;;;;;;OASG;IACH,aAAa,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,eAAe,GAAG,MAAM,CAAC,CAAA;IAE1D;;;;;;;;;OASG;IACH,QAAQ,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,GAAG,MAAM,GAAG,iBAAiB,CAAC,CAAA;IAEpE;;;;;;;;;OASG;IACH,SAAS,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,MAAM,GAAG,iBAAiB,CAAC,CAAA;CACvE,EACC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,SAAS,CAAC,GAC5B,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,WAAW,CAAC,GAChC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,GACpC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,UAAU,CAAC,GAC9B,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,UAAU,CAAC,GAC9B,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,eAAe,CAAC,GACxC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,UAAU,CAAC,GAC9B,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,WAAW,CAAC,CACnC,CACF,EACD,CAAC,CACF,CAAA"}

package/esm/test-utils/expect.js

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

package/esm/test-utils/expect.js.map

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

package/esm/test-utils/index.d.ts

@@ -1,77 +0,0 @@
-/**
- * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
- *
- * @module
- */
-import type { CompareTypes } from './compare.js';
-import type { ExpectType } from './expect.js';
-export type { CompareTypes } from './compare.js';
-export type { ExpectType } from './expect.js';
-/**
- * A universal no-op placeholder implemented via `Proxy`.
- *
- * `NOOP` can be accessed, called, or chained indefinitely without throwing.
- * Every operation returns itself, making it safe to use as a dummy fallback
- * for APIs, optional hooks, or unimplemented interfaces.
- *
- * ### Special behaviors
- *
- * - Callable: invoking `NOOP()` returns `NOOP`
- * - Property access: `NOOP.anything` returns `NOOP`
- * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise
- * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields
- *   a stable string representation: `"[NOOP]"`
- *
- * This is useful in scenarios where a value is required syntactically but
- * should perform no action and never fail at runtime.
- *
- * @example
- * ```ts
- * NOOP.foo.bar().baz.qux; // safe, returns NOOP
- * String(NOOP); // "[NOOP]"
- * await NOOP; // does not await (not thenable)
- * ```
- */
-export declare const NOOP: any;
-/**
- * Creates an instance of CompareTypes to perform type-level comparisons between two types.
- * This function enables testing various relationships between types at compile time.
- * NOTE: This function does nothing at runtime and is purely for type-level testing.
- *
- * @template T First type to compare
- * @template U Second type to compare
- *
- * @returns A CompareTypes instance with methods to test relationships between T and U
- *
- * @example
- * ```ts
- * // Compare two identical types
- * compare<number, number>().same // Results in an available property
- * // Compare two different but overlapping types
- * compare<4, number>().overlap.different // Results in available properties
- * ```
- */
-export declare function compare<T, U>(): CompareTypes<T, U>;
-export declare function compare<T, U>(t: T, u: U): CompareTypes<T, U>;
-/**
- * Creates an instance of ExpectType to perform type-level assertions on the given type.
- * This function enables testing various type relationships at compile time.
- * NOTE: This function does nothing at runtime and is purely for type-level testing.
- *
- * @template T The type to be tested
- *
- * @returns An ExpectType instance with methods to test type relationships
- *
- * @example
- * ```ts
- * // Test exact type equality
- * expect<number>().toBe<number>().success
- * expect<number>().toBe<string>().fail
- * // Test if one type extends another
- * expect<3.14>().toExtend<number>().success
- * expect<2>().toExtend<string>().fail
- * ```
- */
-export declare function expect<T>(): ExpectType<T>;
-export declare function expect<T>(_: T): ExpectType<T>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,IAAI,EAAE,GA0BlB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AACnD,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAK7D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA;AAC1C,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA"}

package/esm/test-utils/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,IAAI,CAAA;AACb,CAAC,EACD;IACE,GAAG,CAAC,CAAC,EAAE,IAAI;QACT,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,OAAO,SAAS,CAAA;YAClB,KAAK,SAAS,CAAC;YACf,KAAK,UAAU,CAAC;YAChB,KAAK,MAAM,CAAC,WAAW;gBACrB,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAA;YACvB;gBACE,OAAO,IAAI,CAAA;QACf,CAAC;IACH,CAAC;IACD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,wBAAwB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC/B,YAAY,EAAE,IAAI;QAClB,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI;IAC1B,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW,CAAC;CAC7B,CACF,CAAA;AAsBD,MAAM,UAAU,OAAO;IACrB,OAAO,IAAI,CAAA;AACb,CAAC;AAuBD,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 { CompareTypes } from './compare.js'\nimport type { ExpectType } from './expect.js'\n\nexport type { CompareTypes } from './compare.js'\nexport type { ExpectType } from './expect.js'\n\n/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * @example\n * ```ts\n * NOOP.foo.bar().baz.qux; // safe, returns NOOP\n * String(NOOP); // \"[NOOP]\"\n * await NOOP; // does not await (not thenable)\n * ```\n */\nexport const NOOP: any = new Proxy(\n  function () {\n    return NOOP\n  },\n  {\n    get(_, prop) {\n      switch (prop) {\n        case 'then':\n          return undefined\n        case 'valueOf':\n        case 'toString':\n        case Symbol.toPrimitive:\n          return () => '[NOOP]'\n        default:\n          return NOOP\n      }\n    },\n    set: () => true,\n    getOwnPropertyDescriptor: () => ({\n      configurable: true,\n      value: NOOP,\n    }),\n    getPrototypeOf: () => null,\n    has: () => true,\n    ownKeys: () => ['prototype'],\n  },\n)\n\n/**\n * Creates an instance of CompareTypes to perform type-level comparisons between two types.\n * This function enables testing various relationships between types at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T First type to compare\n * @template U Second type to compare\n *\n * @returns A CompareTypes instance with methods to test relationships between T and U\n *\n * @example\n * ```ts\n * // Compare two identical types\n * compare<number, number>().same // Results in an available property\n * // Compare two different but overlapping types\n * compare<4, number>().overlap.different // Results in available properties\n * ```\n */\nexport function compare<T, U>(): CompareTypes<T, U>\nexport function compare<T, U>(t: T, u: U): CompareTypes<T, U>\nexport function compare<T, U>(): CompareTypes<T, U> {\n  return NOOP\n}\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * @example\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\n"]}

package/script/main/async.d.ts

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

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

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

package/script/main/async.js.map

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

package/script/main/boolean.d.ts

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

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

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

package/script/main/boolean.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Negates a boolean type\n *\n * @template T - The boolean type to negate\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<Not<true>>().toBeFalse\n * expect<Not<false>>().toBeTrue\n * expect<Not<boolean>>().toBe<boolean>().success\n * ```\n */\nexport type Not<T extends boolean> = T extends true ? false\n  : T extends false ? true\n  : boolean\n\n/**\n * Logical AND operation on two boolean types\n *\n * @template A - The first boolean type to compare\n * @template B - The second boolean type to compare\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<And<true, true>>().toBeTrue\n * expect<And<true, false>>().toBeFalse\n * expect<And<false, true>>().toBeFalse\n * expect<And<false, false>>().toBeFalse\n * expect<And<boolean, boolean>>().toBe<boolean>().success\n * ```\n */\nexport type And<\n  A extends boolean,\n  B extends boolean,\n> = A extends never ? never\n  : [B] extends [never] ? never\n  : (A extends true ? (B extends true ? true : false) : false)\n\n/**\n * Logical OR operation on two boolean types\n *\n * @template A - The first boolean type to compare\n * @template B - The second boolean type to compare\n *\n * ### Result\n *\n * - `never`: if either `A` or `B` is `never`\n * - `boolean`: if either `A` or `B` is `boolean` or `any`\n * - `false`: if both `A` and `B` are `false`\n * - `true`: otherwise\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<Or<true, true>>().toBeTrue\n * expect<Or<true, false>>().toBeTrue\n * expect<Or<false, true>>().toBeTrue\n * expect<Or<false, false>>().toBeFalse\n * expect<Or<boolean, false>>().toBe<boolean>().success\n * ```\n */\nexport type Or<\n  A extends boolean,\n  B extends boolean,\n> = [A] extends [never] ? never\n  : [B] extends [never] ? never\n  : [boolean] extends [A] ? boolean\n  : [boolean] extends [B] ? boolean\n  : true extends A ? true\n  : true extends B ? true\n  : false\n"]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,KAAK,IAAI,SAAS,SAAS,IAAI,GAAG,GAAG,GAAG,EAAE,CAAA;AAE9F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,OAAO,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,KAAK,IAAI,SAAS,SAAS,KAAK,GAAG,GAAG,GAAG,EAAE,CAAA;AAEpG;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAE7D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,EACD,KAAK,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAC3C,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,SAAS,EAAE,MAAM,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,MAAM,GACpF,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GACvF,CAAC,KAAK,CAAC,CACZ,GACC,OAAO,CAAA;AAEX;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,EACD,KAAK,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAC3C,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAC5B,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,GAC5G,KAAK,CACV,GACC,OAAO,CAAA"}

package/script/main/control.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"control.js","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from './type/compare.js'\n\n/**\n * Conditional type - returns `Yes` if condition `Condition` is true, otherwise returns `No`\n *\n * @template Condition - The boolean condition to check\n * @template Yes - The type to return if condition is true\n * @template No - The type to return if condition is false (defaults to `never`)\n *\n * @example\n * ```ts\n * type Result = If<true, 'yes', 'no'> // 'yes'\n * type Result2 = If<false, 'yes', 'no'> // 'no'\n * type BoolResult = If<boolean, 'yes', 'no'> // boolean\n * ```\n */\nexport type If<Condition extends boolean, Yes, No = never> = Condition extends true ? Yes : No\n\n/**\n * Conditional type - returns `Yes` if condition `Condition` is false, otherwise returns `No`\n *\n * @template Condition - The boolean condition to check\n * @template Yes - The type to return if condition is false\n * @template No - The type to return if condition is true (defaults to `never`)\n *\n * ### Result\n *\n * - `never`: if `Condition` is `never`\n * - `Yes`: if `Condition` is `false`\n * - `No`: if `Condition` is `true`\n *\n * @example\n * ```ts\n * type Result = IfFalse<false, 'yes', 'no'> // 'yes'\n * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'\n * type BoolResult = IfFalse<boolean, 'yes', 'no'> // boolean\n * ```\n */\nexport type IfFalse<Condition extends boolean, Yes, No = never> = Condition extends false ? Yes : No\n\n/**\n * Case tuple type used with `SwitchExact` and `SwitchExtends`\n *\n * @template T - The condition type to match against\n * @template Result - The result type to return if match is found\n *\n * @example\n * ```ts\n * type MyCase = Case<1, 'one'>\n * // Equivalent to: [1, 'one']\n * ```\n *\n * @see SwitchExact\n */\nexport type Case<T = unknown, Result = unknown> = [T, Result]\n\n/**\n * Default case type used with `SwitchExact` and `SwitchExtends`\n *\n * @template T - The default result type\n *\n * @example\n * ```ts\n * type NameMap<id> = SwitchExact<id, [\n *   [1, 'Alice'],\n *   [2, 'Bob'],\n * ], DefaultCase<'Steve'>>\n * ```\n *\n * @see SwitchExact\n */\nexport type DefaultCase<T> = T\n\n/**\n * Switch type that uses exact matching logic\n *\n * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.\n *\n * @template T - The type to match against cases\n * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]\n * @template Default - Default result if no exact match is found (defaults to `never`)\n *\n * @example\n * ```ts\n * type Result = SwitchExact<2, [\n *   [1, 'Alice'],\n *   [2, 'Bob'],\n *   [3, 'Charlie'],\n * ], DefaultCase<'Steve'>>\n *\n * // Result: 'Bob'\n * ```\n */\nexport type SwitchExact<\n  T,\n  Cases extends readonly [unknown, unknown][],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer Condition, infer Result] ? (Exact<T, Condition> extends true ? Result\n        : (SwitchExact<T, Rest extends readonly [unknown, unknown][] ? Rest : never, Default>))\n      : (never)\n  )\n  : Default\n\n/**\n * Switch type that uses 'extends' logic instead of 'Exact' logic\n *\n * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.\n *\n * @template T - The type to match against cases\n * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]\n * @template Default - Default result if no match is found (defaults to `never`)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<\n *   SwitchExtends<string, [\n *     [number, boolean],\n *     [string, boolean],\n *   ], Error>\n * >().toBe<boolean>().success\n * ```\n */\nexport type SwitchExtends<\n  T,\n  Cases extends readonly [unknown, unknown][],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer C, infer R]\n      ? ([T] extends [C] ? R : SwitchExtends<T, Rest extends readonly [unknown, unknown][] ? Rest : never, Default>)\n      : never\n  )\n  : Default\n"]}

package/script/main/doc.d.ts

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

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

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

package/script/main/doc.js.map

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

package/script/main/function.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,CAAC,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;AAE/B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,KAAK,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA"}

package/script/main/function.js

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

package/script/main/function.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.js","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents a function with any parameters and a specific return type\n *\n * @template Return - The return type of the function\n * @template Params - The parameters of the function as a tuple type\n *\n * @example\n * ```ts\n * type NumberToStringFn = AnyFunction<string, [number]>\n * // Equivalent to: (arg: number) => string\n * ```\n */\nexport type AnyFunction<\n  Return = any,\n  Params extends any[] = any[],\n> = (...args: Params) => Return\n\n/**\n * Represents a constructor function with any parameters and a specific return type\n *\n * @template Return - The type returned by the constructor function\n * @template Params - The parameters of the constructor function as a tuple type\n *\n * @example\n * ```ts\n * type StringConstructor = Constructor<string, [number]>\n * // Equivalent to: new (arg: number) => string\n * ```\n */\nexport type Constructor<\n  Return = any,\n  Params extends any[] = any[],\n> = new (...args: Params) => Return\n"]}

package/script/main/json.d.ts

@@ -1,44 +0,0 @@
-/**
- * Primitive values allowed by the JSON specification.
- *
- * This represents the set of non-object, non-array values
- * that can appear in valid JSON data.
- */
-export type JsonPrimitive = string | number | boolean | null;
-/**
- * A JSON array.
- *
- * Each element of the array must itself be a valid `JsonValue`.
- */
-export type JsonArray = JsonValue[];
-/**
- * A JSON object.
- *
- * Keys are strings, and values must be valid `JsonValue`s.
- * This mirrors the object structure defined by the JSON specification.
- */
-export type JsonObject = {
-    [key: string]: JsonValue;
-};
-/**
- * Any valid JSON value.
- *
- * This is a strict representation of JSON data, suitable for
- * describing the result of `JSON.parse`, serialized payloads,
- * or schema-level JSON structures.
- */
-export type JsonValue = JsonPrimitive | JsonArray | JsonObject;
-/**
- * A JavaScript value that can be safely serialized to JSON.
- *
- * Unlike `JsonValue`, this type represents values *before*
- * serialization, describing the set of recursive structures
- * that `JSON.stringify` can handle.
- *
- * This is useful for constraining inputs that are expected to
- * be JSON-serializable, rather than already being JSON data.
- */
-export type Jsonable = string | number | boolean | null | Jsonable[] | {
-    [key: string]: Jsonable;
-};
-//# sourceMappingURL=json.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/main/json.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;AAE5D;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,EAAE,CAAA;AAEnC;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAErD;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,SAAS,GAAG,UAAU,CAAA;AAE9D;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAChB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,QAAQ,EAAE,GACV;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA"}

package/script/main/json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/main/json.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Primitive values allowed by the JSON specification.\n *\n * This represents the set of non-object, non-array values\n * that can appear in valid JSON data.\n */\nexport type JsonPrimitive = string | number | boolean | null\n\n/**\n * A JSON array.\n *\n * Each element of the array must itself be a valid `JsonValue`.\n */\nexport type JsonArray = JsonValue[]\n\n/**\n * A JSON object.\n *\n * Keys are strings, and values must be valid `JsonValue`s.\n * This mirrors the object structure defined by the JSON specification.\n */\nexport type JsonObject = { [key: string]: JsonValue }\n\n/**\n * Any valid JSON value.\n *\n * This is a strict representation of JSON data, suitable for\n * describing the result of `JSON.parse`, serialized payloads,\n * or schema-level JSON structures.\n */\nexport type JsonValue = JsonPrimitive | JsonArray | JsonObject\n\n/**\n * A JavaScript value that can be safely serialized to JSON.\n *\n * Unlike `JsonValue`, this type represents values *before*\n * serialization, describing the set of recursive structures\n * that `JSON.stringify` can handle.\n *\n * This is useful for constraining inputs that are expected to\n * be JSON-serializable, rather than already being JSON data.\n */\nexport type Jsonable =\n  | string\n  | number\n  | boolean\n  | null\n  | Jsonable[]\n  | { [key: string]: Jsonable }\n"]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,cAAc,CAAC,GAAG,EAAE,SAAS,IAAI,OAAO,CAClD;KACG,CAAC,IAAI,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK;CAC9E,CAAC,MAAM,GAAG,CAAC,EACZ,SAAS,CACV,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,eAAe,CAAC,GAAG,EAAE,SAAS,IAAI,OAAO,CACnD;KAAG,CAAC,IAAI,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,MAAM,GAAG,CAAC,EAClF,SAAS,CACV,CAAA"}

package/script/main/key.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from './type/index.js'\n\n/**\n * Extracts the keys of an object whose **base value type** matches the specified `ValueType` (ignoring undefined from optional properties).\n *\n * This utility matches the underlying/base type of each property (stripping `undefined` added by optional modifiers `?`).\n * For optional properties (e.g., `a?: string`), the type is treated as `string` – no need to include `undefined` in `ValueType` to match.\n *\n * @template Obj - The target object type to extract keys from.\n * @template ValueType - The base type to match against property values (ignoring undefined from optional properties).\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * // Basic usage: match base type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * expect<KeysOfBaseType<A, 1>>().toBe<'a' | 'c'>().success\n *\n * // Key difference: optional property matching (ignores undefined)\n * type B = { a?: string; b: string };\n * expect<KeysOfBaseType<B, string>>().toBe<'a' | 'b'>().success // matches base type of both\n * expect<KeysOfBaseType<B, string | undefined>>().toBe<never>().success // base type does not include undefined\n *\n * type C = { a: never; b: any; c: unknown };\n * expect<KeysOfBaseType<C, never>>().toBe<'a'>().success\n * expect<KeysOfBaseType<C, any>>().toBe<'b'>().success\n * expect<KeysOfBaseType<C, unknown>>().toBe<'c'>().success\n * ```\n */\nexport type KeysOfBaseType<Obj, ValueType> = Exclude<\n  {\n    [K in keyof Obj]: Exact<Required<Obj>[K], ValueType> extends true ? K : never\n  }[keyof Obj],\n  undefined\n>\n\n/**\n * Extracts the keys of an object whose **complete value type** exactly matches the specified `ValueType` (including undefined for optional properties).\n *\n * This utility strictly matches the full type of each property (including `undefined` added by optional modifiers `?`).\n * For optional properties (e.g., `a?: string`), the type is treated as `string | undefined` – to match, `ValueType` must include `undefined`.\n *\n * @template Obj - The target object type to extract keys from.\n * @template ValueType - The exact type to match against property values (including undefined for optional properties).\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * // Basic usage: match exact type (non-optional property)\n * type A = { a: 1; b: 2; c: 1 };\n * expect<KeysOfExactType<A, 1>>().toBe<'a' | 'c'>().success\n *\n * // Key difference: optional property matching (requires undefined in `ValueType`)\n * type B = { a?: string };\n * expect<KeysOfExactType<B, string | undefined>>().toBe<'a'>().success // matches complete type\n * expect<KeysOfExactType<B, string>>().toBe<never>().success // does not match complete type\n *\n * type C = { a: never; b: any; c: unknown };\n * expect<KeysOfExactType<C, never>>().toBe<'a'>().success\n * expect<KeysOfExactType<C, any>>().toBe<'b'>().success\n * expect<KeysOfExactType<C, unknown>>().toBe<'c'>().success\n * ```\n */\nexport type KeysOfExactType<Obj, ValueType> = Exclude<\n  { [K in keyof Obj]: Exact<Obj[K], ValueType> extends true ? K : never }[keyof Obj],\n  undefined\n>\n"]}

package/script/main/object.d.ts

@@ -1,120 +0,0 @@
-import type { KeysOfExactType } from './key.js';
-/**
- * Get property type from object, with fallback for missing keys.
- *
- * @template Obj - The object type to access
- * @template K - The key to access in the object
- * @template E - The fallback type if the key doesn't exist (defaults to `never`)
- *
- * @returns `Obj[K]` if key exists, otherwise `E`.
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * type User = { name: string; age?: number };
- *
- * expect<Access<User, 'name'>>().toBe<string>().success
- * expect<Access<User, 'age'>>().toBe<number | undefined>().success
- * expect<Access<User, 'email', 'none'>>().toBe<'none'>().success
- * ```
- */
-export type Access<Obj, K extends PropertyKey, E = never> = K extends keyof Obj ? Obj[K] : E;
-/**
- * Inverse of `Access` - gets keys from an object that have values of a specific type
- *
- * @template T - The object type to inspect
- * @template V - The value type to match against
- * @template E - The fallback type if no keys match (defaults to `never`)
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * expect<InverseAccess<{ a: string }, string>>().toBe<'a'>().success
- * expect<InverseAccess<{ a: string; b: string }, string>>().toBe<'a' | 'b'>().success
- * expect<InverseAccess<{ a: string }, number>>().toBe<never>().success
- * ```
- */
-export type InverseAccess<T, V, E = never> = {
-    [K in keyof T]: T[K] extends V ? K : E;
-}[keyof T];
-/**
- * Recursively makes all properties of `T` optional
- *
- * @template T - The object type to make deep partial
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * type Result = DeepPartial<{ a: string; nested: { b: number } }>
- * expect<Result>().toBe<{ a?: string; nested?: { b?: number } }>().success
- * ```
- */
-export type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-/**
- * Recursively makes all properties of `T` required
- *
- * @template T - The object type to make deep required
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * expect<DeepRequire<{ _?: { _?: 1 } }>>().toBe<{ _: { _: 1 } }>().success
- * ```
- */
-export type DeepRequire<T> = {
-    [K in keyof T]-?: T[K] extends object | undefined ? DeepRequire<NonNullable<T[K]>> : T[K];
-};
-/**
- * **⚠️Important:** parameter `T` and `U` are not distributive. When they are union type, it treats them as a single entity.
- *
- * @template T - The type to test (not distributed over unions)
- * @template U - The constraint type to test against
- *
- * @example
- *
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * expect<AssertExtends<string, number>>().toBeNever
- * expect<AssertExtends<1 | 2, 1>>().toBeNever
- * expect<AssertExtends<1, 1 | 2>>().toBe<1>().success
- * ```
- */
-export type AssertExtends<T, U> = [T] extends [U] ? T : never;
-/**
- * Safely picks keys `Key` from type `Obj`, excluding non-existent keys
- *
- * @template Obj - The object type to pick keys from
- * @template Key - The keys to pick from the object
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'>
- * expect<Result>().toBe<{ a: string }>().success
- * ```
- */
-export type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>;
-/**
- * Picks properties from `T` that have values of type `U`
- *
- * @template T - The object type to pick properties from
- * @template U - The value type to match against
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- * type A = { a: string; b: number; c: string }
- * type Strings = PropsOfBaseType<A, string> // { a: string; c: string }
- * expect<PropsOfBaseType<A, string>>().toBe<{ a: string; c: string }>()
- * ```
- */
-export type PropsOfBaseType<T, U> = Pick<T, KeysOfExactType<Required<T>, U>>;
-//# sourceMappingURL=object.d.ts.map

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

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

package/script/main/object.js

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

package/script/main/object.js.map

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