@zudojs/types 0.0.1 → 1.0.0

package/README.md

@@ -13,26 +13,64 @@ npm install @zudojs/types
 ```typescript
 import {
   isPlainObject,
-  isDate,
   isEmail,
-  Maybe,
-  DeepReadonly,
+  isUuid,
+  systemClock,
+  systemRandom,
+  toNumber,
 } from "@zudojs/types";
+import type { Maybe, DeepReadonly } from "@zudojs/types";
 
 if (isPlainObject(value)) {
-  console.log(value.keys());
+  for (const key of Object.keys(value)) {
+    console.log(key, value[key]);
+  }
 }
 
 const id: Maybe<string> = null;
 const config: DeepReadonly<AppConfig> = { db: { host: "localhost" } };
+
+// Injectable runtime primitives, so tests can substitute deterministic ones.
+const token = systemRandom.string(32);
+const now = systemClock.now();
+
+// Converters refuse rather than guessing: "" and "0x10" fall back.
+const limit = toNumber(query.limit, 20);
+```
+
+Deterministic doubles for tests:
+
+```typescript
+import { FixedClock, SeededRandom } from "@zudojs/types";
+import type { PseudoRandom } from "@zudojs/types";
+
+const clock = new FixedClock(0);
+const random: PseudoRandom = new SeededRandom(42);
+
+clock.advance(1_000);
 ```
 
+## Safety Notes
+
+- `Random` is branded, so `SeededRandom` — whose output is fully predictable
+  from its seed — cannot be injected where unpredictability is required.
+  Implement a secure generator through `defineSecureRandom()`.
+- `Random.int()` uses rejection sampling, not `% max`, so draws are uniform for
+  every bound rather than only powers of two.
+- `mapToObject` and `safeJsonParse` cannot be used to reach a prototype.
+- `toNumber` requires a finite number and refuses blank strings, hexadecimal
+  literals and `1e999`; `toBoolean(NaN)` falls back rather than returning true.
+- `isUuid` accepts versions 1–8 including UUIDv7; use `isUuidV4` where the
+  version matters. `isPromise` narrows only to a native `Promise` — use
+  `isThenable` for anything awaitable.
+
 ## Features
 
-- Type guards (`isPlainObject`, `isDate`, `isEmail`, etc.)
+- Type guards (`isPlainObject`, `isDate`, `isEmail`, `isUuid`, etc.)
 - Utility types (`Maybe`, `DeepReadonly`, `Prettify`, etc.)
-- Type converters and transformers
+- Type converters and case transformers
 - Branded type utilities
+- Injectable `Clock` and `Random` primitives, with deterministic test doubles
 
 ## Use Cases
 

package/dist/runtime/index.d.ts

@@ -1,2 +1,10 @@
-export * from "./runtime.core.js";
+/**
+ * @zudojs/types — Runtime primitives barrel.
+ *
+ * An explicit list rather than `export *`: this was the only barrel in the
+ * package without one, so anything newly exported from `runtime.core.ts`
+ * silently became public API.
+ */
+export type { Clock, ClockSeconds, Random, PseudoRandom, } from "./runtime.core.js";
+export { systemClock, systemClockSeconds, defineSecureRandom, systemRandom, FixedClock, SeededRandom, } from "./runtime.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -1,2 +1,9 @@
-export * from "./runtime.core.js";
+/**
+ * @zudojs/types — Runtime primitives barrel.
+ *
+ * An explicit list rather than `export *`: this was the only barrel in the
+ * package without one, so anything newly exported from `runtime.core.ts`
+ * silently became public API.
+ */
+export { systemClock, systemClockSeconds, defineSecureRandom, systemRandom, FixedClock, SeededRandom, } from "./runtime.core.js";
 //# sourceMappingURL=index.js.map

package/dist/runtime/runtime.core.d.ts

@@ -13,21 +13,63 @@ export interface Clock {
 export interface ClockSeconds {
     nowSeconds(): number;
 }
-/** Returns cryptographically-secure random values. */
+/**
+ * Brand marking an implementation as cryptographically secure.
+ *
+ * Structural typing alone would let any object with the right method names
+ * satisfy `Random`, including a seeded test generator. The brand makes the
+ * claim explicit: an implementor opts in through {@link defineSecureRandom}.
+ */
+declare const SecureRandomBrand: unique symbol;
+/**
+ * Returns cryptographically-secure random values.
+ *
+ * Implementations of this interface are safe for tokens, identifiers and
+ * secrets. A deterministic generator must implement {@link PseudoRandom}
+ * instead, so a test double cannot be injected where unpredictability is the
+ * requirement.
+ */
 export interface Random {
+    /** @internal Marks the implementation as unpredictable. */
+    readonly [SecureRandomBrand]: true;
     /** Returns a random UUID v4 string. */
     uuid(): string;
-    /** Returns a random integer in [0, max). */
+    /** Returns a uniformly random integer in [0, max). */
     int(max: number): number;
     /** Returns a random string of the given length (alphanumeric). */
     string(length: number): string;
     /** Returns a random string of the given length from the given alphabet. */
     custom(length: number, alphabet: string): string;
 }
+/**
+ * A reproducible generator for tests.
+ *
+ * Structurally identical to {@link Random} but nominally distinct, so it
+ * cannot be passed where a `Random` is required.
+ */
+export interface PseudoRandom {
+    /** Marks this as a deterministic generator, not a secure one. */
+    readonly deterministic: true;
+    uuid(): string;
+    int(max: number): number;
+    string(length: number): string;
+    custom(length: number, alphabet: string): string;
+}
 /** Default Clock implementation backed by `Date.now()`. */
 export declare const systemClock: Clock;
 /** Default ClockSeconds implementation backed by `Math.floor(Date.now() / 1000)`. */
 export declare const systemClockSeconds: ClockSeconds;
+/**
+ * Declare an implementation cryptographically secure.
+ *
+ * Call this only for a generator whose output is genuinely unpredictable —
+ * one backed by `node:crypto`, Web Crypto, or a hardware source. It is the
+ * single supported way to produce a {@link Random}.
+ *
+ * @param implementation - The generator's operations.
+ * @returns The implementation, branded as secure.
+ */
+export declare function defineSecureRandom(implementation: Omit<Random, typeof SecureRandomBrand>): Random;
 /** Default Random implementation backed by `node:crypto`. */
 export declare const systemRandom: Random;
 /** Deterministic Clock useful for tests. */
@@ -38,13 +80,24 @@ export declare class FixedClock implements Clock {
     set(time: number): void;
     advance(deltaMs: number): void;
 }
-/** Deterministic Random useful for tests. */
-export declare class SeededRandom implements Random {
+/**
+ * Deterministic generator useful for tests.
+ *
+ * Implements {@link PseudoRandom}, never {@link Random}: its output is fully
+ * predictable from the seed, so injecting it where a secure generator is
+ * expected would make every token guessable from a single observation.
+ */
+export declare class SeededRandom implements PseudoRandom {
+    readonly deterministic = true;
     private state;
     constructor(seed?: number);
+    /** Returns a structurally valid v4 UUID derived from the seed. */
     uuid(): string;
     int(max: number): number;
     string(length: number): string;
     custom(length: number, alphabet: string): string;
+    /** Advances the linear congruential state. */
+    private next;
 }
+export {};
 //# sourceMappingURL=runtime.core.d.ts.map

package/dist/runtime/runtime.core.js

@@ -5,6 +5,7 @@
  * avoid direct `Date.now()` and `Math.random()` calls. Tests can substitute
  * deterministic implementations.
  */
+import { randomInt, randomUUID } from "node:crypto";
 /** Default Clock implementation backed by `Date.now()`. */
 export const systemClock = {
     now: () => Date.now(),
@@ -13,37 +14,41 @@ export const systemClock = {
 export const systemClockSeconds = {
     nowSeconds: () => Math.floor(Date.now() / 1000),
 };
-/** Default Random implementation backed by `node:crypto`. */
-export const systemRandom = {
-    uuid: () => cryptoUUID(),
-    int: (max) => cryptoInt(max),
-    string: (length) => randomString(length, ALPHANUMERIC),
-    custom: (length, alphabet) => randomString(length, alphabet),
-};
 const ALPHANUMERIC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+/** Returns a v4 UUID, preferring the Web Crypto implementation. */
 function cryptoUUID() {
     if (typeof globalThis.crypto?.randomUUID === "function") {
         return globalThis.crypto.randomUUID();
     }
-    // node:crypto fallback (older Node, edge runtimes)
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { randomUUID } = require("node:crypto");
     return randomUUID();
 }
+/**
+ * Returns a uniformly random integer in [0, max).
+ *
+ * Rejection sampling, not `% max`. A modulo of a uniform 32-bit draw is only
+ * uniform when `max` is a power of two; for other bounds the low values come
+ * up more often, which is not acceptable from an interface documented as
+ * cryptographically secure.
+ */
 function cryptoInt(max) {
     if (!Number.isInteger(max) || max <= 0) {
         throw new RangeError("Random.int(max) requires a positive integer max");
     }
-    if (typeof globalThis.crypto?.getRandomValues === "function") {
-        const buf = new Uint32Array(1);
-        globalThis.crypto.getRandomValues(buf);
-        return buf[0] % max;
+    if (typeof globalThis.crypto?.getRandomValues !== "function") {
+        return randomInt(max);
+    }
+    const range = 2 ** 32;
+    const limit = range - (range % max);
+    const buffer = new Uint32Array(1);
+    for (;;) {
+        globalThis.crypto.getRandomValues(buffer);
+        const draw = buffer[0];
+        if (draw < limit)
+            return draw % max;
     }
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { randomInt } = require("node:crypto");
-    return randomInt(max);
 }
-function randomString(length, alphabet) {
+/** Builds a random string over an alphabet. */
+function randomString(length, alphabet, nextInt) {
     if (!Number.isInteger(length) || length < 0) {
         throw new RangeError("Random.string(length) requires a non-negative integer");
     }
@@ -52,10 +57,30 @@ function randomString(length, alphabet) {
     }
     let out = "";
     for (let i = 0; i < length; i++) {
-        out += alphabet.charAt(cryptoInt(alphabet.length));
+        out += alphabet.charAt(nextInt(alphabet.length));
     }
     return out;
 }
+/**
+ * Declare an implementation cryptographically secure.
+ *
+ * Call this only for a generator whose output is genuinely unpredictable —
+ * one backed by `node:crypto`, Web Crypto, or a hardware source. It is the
+ * single supported way to produce a {@link Random}.
+ *
+ * @param implementation - The generator's operations.
+ * @returns The implementation, branded as secure.
+ */
+export function defineSecureRandom(implementation) {
+    return implementation;
+}
+/** Default Random implementation backed by `node:crypto`. */
+export const systemRandom = defineSecureRandom({
+    uuid: () => cryptoUUID(),
+    int: (max) => cryptoInt(max),
+    string: (length) => randomString(length, ALPHANUMERIC, cryptoInt),
+    custom: (length, alphabet) => randomString(length, alphabet, cryptoInt),
+});
 /** Deterministic Clock useful for tests. */
 export class FixedClock {
     current;
@@ -72,33 +97,46 @@ export class FixedClock {
         this.current += deltaMs;
     }
 }
-/** Deterministic Random useful for tests. */
+/**
+ * Deterministic generator useful for tests.
+ *
+ * Implements {@link PseudoRandom}, never {@link Random}: its output is fully
+ * predictable from the seed, so injecting it where a secure generator is
+ * expected would make every token guessable from a single observation.
+ */
 export class SeededRandom {
+    deterministic = true;
     state;
     constructor(seed = 1) {
-        this.state = seed;
+        this.state = seed >>> 0 || 1;
     }
+    /** Returns a structurally valid v4 UUID derived from the seed. */
     uuid() {
-        const hex = this.state.toString(16).padStart(8, "0");
-        this.state = (this.state * 1103515245 + 12345) & 0x7fffffff;
-        return `${hex}-${this.state.toString(16).padStart(8, "0")}-0000-0000-000000000000`;
+        const hex = (count) => Array.from({ length: count }, () => this.next().toString(16).padStart(8, "0").slice(-1)).join("");
+        return [
+            hex(8),
+            hex(4),
+            `4${hex(3)}`,
+            `${"89ab".charAt(this.int(4))}${hex(3)}`,
+            hex(12),
+        ].join("-");
     }
     int(max) {
         if (!Number.isInteger(max) || max <= 0) {
-            throw new RangeError("SeededRandom.int(max) requires a positive integer max");
+            throw new RangeError("PseudoRandom.int(max) requires a positive integer max");
         }
-        this.state = (this.state * 1103515245 + 12345) & 0x7fffffff;
-        return this.state % max;
+        return this.next() % max;
     }
     string(length) {
         return this.custom(length, ALPHANUMERIC);
     }
     custom(length, alphabet) {
-        let out = "";
-        for (let i = 0; i < length; i++) {
-            out += alphabet.charAt(this.int(alphabet.length));
-        }
-        return out;
+        return randomString(length, alphabet, (max) => this.int(max));
+    }
+    /** Advances the linear congruential state. */
+    next() {
+        this.state = (Math.imul(this.state, 1103515245) + 12345) & 0x7fffffff;
+        return this.state;
     }
 }
 //# sourceMappingURL=runtime.core.js.map

package/dist/typeConverters/typeConverters.core.d.ts

@@ -5,18 +5,38 @@
  */
 /**
  * Safely parse JSON with a fallback value.
+ *
+ * "Safe" here means only that malformed JSON yields the fallback rather than
+ * throwing. The result is cast to `T` without validation — parse a trust
+ * boundary with `@zudojs/validation` or `@zudojs/schema` instead of relying on
+ * this cast.
+ *
+ * Keys that would reach a prototype are dropped, so the parsed value cannot
+ * seed a pollution chain downstream.
  */
 export declare function safeJsonParse<T>(json: string, fallback: T): T;
 /**
  * Convert a value to a string safely.
+ *
+ * Always returns a string. `JSON.stringify` returns the *value* `undefined`
+ * — not a string, and without throwing — for functions, symbols and
+ * `undefined`, so its result is checked rather than returned directly.
  */
 export declare function toString(value: unknown, fallback?: string): string;
 /**
- * Convert a value to a number safely.
+ * Convert a value to a finite number safely.
+ *
+ * Blank strings, hexadecimal literals and infinities all fall back rather than
+ * converting: a missing query parameter arriving as `""` becoming a real zero
+ * silently turns into a page size, a price or a limit.
  */
 export declare function toNumber(value: unknown, fallback?: number): number;
 /**
  * Convert a value to a boolean safely.
+ *
+ * `NaN` falls back rather than converting to true. It is what `toNumber`
+ * produces on failure, so chaining the two would otherwise turn a parse
+ * failure into the permissive answer for a flag.
  */
 export declare function toBoolean(value: unknown, fallback?: boolean): boolean;
 /**
@@ -25,6 +45,12 @@ export declare function toBoolean(value: unknown, fallback?: boolean): boolean;
 export declare function toArray<T>(value: T | T[]): T[];
 /**
  * Convert a Map to a plain object.
+ *
+ * Built on a null-prototype object with `defineProperty`. Assigning into an
+ * object literal routes a `__proto__` key through the prototype setter, so a
+ * Map built from request data — headers, form fields, query parameters — could
+ * replace the result's prototype with attacker-supplied values that
+ * `Object.keys` does not reveal.
  */
 export declare function mapToObject<K extends string | number | symbol, V>(map: Map<K, V>): Record<K, V>;
 /**
@@ -36,7 +62,11 @@ export declare function objectToMap<K extends string | number | symbol, V>(obj:
  */
 export declare function snakeToCamel(str: string): string;
 /**
- * Convert camelCase to snake_case.
+ * Convert camelCase or PascalCase to snake_case.
+ *
+ * Leading capitals do not produce a leading separator, and acronyms survive
+ * as single words — an identifier like `_hello_world` is not a valid column
+ * name, and `parse_h_t_t_p_response` is not a useful one.
  */
 export declare function camelToSnake(str: string): string;
 /**
@@ -44,7 +74,7 @@ export declare function camelToSnake(str: string): string;
  */
 export declare function kebabToCamel(str: string): string;
 /**
- * Convert camelCase to kebab-case.
+ * Convert camelCase or PascalCase to kebab-case.
  */
 export declare function camelToKebab(str: string): string;
 //# sourceMappingURL=typeConverters.core.d.ts.map

package/dist/typeConverters/typeConverters.core.js

@@ -3,12 +3,30 @@
  *
  * @module typeConverters/typeConverters
  */
+/** Property names that mutate a prototype instead of adding a key. */
+const UNSAFE_KEYS = new Set([
+    "__proto__",
+    "constructor",
+    "prototype",
+]);
 /**
  * Safely parse JSON with a fallback value.
+ *
+ * "Safe" here means only that malformed JSON yields the fallback rather than
+ * throwing. The result is cast to `T` without validation — parse a trust
+ * boundary with `@zudojs/validation` or `@zudojs/schema` instead of relying on
+ * this cast.
+ *
+ * Keys that would reach a prototype are dropped, so the parsed value cannot
+ * seed a pollution chain downstream.
  */
 export function safeJsonParse(json, fallback) {
     try {
-        return JSON.parse(json);
+        return JSON.parse(json, function reviver(key, value) {
+            if (UNSAFE_KEYS.has(key))
+                return undefined;
+            return value;
+        });
     }
     catch {
         return fallback;
@@ -16,48 +34,81 @@ export function safeJsonParse(json, fallback) {
 }
 /**
  * Convert a value to a string safely.
+ *
+ * Always returns a string. `JSON.stringify` returns the *value* `undefined`
+ * — not a string, and without throwing — for functions, symbols and
+ * `undefined`, so its result is checked rather than returned directly.
  */
 export function toString(value, fallback = "") {
     if (value === null || value === undefined)
         return fallback;
     if (typeof value === "string")
         return value;
-    if (typeof value === "number" || typeof value === "boolean")
+    if (typeof value === "number" || typeof value === "boolean") {
         return String(value);
+    }
+    if (typeof value === "bigint")
+        return `${value}`;
+    if (typeof value === "symbol")
+        return value.toString();
+    if (typeof value === "function")
+        return fallback;
     try {
-        return JSON.stringify(value);
+        const serialized = JSON.stringify(value);
+        return typeof serialized === "string" ? serialized : fallback;
     }
     catch {
         return fallback;
     }
 }
 /**
- * Convert a value to a number safely.
+ * Convert a value to a finite number safely.
+ *
+ * Blank strings, hexadecimal literals and infinities all fall back rather than
+ * converting: a missing query parameter arriving as `""` becoming a real zero
+ * silently turns into a page size, a price or a limit.
  */
 export function toNumber(value, fallback = NaN) {
-    if (typeof value === "number")
-        return value;
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : fallback;
+    }
     if (typeof value === "string") {
-        const num = Number(value);
-        return Number.isNaN(num) ? fallback : num;
+        const trimmed = value.trim();
+        if (trimmed.length === 0)
+            return fallback;
+        if (!/^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/u.test(trimmed)) {
+            return fallback;
+        }
+        const parsed = Number(trimmed);
+        return Number.isFinite(parsed) ? parsed : fallback;
     }
     return fallback;
 }
 /**
  * Convert a value to a boolean safely.
+ *
+ * `NaN` falls back rather than converting to true. It is what `toNumber`
+ * produces on failure, so chaining the two would otherwise turn a parse
+ * failure into the permissive answer for a flag.
  */
 export function toBoolean(value, fallback = false) {
     if (typeof value === "boolean")
         return value;
     if (typeof value === "string") {
         const lower = value.toLowerCase().trim();
-        if (lower === "true" || lower === "1" || lower === "yes")
+        if (lower === "true" || lower === "1" || lower === "yes" || lower === "on")
             return true;
-        if (lower === "false" || lower === "0" || lower === "no" || lower === "")
+        if (lower === "false" ||
+            lower === "0" ||
+            lower === "no" ||
+            lower === "off" ||
+            lower === "")
             return false;
+        return fallback;
+    }
+    if (typeof value === "number") {
+        return Number.isNaN(value) ? fallback : value !== 0;
     }
-    if (typeof value === "number")
-        return value !== 0;
     return fallback;
 }
 /**
@@ -70,11 +121,22 @@ export function toArray(value) {
 }
 /**
  * Convert a Map to a plain object.
+ *
+ * Built on a null-prototype object with `defineProperty`. Assigning into an
+ * object literal routes a `__proto__` key through the prototype setter, so a
+ * Map built from request data — headers, form fields, query parameters — could
+ * replace the result's prototype with attacker-supplied values that
+ * `Object.keys` does not reveal.
  */
 export function mapToObject(map) {
-    const obj = {};
+    const obj = Object.create(null);
     for (const [key, value] of map) {
-        obj[key] = value;
+        Object.defineProperty(obj, key, {
+            value,
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
     }
     return obj;
 }
@@ -88,24 +150,41 @@ export function objectToMap(obj) {
  * Convert snake_case to camelCase.
  */
 export function snakeToCamel(str) {
-    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    return str.replace(/(?<!_)_+([a-z0-9])/gu, (_, char) => char.toUpperCase());
+}
+/**
+ * Split a camelCase or PascalCase identifier into its words.
+ *
+ * Runs of capitals are kept together, so `parseHTTPResponse` yields
+ * `["parse", "HTTP", "Response"]` rather than one word per letter.
+ */
+function splitCamelWords(str) {
+    return str.match(/(?:[A-Z](?![a-z]))+|[A-Z]?[a-z0-9]+|[A-Z]|[0-9]+/gu) ?? [];
 }
 /**
- * Convert camelCase to snake_case.
+ * Convert camelCase or PascalCase to snake_case.
+ *
+ * Leading capitals do not produce a leading separator, and acronyms survive
+ * as single words — an identifier like `_hello_world` is not a valid column
+ * name, and `parse_h_t_t_p_response` is not a useful one.
  */
 export function camelToSnake(str) {
-    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    return splitCamelWords(str)
+        .map((word) => word.toLowerCase())
+        .join("_");
 }
 /**
  * Convert kebab-case to camelCase.
  */
 export function kebabToCamel(str) {
-    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    return str.replace(/(?<!-)-+([a-z0-9])/gu, (_, char) => char.toUpperCase());
 }
 /**
- * Convert camelCase to kebab-case.
+ * Convert camelCase or PascalCase to kebab-case.
  */
 export function camelToKebab(str) {
-    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+    return splitCamelWords(str)
+        .map((word) => word.toLowerCase())
+        .join("-");
 }
 //# sourceMappingURL=typeConverters.core.js.map

package/dist/typeGuards/index.d.ts

@@ -3,5 +3,5 @@
  *
  * @module typeGuards
  */
-export { isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isInteger, isDate, isUrl, isEmail, isUuid, isIsoDateString, isArrayOfType, isDefined, isFunction, isPromise, } from "./typeGuards.core.js";
+export { MAX_EMAIL_LENGTH, isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isFiniteNumber, isInteger, isDate, isUrl, isEmail, isUuid, isUuidV4, isIsoDateString, isIsoDateTimeString, isArrayOfType, isDefined, isFunction, isPromise, isThenable, } from "./typeGuards.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/typeGuards/index.js

@@ -3,5 +3,5 @@
  *
  * @module typeGuards
  */
-export { isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isInteger, isDate, isUrl, isEmail, isUuid, isIsoDateString, isArrayOfType, isDefined, isFunction, isPromise, } from "./typeGuards.core.js";
+export { MAX_EMAIL_LENGTH, isPlainObject, isNonNullObject, isNonEmptyString, isPositiveNumber, isFiniteNumber, isInteger, isDate, isUrl, isEmail, isUuid, isUuidV4, isIsoDateString, isIsoDateTimeString, isArrayOfType, isDefined, isFunction, isPromise, isThenable, } from "./typeGuards.core.js";
 //# sourceMappingURL=index.js.map