lay-sing 0.2.0 → 0.3.0

package/script/{test-utils/index.js → main/noop.js}

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOOP = void 0;
-exports.compare = compare;
-exports.expect = expect;
 /**
  * A universal no-op placeholder implemented via `Proxy`.
  *
@@ -28,7 +26,6 @@ exports.expect = expect;
  * await NOOP; // does not await (not thenable)
  * ```
  */
-// deno-lint-ignore no-explicit-any
 exports.NOOP = new Proxy(function () {
     return exports.NOOP;
 }, {
@@ -53,10 +50,4 @@ exports.NOOP = new Proxy(function () {
     has: () => true,
     ownKeys: () => ['prototype'],
 });
-function compare() {
-    return exports.NOOP;
-}
-function expect() {
-    return exports.NOOP;
-}
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=noop.js.map

package/script/main/noop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.js","sourceRoot":"","sources":["../../src/main/noop.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACU,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","sourcesContent":["/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * @example\n * ```ts\n * NOOP.foo.bar().baz.qux; // safe, returns NOOP\n * String(NOOP); // \"[NOOP]\"\n * await NOOP; // does not await (not thenable)\n * ```\n */\nexport const NOOP: any = new Proxy(\n  function () {\n    return NOOP\n  },\n  {\n    get(_, prop) {\n      switch (prop) {\n        case 'then':\n          return undefined\n        case 'valueOf':\n        case 'toString':\n        case Symbol.toPrimitive:\n          return () => '[NOOP]'\n        default:\n          return NOOP\n      }\n    },\n    set: () => true,\n    getOwnPropertyDescriptor: () => ({\n      configurable: true,\n      value: NOOP,\n    }),\n    getPrototypeOf: () => null,\n    has: () => true,\n    ownKeys: () => ['prototype'],\n  },\n)\n"]}

package/script/utils/compare/assignable.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ *
+ * @template A - The first type to check
+ * @template B - The second type to check
+ * @template Yes - The result if types are mutually assignable (defaults to `true`)
+ * @template No - The result if types are not mutually assignable (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` and `B` are mutually assignable
+ * - `No`: Otherwise
+ *
+ * @example
+ * ```ts
+ * type T1 = MutuallyAssignable<number, number> // true
+ * type T2 = MutuallyAssignable<1 | 2, 2 | 1> // true
+ * type F1 = MutuallyAssignable<string, number> // false
+ * type F2 = MutuallyAssignable<1, number> // false
+ * ```
+ */
+export type MutuallyAssignable<A, B, Yes = true, No = false> = [A] extends [B] ? [B] extends [A] ? Yes : No : No;
+//# sourceMappingURL=assignable.d.ts.map

package/script/utils/compare/assignable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignable.d.ts","sourceRoot":"","sources":["../../../src/utils/compare/assignable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,kBAAkB,CAC5B,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAA"}

package/script/utils/compare/assignable.js

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

package/script/utils/compare/assignable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignable.js","sourceRoot":"","sources":["../../../src/utils/compare/assignable.ts"],"names":[],"mappings":"","sourcesContent":["/**\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 *\n * @template A - The first type to check\n * @template B - The second type to check\n * @template Yes - The result if types are mutually assignable (defaults to `true`)\n * @template No - The result if types are not mutually assignable (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` are mutually assignable\n * - `No`: Otherwise\n *\n * @example\n * ```ts\n * type T1 = MutuallyAssignable<number, number> // true\n * type T2 = MutuallyAssignable<1 | 2, 2 | 1> // true\n * type F1 = MutuallyAssignable<string, number> // false\n * type F2 = MutuallyAssignable<1, number> // false\n * ```\n */\nexport type MutuallyAssignable<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? [B] extends [A] ? Yes : No : No\n"]}

package/script/utils/compare/exact.d.ts

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

package/script/utils/compare/exact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exact.d.ts","sourceRoot":"","sources":["../../../src/utils/compare/exact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,KAAK,CACf,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,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,GAAG,GAAG,EAAE,CAAA;AAEpF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,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,EAAE,GAAG,GAAG,CAAA"}

package/script/{main/async.js → utils/compare/exact.js}

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

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

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

package/script/utils/compare/extends.d.ts

@@ -0,0 +1,46 @@
+import type { Exact } from '../index.js';
+/**
+ * Checks whether type `A` extends type `B`.
+ *
+ * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it treats them as a single entity.
+ *
+ * @template A - The type to check if it extends another type
+ * @template B - The type to check if `A` extends
+ * @template Yes - The result if `A` extends `B` (defaults to `true`)
+ * @template No - The result if `A` does not extend `B` (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` is assignable to `B`
+ * - `No`: Otherwise
+ */
+export type Extends<A, B, Yes = true, No = false> = [A] extends [B] ? Yes : No;
+/**
+ * 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`
+ *
+ * @template A - The type to check if it is a proper subtype
+ * @template B - The type to check against
+ * @template Yes - The result if `A` is a proper subtype of `B` (defaults to `true`)
+ * @template No - The result if `A` is not a proper subtype of `B` (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` is a proper subtype of `B`
+ * - `No`: Otherwise
+ *
+ * **Note:** the result will never be `boolean`.
+ *
+ * @example
+ * ```ts
+ * type T1 = ProperExtend<true, boolean> // true
+ * type T2 = ProperExtend<1, number> // true
+ * type F1 = ProperExtend<boolean, boolean> // false
+ * type F2 = ProperExtend<number, string> // false
+ * ```
+ */
+export type ProperExtend<A, B, Yes = true, No = false> = [A] extends [B] ? Exact<A, B> extends false ? Yes : No : No;
+//# sourceMappingURL=extends.d.ts.map

package/script/utils/compare/extends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extends.d.ts","sourceRoot":"","sources":["../../../src/utils/compare/extends.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,KAAK,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAA"}

package/script/{main/boolean.js → utils/compare/extends.js}

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

package/script/utils/compare/extends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extends.js","sourceRoot":"","sources":["../../../src/utils/compare/extends.ts"],"names":[],"mappings":"","sourcesContent":["import type { Exact } from '../index.js'\n\n/**\n * Checks whether type `A` extends type `B`.\n *\n * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it treats them as a single entity.\n *\n * @template A - The type to check if it extends another type\n * @template B - The type to check if `A` extends\n * @template Yes - The result if `A` extends `B` (defaults to `true`)\n * @template No - The result if `A` does not extend `B` (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` is assignable to `B`\n * - `No`: Otherwise\n */\nexport type Extends<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Yes : No\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 * @template A - The type to check if it is a proper subtype\n * @template B - The type to check against\n * @template Yes - The result if `A` is a proper subtype of `B` (defaults to `true`)\n * @template No - The result if `A` is not a proper subtype of `B` (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` is a proper subtype of `B`\n * - `No`: Otherwise\n *\n * **Note:** the result will never be `boolean`.\n *\n * @example\n * ```ts\n * type T1 = ProperExtend<true, boolean> // true\n * type T2 = ProperExtend<1, number> // true\n * type F1 = ProperExtend<boolean, boolean> // false\n * type F2 = ProperExtend<number, string> // false\n * ```\n */\nexport type ProperExtend<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Exact<A, B> extends false ? Yes : No : No\n"]}

package/script/utils/compare/index.d.ts

@@ -0,0 +1,5 @@
+export * from './assignable.js';
+export * from './exact.js';
+export * from './extends.js';
+export * from './overlap.js';
+//# sourceMappingURL=index.d.ts.map

package/script/utils/compare/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/compare/index.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}

package/script/utils/compare/index.js

@@ -0,0 +1,23 @@
+"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 });
+// Index start >>>>>>>>>>>>>>>>
+__exportStar(require("./assignable.js"), exports);
+__exportStar(require("./exact.js"), exports);
+__exportStar(require("./extends.js"), exports);
+__exportStar(require("./overlap.js"), exports);
+// <<<<<<<<<<<<<<<<   Index end
+//# sourceMappingURL=index.js.map

package/script/utils/compare/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/compare/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,kDAA+B;AAC/B,6CAA0B;AAC1B,+CAA4B;AAC5B,+CAA4B;AAC5B,+BAA+B","sourcesContent":["// Index start >>>>>>>>>>>>>>>>\nexport * from './assignable.js'\nexport * from './exact.js'\nexport * from './extends.js'\nexport * from './overlap.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}

package/script/utils/compare/overlap.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Checks whether two types have any overlapping members.
+ *
+ * @template A - The first type to check for overlap
+ * @template B - The second type to check for overlap
+ * @template Yes - The result if types overlap (defaults to `true`)
+ * @template No - The result if types do not overlap (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` and `B` share at least one common type
+ * - `No`: `A` and `B` are completely disjoint
+ *
+ * @example
+ * ```ts
+ * type T1 = Overlap<1 | 2, 2 | 3> // true
+ * type T2 = Overlap<string, 'hello'> // true
+ * type F1 = Overlap<string, number> // false
+ * type F2 = Overlap<1, 'one'> // false
+ * ```
+ */
+export type Overlap<A, B, Yes = true, No = false> = [A & B] extends [never] ? No : Yes;
+/**
+ * Checks whether two types are disjoint.
+ *
+ * This is the logical negation of `Overlap<A, B>`.
+ *
+ * @template A - The first type to check for disjointness
+ * @template B - The second type to check for disjointness
+ * @template Yes - The result if types are disjoint (defaults to `true`)
+ * @template No - The result if types are not disjoint (defaults to `false`)
+ *
+ * ### Result
+ *
+ * - `Yes`: `A` and `B` have no overlap
+ * - `No`: `A` and `B` share at least one common type
+ *
+ * @example
+ * ```ts
+ * type T1 = Disjoint<string, number> // true
+ * type T2 = Disjoint<1, 'one'> // true
+ * type F1 = Disjoint<1 | 2, 2 | 3> // false
+ * type F2 = Disjoint<string, 'hello'> // false
+ * ```
+ */
+export type Disjoint<A, B, Yes = true, No = false> = [A & B] extends [never] ? Yes : No;
+//# sourceMappingURL=overlap.d.ts.map

package/script/utils/compare/overlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap.d.ts","sourceRoot":"","sources":["../../../src/utils/compare/overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA"}

package/script/{main/control.js → utils/compare/overlap.js}

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

package/script/utils/compare/overlap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap.js","sourceRoot":"","sources":["../../../src/utils/compare/overlap.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Checks whether two types have any overlapping members.\n *\n * @template A - The first type to check for overlap\n * @template B - The second type to check for overlap\n * @template Yes - The result if types overlap (defaults to `true`)\n * @template No - The result if types do not overlap (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` share at least one common type\n * - `No`: `A` and `B` are completely disjoint\n *\n * @example\n * ```ts\n * type T1 = Overlap<1 | 2, 2 | 3> // true\n * type T2 = Overlap<string, 'hello'> // true\n * type F1 = Overlap<string, number> // false\n * type F2 = Overlap<1, 'one'> // false\n * ```\n */\nexport type Overlap<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? No : Yes\n\n/**\n * Checks whether two types are disjoint.\n *\n * This is the logical negation of `Overlap<A, B>`.\n *\n * @template A - The first type to check for disjointness\n * @template B - The second type to check for disjointness\n * @template Yes - The result if types are disjoint (defaults to `true`)\n * @template No - The result if types are not disjoint (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` have no overlap\n * - `No`: `A` and `B` share at least one common type\n *\n * @example\n * ```ts\n * type T1 = Disjoint<string, number> // true\n * type T2 = Disjoint<1, 'one'> // true\n * type F1 = Disjoint<1 | 2, 2 | 3> // false\n * type F2 = Disjoint<string, 'hello'> // false\n * ```\n */\nexport type Disjoint<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? Yes : No\n"]}

package/script/utils/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
+ *
+ * @module
+ */
+export * from './compare/index.js';
+export * from './logic/index.js';
+export * from './object/index.js';
+export * from './tuple/index.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/script/utils/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
+ *
+ * @module
+ */
+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 });
+// Index start >>>>>>>>>>>>>>>>
+__exportStar(require("./compare/index.js"), exports);
+__exportStar(require("./logic/index.js"), exports);
+__exportStar(require("./object/index.js"), exports);
+__exportStar(require("./tuple/index.js"), exports);
+// <<<<<<<<<<<<<<<<   Index end
+//# sourceMappingURL=index.js.map

package/script/utils/index.js.map

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

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

@@ -0,0 +1,18 @@
+/**
+ * **⚠️Important:** parameter `T` and `U` are not distributive. When they are union type, it treats them as a single entity.
+ *
+ * @template T - The type to test (not distributed over unions)
+ * @template U - The constraint type to test against
+ *
+ * @example
+ *
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * expect<AssertExtends<string, number>>().toBeNever
+ * expect<AssertExtends<1 | 2, 1>>().toBeNever
+ * expect<AssertExtends<1, 1 | 2>>().toBe<1>().success
+ * ```
+ */
+export type AssertExtends<T, U> = [T] extends [U] ? T : never;
+//# sourceMappingURL=assert.d.ts.map

package/script/utils/logic/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/utils/logic/assert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA"}

package/script/utils/logic/assert.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../../../src/utils/logic/assert.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * **⚠️Important:** parameter `T` and `U` are not distributive. When they are union type, it treats them as a single entity.\n *\n * @template T - The type to test (not distributed over unions)\n * @template U - The constraint type to test against\n *\n * @example\n *\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * expect<AssertExtends<string, number>>().toBeNever\n * expect<AssertExtends<1 | 2, 1>>().toBeNever\n * expect<AssertExtends<1, 1 | 2>>().toBe<1>().success\n * ```\n */\nexport type AssertExtends<T, U> = [T] extends [U] ? T : never\n"]}

package/script/utils/logic/if.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Conditional type - returns `Yes` if condition `Condition` is true, otherwise returns `No`
+ *
+ * @template Condition - The boolean condition to check
+ * @template Yes - The type to return if condition is true
+ * @template No - The type to return if condition is false (defaults to `never`)
+ *
+ * @example
+ * ```ts
+ * type Result = If<true, 'yes', 'no'> // 'yes'
+ * type Result2 = If<false, 'yes', 'no'> // 'no'
+ * type BoolResult = If<boolean, 'yes', 'no'> // boolean
+ * ```
+ */
+export type If<Condition extends boolean, Yes, No = never> = Condition extends true ? Yes : No;
+/**
+ * Conditional type - returns `Yes` if condition `Condition` is false, otherwise returns `No`
+ *
+ * @template Condition - The boolean condition to check
+ * @template Yes - The type to return if condition is false
+ * @template No - The type to return if condition is true (defaults to `never`)
+ *
+ * ### Result
+ *
+ * - `never`: if `Condition` is `never`
+ * - `Yes`: if `Condition` is `false`
+ * - `No`: if `Condition` is `true`
+ *
+ * @example
+ * ```ts
+ * type Result = IfFalse<false, 'yes', 'no'> // 'yes'
+ * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'
+ * type BoolResult = IfFalse<boolean, 'yes', 'no'> // boolean
+ * ```
+ */
+export type IfFalse<Condition extends boolean, Yes, No = never> = Condition extends false ? Yes : No;
+//# sourceMappingURL=if.d.ts.map

package/script/utils/logic/if.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"if.d.ts","sourceRoot":"","sources":["../../../src/utils/logic/if.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,KAAK,IAAI,SAAS,SAAS,IAAI,GAAG,GAAG,GAAG,EAAE,CAAA;AAE9F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,OAAO,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,KAAK,IAAI,SAAS,SAAS,KAAK,GAAG,GAAG,GAAG,EAAE,CAAA"}

package/script/{main/type/set.js → utils/logic/if.js}

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

package/script/utils/logic/if.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"if.js","sourceRoot":"","sources":["../../../src/utils/logic/if.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Conditional type - returns `Yes` if condition `Condition` is true, otherwise returns `No`\n *\n * @template Condition - The boolean condition to check\n * @template Yes - The type to return if condition is true\n * @template No - The type to return if condition is false (defaults to `never`)\n *\n * @example\n * ```ts\n * type Result = If<true, 'yes', 'no'> // 'yes'\n * type Result2 = If<false, 'yes', 'no'> // 'no'\n * type BoolResult = If<boolean, 'yes', 'no'> // boolean\n * ```\n */\nexport type If<Condition extends boolean, Yes, No = never> = Condition extends true ? Yes : No\n\n/**\n * Conditional type - returns `Yes` if condition `Condition` is false, otherwise returns `No`\n *\n * @template Condition - The boolean condition to check\n * @template Yes - The type to return if condition is false\n * @template No - The type to return if condition is true (defaults to `never`)\n *\n * ### Result\n *\n * - `never`: if `Condition` is `never`\n * - `Yes`: if `Condition` is `false`\n * - `No`: if `Condition` is `true`\n *\n * @example\n * ```ts\n * type Result = IfFalse<false, 'yes', 'no'> // 'yes'\n * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'\n * type BoolResult = IfFalse<boolean, 'yes', 'no'> // boolean\n * ```\n */\nexport type IfFalse<Condition extends boolean, Yes, No = never> = Condition extends false ? Yes : No\n"]}

package/script/utils/logic/index.d.ts

@@ -0,0 +1,4 @@
+export * from './assert.js';
+export * from './if.js';
+export * from './switch.js';
+//# sourceMappingURL=index.d.ts.map

package/script/utils/logic/index.d.ts.map

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

package/script/utils/logic/index.js

@@ -0,0 +1,22 @@
+"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 });
+// Index start >>>>>>>>>>>>>>>>
+__exportStar(require("./assert.js"), exports);
+__exportStar(require("./if.js"), exports);
+__exportStar(require("./switch.js"), exports);
+// <<<<<<<<<<<<<<<<   Index end
+//# sourceMappingURL=index.js.map

package/script/utils/logic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/logic/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,8CAA2B;AAC3B,0CAAuB;AACvB,8CAA2B;AAC3B,+BAA+B","sourcesContent":["// Index start >>>>>>>>>>>>>>>>\nexport * from './assert.js'\nexport * from './if.js'\nexport * from './switch.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}

package/script/utils/logic/switch.d.ts

@@ -0,0 +1,87 @@
+import type { Exact } from '../index.js';
+/**
+ * Case tuple type used with `SwitchExact` and `SwitchExtends`
+ *
+ * @template T - The condition type to match against
+ * @template Result - The result type to return if match is found
+ *
+ * @example
+ * ```ts
+ * type MyCase = Case<1, 'one'>
+ * // Equivalent to: [1, 'one']
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { SwitchExact, DefaultCase } from '@leawind/lay-sing/utils'
+ * type NameMap<id> = SwitchExact<id, [
+ *   [1, 'Alice'],
+ *   [2, 'Bob'],
+ * ], DefaultCase<'Steve'>>
+ * ```
+ *
+ * @see SwitchExact
+ */
+export type Case<T = unknown, Result = unknown> = [T, Result];
+/**
+ * Default case type used with `SwitchExact` and `SwitchExtends`
+ *
+ * @template T - The default result type
+ *
+ * @example
+ * ```ts
+ * import { SwitchExact, DefaultCase } from '@leawind/lay-sing/utils'
+ * type NameMap<id> = SwitchExact<id, [
+ *   [1, 'Alice'],
+ *   [2, 'Bob'],
+ * ], DefaultCase<'Steve'>>
+ * ```
+ *
+ * @see SwitchExact
+ */
+export type DefaultCase<T> = T;
+/**
+ * Switch type that uses exact matching logic
+ *
+ * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.
+ *
+ * @template T - The type to match against cases
+ * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]
+ * @template Default - Default result if no exact match is found (defaults to `never`)
+ *
+ * @example
+ * ```ts
+ * import { SwitchExact, DefaultCase } from '@leawind/lay-sing/utils'
+ * type Result = SwitchExact<2, [
+ *   [1, 'Alice'],
+ *   [2, 'Bob'],
+ *   [3, 'Charlie'],
+ * ], DefaultCase<'Steve'>>
+ *
+ * // Result: 'Bob'
+ * ```
+ */
+export type SwitchExact<T, Cases extends readonly [unknown, unknown][], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer Condition, infer Result] ? (Exact<T, Condition> extends true ? Result : (SwitchExact<T, Rest extends readonly [unknown, unknown][] ? Rest : never, Default>)) : (never)) : Default;
+/**
+ * Switch type that uses 'extends' logic instead of 'Exact' logic
+ *
+ * **⚠️Important:** `T` parameter is not distributive. When `T` is a union type, it does not check each member separately.
+ *
+ * @template T - The type to match against cases
+ * @template Cases - Array of case tuples, each tuple has the form [Condition, Result]
+ * @template Default - Default result if no match is found (defaults to `never`)
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * expect<
+ *   SwitchExtends<string, [
+ *     [number, boolean],
+ *     [string, boolean],
+ *   ], Error>
+ * >().toBe<boolean>().success
+ * ```
+ */
+export type SwitchExtends<T, Cases extends readonly [unknown, unknown][], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer C, infer R] ? ([T] extends [C] ? R : SwitchExtends<T, Rest extends readonly [unknown, unknown][] ? Rest : never, Default>) : never) : Default;
+//# sourceMappingURL=switch.d.ts.map

package/script/utils/logic/switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch.d.ts","sourceRoot":"","sources":["../../../src/utils/logic/switch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAE7D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,EACD,KAAK,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAC3C,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,SAAS,EAAE,MAAM,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,MAAM,GACpF,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GACvF,CAAC,KAAK,CAAC,CACZ,GACC,OAAO,CAAA;AAEX;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,EACD,KAAK,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAC3C,OAAO,GAAG,KAAK,IACb,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAC7C,KAAK,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAC5B,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,GAC5G,KAAK,CACV,GACC,OAAO,CAAA"}

package/script/utils/logic/switch.js

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

package/script/utils/logic/switch.js.map

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

package/script/utils/object/index.d.ts

@@ -0,0 +1,4 @@
+export * from './keys.js';
+export * from './pick.js';
+export * from './props.js';
+//# sourceMappingURL=index.d.ts.map

package/script/utils/object/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/object/index.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA"}

package/script/{main/type → utils/object}/index.js

@@ -15,7 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // Index start >>>>>>>>>>>>>>>>
-__exportStar(require("./compare.js"), exports);
-__exportStar(require("./set.js"), exports);
+__exportStar(require("./keys.js"), exports);
+__exportStar(require("./pick.js"), exports);
+__exportStar(require("./props.js"), exports);
 // <<<<<<<<<<<<<<<<   Index end
 //# sourceMappingURL=index.js.map

package/script/utils/object/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/object/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,4CAAyB;AACzB,4CAAyB;AACzB,6CAA0B;AAC1B,+BAA+B","sourcesContent":["// Index start >>>>>>>>>>>>>>>>\nexport * from './keys.js'\nexport * from './pick.js'\nexport * from './props.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}