lay-sing 0.1.0

package/script/main/object.d.ts

@@ -0,0 +1,81 @@
+import type { KeysOfOtherType, KeysOfType } from './key.js';
+/**
+ * Access a property `K` of object `T`, with a fallback `E` if the property doesn't exist
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type Result = Access<{ a: string }, 'a'> // string
+ * type Missing = Access<{ a: string }, 'x', 'default'> // 'default'
+ * ```
+ */
+export type Access<T, K extends PropertyKey, E = never> = K extends keyof T ? T[K] : E;
+/**
+ * Recursively makes all properties of `T` optional
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type Result = DeepPartial<{ a: string; nested: { b: number } }> // { a?: string; nested?: { b?: number } }
+ * ```
+ */
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Recursively makes all properties of `T` required
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type Result = DeepRequire<{ a?: string; nested?: { b?: number } }>
+ * // { a: string; nested: { b: number } }
+ * ```
+ */
+export type DeepRequire<T> = {
+    [P in keyof T]-?: T[P] extends object ? DeepRequire<T[P]> : T[P];
+};
+/**
+ * Returns `T` if `T` extends `A`, otherwise returns never
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type _1 = AssertExtends<string, string> // string
+ * type _2 = AssertExtends<string, number> // never
+ * ```
+ */
+export type AssertExtends<T, A> = T extends A ? T : never;
+/**
+ * Safely picks keys `K` from type T, excluding non-existent keys
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'> // { a: string }
+ * ```
+ */
+export type SafePick<T, K> = Pick<T, K & keyof T>;
+/**
+ * Picks properties from `T` that have values of type U
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type A = { a: string; b: number; c: string }
+ * type Strings = PropsOfType<A, string> // { a: string; c: string }
+ * ```
+ */
+export type PropsOfType<T, U> = Pick<T, KeysOfType<T, U>>;
+/**
+ * Picks properties from `T` that do not have values of type U
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type A = { a: string; b: number; c: string }
+ * type NonStrings = PropsOfOtherType<A, string> // { b: number }
+ * ```
+ */
+export type PropsOfOtherType<T, U> = Pick<T, KeysOfOtherType<T, U>>;
+//# sourceMappingURL=object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/main/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE3D;;;;;;;;;GASG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AAEtF;;;;;;;;GAQG;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;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACjE,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEzD;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAA;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAEzD;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}

package/script/main/object.js

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

package/script/main/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/main/object.ts"],"names":[],"mappings":"","sourcesContent":["import type { KeysOfOtherType, KeysOfType } from './key.js'\n\n/**\n * Access a property `K` of object `T`, with a fallback `E` if the property doesn't exist\n *\n * ### Examples\n *\n * ```ts\n * type Result = Access<{ a: string }, 'a'> // string\n * type Missing = Access<{ a: string }, 'x', 'default'> // 'default'\n * ```\n */\nexport type Access<T, K extends PropertyKey, E = never> = K extends keyof T ? T[K] : E\n\n/**\n * Recursively makes all properties of `T` optional\n *\n * ### Examples\n *\n * ```ts\n * type Result = DeepPartial<{ a: string; nested: { b: number } }> // { a?: string; nested?: { b?: number } }\n * ```\n */\nexport type DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]\n}\n\n/**\n * Recursively makes all properties of `T` required\n *\n * ### Examples\n *\n * ```ts\n * type Result = DeepRequire<{ a?: string; nested?: { b?: number } }>\n * // { a: string; nested: { b: number } }\n * ```\n */\nexport type DeepRequire<T> = {\n  [P in keyof T]-?: T[P] extends object ? DeepRequire<T[P]> : T[P]\n}\n\n/**\n * Returns `T` if `T` extends `A`, otherwise returns never\n *\n * ### Examples\n *\n * ```ts\n * type _1 = AssertExtends<string, string> // string\n * type _2 = AssertExtends<string, number> // never\n * ```\n */\nexport type AssertExtends<T, A> = T extends A ? T : never\n\n/**\n * Safely picks keys `K` from type T, excluding non-existent keys\n *\n * ### Examples\n *\n * ```ts\n * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'> // { a: string }\n * ```\n */\nexport type SafePick<T, K> = Pick<T, K & keyof T>\n\n/**\n * Picks properties from `T` that have values of type U\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: string; b: number; c: string }\n * type Strings = PropsOfType<A, string> // { a: string; c: string }\n * ```\n */\nexport type PropsOfType<T, U> = Pick<T, KeysOfType<T, U>>\n\n/**\n * Picks properties from `T` that do not have values of type U\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: string; b: number; c: string }\n * type NonStrings = PropsOfOtherType<A, string> // { b: number }\n * ```\n */\nexport type PropsOfOtherType<T, U> = Pick<T, KeysOfOtherType<T, U>>\n"]}

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

@@ -0,0 +1,79 @@
+/**
+ * Checks whether two types are exactly the same.
+ *
+ * This performs a structural equality comparison between `A` and `B`,
+ * rather than a one-way assignability check.
+ *
+ * ### Result
+ *
+ * - `true`: `A` and `B` are identical types
+ * - `false`: Otherwise
+ */
+export type Same<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+/**
+ * Checks whether two types are different.
+ *
+ * This is the logical negation of `Same<A, B>`.
+ *
+ * ### Result
+ *
+ * - `true`: `A` and `B` are not identical
+ * - `false`: `A` and `B` are exactly the same type
+ */
+export type Diff<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? false : true;
+/**
+ * Checks whether type `A` extends type `B`.
+ *
+ * This is a non-distributive version of `extends`, ensuring
+ * the result is always a concrete boolean literal.
+ *
+ * ### Result
+ *
+ * - `true`: `A` is assignable to `B`
+ * - `false`: Otherwise
+ *
+ * **Note:** the result will never be `boolean`.
+ */
+export type Extends<A, B> = [A] extends [B] ? true : false;
+/**
+ * Checks whether type `A` is a *proper* subtype of type `B`.
+ *
+ * A proper extension means:
+ * - `A` extends `B`
+ * - `A` is not exactly the same type as `B`
+ *
+ * **Note:** the result will never be `boolean`.
+ */
+export type ProperExtend<A, B> = [A] extends [B] ? Same<A, B> extends false ? true : false : false;
+/**
+ * Checks whether two types have any overlapping members.
+ *
+ * ### Result
+ *
+ * - `true`: `A` and `B` share at least one common type
+ * - `false`: `A` and `B` are completely disjoint
+ */
+export type Overlap<A, B> = [A & B] extends [never] ? false : true;
+/**
+ * Checks whether two types are disjoint.
+ *
+ * This is the logical negation of `Overlap<A, B>`.
+ *
+ * ### Result
+ *
+ * - `true`: `A` and `B` have no overlap
+ * - `false`: `A` and `B` share at least one common type
+ */
+export type Disjoint<A, B> = [A & B] extends [never] ? true : false;
+/**
+ * Checks whether two types are mutually assignable.
+ *
+ * This is equivalent to checking that:
+ * - `A` extends `B`
+ * - `B` extends `A`
+ *
+ * In other words, the two types describe the same set of values,
+ * even if they are written differently.
+ */
+export type MutuallyAssignable<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
+//# sourceMappingURL=compare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/main/type/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAA;AAE7G;;;;;;;;;GASG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAA;AAE7G;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAA;AAE1D;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAA;AAElG;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,CAAA;AAElE;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAA;AAEnE;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAA"}

package/script/main/type/compare.js

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

package/script/main/type/compare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.js","sourceRoot":"","sources":["../../../src/main/type/compare.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Checks whether two types are exactly the same.\n *\n * This performs a structural equality comparison between `A` and `B`,\n * rather than a one-way assignability check.\n *\n * ### Result\n *\n * - `true`: `A` and `B` are identical types\n * - `false`: Otherwise\n */\nexport type Same<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false\n\n/**\n * Checks whether two types are different.\n *\n * This is the logical negation of `Same<A, B>`.\n *\n * ### Result\n *\n * - `true`: `A` and `B` are not identical\n * - `false`: `A` and `B` are exactly the same type\n */\nexport type Diff<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? false : true\n\n/**\n * Checks whether type `A` extends type `B`.\n *\n * This is a non-distributive version of `extends`, ensuring\n * the result is always a concrete boolean literal.\n *\n * ### Result\n *\n * - `true`: `A` is assignable to `B`\n * - `false`: Otherwise\n *\n * **Note:** the result will never be `boolean`.\n */\nexport type Extends<A, B> = [A] extends [B] ? true : false\n\n/**\n * Checks whether type `A` is a *proper* subtype of type `B`.\n *\n * A proper extension means:\n * - `A` extends `B`\n * - `A` is not exactly the same type as `B`\n *\n * **Note:** the result will never be `boolean`.\n */\nexport type ProperExtend<A, B> = [A] extends [B] ? Same<A, B> extends false ? true : false : false\n\n/**\n * Checks whether two types have any overlapping members.\n *\n * ### Result\n *\n * - `true`: `A` and `B` share at least one common type\n * - `false`: `A` and `B` are completely disjoint\n */\nexport type Overlap<A, B> = [A & B] extends [never] ? false : true\n\n/**\n * Checks whether two types are disjoint.\n *\n * This is the logical negation of `Overlap<A, B>`.\n *\n * ### Result\n *\n * - `true`: `A` and `B` have no overlap\n * - `false`: `A` and `B` share at least one common type\n */\nexport type Disjoint<A, B> = [A & B] extends [never] ? true : false\n\n/**\n * Checks whether two types are mutually assignable.\n *\n * This is equivalent to checking that:\n * - `A` extends `B`\n * - `B` extends `A`\n *\n * In other words, the two types describe the same set of values,\n * even if they are written differently.\n */\nexport type MutuallyAssignable<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false\n"]}

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

@@ -0,0 +1,3 @@
+export * from './compare.js';
+export * from './set.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/main/type/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA"}

package/script/main/type/index.js

@@ -0,0 +1,19 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compare.js"), exports);
+__exportStar(require("./set.js"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/main/type/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA4B;AAC5B,2CAAwB","sourcesContent":["export * from './compare.js'\nexport * from './set.js'\n"]}

package/script/main/type/set.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ## `IntersectOf<[A, B, ... T]>` = `A & B & ... & T`
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type A = { a: string, b: number };
+ * type B = { a: number, c: boolean };
+ *
+ * type Result = IntersectOf<[A, B]>;
+ * type Result = { a: never, b: number, c: boolean }
+ * ```
+ */
+export type IntersectOf<T extends readonly unknown[]> = T extends [infer F, ...infer R] ? F & IntersectOf<R> : unknown;
+/**
+ * ## `UnionOf<[A, B, ... T]>` = `A | B | ... | T`
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type A = { a: string, b: number };
+ * type B = { a: number, c: boolean };
+ *
+ * type Result = UnionOf<[A, B]>;
+ * type Result = { a: string | number }
+ * ```
+ */
+export type UnionOf<T extends readonly unknown[]> = T extends [infer F, ...infer R] ? F | UnionOf<R> : never;
+//# sourceMappingURL=set.d.ts.map

package/script/main/type/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../src/main/type/set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAA;AAEtH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA"}

package/script/main/type/set.js

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

package/script/main/type/set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.js","sourceRoot":"","sources":["../../../src/main/type/set.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * ## `IntersectOf<[A, B, ... T]>` = `A & B & ... & T`\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: string, b: number };\n * type B = { a: number, c: boolean };\n *\n * type Result = IntersectOf<[A, B]>;\n * type Result = { a: never, b: number, c: boolean }\n * ```\n */\nexport type IntersectOf<T extends readonly unknown[]> = T extends [infer F, ...infer R] ? F & IntersectOf<R> : unknown\n\n/**\n * ## `UnionOf<[A, B, ... T]>` = `A | B | ... | T`\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: string, b: number };\n * type B = { a: number, c: boolean };\n *\n * type Result = UnionOf<[A, B]>;\n * type Result = { a: string | number }\n * ```\n */\nexport type UnionOf<T extends readonly unknown[]> = T extends [infer F, ...infer R] ? F | UnionOf<R> : never\n"]}

package/script/main/typed-array.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Represents all possible TypedArray types
+ */
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Float32Array | Float64Array | Uint32Array | BigInt64Array | BigUint64Array;
+//# sourceMappingURL=typed-array.d.ts.map

package/script/main/typed-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array.d.ts","sourceRoot":"","sources":["../../src/main/typed-array.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,UAAU,GACV,iBAAiB,GACjB,UAAU,GACV,WAAW,GACX,UAAU,GACV,YAAY,GACZ,YAAY,GACZ,WAAW,GACX,aAAa,GACb,cAAc,CAAA"}

package/script/main/typed-array.js

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

package/script/main/typed-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array.js","sourceRoot":"","sources":["../../src/main/typed-array.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents all possible TypedArray types\n */\nexport type TypedArray =\n  | Int8Array\n  | Uint8Array\n  | Uint8ClampedArray\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Float32Array\n  | Float64Array\n  | Uint32Array\n  | BigInt64Array\n  | BigUint64Array\n"]}

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/test-utils.d.ts

@@ -0,0 +1,348 @@
+import type { Diff, Disjoint, Extends, If, MutuallyAssignable, Overlap, ProperExtend, SafePick, Same } from './main/index.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.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * NOOP.foo.bar().baz.qux; // safe, returns NOOP
+ * String(NOOP); // "[NOOP]"
+ * await NOOP; // does not await (not thenable)
+ * ```
+ */
+export declare const NOOP: any;
+/**
+ * Represents the result of a type assertion based on a boolean condition.
+ * If the condition is true, the result has a `success` property; otherwise, it has a `fail` property.
+ *
+ * @template B The boolean condition result (true or false)
+ * @template R The type of the result value (default is void)
+ */
+type Result<B extends true | false, R = void> = B extends true ? {
+    /**
+     * ## Expect to succeed without type error
+     */
+    success: R;
+} : {
+    /**
+     * ## Expect to fail with type error
+     */
+    fail: R;
+};
+/**
+ * Type-level testing utility that allows checking various relationships between types.
+ * Provides methods to test type equality, extension, properties, and more.
+ *
+ * @template T The type being tested
+ * @template H Hidden property keys that are already used (internal tracking)
+ *
+ * ### Examples
+ *
+ * ```ts
+ * // Test if two types are identical
+ * expect<number>().toBe<number>().success
+ * expect<number>().toBe<string>().fail
+ * // Test if one type extends another
+ * expect<2>().toExtend<number>().success
+ * expect<2>().toExtend<string>().fail
+ * // Test if type has a specific property
+ * expect<{name: string}>().toHaveProperty<'name'>().success
+ * ```
+ */
+export type ExpectType<T, H extends PropertyKey = never> = Omit<({
+    T: T;
+    inspect: {
+        [K in keyof T]: T[K];
+    };
+    /**
+     * Tests if the current type is exactly the same as the provided type U.
+     *
+     * @template U The type to compare with
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<any>().toBe<any>().success
+     * expect<never>().toBe<never>().success
+     * expect<false>().toBe<true>().fail
+     * ```
+     */
+    toBe<U>(): Result<Same<T, U>>;
+    /**
+     * Tests if the current type T extends the provided type U.
+     *
+     * @template U The type to check extension against
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<3.14>().toExtend<number>().success
+     * expect<2>().toExtend<string>().fail
+     * expect<'hello'>().toExtend<string>().success
+     * ```
+     */
+    toExtend<U>(): Result<Extends<T, U>>;
+    /**
+     * Tests if the current type T properly extends the provided type U (extends but is not the same).
+     *
+     * @template U The type to check proper extension against
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<2>().toProperExtend<number>().success
+     * expect<'a' | 'b'>().toProperExtend<string>().success
+     * expect<number>().toProperExtend<number>().fail
+     * ```
+     */
+    toProperExtend<U>(): Result<ProperExtend<T, U>>;
+    /**
+     * Tests if the current type T has a property with key K.
+     *
+     * @template K The property key to check for
+     *
+     * ### Examples
+     *
+     * ```ts
+     * type WithProp = { prop: string; another: number }
+     * expect<WithProp>().toHaveProperty<'prop'>().success
+     * expect<WithProp>().toHaveProperty<'another'>().success
+     * expect<WithProp>().toHaveProperty<'missing'>().fail
+     * ```
+     */
+    toHaveProperty<K extends PropertyKey>(): Result<Extends<K, keyof T>>;
+} & SafePick<{
+    /**
+     * Tests if the current type extends the Number primitive type.
+     * Available only if the current type extends number.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<3.14>().toExtendNumber // Available and would succeed
+     * ```
+     */
+    toExtendNumber: ExpectType<T, H | 'toExtendNumber' | 'toExtend'>;
+    /**
+     * Tests if the current type extends the String primitive type.
+     * Available only if the current type extends string.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<'hello'>().toExtendString // Available and would succeed
+     * ```
+     */
+    toExtendString: ExpectType<T, H | 'toExtendString' | 'toExtend'>;
+    /**
+     * Tests if the current type extends the Boolean primitive type.
+     * Available only if the current type extends boolean.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<true>().toExtendBoolean // Available and would succeed
+     * ```
+     */
+    toExtendBoolean: ExpectType<T, H | 'toExtendBoolean' | 'toExtend'>;
+}, If<Extends<T, number>, 'toExtendNumber'> | If<Extends<T, string>, 'toExtendString'> | If<Extends<T, boolean>, 'toExtendBoolean'>> & SafePick<{
+    /**
+     * Tests if the current type is exactly `any`.
+     * Available only if the current type is `any`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<any>().toBeAny // Available and would succeed
+     * ```
+     */
+    toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>;
+    /**
+     * Tests if the current type is exactly `never`.
+     * Available only if the current type is `never`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<never>().toBeNever // Available and would succeed
+     * ```
+     */
+    toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>;
+    /**
+     * Tests if the current type is exactly `unknown`.
+     * Available only if the current type is `unknown`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<unknown>().toBeUnknown // Available and would succeed
+     * ```
+     */
+    toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>;
+    /**
+     * Tests if the current type is exactly `void`.
+     * Available only if the current type is `void`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<void>().toBeVoid // Available and would succeed
+     * ```
+     */
+    toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>;
+    /**
+     * Tests if the current type is exactly `true` (boolean literal).
+     * Available only if the current type is `true`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<true>().toBeTrue // Available and would succeed
+     * ```
+     */
+    toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>;
+    /**
+     * Tests if the current type is exactly `false` (boolean literal).
+     * Available only if the current type is `false`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * expect<false>().toBeFalse // Available and would succeed
+     * ```
+     */
+    toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>;
+}, If<Same<T, any>, 'toBeAny'> | If<Same<T, never>, 'toBeNever'> | If<Same<T, unknown>, 'toBeUnknown'> | If<Same<T, void>, 'toBeVoid'> | If<Same<T, true>, 'toBeTrue'> | If<Same<T, false>, 'toBeFalse'>>), H>;
+/**
+ * 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
+ *
+ * ### Examples
+ *
+ * ```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>;
+/**
+ * Type-level utility that compares two types and provides methods to test their relationship.
+ * Offers options to check if types are same, different, overlapping, disjoint, or mutually assignable.
+ *
+ * @template T First type to compare
+ * @template U Second type to compare
+ * @template H Hidden property keys that are already used (internal tracking)
+ *
+ * ### Examples
+ *
+ * ```ts
+ * // Check if two types are the same
+ * compare<number, number>().same // Available
+ * // Check if two types are different
+ * compare<number, string>().different // Available
+ * // Check if two types overlap
+ * compare<4, number>().overlap.different // Available
+ * ```
+ */
+export type CompareTypes<T, U, H extends PropertyKey = never> = Omit<SafePick<{
+    /**
+     * Available when types T and U are exactly the same.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * compare<3, 3>().same // Available
+     * compare<boolean, boolean>().same // Available
+     * ```
+     */
+    same: CompareTypes<T, U, H | 'same'>;
+    /**
+     * Available when types T and U are different.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * compare<4, 'abc'>().different // Available
+     * compare<number, 4>().different // Available
+     * ```
+     */
+    different: CompareTypes<T, U, H | 'different'>;
+    /**
+     * Available when types T and U have some overlap.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * compare<4, number>().overlap // Available since 4 overlaps with number
+     * ```
+     */
+    overlap: CompareTypes<T, U, H | 'overlap'>;
+    /**
+     * Available when types T and U have no overlap (are disjoint).
+     *
+     * ### Examples
+     *
+     * ```ts
+     * compare<4, 'abc'>().different.disjoint // Available since 4 and 'abc' are disjoint
+     * ```
+     */
+    disjoint: CompareTypes<T, U, H | 'disjoint'>;
+    /**
+     * Available when types T and U are mutually assignable (each type can be assigned to the other).
+     *
+     * ### Examples
+     *
+     * ```ts
+     * compare<1 | 2, 1 | 2>().mutuallyAssignable // Available since identical union types are mutually assignable
+     * ```
+     */
+    mutuallyAssignable: CompareTypes<T, U, H | 'mutuallyAssignable'>;
+}, If<Same<T, U>, 'same'> | If<Diff<T, U>, 'different'> | If<Overlap<T, U>, 'overlap'> | If<Disjoint<T, U>, 'disjoint'> | If<MutuallyAssignable<T, U>, 'mutuallyAssignable'>>, H>;
+/**
+ * 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
+ *
+ * ### Examples
+ *
+ * ```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>;
+export {};
+//# sourceMappingURL=test-utils.d.ts.map

package/script/test-utils.d.ts.map

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