lay-sing 0.1.0

package/esm/test-utils.js

@@ -0,0 +1,49 @@
+/**
+ * A universal no-op placeholder implemented via `Proxy`.
+ *
+ * `NOOP` can be accessed, called, or chained indefinitely without throwing.
+ * Every operation returns itself, making it safe to use as a dummy fallback
+ * for APIs, optional hooks, or unimplemented interfaces.
+ *
+ * ### Special behaviors
+ *
+ * - Callable: invoking `NOOP()` returns `NOOP`
+ * - Property access: `NOOP.anything` returns `NOOP`
+ * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise
+ * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields
+ *   a stable string representation: `"[NOOP]"`
+ *
+ * This is useful in scenarios where a value is required syntactically but
+ * should perform no action and never fail at runtime.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * NOOP.foo.bar().baz.qux; // safe, returns NOOP
+ * String(NOOP); // "[NOOP]"
+ * await NOOP; // does not await (not thenable)
+ * ```
+ */
+export const NOOP = new Proxy(function () {
+    return NOOP;
+}, {
+    get(_, prop) {
+        switch (prop) {
+            case 'then':
+                return undefined;
+            case 'valueOf':
+            case 'toString':
+            case Symbol.toPrimitive:
+                return () => '[NOOP]';
+            default:
+                return NOOP;
+        }
+    },
+});
+export function expect() {
+    return NOOP;
+}
+export function compare() {
+    return NOOP;
+}
+//# sourceMappingURL=test-utils.js.map

package/esm/test-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,IAAI,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,IAAI,CAAA;QACf,CAAC;IACH,CAAC;CACF,CACF,CAAA;AAkQD,MAAM,UAAU,MAAM;IACpB,OAAO,IAAI,CAAA;AACb,CAAC;AA+GD,MAAM,UAAU,OAAO;IACrB,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\nimport type {\n  Diff,\n  Disjoint,\n  Extends,\n  If,\n  MutuallyAssignable,\n  Overlap,\n  ProperExtend,\n  SafePick,\n  Same,\n} from './main/index.js'\n\n/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * ### Examples\n *\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  },\n)\n\n/**\n * Represents the result of a type assertion based on a boolean condition.\n * If the condition is true, the result has a `success` property; otherwise, it has a `fail` property.\n *\n * @template B The boolean condition result (true or false)\n * @template R The type of the result value (default is void)\n */\ntype Result<B extends true | false, R = void> = B extends true ? {\n    /**\n     * ## Expect to succeed without type error\n     */\n    success: R\n  }\n  : {\n    /**\n     * ## Expect to fail with type error\n     */\n    fail: R\n  }\n\n/**\n * Type-level testing utility that allows checking various relationships between types.\n * Provides methods to test type equality, extension, properties, and more.\n *\n * @template T The type being tested\n * @template H Hidden property keys that are already used (internal tracking)\n *\n * ### Examples\n *\n * ```ts\n * // Test if two types are identical\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<2>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * // Test if type has a specific property\n * expect<{name: string}>().toHaveProperty<'name'>().success\n * ```\n */\nexport type ExpectType<T, H extends PropertyKey = never> = Omit<\n  (\n    & {\n      T: T\n      inspect: { [K in keyof T]: T[K] }\n\n      /**\n       * Tests if the current type is exactly the same as the provided type U.\n       *\n       * @template U The type to compare with\n       *\n       * ### Examples\n       *\n       * ```ts\n       * expect<any>().toBe<any>().success\n       * expect<never>().toBe<never>().success\n       * expect<false>().toBe<true>().fail\n       * ```\n       */\n      toBe<U>(): Result<Same<T, U>>\n\n      /**\n       * Tests if the current type T extends the provided type U.\n       *\n       * @template U The type to check extension against\n       *\n       * ### Examples\n       *\n       * ```ts\n       * expect<3.14>().toExtend<number>().success\n       * expect<2>().toExtend<string>().fail\n       * expect<'hello'>().toExtend<string>().success\n       * ```\n       */\n      toExtend<U>(): Result<Extends<T, U>>\n\n      /**\n       * Tests if the current type T properly extends the provided type U (extends but is not the same).\n       *\n       * @template U The type to check proper extension against\n       *\n       * ### Examples\n       *\n       * ```ts\n       * expect<2>().toProperExtend<number>().success\n       * expect<'a' | 'b'>().toProperExtend<string>().success\n       * expect<number>().toProperExtend<number>().fail\n       * ```\n       */\n      toProperExtend<U>(): Result<ProperExtend<T, U>>\n\n      /**\n       * Tests if the current type T has a property with key K.\n       *\n       * @template K The property key to check for\n       *\n       * ### Examples\n       *\n       * ```ts\n       * type WithProp = { prop: string; another: number }\n       * expect<WithProp>().toHaveProperty<'prop'>().success\n       * expect<WithProp>().toHaveProperty<'another'>().success\n       * expect<WithProp>().toHaveProperty<'missing'>().fail\n       * ```\n       */\n      toHaveProperty<K extends PropertyKey>(): Result<Extends<K, keyof T>>\n    }\n    & SafePick<\n      {\n        /**\n         * Tests if the current type extends the Number primitive type.\n         * Available only if the current type extends number.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<3.14>().toExtendNumber // Available and would succeed\n         * ```\n         */\n        toExtendNumber: ExpectType<T, H | 'toExtendNumber' | 'toExtend'>\n\n        /**\n         * Tests if the current type extends the String primitive type.\n         * Available only if the current type extends string.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<'hello'>().toExtendString // Available and would succeed\n         * ```\n         */\n        toExtendString: ExpectType<T, H | 'toExtendString' | 'toExtend'>\n\n        /**\n         * Tests if the current type extends the Boolean primitive type.\n         * Available only if the current type extends boolean.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toExtendBoolean // Available and would succeed\n         * ```\n         */\n        toExtendBoolean: ExpectType<T, H | 'toExtendBoolean' | 'toExtend'>\n      },\n      | If<Extends<T, number>, 'toExtendNumber'>\n      | If<Extends<T, string>, 'toExtendString'>\n      | If<Extends<T, boolean>, 'toExtendBoolean'>\n    >\n    & SafePick<\n      {\n        /**\n         * Tests if the current type is exactly `any`.\n         * Available only if the current type is `any`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<any>().toBeAny // Available and would succeed\n         * ```\n         */\n        toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `never`.\n         * Available only if the current type is `never`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<never>().toBeNever // Available and would succeed\n         * ```\n         */\n        toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `unknown`.\n         * Available only if the current type is `unknown`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<unknown>().toBeUnknown // Available and would succeed\n         * ```\n         */\n        toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `void`.\n         * Available only if the current type is `void`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<void>().toBeVoid // Available and would succeed\n         * ```\n         */\n        toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `true` (boolean literal).\n         * Available only if the current type is `true`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toBeTrue // Available and would succeed\n         * ```\n         */\n        toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>\n\n        /**\n         * Tests if the current type is exactly `false` (boolean literal).\n         * Available only if the current type is `false`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<false>().toBeFalse // Available and would succeed\n         * ```\n         */\n        toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>\n      },\n      | If<Same<T, any>, 'toBeAny'>\n      | If<Same<T, never>, 'toBeNever'>\n      | If<Same<T, unknown>, 'toBeUnknown'>\n      | If<Same<T, void>, 'toBeVoid'>\n      | If<Same<T, true>, 'toBeTrue'>\n      | If<Same<T, false>, 'toBeFalse'>\n    >\n  ),\n  H\n>\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * ### Examples\n *\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\n\n/**\n * Type-level utility that compares two types and provides methods to test their relationship.\n * Offers options to check if types are same, different, overlapping, disjoint, or mutually assignable.\n *\n * @template T First type to compare\n * @template U Second type to compare\n * @template H Hidden property keys that are already used (internal tracking)\n *\n * ### Examples\n *\n * ```ts\n * // Check if two types are the same\n * compare<number, number>().same // Available\n * // Check if two types are different\n * compare<number, string>().different // Available\n * // Check if two types overlap\n * compare<4, number>().overlap.different // Available\n * ```\n */\nexport type CompareTypes<T, U, H extends PropertyKey = never> = Omit<\n  SafePick<\n    {\n      /**\n       * Available when types T and U are exactly the same.\n       *\n       * ### Examples\n       *\n       * ```ts\n       * compare<3, 3>().same // Available\n       * compare<boolean, boolean>().same // Available\n       * ```\n       */\n      same: CompareTypes<T, U, H | 'same'>\n\n      /**\n       * Available when types T and U are different.\n       *\n       * ### Examples\n       *\n       * ```ts\n       * compare<4, 'abc'>().different // Available\n       * compare<number, 4>().different // Available\n       * ```\n       */\n      different: CompareTypes<T, U, H | 'different'>\n\n      /**\n       * Available when types T and U have some overlap.\n       *\n       * ### Examples\n       *\n       * ```ts\n       * compare<4, number>().overlap // Available since 4 overlaps with number\n       * ```\n       */\n      overlap: CompareTypes<T, U, H | 'overlap'>\n\n      /**\n       * Available when types T and U have no overlap (are disjoint).\n       *\n       * ### Examples\n       *\n       * ```ts\n       * compare<4, 'abc'>().different.disjoint // Available since 4 and 'abc' are disjoint\n       * ```\n       */\n      disjoint: CompareTypes<T, U, H | 'disjoint'>\n\n      /**\n       * Available when types T and U are mutually assignable (each type can be assigned to the other).\n       *\n       * ### Examples\n       *\n       * ```ts\n       * compare<1 | 2, 1 | 2>().mutuallyAssignable // Available since identical union types are mutually assignable\n       * ```\n       */\n      mutuallyAssignable: CompareTypes<T, U, H | 'mutuallyAssignable'>\n    },\n    | If<Same<T, U>, 'same'>\n    | If<Diff<T, U>, 'different'>\n    | If<Overlap<T, U>, 'overlap'>\n    | If<Disjoint<T, U>, 'disjoint'>\n    | If<MutuallyAssignable<T, U>, 'mutuallyAssignable'>\n  >,\n  H\n>\n\n/**\n * Creates an instance of CompareTypes to perform type-level comparisons between two types.\n * This function enables testing various relationships between types at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T First type to compare\n * @template U Second type to compare\n *\n * @returns A CompareTypes instance with methods to test relationships between T and U\n *\n * ### Examples\n *\n * ```ts\n * // Compare two identical types\n * compare<number, number>().same // Results in an available property\n * // Compare two different but overlapping types\n * compare<4, number>().overlap.different // Results in available properties\n * ```\n */\nexport function compare<T, U>(): CompareTypes<T, U>\nexport function compare<T, U>(t: T, u: U): CompareTypes<T, U>\nexport function compare<T, U>(): CompareTypes<T, U> {\n  return NOOP\n}\n"]}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "lay-sing",
+  "version": "0.1.0",
+  "description": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Leawind/lay-sing.git"
+  },
+  "license": "MIT",
+  "main": "./esm/index.js",
+  "module": "./esm/index.js",
+  "exports": {
+    "./test-utils": {
+      "import": "./esm/test-utils.js",
+      "require": "./script/test-utils.js"
+    },
+    ".": {
+      "import": "./esm/main/index.js",
+      "require": "./script/main/index.js"
+    }
+  },
+  "scripts": {},
+  "type": "module",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/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/script/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/script/main/array.js

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

package/script/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/script/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/script/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/script/main/async.js

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

package/script/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/script/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/script/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/script/main/boolean.js

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

package/script/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/script/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/script/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/script/main/control.js

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

package/script/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/script/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/script/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/script/main/doc.js

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

package/script/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/script/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/script/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/script/main/function.js

@@ -0,0 +1,4 @@
+"use strict";
+// deno-lint-ignore-file no-explicit-any
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=function.js.map

package/script/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/script/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/script/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/script/main/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array.js"), exports);
+__exportStar(require("./async.js"), exports);
+__exportStar(require("./boolean.js"), exports);
+__exportStar(require("./control.js"), exports);
+__exportStar(require("./doc.js"), exports);
+__exportStar(require("./function.js"), exports);
+__exportStar(require("./json.js"), exports);
+__exportStar(require("./key.js"), exports);
+__exportStar(require("./object.js"), exports);
+__exportStar(require("./type/index.js"), exports);
+__exportStar(require("./typed-array.js"), exports);
+//# sourceMappingURL=index.js.map

package/script/main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA0B;AAC1B,6CAA0B;AAC1B,+CAA4B;AAC5B,+CAA4B;AAC5B,2CAAwB;AACxB,gDAA6B;AAC7B,4CAAyB;AACzB,2CAAwB;AACxB,8CAA2B;AAC3B,kDAA+B;AAC/B,mDAAgC","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/script/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/script/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/script/main/json.js

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

package/script/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/script/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/script/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/script/main/key.js

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

package/script/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"]}