lay-sing 0.2.1 → 0.4.0

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/key.js → utils/logic/if.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=key.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/{esm/main/control.d.ts → script/utils/logic/switch.d.ts}

@@ -1,40 +1,4 @@
-import type { Exact } from './type/compare.js';
-/**
- * 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;
+import type { Exact } from '../index.js';
 /**
  * Case tuple type used with `SwitchExact` and `SwitchExtends`
  *
@@ -47,6 +11,15 @@ export type IfFalse<Condition extends boolean, Yes, No = never> = Condition exte
  * // 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];
@@ -57,6 +30,7 @@ export type Case<T = unknown, Result = unknown> = [T, Result];
  *
  * @example
  * ```ts
+ * import { SwitchExact, DefaultCase } from '@leawind/lay-sing/utils'
  * type NameMap<id> = SwitchExact<id, [
  *   [1, 'Alice'],
  *   [2, 'Bob'],
@@ -77,6 +51,7 @@ export type DefaultCase<T> = T;
  *
  * @example
  * ```ts
+ * import { SwitchExact, DefaultCase } from '@leawind/lay-sing/utils'
  * type Result = SwitchExact<2, [
  *   [1, 'Alice'],
  *   [2, 'Bob'],
@@ -98,15 +73,15 @@ export type SwitchExact<T, Cases extends readonly [unknown, unknown][], Default
  *
  * @example
  * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
+ * import { expect } from '@leawind/lay-sing'
  *
  * expect<
  *   SwitchExtends<string, [
  *     [number, boolean],
  *     [string, boolean],
  *   ], Error>
- * >().toBe<boolean>().success
+ * >().to.be<boolean>().pass
  * ```
  */
 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=control.d.ts.map
+//# 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 * >().to.be<boolean>().pass\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/misc.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Creates an intersection of all types in the provided tuple
+ *
+ * ## `IntersectionOf<[A, B, ... T]>` = `A & B & ... & T`
+ *
+ * @template Types - A tuple of types to create an intersection from
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * type Result = IntersectionOf<[{ a: string }, { b: number }, { c: boolean }]>
+ * expect<Result>().to.extend<{ a: string } & { b: number } & { c: boolean }>().pass
+ * expect<Result>().to.extend<{ a: string; b: number; c: boolean }>().pass
+ * ```
+ */
+export type IntersectionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest] ? First & IntersectionOf<Rest> : unknown;
+/**
+ * Creates a union of all types in the provided tuple
+ *
+ * ## `UnionOf<[A, B, ... T]>` = `A | B | ... | T`
+ *
+ * @template Types - A tuple of types to create a union from
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * type Result = UnionOf<[string, number, boolean]>
+ * expect<Result>().to.be<string | number | boolean>().pass
+ * ```
+ */
+export type UnionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest] ? First | UnionOf<Rest> : never;
+//# sourceMappingURL=misc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GACrG,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,GAC5B,OAAO,CAAA;AAEX;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,OAAO,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC9F,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,GACrB,KAAK,CAAA"}

package/script/{main/json.js → utils/misc.js}

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

package/script/utils/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Creates an intersection of all types in the provided tuple\n *\n * ## `IntersectionOf<[A, B, ... T]>` = `A & B & ... & T`\n *\n * @template Types - A tuple of types to create an intersection from\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * type Result = IntersectionOf<[{ a: string }, { b: number }, { c: boolean }]>\n * expect<Result>().to.extend<{ a: string } & { b: number } & { c: boolean }>().pass\n * expect<Result>().to.extend<{ a: string; b: number; c: boolean }>().pass\n * ```\n */\nexport type IntersectionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]\n  ? First & IntersectionOf<Rest>\n  : unknown\n\n/**\n * Creates a union of all types in the provided tuple\n *\n * ## `UnionOf<[A, B, ... T]>` = `A | B | ... | T`\n *\n * @template Types - A tuple of types to create a union from\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing'\n *\n * type Result = UnionOf<[string, number, boolean]>\n * expect<Result>().to.be<string | number | boolean>().pass\n * ```\n */\nexport type UnionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]\n  ? First | UnionOf<Rest>\n  : never\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"]}

package/{esm/main/key.d.ts → script/utils/object/keys.d.ts}

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

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

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

package/script/{main/doc.js → utils/object/keys.js}

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

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * Safely picks keys `Key` from type `Obj`, excluding non-existent keys
+ *
+ * @template Obj - The object type to pick keys from
+ * @template Key - The keys to pick from the object
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ *
+ * type Result = SafePick<{ a: string; b: number }, 'a' | 'c'>
+ * expect<Result>().to.be<{ a: string }>().pass
+ * ```
+ */
+export type SafePick<Obj, Key> = Pick<Obj, Key & keyof Obj>;
+//# sourceMappingURL=pick.d.ts.map

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

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

package/script/utils/object/pick.js

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

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

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

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

@@ -0,0 +1,17 @@
+import type { KeysOfBaseType } from '../index.js';
+/**
+ * Picks properties from `T` that have values of type `U`
+ *
+ * @template T - The object type to pick properties from
+ * @template U - The value type to match against
+ *
+ * @example
+ * ```ts
+ * import { expect } from '@leawind/lay-sing'
+ * type A = { a: string; b: number; c: string }
+ * type Strings = PropsOfBaseType<A, string> // { a: string; c: string }
+ * expect<PropsOfBaseType<A, string>>().to.be<{ a: string; c: string }>()
+ * ```
+ */
+export type PropsOfBaseType<T, U> = Pick<T, KeysOfBaseType<Required<T>, U>>;
+//# sourceMappingURL=props.d.ts.map

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

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

package/script/utils/object/props.js

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

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

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

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

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

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

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

package/script/utils/tuple/append.js

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

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

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

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

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

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

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

package/script/utils/tuple/concat.js

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

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

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

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

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

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

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

package/script/utils/tuple/includes.js

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

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

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

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

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

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

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

package/script/utils/tuple/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("./append.js"), exports);
+__exportStar(require("./concat.js"), exports);
+__exportStar(require("./includes.js"), exports);
+// <<<<<<<<<<<<<<<<   Index end
+//# sourceMappingURL=index.js.map

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

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

package/esm/main/async.d.ts

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

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

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

package/esm/main/async.js

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