lay-sing 0.2.0 → 0.3.0

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

@@ -0,0 +1,16 @@
+/**
+ * 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'
+ *
+ * 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>;
+//# sourceMappingURL=pick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../src/utils/object/pick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,CAAC,CAAA"}

package/esm/utils/object/pick.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pick.js","sourceRoot":"","sources":["../../../src/utils/object/pick.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Safely picks keys `Key` from type `Obj`, excluding non-existent keys\n *\n * @template Obj - The object type to pick keys from\n * @template Key - The keys to pick from the object\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'>\n * expect<Result>().toBe<{ a: string }>().success\n * ```\n */\nexport type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>\n"]}

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

@@ -0,0 +1,17 @@
+import type { KeysOfBaseType } from '../index.js';
+/**
+ * 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'
+ * 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, KeysOfBaseType<Required<T>, U>>;
+//# sourceMappingURL=props.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/utils/object/props.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}

package/esm/utils/object/props.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"props.js","sourceRoot":"","sources":["../../../src/utils/object/props.ts"],"names":[],"mappings":"","sourcesContent":["import type { KeysOfBaseType } from '../index.js'\n\n/**\n * Picks properties from `T` that have values of type `U`\n *\n * @template T - The object type to pick properties from\n * @template U - The value type to match against\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n * type A = { a: string; b: number; c: string }\n * type Strings = PropsOfBaseType<A, string> // { a: string; c: string }\n * expect<PropsOfBaseType<A, string>>().toBe<{ a: string; c: string }>()\n * ```\n */\nexport type PropsOfBaseType<T, U> = Pick<T, KeysOfBaseType<Required<T>, U>>\n"]}

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

@@ -0,0 +1,17 @@
+import type { IfTupleIncludes } from '../index.js';
+/**
+ * Appends an element to a tuple only if it doesn't already exist in the tuple
+ *
+ * @template Tuple - The tuple type to append to
+ * @template Element - The element type to append
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * expect<AppendUnique<[1, 2, 3], 4>>().toBe<[1, 2, 3, 4]>().success
+ * expect<AppendUnique<[1, 2, 3], 2>>().toBe<[1, 2, 3]>().success
+ * ```
+ */
+export type AppendUnique<Tuple extends readonly unknown[], Element> = IfTupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element];
+//# sourceMappingURL=append.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../../../src/utils/tuple/append.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,CACtB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,CAAA"}

package/esm/utils/tuple/append.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"append.js","sourceRoot":"","sources":["../../../src/utils/tuple/append.ts"],"names":[],"mappings":"","sourcesContent":["import type { IfTupleIncludes } from '../index.js'\n\n/**\n * Appends an element to a tuple only if it doesn't already exist in the tuple\n *\n * @template Tuple - The tuple type to append to\n * @template Element - The element type to append\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * expect<AppendUnique<[1, 2, 3], 4>>().toBe<[1, 2, 3, 4]>().success\n * expect<AppendUnique<[1, 2, 3], 2>>().toBe<[1, 2, 3]>().success\n * ```\n */\nexport type AppendUnique<\n  Tuple extends readonly unknown[],\n  Element,\n> = IfTupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element]\n"]}

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

@@ -0,0 +1,31 @@
+import type { AppendUnique } from '../index.js';
+/**
+ * Concatenates two tuples into a single tuple type
+ *
+ * @template Left - The first tuple type to concatenate
+ * @template Right - The second tuple type to concatenate
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * expect<ConcatTuple<[1, 2], [3, 4]>>().toBe<[1, 2, 3, 4]>().success
+ * ```
+ */
+export type ConcatTuple<Left extends readonly unknown[], Right extends readonly unknown[]> = Left extends readonly unknown[] ? (Right extends readonly unknown[] ? [...Left, ...Right] : never) : never;
+/**
+ * Concatenates two tuples while ensuring uniqueness of elements
+ *
+ * @template Left - The first tuple type to concatenate
+ * @template Right - The second tuple type to concatenate
+ * @template R - The intermediate result tuple type (defaults to `Left`)
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * expect<ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]>>().toBe<[1, 2, 3, 4]>().success
+ * ```
+ */
+export type ConcatUniqueTuple<Left extends readonly unknown[], Right extends readonly unknown[], R extends readonly unknown[] = Left> = Right extends readonly [infer First, ...infer Rest] ? ConcatUniqueTuple<Left, Rest, AppendUnique<R, First>> : R;
+//# sourceMappingURL=concat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../src/utils/tuple/concat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CACrB,IAAI,SAAS,SAAS,OAAO,EAAE,EAC/B,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,IAAI,SAAS,SAAS,OAAO,EAAE,GAAG,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,CAAA;AAE9G;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,CAC3B,IAAI,SAAS,SAAS,OAAO,EAAE,EAC/B,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,IAAI,IACjC,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAA"}

package/esm/utils/tuple/concat.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat.js","sourceRoot":"","sources":["../../../src/utils/tuple/concat.ts"],"names":[],"mappings":"","sourcesContent":["// Import needed for ConcatUniqueTuple\nimport type { AppendUnique } from '../index.js'\n\n/**\n * Concatenates two tuples into a single tuple type\n *\n * @template Left - The first tuple type to concatenate\n * @template Right - The second tuple type to concatenate\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * expect<ConcatTuple<[1, 2], [3, 4]>>().toBe<[1, 2, 3, 4]>().success\n * ```\n */\nexport type ConcatTuple<\n  Left extends readonly unknown[],\n  Right extends readonly unknown[],\n> = Left extends readonly unknown[] ? (Right extends readonly unknown[] ? [...Left, ...Right] : never) : never\n\n/**\n * Concatenates two tuples while ensuring uniqueness of elements\n *\n * @template Left - The first tuple type to concatenate\n * @template Right - The second tuple type to concatenate\n * @template R - The intermediate result tuple type (defaults to `Left`)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * expect<ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]>>().toBe<[1, 2, 3, 4]>().success\n * ```\n */\nexport type ConcatUniqueTuple<\n  Left extends readonly unknown[],\n  Right extends readonly unknown[],\n  R extends readonly unknown[] = Left,\n> = Right extends readonly [infer First, ...infer Rest] ? ConcatUniqueTuple<Left, Rest, AppendUnique<R, First>> : R\n"]}

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

@@ -0,0 +1,20 @@
+import type { Exact } from '../index.js';
+/**
+ * Checks whether a tuple includes a specific element type
+ *
+ * @template Tuple - The tuple type to check
+ * @template Element - The element type to look for
+ * @template Yes - The result if the element is found (defaults to `true`)
+ * @template No - The result if the element is not found (defaults to `false`)
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * expect<IfTupleIncludes<[1, 2, 3], 2>>().toBeTrue
+ * expect<IfTupleIncludes<[1, 2, 3], 4>>().toBeFalse
+ * expect<IfTupleIncludes<[1, 2, 1], 1>>().toBeTrue
+ * ```
+ */
+export type IfTupleIncludes<Tuple extends readonly unknown[], Element, Yes = true, No = false> = Exact<Tuple, any> extends true ? never : Tuple extends readonly [infer First, ...infer Rest] ? (Exact<Element, First> extends true ? Yes : IfTupleIncludes<Rest, Element, Yes, No>) : No;
+//# sourceMappingURL=includes.d.ts.map

package/esm/utils/tuple/includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.ts","sourceRoot":"","sources":["../../../src/utils/tuple/includes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,eAAe,CACzB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,EACP,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,IAAI,GAAG,KAAK,GACtC,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GACjD,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,IAAI,GAAG,GAAG,GAAG,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,GACtF,EAAE,CAAA"}

package/esm/utils/tuple/includes.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../../src/utils/tuple/includes.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from '../index.js'\n\n/**\n * Checks whether a tuple includes a specific element type\n *\n * @template Tuple - The tuple type to check\n * @template Element - The element type to look for\n * @template Yes - The result if the element is found (defaults to `true`)\n * @template No - The result if the element is not found (defaults to `false`)\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * expect<IfTupleIncludes<[1, 2, 3], 2>>().toBeTrue\n * expect<IfTupleIncludes<[1, 2, 3], 4>>().toBeFalse\n * expect<IfTupleIncludes<[1, 2, 1], 1>>().toBeTrue\n * ```\n */\nexport type IfTupleIncludes<\n  Tuple extends readonly unknown[],\n  Element,\n  Yes = true,\n  No = false,\n> = Exact<Tuple, any> extends true ? never\n  : Tuple extends readonly [infer First, ...infer Rest]\n    ? (Exact<Element, First> extends true ? Yes : IfTupleIncludes<Rest, Element, Yes, No>)\n  : No\n"]}

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

@@ -0,0 +1,4 @@
+export * from './append.js';
+export * from './concat.js';
+export * from './includes.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/tuple/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA"}

package/esm/utils/tuple/index.js

@@ -0,0 +1,6 @@
+// Index start >>>>>>>>>>>>>>>>
+export * from './append.js';
+export * from './concat.js';
+export * from './includes.js';
+// <<<<<<<<<<<<<<<<   Index end
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/tuple/index.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,+BAA+B","sourcesContent":["// Index start >>>>>>>>>>>>>>>>\nexport * from './append.js'\nexport * from './concat.js'\nexport * from './includes.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lay-sing",
-  "version": "0.2.0",
-  "description": "Utilities for compile-time type testing and utility types",
+  "version": "0.3.0",
+  "description": "Utilities for compile-time type testing",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Leawind/lay-sing.git"
@@ -10,9 +10,9 @@
   "main": "./esm/index.js",
   "module": "./esm/index.js",
   "exports": {
-    "./test-utils": {
-      "import": "./esm/test-utils/index.js",
-      "require": "./script/test-utils/index.js"
+    "./utils": {
+      "import": "./esm/utils/index.js",
+      "require": "./script/utils/index.js"
     },
     ".": {
       "import": "./esm/main/index.js",

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

@@ -1,4 +1,4 @@
-import type { Exact, Extends, If, IfTupleIncludes, ProperExtend, SafePick } from '../main/index.js';
+import type { Exact, Extends, If, IfTupleIncludes, MutuallyAssignable, ProperExtend, SafePick } from '../utils/index.js';
 /**
  * Represents the result of a type assertion based on a boolean condition.
  *
@@ -32,12 +32,36 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      *
      * @example
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<any>().toBe<any>().success
      * expect<never>().toBe<never>().success
      * expect<false>().toBe<true>().fail
      * ```
      */
-    toBe<U>(): TypeAssertionResult<Exact<T, U>>;
+    toBe<U>(): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>;
+    toBe<U>(_: U): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>;
+    /**
+     * Tests if the current type is mutually assignable with the provided type U.
+     *
+     * 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 }>().toEqual<{ a: 1 } & { b: 2 }>().success
+     * expect<1>().toEqual<1 | 2>().fail
+     * ```
+     */
+    toEqual<U>(): TypeAssertionResult<MutuallyAssignable<T, U>, ExpectType<T, H>>;
+    toEqual<U>(_: U): TypeAssertionResult<MutuallyAssignable<T, U>, ExpectType<T, H>>;
     /**
      * Tests if the current type T extends the provided type U.
      *
@@ -45,12 +69,15 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      *
      * @example
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<3.14>().toExtend<number>().success
      * expect<2>().toExtend<string>().fail
      * expect<'hello'>().toExtend<string>().success
      * ```
      */
-    toExtend<U>(): TypeAssertionResult<Extends<T, U>>;
+    toExtend<U>(): TypeAssertionResult<Extends<T, U>, ExpectType<T, H>>;
+    toExtend<U>(_: U): TypeAssertionResult<Extends<T, U>, ExpectType<T, H>>;
     /**
      * Tests if the current type T properly extends the provided type U (extends but is not the same).
      *
@@ -58,12 +85,15 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      *
      * @example
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<2>().toProperExtend<number>().success
      * expect<'a' | 'b'>().toProperExtend<string>().success
      * expect<number>().toProperExtend<number>().fail
      * ```
      */
-    toProperExtend<U>(): TypeAssertionResult<ProperExtend<T, U>>;
+    toProperExtend<U>(): TypeAssertionResult<ProperExtend<T, U>, ExpectType<T, H>>;
+    toProperExtend<U>(_: U): TypeAssertionResult<ProperExtend<T, U>, ExpectType<T, H>>;
     /**
      * Tests if the current type `T` has a property with key `K`.
      *
@@ -77,6 +107,8 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      * ### Examples
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * type WithProp = { prop: string; another: number; may?: 5 }
      *
      * // Single key checks
@@ -88,8 +120,22 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
      * expect<WithProp>().toHaveKey<'may' | 'unexist'>().fail
      * ```
      */
-    toHaveKey<K extends PropertyKey>(): IfTupleIncludes<[never, any], K, never, TypeAssertionResult<Extends<K, keyof T>>>;
+    toHaveKey<K extends PropertyKey>(): IfTupleIncludes<[
+        never,
+        any
+    ], K, never, TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>>;
+    toHaveKey<K extends PropertyKey>(_: K): IfTupleIncludes<[
+        never,
+        any
+    ], K, never, TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>>;
 };
+type ExpectFunction<T, H extends PropertyKey = never> = Exact<T, any> extends true ? unknown : Exact<T, never> extends true ? unknown : [T] extends [(...args: infer Args) => infer R] ? {
+    argsType(): ExpectType<Args, H>;
+    returnType(): ExpectType<R, H>;
+} : [T] extends [new (...args: infer Args) => infer R] ? {
+    argsType(): ExpectType<Args, H>;
+    returnType(): ExpectType<R, H>;
+} : unknown;
 /**
  * Type-level testing utility that allows checking various relationships between types.
  * Provides methods to test type equality, extension, properties, and more.
@@ -99,6 +145,8 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
  *
  * @example
  * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
  * // Test if two types are identical
  * expect<number>().toBe<number>().success
  * expect<number>().toBe<string>().fail
@@ -109,7 +157,7 @@ type ExpectTypeMethods<T, H extends PropertyKey = never> = {
  * expect<{name: string}>().toHaveKey<'name'>().success
  * ```
  */
-export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMethods<T, H> & {
+export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMethods<T, H> & ExpectFunction<T, H> & {
     T: T;
     inspect: {
         [K in keyof T]: T[K];
@@ -121,7 +169,9 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      *
      * @example
      * ```ts
-     * expect<3.14>().toExtendNumber // Available and would succeed
+     * import { expect } from '@leawind/lay-sing'
+     *
+     * expect<3.14>().toExtendNumber
      * ```
      */
     toExtendNumber: ExpectType<T, H | 'toExtendNumber' | 'toExtend'>;
@@ -131,7 +181,9 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      *
      * @example
      * ```ts
-     * expect<'hello'>().toExtendString // Available and would succeed
+     * import { expect } from '@leawind/lay-sing'
+     *
+     * expect<'hello'>().toExtendString
      * ```
      */
     toExtendString: ExpectType<T, H | 'toExtendString' | 'toExtend'>;
@@ -141,7 +193,9 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      *
      * @example
      * ```ts
-     * expect<true>().toExtendBoolean // Available and would succeed
+     * import { expect } from '@leawind/lay-sing'
+     *
+     * expect<true>().toExtendBoolean
      * ```
      */
     toExtendBoolean: ExpectType<T, H | 'toExtendBoolean' | 'toExtend'>;
@@ -150,6 +204,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = any`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<any>().toBeAny
      * expect<any>().toBe<any>().success
      * ```
@@ -159,6 +215,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = never`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<never>().toBeNever
      * expect<never>().toBe<never>().success
      * ```
@@ -168,6 +226,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = unknown`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<unknown>().toBeUnknown
      * expect<unknown>().toBe<unknown>().success
      * ```
@@ -177,6 +237,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = void`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<void>().toBeVoid
      * expect<void>().toBe<void>().success
      * ```
@@ -186,6 +248,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = null`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<null>().toBeNull
      * expect<null>().toBe<null>().success
      * ```
@@ -195,6 +259,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = undefined`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<undefined>().toBeUndefined
      * expect<undefined>().toBe<undefined>().success
      * ```
@@ -204,6 +270,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = true`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<true>().toBeTrue
      * expect<true>().toBe<true>().success
      * ```
@@ -213,6 +281,8 @@ export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMetho
      * Alias for {@link ExpectTypeMethods.toBe} where `U = false`
      *
      * ```ts
+     * import { expect } from '@leawind/lay-sing'
+     *
      * expect<false>().toBeFalse
      * expect<false>().toBe<false>().success
      * ```

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

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

package/script/main/expect.js.map

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

package/script/main/index.d.ts

@@ -1,12 +1,30 @@
-export * from './async.js';
-export * from './boolean.js';
-export * from './control.js';
-export * from './doc.js';
-export * from './function.js';
-export * from './json.js';
-export * from './key.js';
-export * from './object.js';
-export * from './tuple.js';
-export * from './type/index.js';
-export * from './typed-array.js';
+/**
+ * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
+ *
+ * @module
+ */
+import type { ExpectType } from './expect.js';
+export type { ExpectType } from './expect.js';
+export { NOOP } from './noop.js';
+/**
+ * Creates an instance of ExpectType to perform type-level assertions on the given type.
+ * This function enables testing various type relationships at compile time.
+ * NOTE: This function does nothing at runtime and is purely for type-level testing.
+ *
+ * @template T The type to be tested
+ *
+ * @returns An ExpectType instance with methods to test type relationships
+ *
+ * @example
+ * ```ts
+ * // Test exact type equality
+ * expect<number>().toBe<number>().success
+ * expect<number>().toBe<string>().fail
+ * // Test if one type extends another
+ * expect<3.14>().toExtend<number>().success
+ * expect<2>().toExtend<string>().fail
+ * ```
+ */
+export declare function expect<T>(): ExpectType<T>;
+export declare function expect<T>(_: T): ExpectType<T>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA;AAC1C,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA"}

package/script/main/index.js

@@ -1,30 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
+/**
+ * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
+ *
+ * @module
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-// Index start >>>>>>>>>>>>>>>>
-__exportStar(require("./async.js"), exports);
-__exportStar(require("./boolean.js"), exports);
-__exportStar(require("./control.js"), exports);
-__exportStar(require("./doc.js"), exports);
-__exportStar(require("./function.js"), exports);
-__exportStar(require("./json.js"), exports);
-__exportStar(require("./key.js"), exports);
-__exportStar(require("./object.js"), exports);
-__exportStar(require("./tuple.js"), exports);
-__exportStar(require("./type/index.js"), exports);
-__exportStar(require("./typed-array.js"), exports);
-// <<<<<<<<<<<<<<<<   Index end
+exports.NOOP = void 0;
+exports.expect = expect;
+const noop_js_1 = require("./noop.js");
+var noop_js_2 = require("./noop.js");
+Object.defineProperty(exports, "NOOP", { enumerable: true, get: function () { return noop_js_2.NOOP; } });
+function expect() {
+    return noop_js_1.NOOP;
+}
 //# sourceMappingURL=index.js.map

package/script/main/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,6CAA0B;AAC1B,+CAA4B;AAC5B,+CAA4B;AAC5B,2CAAwB;AACxB,gDAA6B;AAC7B,4CAAyB;AACzB,2CAAwB;AACxB,8CAA2B;AAC3B,6CAA0B;AAC1B,kDAA+B;AAC/B,mDAAgC;AAChC,+BAA+B","sourcesContent":["// Index start >>>>>>>>>>>>>>>>\nexport * from './async.js'\nexport * from './boolean.js'\nexport * from './control.js'\nexport * from './doc.js'\nexport * from './function.js'\nexport * from './json.js'\nexport * from './key.js'\nexport * from './object.js'\nexport * from './tuple.js'\nexport * from './type/index.js'\nexport * from './typed-array.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AA6BH,wBAEC;AA5BD,uCAAgC;AAGhC,qCAAgC;AAAvB,+FAAA,IAAI,OAAA;AAuBb,SAAgB,MAAM;IACpB,OAAO,cAAI,CAAA;AACb,CAAC","sourcesContent":["/**\n * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)\n *\n * @module\n */\n\nimport type { ExpectType } from './expect.js'\nimport { NOOP } from './noop.js'\n\nexport type { ExpectType } from './expect.js'\nexport { NOOP } from './noop.js'\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * @example\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\n"]}

package/script/main/noop.d.ts

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

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

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