lay-sing 0.1.2 → 0.2.0

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

@@ -0,0 +1,223 @@
+import type { Exact, Extends, If, IfTupleIncludes, ProperExtend, SafePick } from '../main/index.js';
+/**
+ * Represents the result of a type assertion based on a boolean condition.
+ *
+ * - If `true`, the result has a `success` property;
+ * - If `false`, the result has a `fail` property;
+ * - Otherwise, the result is `never`
+ *
+ * @template B The boolean condition result (true or false)
+ * @template R The type of the result value (default is void)
+ */
+export type TypeAssertionResult<B extends boolean, R = void> = Exact<B, never> extends true ? never : [boolean] extends [B] ? never : [B] extends [true] ? {
+    /**
+     * This field exist only when this type assertion succeed
+     *
+     * If you expect this assertion to fail, use `.fail`
+     */
+    success: R;
+} : [B] extends [false] ? {
+    /**
+     * This field exist only when this type assertion failed
+     *
+     * If you expect this assertion to success, use `.success`
+     */
+    fail: R;
+} : never;
+type ExpectTypeMethods<T, H extends PropertyKey = never> = {
+    /**
+     * Tests if the current type is exactly the same as the provided type U.
+     *
+     * @template U The type to compare with
+     *
+     * @example
+     * ```ts
+     * expect<any>().toBe<any>().success
+     * expect<never>().toBe<never>().success
+     * expect<false>().toBe<true>().fail
+     * ```
+     */
+    toBe<U>(): TypeAssertionResult<Exact<T, U>>;
+    /**
+     * Tests if the current type T extends the provided type U.
+     *
+     * @template U The type to check extension against
+     *
+     * @example
+     * ```ts
+     * expect<3.14>().toExtend<number>().success
+     * expect<2>().toExtend<string>().fail
+     * expect<'hello'>().toExtend<string>().success
+     * ```
+     */
+    toExtend<U>(): TypeAssertionResult<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
+     *
+     * @example
+     * ```ts
+     * expect<2>().toProperExtend<number>().success
+     * expect<'a' | 'b'>().toProperExtend<string>().success
+     * expect<number>().toProperExtend<number>().fail
+     * ```
+     */
+    toProperExtend<U>(): TypeAssertionResult<ProperExtend<T, U>>;
+    /**
+     * Tests if the current type `T` has a property with key `K`.
+     *
+     * @template K The property key to check for
+     *
+     * ### Behavior
+     *
+     * - For single keys: succeeds if the key exists in `T`
+     * - For union types: succeeds only if **all** keys in the union exist in `T`
+     *
+     * ### Examples
+     *
+     * ```ts
+     * type WithProp = { prop: string; another: number; may?: 5 }
+     *
+     * // Single key checks
+     * expect<WithProp>().toHaveKey<'prop'>().success
+     * expect<WithProp>().toHaveKey<'missing'>().fail
+     *
+     * // Union type checks
+     * expect<WithProp>().toHaveKey<'prop' | 'another'>().success
+     * expect<WithProp>().toHaveKey<'may' | 'unexist'>().fail
+     * ```
+     */
+    toHaveKey<K extends PropertyKey>(): IfTupleIncludes<[never, any], K, never, TypeAssertionResult<Extends<K, keyof T>>>;
+};
+/**
+ * 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)
+ *
+ * @example
+ * ```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}>().toHaveKey<'name'>().success
+ * ```
+ */
+export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMethods<T, H> & {
+    T: T;
+    inspect: {
+        [K in keyof T]: T[K];
+    };
+} & SafePick<{
+    /**
+     * Tests if the current type extends the Number primitive type.
+     * Available only if the current type extends number.
+     *
+     * @example
+     * ```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.
+     *
+     * @example
+     * ```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.
+     *
+     * @example
+     * ```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<{
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = any`
+     *
+     * ```ts
+     * expect<any>().toBeAny
+     * expect<any>().toBe<any>().success
+     * ```
+     */
+    toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>;
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = never`
+     *
+     * ```ts
+     * expect<never>().toBeNever
+     * expect<never>().toBe<never>().success
+     * ```
+     */
+    toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>;
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = unknown`
+     *
+     * ```ts
+     * expect<unknown>().toBeUnknown
+     * expect<unknown>().toBe<unknown>().success
+     * ```
+     */
+    toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>;
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = void`
+     *
+     * ```ts
+     * expect<void>().toBeVoid
+     * expect<void>().toBe<void>().success
+     * ```
+     */
+    toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>;
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = null`
+     *
+     * ```ts
+     * expect<null>().toBeNull
+     * expect<null>().toBe<null>().success
+     * ```
+     */
+    toBeNull: ExpectType<T, H | 'toBeNull' | 'toBe'>;
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = undefined`
+     *
+     * ```ts
+     * expect<undefined>().toBeUndefined
+     * expect<undefined>().toBe<undefined>().success
+     * ```
+     */
+    toBeUndefined: ExpectType<T, H | 'toBeUndefined' | 'toBe'>;
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = true`
+     *
+     * ```ts
+     * expect<true>().toBeTrue
+     * expect<true>().toBe<true>().success
+     * ```
+     */
+    toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>;
+    /**
+     * Alias for {@link ExpectTypeMethods.toBe} where `U = false`
+     *
+     * ```ts
+     * expect<false>().toBeFalse
+     * expect<false>().toBe<false>().success
+     * ```
+     */
+    toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>;
+}, If<Exact<T, any>, 'toBeAny'> | If<Exact<T, never>, 'toBeNever'> | If<Exact<T, unknown>, 'toBeUnknown'> | If<Exact<T, void>, 'toBeVoid'> | If<Exact<T, null>, 'toBeNull'> | If<Exact<T, undefined>, 'toBeUndefined'> | If<Exact<T, true>, 'toBeTrue'> | If<Exact<T, false>, 'toBeFalse'>>), H>;
+export {};
+//# sourceMappingURL=expect.d.ts.map

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

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

package/script/test-utils/expect.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"expect.js","sourceRoot":"","sources":["../../src/test-utils/expect.ts"],"names":[],"mappings":"","sourcesContent":["// deno-lint-ignore-file no-explicit-any\nimport type { Exact, Extends, If, IfTupleIncludes, 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   * 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>>\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   * 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>>\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   * 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>>\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   * 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<[never, any], K, never, TypeAssertionResult<Extends<K, keyof T>>>\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 * // 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         * expect<3.14>().toExtendNumber // Available and would succeed\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         * expect<'hello'>().toExtendString // Available and would succeed\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         * expect<true>().toExtendBoolean // Available and would succeed\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         * 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         * 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         * 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         * 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         * 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         * 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         * 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         * 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/test-utils/index.d.ts

@@ -0,0 +1,72 @@
+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/script/test-utils/index.d.ts.map

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOOP = void 0;
-exports.expect = expect;
 exports.compare = compare;
+exports.expect = expect;
 /**
  * A universal no-op placeholder implemented via `Proxy`.
  *
@@ -21,14 +21,14 @@ exports.compare = compare;
  * This is useful in scenarios where a value is required syntactically but
  * should perform no action and never fail at runtime.
  *
- * ### Examples
- *
+ * @example
  * ```ts
  * NOOP.foo.bar().baz.qux; // safe, returns NOOP
  * String(NOOP); // "[NOOP]"
  * await NOOP; // does not await (not thenable)
  * ```
  */
+// deno-lint-ignore no-explicit-any
 exports.NOOP = new Proxy(function () {
     return exports.NOOP;
 }, {
@@ -53,10 +53,10 @@ exports.NOOP = new Proxy(function () {
     has: () => true,
     ownKeys: () => ['prototype'],
 });
-function expect() {
+function compare() {
     return exports.NOOP;
 }
-function compare() {
+function expect() {
     return exports.NOOP;
 }
-//# sourceMappingURL=test-utils.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":";;;AAgFA,0BAEC;AAuBD,wBAEC;AArGD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,mCAAmC;AACtB,QAAA,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,YAAI,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,YAAI,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,YAAI;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,SAAgB,OAAO;IACrB,OAAO,YAAI,CAAA;AACb,CAAC;AAuBD,SAAgB,MAAM;IACpB,OAAO,YAAI,CAAA;AACb,CAAC","sourcesContent":["import 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 */\n// deno-lint-ignore no-explicit-any\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/esm/main/array.d.ts

@@ -1,48 +0,0 @@
-import type { Same } from './type/compare.js';
-/**
- * Represents a readonly array of type T
- */
-export type ReadonlyArray<T = unknown> = readonly T[];
-/**
- * Concatenates two tuples into a single tuple type
- *
- * ### Examples
- *
- * ```ts
- * type Result = ConcatTuple<[1, 2], [3, 4]> // [1, 2, 3, 4]
- * ```
- */
-export type ConcatTuple<Left extends readonly unknown[], Right extends readonly unknown[]> = Left extends readonly unknown[] ? (Right extends readonly unknown[] ? [...Left, ...Right] : never) : never;
-/**
- * Checks whether a tuple includes a specific element type
- *
- * ### Examples
- *
- * ```ts
- * type HasTwo = TupleIncludes<[1, 2, 3], 2> // true
- * type HasFour = TupleIncludes<[1, 2, 3], 4> // false
- * ```
- */
-export type TupleIncludes<Tuple extends readonly unknown[], Element> = Tuple extends readonly [infer First, ...infer Rest] ? (Same<Element, First> extends true ? true : TupleIncludes<Rest, Element>) : false;
-/**
- * Appends an element to a tuple only if it doesn't already exist in the tuple
- *
- * ### Examples
- *
- * ```ts
- * type Result1 = AppendUnique<[1, 2, 3], 4> // [1, 2, 3, 4]
- * type Result2 = AppendUnique<[1, 2, 3], 2> // [1, 2, 3]
- * ```
- */
-export type AppendUnique<Tuple extends readonly unknown[], Element> = TupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element];
-/**
- * Concatenates two tuples while ensuring uniqueness of elements
- *
- * ### Examples
- *
- * ```ts
- * type Result = ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]> // [1, 2, 3, 4]
- * ```
- */
-export type ConcatUniqueTuple<A extends readonly unknown[], B extends readonly unknown[], R extends readonly unknown[] = A> = B extends readonly [infer First, ...infer Rest] ? ConcatUniqueTuple<A, Rest, AppendUnique<R, First>> : R;
-//# sourceMappingURL=array.d.ts.map

package/esm/main/array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/main/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAE7C;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,OAAO,IAAI,SAAS,CAAC,EAAE,CAAA;AAErD;;;;;;;;GAQG;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;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,CACvB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GACnD,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,GACzE,KAAK,CAAA;AAET;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CACtB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,CAAA;AAE5E;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,CAC3B,CAAC,SAAS,SAAS,OAAO,EAAE,EAC5B,CAAC,SAAS,SAAS,OAAO,EAAE,EAC5B,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,CAAC,IAC9B,CAAC,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAA"}

package/esm/main/array.js

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

package/esm/main/array.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.js","sourceRoot":"","sources":["../../src/main/array.ts"],"names":[],"mappings":"","sourcesContent":["import type { Same } from './type/compare.js'\n\n/**\n * Represents a readonly array of type T\n */\nexport type ReadonlyArray<T = unknown> = readonly T[]\n\n/**\n * Concatenates two tuples into a single tuple type\n *\n * ### Examples\n *\n * ```ts\n * type Result = ConcatTuple<[1, 2], [3, 4]> // [1, 2, 3, 4]\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 * Checks whether a tuple includes a specific element type\n *\n * ### Examples\n *\n * ```ts\n * type HasTwo = TupleIncludes<[1, 2, 3], 2> // true\n * type HasFour = TupleIncludes<[1, 2, 3], 4> // false\n * ```\n */\nexport type TupleIncludes<\n  Tuple extends readonly unknown[],\n  Element,\n> = Tuple extends readonly [infer First, ...infer Rest]\n  ? (Same<Element, First> extends true ? true : TupleIncludes<Rest, Element>)\n  : false\n\n/**\n * Appends an element to a tuple only if it doesn't already exist in the tuple\n *\n * ### Examples\n *\n * ```ts\n * type Result1 = AppendUnique<[1, 2, 3], 4> // [1, 2, 3, 4]\n * type Result2 = AppendUnique<[1, 2, 3], 2> // [1, 2, 3]\n * ```\n */\nexport type AppendUnique<\n  Tuple extends readonly unknown[],\n  Element,\n> = TupleIncludes<Tuple, Element> extends true ? Tuple : [...Tuple, Element]\n\n/**\n * Concatenates two tuples while ensuring uniqueness of elements\n *\n * ### Examples\n *\n * ```ts\n * type Result = ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]> // [1, 2, 3, 4]\n * ```\n */\nexport type ConcatUniqueTuple<\n  A extends readonly unknown[],\n  B extends readonly unknown[],\n  R extends readonly unknown[] = A,\n> = B extends readonly [infer First, ...infer Rest] ? ConcatUniqueTuple<A, Rest, AppendUnique<R, First>> : R\n"]}