lay-sing 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Leawind <leawind@yeah.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+|         |                            |
+| ------- | -------------------------- |
+| English | [简体中文](./README-zh.md) |
+
+# `lay-sing`
+
+A collection of testing utilities and type manipulation tools for compile-time type validation and advanced type operations.
+
+## What is it
+
+1. **Testing Utilities**
+
+```ts
+// They do nothing at runtime
+expect<number>().toBe<number>().success
+expect<number>().toBe<string>().fail
+
+// Type error: Property 'success' does not exist on type '{ fail: void; }'.
+expect<number>().toBe<string>().success
+```
+
+2. **Type Manipulation Tools**
+
+```ts
+// Result is 'Bob'
+type Result = Switch<2, [
+  Case<1, 'Alice'>,
+  Case<2, 'Bob'>,
+  Case<3, 'Charlie'>,
+], DefaultCase<'Unknown'>>
+```
+
+## Install
+
+(#TODO)
+
+## Testing Utilities
+
+The `test-utils` module provides type-level testing utilities for compile-time type validation.
+
+### Type Expectations
+
+The `expect` function provides a fluent API for type-level assertions:
+
+```ts
+// Test if two types are identical
+expect<number>().toBe<number>().success
+expect<number>().toBe<string>().fail
+
+// Test if one type extends another
+expect<2>().toExtend<number>().success
+expect<2>().toExtend<string>().fail
+
+// Test if type has a specific property
+expect<{ name: string }>().toHaveProperty<'name'>().success
+
+// Test primitive types
+expect<'hello'>().toExtendString.success
+expect<true>().toExtendBoolean.success
+```
+
+Available assertion methods:
+
+- `toBe<U>()` - Tests exact type equality
+- `toExtend<U>()` - Tests if type extends another
+- `toProperExtend<U>()` - Tests if type properly extends another (extends but is not the same)
+- `toHaveProperty<K>()` - Tests if type has a property with key K
+- `toExtendNumber` - Tests if type extends the Number primitive (available only when type extends number)
+- `toExtendString` - Tests if type extends the String primitive (available only when type extends string)
+- `toExtendBoolean` - Tests if type extends the Boolean primitive (available only when type extends boolean)
+- Specific primitive type checks: `toBeAny`, `toBeNever`, `toBeUnknown`, `toBeVoid`, `toBeTrue`, `toBeFalse`
+
+### Type Comparisons
+
+The `compare` function allows for sophisticated type-to-type relationship testing:
+
+```ts
+// Check if two types are the same
+compare<number, number>().same // Available
+
+// Check if two types are different
+compare<number, string>().different // Available
+
+// Check if two types overlap
+compare<4, number>().overlap.different // Available
+
+// Check if two types are disjoint
+compare<4, 'abc'>().different.disjoint // Available
+
+// Check if two types are mutually assignable
+compare<1 | 2, 1 | 2>().mutuallyAssignable // Available
+```
+
+Available comparison methods:
+
+- `same` - Available when types are exactly the same
+- `different` - Available when types are different
+- `overlap` - Available when types have some overlap
+- `disjoint` - Available when types have no overlap
+- `mutuallyAssignable` - Available when types are mutually assignable
+
+These utilities are invaluable for creating type-level tests that validate your type definitions at compile time.
+
+### NOOP Placeholder
+
+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.
+
+```ts
+NOOP.foo.bar().baz.qux // safe, returns NOOP
+String(NOOP) // "[NOOP]"
+await NOOP // does not await (not thenable)
+```
+
+## Type Tools
+
+Here are some of type tools:
+
+### Conditional Types
+
+```typescript
+type Result = If<true, 'yes', 'no'> // 'yes'
+type Conditional = If<boolean, 'yes', 'no'> // 'yes' | 'no'
+```
+
+### Boolean Operations
+
+```typescript
+type IsTrue = And<true, true> // true
+type IsFalse = And<true, false> // false
+type Either = Or<true, false> // true
+type Negation = Not<true> // false
+```
+
+### Array/Tuple Operations
+
+```typescript
+type Combined = ConcatTuple<[1, 2], [3, 4]> // [1, 2, 3, 4]
+type UniqueCombined = ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]> // [1, 2, 3, 4]
+type HasElement = TupleIncludes<[1, 2, 3], 2> // true
+```
+
+### Object Manipulation
+
+```typescript
+type PartialObj = DeepPartial<{ a: string; nested: { b: number } }> // { a?: string; nested?: { b?: number } }
+type PickedProps = PropsOfType<{ a: string; b: number; c: string }, string> // { a: string; c: string }
+```
+
+## Name
+
+The name "lay-sing" (pronounced /leɪ sɪŋ/) is phonetically similar to the Chinese word "类型" (pinyin: lèi xíng), which translates to "type" in English.

package/esm/main/array.d.ts

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1 @@
+{"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

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

package/esm/main/array.js.map

@@ -0,0 +1 @@
+{"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"]}

package/esm/main/async.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Represents a value that can be either T or a Promise of T
+ */
+export type Awaitable<T> = Promise<T> | T;
+//# sourceMappingURL=async.d.ts.map

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

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

package/esm/main/async.js

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

package/esm/main/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../src/main/async.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents a value that can be either T or a Promise of T\n */\nexport type Awaitable<T> = Promise<T> | T\n"]}

package/esm/main/boolean.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ### Result
+ *
+ * - `never`: if `T` is `never`
+ * - `boolean`: if `T` is `boolean` or `any`
+ * - `false`: if `T` is `true`
+ * - `true`: if `T` is `false`
+ *
+ * ### Examples
+ *
+ * | `T`       | `Not<T>`  |
+ * | --------- | --------- |
+ * | `never`   | `never`    |
+ * | `true`    | `false`   |
+ * | `false`   | `true`    |
+ * | `boolean` | `boolean` |
+ * | `any`     | `boolean` |
+ */
+export type Not<T extends boolean> = T extends true ? false : T extends false ? true : boolean;
+/**
+ * - `never`: if anyone of A,B is `never`
+ * - `boolean`: if anyone of A,B is `boolean` or `any`
+ * - `true`: if both A,B are `true`
+ * - `false`: otherwise
+ */
+export type And<A extends boolean, B extends boolean> = A extends never ? never : [B] extends [never] ? never : (A extends true ? (B extends true ? true : false) : false);
+/**
+ * ### Result
+ *
+ * - `never`: if anyone of A,B is `never`
+ * - `boolean`: if anyone of A,B is `boolean` or `any`
+ * - `false`: if both A,B are `false`
+ * - `true`: otherwise
+ */
+export type Or<A extends boolean, B extends boolean> = [A] extends [never] ? never : [B] extends [never] ? never : [boolean] extends [A] ? boolean : [boolean] extends [B] ? boolean : true extends A ? true : true extends B ? true : false;
+//# sourceMappingURL=boolean.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,OAAO,IAAI,CAAC,SAAS,IAAI,GAAG,KAAK,GACvD,CAAC,SAAS,KAAK,GAAG,IAAI,GACtB,OAAO,CAAA;AAEX;;;;;GAKG;AACH,MAAM,MAAM,GAAG,CACb,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,IACf,CAAC,SAAS,KAAK,GAAG,KAAK,GACvB,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;AAE9D;;;;;;;GAOG;AACH,MAAM,MAAM,EAAE,CACZ,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,IACf,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC3B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,GAC/B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,GAC/B,IAAI,SAAS,CAAC,GAAG,IAAI,GACrB,IAAI,SAAS,CAAC,GAAG,IAAI,GACrB,KAAK,CAAA"}

package/esm/main/boolean.js

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

package/esm/main/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/main/boolean.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * ### Result\n *\n * - `never`: if `T` is `never`\n * - `boolean`: if `T` is `boolean` or `any`\n * - `false`: if `T` is `true`\n * - `true`: if `T` is `false`\n *\n * ### Examples\n *\n * | `T`       | `Not<T>`  |\n * | --------- | --------- |\n * | `never`   | `never`    |\n * | `true`    | `false`   |\n * | `false`   | `true`    |\n * | `boolean` | `boolean` |\n * | `any`     | `boolean` |\n */\nexport type Not<T extends boolean> = T extends true ? false\n  : T extends false ? true\n  : boolean\n\n/**\n * - `never`: if anyone of A,B is `never`\n * - `boolean`: if anyone of A,B is `boolean` or `any`\n * - `true`: if both A,B are `true`\n * - `false`: otherwise\n */\nexport type And<\n  A extends boolean,\n  B extends boolean,\n> = A extends never ? never\n  : [B] extends [never] ? never\n  : (A extends true ? (B extends true ? true : false) : false)\n\n/**\n * ### Result\n *\n * - `never`: if anyone of A,B is `never`\n * - `boolean`: if anyone of A,B is `boolean` or `any`\n * - `false`: if both A,B are `false`\n * - `true`: otherwise\n */\nexport type Or<\n  A extends boolean,\n  B extends boolean,\n> = [A] extends [never] ? never\n  : [B] extends [never] ? never\n  : [boolean] extends [A] ? boolean\n  : [boolean] extends [B] ? boolean\n  : true extends A ? true\n  : true extends B ? true\n  : false\n"]}

package/esm/main/control.d.ts

@@ -0,0 +1,88 @@
+import type { Same } from './type/compare.js';
+/**
+ * Conditional type - returns `T` if condition `C` is true, otherwise returns `F`
+ *
+ * ### Result
+ *
+ * - `never`: if `C` is `never`
+ * - `T`: if `C` is `true`
+ * - `F`: if `C` is `false`
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type Result = If<true, 'yes', 'no'> // 'yes'
+ * type Result2 = If<false, 'yes', 'no'> // 'no'
+ * type NeverResult = If<never, 'yes', 'no'> // never
+ * ```
+ */
+export type If<C extends boolean, T, F = never> = [C] extends [never] ? never : C extends true ? T : F;
+/**
+ * Conditional type - returns `T` if condition `C` is false, otherwise returns `F`
+ *
+ * ### Result
+ *
+ * - `never`: if `C` is `never`
+ * - `T`: if `C` is `false`
+ * - `F`: if `C` is `true`
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type Result = IfFalse<false, 'yes', 'no'> // 'yes'
+ * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'
+ * type NeverResult = IfFalse<never, 'yes', 'no'> // never
+ * ```
+ */
+export type IfFalse<C extends boolean, T, F = never> = [C] extends [never] ? never : C extends false ? T : F;
+/**
+ * Used with:
+ * - {@link Switch}
+ * - {@link SwitchExtends}
+ */
+export type Case<T = unknown, Return = unknown> = [T, Return];
+/**
+ * Used with:
+ *
+ * - {@link Switch}
+ * - {@link SwitchExtends}
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type NameMap<id> = Switch<id, [
+ *   Case<1, 'Alice'>,
+ *   Case<2, 'Bob'>,
+ *   Case<3, 'Charlie'>,
+ * ], DefaultCase<'Steve'>>
+ * ```
+ */
+export type DefaultCase<T> = T;
+/**
+ * ### Examples
+ *
+ * ```ts
+ * type Result = Switch<2, [
+ *   Case<1, 'Alice'>,
+ *   Case<2, 'Bob'>,
+ *   Case<3, 'Charlie'>,
+ * ], DefaultCase<'Steve'>>
+ *
+ * // Result: 'Bob'
+ * ```
+ */
+export type Switch<T, Cases extends readonly Case[], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer C, infer R] ? (Same<T, C> extends true ? R : (Switch<T, Rest extends readonly Case[] ? Rest : never, Default>)) : (never)) : Default;
+/**
+ * Switch type that uses 'extends' logic instead of 'Same' logic
+ *
+ * ### Examples
+ * ```ts
+ * type Result = SwitchExtends<string | number, [
+ *   Case<string, 'string type'>,
+ *   Case<number, 'number type'>,
+ * ], 'other'>
+ * // Result: 'string type' | 'number type'
+ * ```
+ */
+export type SwitchExtends<T, Cases extends readonly Case[], Default = never> = Cases extends [infer First, ...infer Rest] ? (First extends [infer C, infer R] ? ([T] extends [C] ? R : SwitchExtends<T, Rest extends readonly Case[] ? Rest : never, Default>) : never) : Default;
+//# sourceMappingURL=control.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,EAAE,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GACzE,CAAC,SAAS,IAAI,GAAG,CAAC,GAClB,CAAC,CAAA;AAEL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAC9E,CAAC,SAAS,KAAK,GAAG,CAAC,GACnB,CAAC,CAAA;AAEL;;;;GAIG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAC7D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAA;AAE9B;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EACD,KAAK,SAAS,SAAS,IAAI,EAAE,EAC7B,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,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,SAAS,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GACjG,CAAC,KAAK,CAAC,CACZ,GACC,OAAO,CAAA;AAEX;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,EACD,KAAK,SAAS,SAAS,IAAI,EAAE,EAC7B,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,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,GAC9F,KAAK,CACV,GACC,OAAO,CAAA"}

package/esm/main/control.js

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

package/esm/main/control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.js","sourceRoot":"","sources":["../../src/main/control.ts"],"names":[],"mappings":"","sourcesContent":["import type { Same } from './type/compare.js'\n\n/**\n * Conditional type - returns `T` if condition `C` is true, otherwise returns `F`\n *\n * ### Result\n *\n * - `never`: if `C` is `never`\n * - `T`: if `C` is `true`\n * - `F`: if `C` is `false`\n *\n * ### Examples\n *\n * ```ts\n * type Result = If<true, 'yes', 'no'> // 'yes'\n * type Result2 = If<false, 'yes', 'no'> // 'no'\n * type NeverResult = If<never, 'yes', 'no'> // never\n * ```\n */\nexport type If<C extends boolean, T, F = never> = [C] extends [never] ? never\n  : C extends true ? T\n  : F\n\n/**\n * Conditional type - returns `T` if condition `C` is false, otherwise returns `F`\n *\n * ### Result\n *\n * - `never`: if `C` is `never`\n * - `T`: if `C` is `false`\n * - `F`: if `C` is `true`\n *\n * ### Examples\n *\n * ```ts\n * type Result = IfFalse<false, 'yes', 'no'> // 'yes'\n * type Result2 = IfFalse<true, 'yes', 'no'> // 'no'\n * type NeverResult = IfFalse<never, 'yes', 'no'> // never\n * ```\n */\nexport type IfFalse<C extends boolean, T, F = never> = [C] extends [never] ? never\n  : C extends false ? T\n  : F\n\n/**\n * Used with:\n * - {@link Switch}\n * - {@link SwitchExtends}\n */\nexport type Case<T = unknown, Return = unknown> = [T, Return]\n/**\n * Used with:\n *\n * - {@link Switch}\n * - {@link SwitchExtends}\n *\n * ### Examples\n *\n * ```ts\n * type NameMap<id> = Switch<id, [\n *   Case<1, 'Alice'>,\n *   Case<2, 'Bob'>,\n *   Case<3, 'Charlie'>,\n * ], DefaultCase<'Steve'>>\n * ```\n */\nexport type DefaultCase<T> = T\n\n/**\n * ### Examples\n *\n * ```ts\n * type Result = Switch<2, [\n *   Case<1, 'Alice'>,\n *   Case<2, 'Bob'>,\n *   Case<3, 'Charlie'>,\n * ], DefaultCase<'Steve'>>\n *\n * // Result: 'Bob'\n * ```\n */\nexport type Switch<\n  T,\n  Cases extends readonly Case[],\n  Default = never,\n> = Cases extends [infer First, ...infer Rest] ? (\n    First extends [infer C, infer R]\n      ? (Same<T, C> extends true ? R : (Switch<T, Rest extends readonly Case[] ? Rest : never, Default>))\n      : (never)\n  )\n  : Default\n\n/**\n * Switch type that uses 'extends' logic instead of 'Same' logic\n *\n * ### Examples\n * ```ts\n * type Result = SwitchExtends<string | number, [\n *   Case<string, 'string type'>,\n *   Case<number, 'number type'>,\n * ], 'other'>\n * // Result: 'string type' | 'number type'\n * ```\n */\nexport type SwitchExtends<\n  T,\n  Cases extends readonly Case[],\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 Case[] ? Rest : never, Default>)\n      : never\n  )\n  : Default\n"]}

package/esm/main/doc.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Append documentation or auxiliary metadata to type `A`
+ * without changing its shape.
+ *
+ * This type intersects `Doc` onto `A`, but only keeps the keys
+ * originally defined in `A`. As a result:
+ *
+ * - `Doc` cannot introduce new properties
+ * - Existing properties in `A` are preserved
+ * - `Doc` may further constrain or annotate existing properties
+ *
+ * This is typically used to attach JSDoc comments, branding,
+ * or editor-only metadata to an existing type while keeping
+ * its public structure intact.
+ */
+export type AppendDoc<T, Doc> = Pick<T & Doc, keyof T>;
+/**
+ * Prepend documentation or auxiliary metadata to type `A`
+ * without changing its shape.
+ *
+ * This is similar to {@link AppendDoc}, but the intersection order
+ * is reversed (`Doc & A`), which can affect how property types,
+ * documentation, and hover information are presented by tooling.
+ *
+ * In practice, this allows `Doc` to act as a non-invasive,
+ * descriptive layer while ensuring `A` remains the authoritative
+ * source of truth for property types.
+ */
+export type PrependDoc<T, Doc> = Pick<Doc & T, keyof T>;
+//# sourceMappingURL=doc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/main/doc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,GAAG,IAAI,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,CAAC,CAAC,CAAA;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA"}

package/esm/main/doc.js

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

package/esm/main/doc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc.js","sourceRoot":"","sources":["../../src/main/doc.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Append documentation or auxiliary metadata to type `A`\n * without changing its shape.\n *\n * This type intersects `Doc` onto `A`, but only keeps the keys\n * originally defined in `A`. As a result:\n *\n * - `Doc` cannot introduce new properties\n * - Existing properties in `A` are preserved\n * - `Doc` may further constrain or annotate existing properties\n *\n * This is typically used to attach JSDoc comments, branding,\n * or editor-only metadata to an existing type while keeping\n * its public structure intact.\n */\nexport type AppendDoc<T, Doc> = Pick<T & Doc, keyof T>\n\n/**\n * Prepend documentation or auxiliary metadata to type `A`\n * without changing its shape.\n *\n * This is similar to {@link AppendDoc}, but the intersection order\n * is reversed (`Doc & A`), which can affect how property types,\n * documentation, and hover information are presented by tooling.\n *\n * In practice, this allows `Doc` to act as a non-invasive,\n * descriptive layer while ensuring `A` remains the authoritative\n * source of truth for property types.\n */\nexport type PrependDoc<T, Doc> = Pick<Doc & T, keyof T>\n"]}

package/esm/main/function.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Represents a function with any parameters and a specific return type
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type _ = AnyFunction<string, [number]> // (arg: number) => string
+ * ```
+ */
+export type AnyFunction<Return = any, Params extends any[] = any[]> = (...args: Params) => Return;
+/**
+ * Represents a constructor with any parameters and a specific return type
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type _ = Constructor<string, [number]> // new (arg: number) => string
+ * ```
+ */
+export type Constructor<Return = any, Params extends any[] = any[]> = new (...args: Params) => Return;
+//# sourceMappingURL=function.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,CAAC,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;AAE/B;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,GAAG,GAAG,EACZ,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,IAC1B,KAAK,GAAG,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA"}

package/esm/main/function.js

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file no-explicit-any
+export {};
+//# sourceMappingURL=function.js.map

package/esm/main/function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.js","sourceRoot":"","sources":["../../src/main/function.ts"],"names":[],"mappings":"AAAA,wCAAwC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\n\n/**\n * Represents a function with any parameters and a specific return type\n *\n * ### Examples\n *\n * ```ts\n * type _ = AnyFunction<string, [number]> // (arg: number) => string\n * ```\n */\nexport type AnyFunction<\n  Return = any,\n  Params extends any[] = any[],\n> = (...args: Params) => Return\n\n/**\n * Represents a constructor with any parameters and a specific return type\n *\n * ### Examples\n *\n * ```ts\n * type _ = Constructor<string, [number]> // new (arg: number) => string\n * ```\n */\nexport type Constructor<\n  Return = any,\n  Params extends any[] = any[],\n> = new (...args: Params) => Return\n"]}

package/esm/main/index.d.ts

@@ -0,0 +1,12 @@
+export * from './array.js';
+export * from './async.js';
+export * from './boolean.js';
+export * from './control.js';
+export * from './doc.js';
+export * from './function.js';
+export * from './json.js';
+export * from './key.js';
+export * from './object.js';
+export * from './type/index.js';
+export * from './typed-array.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}

package/esm/main/index.js

@@ -0,0 +1,12 @@
+export * from './array.js';
+export * from './async.js';
+export * from './boolean.js';
+export * from './control.js';
+export * from './doc.js';
+export * from './function.js';
+export * from './json.js';
+export * from './key.js';
+export * from './object.js';
+export * from './type/index.js';
+export * from './typed-array.js';
+//# sourceMappingURL=index.js.map

package/esm/main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA","sourcesContent":["export * from './array.js'\nexport * from './async.js'\nexport * from './boolean.js'\nexport * from './control.js'\nexport * from './doc.js'\nexport * from './function.js'\nexport * from './json.js'\nexport * from './key.js'\nexport * from './object.js'\nexport * from './type/index.js'\nexport * from './typed-array.js'\n"]}

package/esm/main/json.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Primitive values allowed by the JSON specification.
+ *
+ * This represents the set of non-object, non-array values
+ * that can appear in valid JSON data.
+ */
+export type JsonPrimitive = string | number | boolean | null;
+/**
+ * A JSON array.
+ *
+ * Each element of the array must itself be a valid `JsonValue`.
+ */
+export type JsonArray = JsonValue[];
+/**
+ * A JSON object.
+ *
+ * Keys are strings, and values must be valid `JsonValue`s.
+ * This mirrors the object structure defined by the JSON specification.
+ */
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+/**
+ * Any valid JSON value.
+ *
+ * This is a strict representation of JSON data, suitable for
+ * describing the result of `JSON.parse`, serialized payloads,
+ * or schema-level JSON structures.
+ */
+export type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+/**
+ * A JavaScript value that can be safely serialized to JSON.
+ *
+ * Unlike `JsonValue`, this type represents values *before*
+ * serialization, describing the set of recursive structures
+ * that `JSON.stringify` can handle.
+ *
+ * This is useful for constraining inputs that are expected to
+ * be JSON-serializable, rather than already being JSON data.
+ */
+export type Jsonable = string | number | boolean | null | Jsonable[] | {
+    [key: string]: Jsonable;
+};
+//# sourceMappingURL=json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/main/json.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;AAE5D;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,EAAE,CAAA;AAEnC;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAErD;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,SAAS,GAAG,UAAU,CAAA;AAE9D;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAChB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,QAAQ,EAAE,GACV;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA"}

package/esm/main/json.js

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

package/esm/main/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/main/json.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Primitive values allowed by the JSON specification.\n *\n * This represents the set of non-object, non-array values\n * that can appear in valid JSON data.\n */\nexport type JsonPrimitive = string | number | boolean | null\n\n/**\n * A JSON array.\n *\n * Each element of the array must itself be a valid `JsonValue`.\n */\nexport type JsonArray = JsonValue[]\n\n/**\n * A JSON object.\n *\n * Keys are strings, and values must be valid `JsonValue`s.\n * This mirrors the object structure defined by the JSON specification.\n */\nexport type JsonObject = { [key: string]: JsonValue }\n\n/**\n * Any valid JSON value.\n *\n * This is a strict representation of JSON data, suitable for\n * describing the result of `JSON.parse`, serialized payloads,\n * or schema-level JSON structures.\n */\nexport type JsonValue = JsonPrimitive | JsonArray | JsonObject\n\n/**\n * A JavaScript value that can be safely serialized to JSON.\n *\n * Unlike `JsonValue`, this type represents values *before*\n * serialization, describing the set of recursive structures\n * that `JSON.stringify` can handle.\n *\n * This is useful for constraining inputs that are expected to\n * be JSON-serializable, rather than already being JSON data.\n */\nexport type Jsonable =\n  | string\n  | number\n  | boolean\n  | null\n  | Jsonable[]\n  | { [key: string]: Jsonable }\n"]}

package/esm/main/key.d.ts

@@ -0,0 +1,26 @@
+import type { Same } from './type/index.js';
+/**
+ * Extracts the keys of type T that have values of type U
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type A = { a: 1; b: 2; c: 1 }
+ * type Keys = KeysOfType<A, 1> // 'a' | 'c'
+ * ```
+ */
+export type KeysOfType<T, U> = Exclude<{
+    [K in keyof T]: Same<T[K], U> extends true ? K : never;
+}[keyof T], undefined>;
+/**
+ * Extracts the keys of type T that do not have values of type U
+ *
+ * ### Examples
+ *
+ * ```ts
+ * type A = { a: 1; b: 2; c: 1 }
+ * type Keys = KeysOfOtherType<A, 1> // 'b'
+ * ```
+ */
+export type KeysOfOtherType<T, U> = Exclude<keyof T, KeysOfType<T, U>>;
+//# sourceMappingURL=key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;AAEtH;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}

package/esm/main/key.js

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

package/esm/main/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/main/key.ts"],"names":[],"mappings":"","sourcesContent":["import type { Same } from './type/index.js'\n\n/**\n * Extracts the keys of type T that have values of type U\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: 1; b: 2; c: 1 }\n * type Keys = KeysOfType<A, 1> // 'a' | 'c'\n * ```\n */\nexport type KeysOfType<T, U> = Exclude<{ [K in keyof T]: Same<T[K], U> extends true ? K : never }[keyof T], undefined>\n\n/**\n * Extracts the keys of type T that do not have values of type U\n *\n * ### Examples\n *\n * ```ts\n * type A = { a: 1; b: 2; c: 1 }\n * type Keys = KeysOfOtherType<A, 1> // 'b'\n * ```\n */\nexport type KeysOfOtherType<T, U> = Exclude<keyof T, KeysOfType<T, U>>\n"]}