tyneq 1.0.0

package/dist/Lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lazy.js","names":[],"sources":["../src/utility/nameof.ts","../src/utility/guards/extractParameter.ts","../src/core/errors/TyneqError.ts","../src/core/errors/argument/ArgumentError.ts","../src/core/errors/argument/ArgumentNullError.ts","../src/utility/guards/NullGuards.ts","../src/utility/guards/StringGuards.ts","../src/core/errors/argument/ArgumentOutOfRangeError.ts","../src/utility/guards/NumericGuards.ts","../src/core/errors/argument/ArgumentTypeError.ts","../src/utility/TypeGuardUtility.ts","../src/utility/guards/TypeGuards.ts","../src/utility/ArgumentUtility.ts","../src/core/errors/ReflectionError.ts","../src/utility/reflect.ts","../src/utility/Lazy.ts"],"sourcesContent":["\r\n/**\r\n * Extracts the first property name and value from a single-property object.\r\n * Used to infer parameter names for error messages without string literals.\r\n *\r\n * @example\r\n * ```ts\r\n * const count = 5;\r\n * const [name, value] = nameof({ count }); // -> [\"count\", 5]\r\n * ```\r\n *\r\n * @internal\r\n */\r\nexport function nameof<T>(param: Record<string, T>): [name: string, value: T] {\r\n    if (param === null || typeof param !== \"object\") {\r\n        throw new TypeError(\"nameof expects a non-null object with exactly one own enumerable property.\");\r\n    }\r\n\r\n    const keys = Object.keys(param);\r\n    if (keys.length !== 1) {\r\n        throw new TypeError(\"nameof expects an object with exactly one own enumerable property.\");\r\n    }\r\n\r\n    const key = keys[0];\r\n    return [key, param[key]] as [string, T];\r\n}\r\n","import type { KeyValuePair } from \"../../types/core\";\r\nimport { nameof } from \"../nameof\";\r\n\r\n/**\r\n * Normalises the two-overload pattern used by `ArgumentUtility`:\r\n * either a `{ paramName: value }` object (name inferred) or a raw value + explicit name.\r\n *\r\n * @internal\r\n */\r\nexport function extractParameter<T>(param: Record<string, T>): KeyValuePair<string, T>;\r\nexport function extractParameter<T>(param: T, paramName: string): KeyValuePair<string, T>;\r\nexport function extractParameter<T>(param: Record<string, T> | T, paramName?: string): KeyValuePair<string, T> {\r\n    const [extractedParamName, value] = paramName\r\n        ? [paramName, param as T]\r\n        : nameof(param as Record<string, T>);\r\n    return { key: extractedParamName, value };\r\n}\r\n","import { Maybe } from \"../../types/utility\";\r\n\r\n/**\r\n * Base class for all errors thrown by Tyneq.\r\n *\r\n * @example\r\n * ```ts\r\n * try { Tyneq.from([]).first(); }\r\n * catch (e) { if (e instanceof TyneqError) { console.log(e.message); } }\r\n * ```\r\n *\r\n * @group Errors\r\n */\r\nexport class TyneqError extends Error {\r\n\r\n    /** The underlying error that caused this error, if any. */\r\n    public inner: Maybe<Error>;\r\n\r\n    public constructor(message: string, options?: { inner?: Error}) {\r\n        super(message);\r\n        this.name = new.target.name;\r\n        this.inner = options?.inner;\r\n        Object.setPrototypeOf(this, new.target.prototype);\r\n    }\r\n}\r\n","import { TyneqError } from \"../TyneqError\";\r\n\r\n/**\r\n * Thrown when a method argument fails validation.\r\n *\r\n * @example\r\n * ```ts\r\n * try { Tyneq.from([]).take(-1); }\r\n * catch (e) { if (e instanceof ArgumentError) { console.log(e.paramName); } }\r\n * ```\r\n *\r\n * @see {@link TyneqError}\r\n * @group Errors\r\n */\r\nexport class ArgumentError extends TyneqError {\r\n    /** The name of the parameter that caused the error. */\r\n    public readonly paramName?: string;\r\n\r\n    public constructor(message: string, paramName?: string, inner?: Error) {\r\n        super(message, { inner });\r\n        this.paramName = paramName;\r\n    }\r\n}\r\n","import { ArgumentError } from \"./ArgumentError\";\r\n\r\n/**\r\n * Thrown when a required argument is `null`.\r\n *\r\n * @example\r\n * ```ts\r\n * try { Tyneq.from([1, 2]).select(null as any); }\r\n * catch (e) { if (e instanceof ArgumentNullError) { console.log(e.paramName); } }\r\n * ```\r\n *\r\n * @see {@link ArgumentError}\r\n * @group Errors\r\n */\r\nexport class ArgumentNullError extends ArgumentError {\r\n    public constructor(paramName: string, inner?: Error) {\r\n        super(`${paramName} cannot be null.`, paramName, inner);\r\n    }\r\n}\r\n","import { ArgumentError } from \"../../core/errors/argument/ArgumentError\";\r\nimport { ArgumentNullError } from \"../../core/errors/argument/ArgumentNullError\";\r\nimport type { HasLength, Nullable, Optional, Maybe } from \"../../types/utility\";\r\n\r\n/**\r\n * Null and undefined guard implementations. Called by `ArgumentUtility`.\r\n *\r\n * @internal\r\n */\r\nexport class NullGuards {\r\n    private constructor() { }\r\n\r\n    \r\n    public static checkNotNull<T>(value: Nullable<T>, paramName: string): asserts value is T {\r\n        if (value === null) {\r\n            throw new ArgumentNullError(paramName);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkNotUndefined<T>(value: Maybe<T>, paramName: string): asserts value is T {\r\n        if (value === undefined) {\r\n            throw new ArgumentError(`'${paramName}' cannot be undefined.`, paramName);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkNotOptional<T>(value: Optional<T>, paramName: string): asserts value is T {\r\n        NullGuards.checkNotNull(value, paramName);\r\n        NullGuards.checkNotUndefined(value, paramName);\r\n    }\r\n\r\n    \r\n    public static checkNotNullOrEmpty<T extends HasLength>(value: Nullable<T>, paramName: string): asserts value is T {\r\n        NullGuards.checkNotNull(value, paramName);\r\n        if (value.length === 0) {\r\n            throw new ArgumentError(`'${paramName}' cannot be empty.`, paramName);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkNotOptionalOrEmpty<T extends HasLength>(value: Optional<T>, paramName: string): asserts value is T {\r\n        NullGuards.checkNotOptional(value, paramName);\r\n        if (value.length === 0) {\r\n            throw new ArgumentError(`'${paramName}' cannot be empty.`, paramName);\r\n        }\r\n    }\r\n}\r\n","import { ArgumentError } from \"../../core/errors/argument/ArgumentError\";\r\nimport type { Optional } from \"../../types/utility\";\r\nimport { NullGuards } from \"./NullGuards\";\r\n\r\n/**\r\n * String-specific guard implementations. Called by `ArgumentUtility`.\r\n *\r\n * @internal\r\n */\r\nexport class StringGuards {\r\n    private constructor() { }\r\n\r\n    public static checkNotNullOrWhiteSpace(value: Optional<string>, paramName: string): asserts value is string {\r\n        NullGuards.checkNotOptional(value, paramName);\r\n        if (value.trim().length === 0) {\r\n            throw new ArgumentError(`'${paramName}' cannot be empty or whitespace.`, paramName);\r\n        }\r\n    }\r\n}\r\n","import { ArgumentError } from \"./ArgumentError\";\r\n\r\n/**\r\n * Thrown when an argument is outside the valid range.\r\n *\r\n * @example\r\n * ```ts\r\n * try { Tyneq.from([1, 2]).take(-1); }\r\n * catch (e) { if (e instanceof ArgumentOutOfRangeError) { console.log(e.actualValue); } }\r\n * ```\r\n *\r\n * @see {@link ArgumentError}\r\n * @group Errors\r\n */\r\nexport class ArgumentOutOfRangeError extends ArgumentError {\r\n    /** The actual value that was out of range. */\r\n    public readonly actualValue?: unknown;\r\n\r\n    public constructor(paramName: string, message?: string, actualValue?: unknown, inner?: Error) {\r\n        super(message ?? `${paramName} was out of range.`, paramName, inner);\r\n        this.actualValue = actualValue;\r\n    }\r\n}\r\n","import { ArgumentError } from \"../../core/errors/argument/ArgumentError\";\r\nimport { ArgumentOutOfRangeError } from \"../../core/errors/argument/ArgumentOutOfRangeError\";\r\n\r\n/**\r\n * Numeric range and type guard implementations. Called by `ArgumentUtility`.\r\n *\r\n * @internal\r\n */\r\nexport class NumericGuards {\r\n    private constructor() { }\r\n\r\n    \r\n    public static checkNonNegative(value: number, paramName: string): void {\r\n        if (!Number.isFinite(value) || value < 0) {\r\n            throw new ArgumentOutOfRangeError(paramName, `'${paramName}' must be a non-negative number.`);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkPositive(value: number, paramName: string): void {\r\n        if (!Number.isFinite(value) || value <= 0) {\r\n            throw new ArgumentOutOfRangeError(paramName, `'${paramName}' must be a positive number.`);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkNegative(value: number, paramName: string): void {\r\n        if (!Number.isFinite(value) || value >= 0) {\r\n            throw new ArgumentOutOfRangeError(paramName, `'${paramName}' must be a negative number.`, value);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkNonPositive(value: number, paramName: string): void {\r\n        if (!Number.isFinite(value) || value > 0) {\r\n            throw new ArgumentOutOfRangeError(paramName, `'${paramName}' must be a non-positive number.`, value);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkInRange(value: number, min: number, max: number, paramName: string): void {\r\n        if (min > max) {\r\n            throw new ArgumentError(`'min' (${min}) must be <= 'max' (${max}).`, \"min\");\r\n        }\r\n        if (!Number.isFinite(value) || value < min || value > max) {\r\n            throw new ArgumentOutOfRangeError(paramName, `'${paramName}' must be in range [${min}, ${max}].`);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkInteger(value: number, paramName: string): void {\r\n        if (!Number.isFinite(value) || !Number.isInteger(value)) {\r\n            throw new ArgumentError(`'${paramName}' must be an integer.`, paramName);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkFinite(value: number, paramName: string): void {\r\n        if (!Number.isFinite(value)) {\r\n            throw new ArgumentError(`'${paramName}' must be a finite number.`, paramName);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkNotNaN(value: number, paramName: string): void {\r\n        if (Number.isNaN(value)) {\r\n            throw new ArgumentError(`'${paramName}' cannot be NaN.`, paramName);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkSafeInteger(value: number, paramName: string): void {\r\n        if (!Number.isSafeInteger(value)) {\r\n            throw new ArgumentError(`'${paramName}' must be a safe integer.`, paramName);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkArrayIndex(value: number, paramName: string, arrayLength?: number): void {\r\n        NumericGuards.checkSafeInteger(value, paramName);\r\n        const maxLength = arrayLength ?? Number.MAX_SAFE_INTEGER;\r\n        if (value < 0 || value >= maxLength) {\r\n            throw new ArgumentOutOfRangeError(\r\n                paramName,\r\n                `'${paramName}' must be in range [0, ${maxLength}).`,\r\n                value\r\n            );\r\n        }\r\n    }\r\n}\r\n","import { ArgumentError } from \"./ArgumentError\";\r\n\r\n/**\r\n * Thrown when an argument has the wrong type.\r\n *\r\n * @example\r\n * ```ts\r\n * try { Tyneq.from([1, 2]).where(\"not a function\" as any); }\r\n * catch (e) { if (e instanceof ArgumentTypeError) { console.log(e.expectedType, e.actualType); } }\r\n * ```\r\n *\r\n * @see {@link ArgumentError}\r\n * @group Errors\r\n */\r\nexport class ArgumentTypeError extends ArgumentError {\r\n    /** The expected type name. */\r\n    public readonly expectedType?: string;\r\n\r\n    /** The actual type name received. */\r\n    public readonly actualType?: string;\r\n\r\n    public constructor(\r\n        paramName: string,\r\n        expectedType?: string,\r\n        actualType?: string,\r\n        message?: string,\r\n        inner?: Error\r\n    ) {\r\n        let errorMessage: string;\r\n\r\n        if (message) {\r\n            errorMessage = message;\r\n        } else if (expectedType && actualType) {\r\n            errorMessage = `'${paramName}' expected type ${expectedType} but got ${actualType}.`;\r\n        } else if (expectedType) {\r\n            errorMessage = `'${paramName}' must be of type ${expectedType}.`;\r\n        } else {\r\n            errorMessage = `'${paramName}' has incorrect type.`;\r\n        }\r\n\r\n        super(errorMessage, paramName, inner);\r\n        this.expectedType = expectedType;\r\n        this.actualType = actualType;\r\n    }\r\n}\r\n","import type { Enumerable, Enumerator } from \"../types/core\";\r\n\r\n/**\r\n * Type guard predicates for Tyneq's core protocol types.\r\n *\r\n * @group Utilities\r\n */\r\nexport class TypeGuardUtility {\r\n    private constructor() { }\r\n\r\n    \r\n    public static isIterable<T = unknown>(value: unknown): value is Iterable<T> {\r\n        return value !== null\r\n            && value !== undefined\r\n            && typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] === \"function\";\r\n    }\r\n\r\n    \r\n    public static isIterator<T = unknown>(value: unknown): value is Iterator<T> {\r\n        const valueType = typeof value;\r\n\r\n        return value !== null\r\n            && (valueType === \"object\" || valueType === \"function\")\r\n            && typeof (value as { next?: unknown }).next === \"function\";\r\n    }\r\n\r\n    \r\n    public static isIterableIterator<T = unknown>(value: unknown): value is IterableIterator<T> {\r\n        return this.isIterable<T>(value) && this.isIterator<T>(value);\r\n    }\r\n\r\n    \r\n    public static isEnumerator<T = unknown>(value: unknown): value is Enumerator<T> {\r\n        if (!this.isIterator<T>(value)) return false;\r\n\r\n        const candidate = value as { return?: unknown; throw?: unknown };\r\n        return (candidate.return === undefined || typeof candidate.return === \"function\")\r\n            && (candidate.throw === undefined || typeof candidate.throw === \"function\");\r\n    }\r\n\r\n    \r\n    public static isEnumerable<T = unknown>(value: unknown): value is Enumerable<T> {\r\n        if (value === null || value === undefined) return false;\r\n\r\n        const candidate = value as { getEnumerator?: unknown };\r\n        return this.isIterable<T>(value)\r\n            && typeof candidate.getEnumerator === \"function\";\r\n    }\r\n}\r\n","import { ArgumentError } from \"../../core/errors/argument/ArgumentError\";\r\nimport { ArgumentTypeError } from \"../../core/errors/argument/ArgumentTypeError\";\r\nimport type { Enumerable, Enumerator } from \"../../types/core\";\r\nimport type { HasLength } from \"../../types/utility\";\r\nimport { TypeGuardUtility } from \"../TypeGuardUtility\";\r\n\r\n/**\r\n * Type-checking guard implementations. Called by `ArgumentUtility`.\r\n *\r\n * @internal\r\n */\r\nexport class TypeGuards {\r\n    private constructor() { }\r\n\r\n    \r\n    public static checkFunction(value: unknown, paramName: string): asserts value is Function {\r\n        if (typeof value !== \"function\") {\r\n            throw new ArgumentTypeError(paramName, \"function\", typeof value);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkIterable<T = unknown>(value: unknown, paramName: string): asserts value is Iterable<T> {\r\n        if (!TypeGuardUtility.isIterable<T>(value)) {\r\n            const actualType = value === null ? \"null\" : value === undefined ? \"undefined\" : typeof value;\r\n            throw new ArgumentTypeError(paramName, \"iterable\", actualType);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkIterator<T = unknown>(value: unknown, paramName: string): asserts value is Iterator<T> {\r\n        if (!TypeGuardUtility.isIterator<T>(value)) {\r\n            const actualType = value === null ? \"null\" : value === undefined ? \"undefined\" : typeof value;\r\n            throw new ArgumentTypeError(paramName, \"iterator\", actualType);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkEnumerable<T = unknown>(value: unknown, paramName: string): asserts value is Enumerable<T> {\r\n        if (!TypeGuardUtility.isEnumerable<T>(value)) {\r\n            const actualType = value === null ? \"null\" : value === undefined ? \"undefined\" : typeof value;\r\n            throw new ArgumentTypeError(paramName, \"Enumerable\", actualType);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkEnumerator<T = unknown>(value: unknown, paramName: string): asserts value is Enumerator<T> {\r\n        if (!TypeGuardUtility.isEnumerator<T>(value)) {\r\n            const actualType = value === null ? \"null\" : value === undefined ? \"undefined\" : typeof value;\r\n            throw new ArgumentTypeError(paramName, \"Enumerator\", actualType);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkInstanceOf<T>(\r\n        value: unknown,\r\n        constructor: new (...args: any[]) => T,\r\n        paramName: string\r\n    ): asserts value is T {\r\n        if (!(value instanceof constructor)) {\r\n            const constructorName = constructor.name || \"unknown\";\r\n            const actualType = value === null ? \"null\" : value === undefined ? \"undefined\" : typeof value;\r\n            throw new ArgumentTypeError(paramName, constructorName, actualType);\r\n        }\r\n    }\r\n\r\n    \r\n    public static checkHasLength(value: unknown, paramName: string): asserts value is HasLength {\r\n        if (typeof value !== \"object\" || value === null || typeof (value as any).length !== \"number\") {\r\n            throw new ArgumentTypeError(paramName, \"object with numeric length property\", typeof value);\r\n        }\r\n    }\r\n\r\n    \r\n    public static check<T>(value: T, paramName: string, predicate: (v: T) => boolean, message: string): void {\r\n        if (!predicate(value)) {\r\n            throw new ArgumentError(message, paramName);\r\n        }\r\n    }\r\n}\r\n","import type { KeyValuePair } from \"../types/core\";\r\nimport type { HasLength, Nullable, Optional, Maybe } from \"../types/utility\";\r\nimport { extractParameter } from \"./guards/extractParameter\";\r\nimport { NullGuards } from \"./guards/NullGuards\";\r\nimport { StringGuards } from \"./guards/StringGuards\";\r\nimport { NumericGuards } from \"./guards/NumericGuards\";\r\nimport { TypeGuards } from \"./guards/TypeGuards\";\r\nimport type { Enumerable, Enumerator } from \"../types/core\";\r\n\r\n/**\r\n * Facade for all argument validation guards.\r\n *\r\n * Every method accepts either a single-property object (`{ count }`) - where the\r\n * property name becomes the error message's parameter name - or a raw value with\r\n * an explicit `paramName` string. Prefer the object form; the name is inferred\r\n * automatically via `nameof`.\r\n *\r\n * @example\r\n * ```ts\r\n * import { ArgumentUtility } from \"tyneq/utility\";\r\n *\r\n * function take(count: number) {\r\n *     ArgumentUtility.checkNonNegative({ count });   // throws ArgumentOutOfRangeError if count < 0\r\n *     ArgumentUtility.checkInteger({ count });       // throws ArgumentError if count is not an integer\r\n * }\r\n * ```\r\n *\r\n * @group Utilities\r\n */\r\nexport class ArgumentUtility {\r\n    private constructor() { }\r\n\r\n\r\n    public static checkNotNull<T>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;\r\n    public static checkNotNull<T>(param: Nullable<T>, paramName: string): asserts param is T;\r\n    public static checkNotNull<T>(param: Record<string, Nullable<T>> | Nullable<T>, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NullGuards.checkNotNull(value, key);\r\n    }\r\n\r\n    \r\n    public static checkNotUndefined<T>(param: Record<string, Maybe<T>>): asserts param is Record<string, T>;\r\n    public static checkNotUndefined<T>(param: Maybe<T>, paramName: string): asserts param is T;\r\n    public static checkNotUndefined<T>(param: Record<string, Maybe<T>> | Maybe<T>, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NullGuards.checkNotUndefined(value, key);\r\n    }\r\n\r\n    \r\n    public static checkNotOptional<T>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;\r\n    public static checkNotOptional<T>(param: Optional<T>, paramName: string): asserts param is T;\r\n    public static checkNotOptional<T>(param: Record<string, Optional<T>> | Optional<T>, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NullGuards.checkNotOptional(value, key);\r\n    }\r\n\r\n    \r\n    public static checkNotNullOrEmpty<T extends HasLength>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;\r\n    public static checkNotNullOrEmpty<T extends HasLength>(param: Nullable<T>, paramName: string): asserts param is T;\r\n    public static checkNotNullOrEmpty<T extends HasLength>(param: Record<string, Nullable<T>> | Nullable<T>, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NullGuards.checkNotNullOrEmpty(value, key);\r\n    }\r\n\r\n    \r\n    public static checkNotOptionalOrEmpty<T extends HasLength>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;\r\n    public static checkNotOptionalOrEmpty<T extends HasLength>(param: Optional<T>, paramName: string): asserts param is T;\r\n    public static checkNotOptionalOrEmpty<T extends HasLength>(param: Record<string, Optional<T>> | Optional<T>, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NullGuards.checkNotOptionalOrEmpty(value, key);\r\n    }\r\n\r\n\r\n    public static checkNotNullOrWhiteSpace(param: Record<string, Optional<string>>): asserts param is Record<string, string>;\r\n    public static checkNotNullOrWhiteSpace(param: Optional<string>, paramName: string): asserts param is string;\r\n    public static checkNotNullOrWhiteSpace(param: Record<string, Optional<string>> | Optional<string>, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        StringGuards.checkNotNullOrWhiteSpace(value, key);\r\n    }\r\n\r\n\r\n    public static checkNonNegative(param: Record<string, number>): void;\r\n    public static checkNonNegative(param: number, paramName: string): void;\r\n    public static checkNonNegative(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkNonNegative(value, key);\r\n    }\r\n\r\n    \r\n    public static checkPositive(param: Record<string, number>): void;\r\n    public static checkPositive(param: number, paramName: string): void;\r\n    public static checkPositive(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkPositive(value, key);\r\n    }\r\n\r\n    \r\n    public static checkNegative(param: Record<string, number>): void;\r\n    public static checkNegative(param: number, paramName: string): void;\r\n    public static checkNegative(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkNegative(value, key);\r\n    }\r\n\r\n    \r\n    public static checkNonPositive(param: Record<string, number>): void;\r\n    public static checkNonPositive(param: number, paramName: string): void;\r\n    public static checkNonPositive(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkNonPositive(value, key);\r\n    }\r\n\r\n    \r\n    public static checkInRange(param: Record<string, number>, min: number, max: number): void;\r\n    public static checkInRange(param: number, min: number, max: number, paramName: string): void;\r\n    public static checkInRange(param: Record<string, number> | number, min: number, max: number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkInRange(value, min, max, key);\r\n    }\r\n\r\n    \r\n    public static checkInteger(param: Record<string, number>): void;\r\n    public static checkInteger(param: number, paramName: string): void;\r\n    public static checkInteger(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkInteger(value, key);\r\n    }\r\n\r\n    \r\n    public static checkFinite(param: Record<string, number>): void;\r\n    public static checkFinite(param: number, paramName: string): void;\r\n    public static checkFinite(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkFinite(value, key);\r\n    }\r\n\r\n    \r\n    public static checkNotNaN(param: Record<string, number>): void;\r\n    public static checkNotNaN(param: number, paramName: string): void;\r\n    public static checkNotNaN(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkNotNaN(value, key);\r\n    }\r\n\r\n    \r\n    public static checkSafeInteger(param: Record<string, number>): void;\r\n    public static checkSafeInteger(param: number, paramName: string): void;\r\n    public static checkSafeInteger(param: Record<string, number> | number, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        NumericGuards.checkSafeInteger(value, key);\r\n    }\r\n\r\n    \r\n    public static checkArrayIndex(param: Record<string, number>, arrayLength?: number): void;\r\n    public static checkArrayIndex(param: number, paramName: string, arrayLength?: number): void;\r\n    public static checkArrayIndex(\r\n        param: Record<string, number> | number,\r\n        paramNameOrArrayLength?: string | number,\r\n        arrayLength?: number\r\n    ): void {\r\n        const hasExplicitParamName = typeof paramNameOrArrayLength === \"string\";\r\n        const { key, value } = hasExplicitParamName\r\n            ? this.extractParameter(param as number, paramNameOrArrayLength)\r\n            : this.extractParameter(param as Record<string, number>);\r\n        const resolvedArrayLength = hasExplicitParamName ? arrayLength : paramNameOrArrayLength as Maybe<number>;\r\n        NumericGuards.checkArrayIndex(value, key, resolvedArrayLength);\r\n    }\r\n\r\n\r\n\r\n    public static checkFunction(param: Record<string, unknown>): asserts param is Record<string, Function>;\r\n     \r\n    public static checkFunction(param: unknown, paramName: string): asserts param is Function;\r\n    public static checkFunction(param: Record<string, unknown> | unknown, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        TypeGuards.checkFunction(value, key);\r\n    }\r\n\r\n    \r\n    public static checkIterable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterable<T>>;\r\n    public static checkIterable<T = unknown>(param: unknown, paramName: string): asserts param is Iterable<T>;\r\n    public static checkIterable<T = unknown>(param: Record<string, unknown> | unknown, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        TypeGuards.checkIterable<T>(value, key);\r\n    }\r\n\r\n    \r\n    public static checkIterator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterator<T>>;\r\n    public static checkIterator<T = unknown>(param: unknown, paramName: string): asserts param is Iterator<T>;\r\n    public static checkIterator<T = unknown>(param: Record<string, unknown> | unknown, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        TypeGuards.checkIterator<T>(value, key);\r\n    }\r\n\r\n    \r\n    public static checkEnumerable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerable<T>>;\r\n    public static checkEnumerable<T = unknown>(param: unknown, paramName: string): asserts param is Enumerable<T>;\r\n    public static checkEnumerable<T = unknown>(param: Record<string, unknown> | unknown, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        TypeGuards.checkEnumerable<T>(value, key);\r\n    }\r\n\r\n    \r\n    public static checkEnumerator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerator<T>>;\r\n    public static checkEnumerator<T = unknown>(param: unknown, paramName: string): asserts param is Enumerator<T>;\r\n    public static checkEnumerator<T = unknown>(param: Record<string, unknown> | unknown, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        TypeGuards.checkEnumerator<T>(value, key);\r\n    }\r\n\r\n    \r\n    public static checkInstanceOf<T>(\r\n        param: Record<string, unknown>,\r\n        constructor: new (...args: any[]) => T\r\n    ): asserts param is Record<string, T>;\r\n    public static checkInstanceOf<T>(\r\n        param: unknown,\r\n        constructor: new (...args: any[]) => T,\r\n        paramName: string\r\n    ): asserts param is T;\r\n    public static checkInstanceOf<T>(\r\n        param: Record<string, unknown> | unknown,\r\n        constructor: new (...args: any[]) => T,\r\n        paramName?: string\r\n    ): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        TypeGuards.checkInstanceOf(value, constructor, key);\r\n    }\r\n\r\n    \r\n    public static checkHasLength(param: Record<string, unknown>): asserts param is Record<string, HasLength>;\r\n    public static checkHasLength(param: unknown, paramName: string): asserts param is HasLength;\r\n    public static checkHasLength(param: Record<string, unknown> | unknown, paramName?: string): void {\r\n        const { key, value } = this.extractParameter(param, paramName);\r\n        TypeGuards.checkHasLength(value, key);\r\n    }\r\n\r\n    \r\n    public static check<T>(\r\n        param: Record<string, T>,\r\n        predicate: (v: T) => boolean,\r\n        message: string\r\n    ): void;\r\n    public static check<T>(\r\n        param: T,\r\n        paramName: string,\r\n        predicate: (v: T) => boolean,\r\n        message: string\r\n    ): void;\r\n    public static check<T>(\r\n        param: Record<string, T> | T,\r\n        paramNameOrPredicate: string | ((v: T) => boolean),\r\n        predicateOrMessage: ((v: T) => boolean) | string,\r\n        message?: string\r\n    ): void {\r\n        const hasExplicitParamName = typeof paramNameOrPredicate === \"string\";\r\n        const predicate = (hasExplicitParamName ? predicateOrMessage : paramNameOrPredicate) as (v: T) => boolean;\r\n        const validationMessage = (hasExplicitParamName ? message : predicateOrMessage) as string;\r\n        const { key, value } = hasExplicitParamName\r\n            ? this.extractParameter(param as T, paramNameOrPredicate)\r\n            : this.extractParameter(param as Record<string, T>);\r\n        TypeGuards.check(value, key, predicate, validationMessage);\r\n    }\r\n\r\n    private static extractParameter<T>(param: Record<string, T>): KeyValuePair<string, T>;\r\n    private static extractParameter<T>(param: T, paramName: string): KeyValuePair<string, T>;\r\n    private static extractParameter<T>(param: Record<string, T> | T, paramName?: string): KeyValuePair<string, T>;\r\n    private static extractParameter<T>(param: Record<string, T> | T, paramName?: string): KeyValuePair<string, T> {\r\n        return extractParameter(param as any, paramName as any);\r\n    }\r\n}\r\n","import { Maybe } from \"../../types/utility\";\r\nimport { TyneqError } from \"./TyneqError\";\r\n\r\n/**\r\n * Thrown when a prototype reflection operation fails - for example, when a\r\n * method that is expected to exist on a prototype cannot be found.\r\n *\r\n * @example\r\n * ```ts\r\n * try { reflect(proto).getMethod(\"missing\"); }\r\n * catch (e) {\r\n *   if (e instanceof ReflectionError) {\r\n *     console.log(e.methodName, e.prototypeName, e.message);\r\n *   }\r\n * }\r\n * ```\r\n *\r\n * @see {@link TyneqError}\r\n * @group Errors\r\n */\r\nexport class ReflectionError extends TyneqError {\r\n    /** The name of the method that could not be found. */\r\n    public readonly methodName: string;\r\n\r\n    /** The name of the prototype/class that was searched. */\r\n    public readonly prototypeName: Maybe<string>;\r\n\r\n    public constructor(\r\n        message: string,\r\n        methodName: string,\r\n        prototypeName?: string,\r\n        inner?: Error\r\n    ) {\r\n        super(message, { inner });\r\n        this.methodName = methodName;\r\n        this.prototypeName = prototypeName;\r\n    }\r\n}\r\n","import { ReflectionError } from \"../core/errors/ReflectionError\";\r\nimport type { Maybe } from \"../types/utility\";\r\nimport type {\r\n    AccessorDescriptor,\r\n    DataDescriptor,\r\n    MemberDescriptor,\r\n    MethodDescriptor,\r\n    ReflectOptions,\r\n} from \"../types/reflection\";\r\n\r\nexport type { AccessorDescriptor, DataDescriptor, MemberDescriptor, MethodDescriptor, ReflectOptions };\r\n\r\n/**\r\n * The result of a {@link reflect} call. Provides typed access to the members of\r\n * the reflected target.\r\n *\r\n * @group Reflection\r\n */\r\nexport class ReflectionContext<_T extends object> {\r\n    private readonly proto: object;\r\n    private readonly options: ReflectOptions;\r\n\r\n    /** @internal */\r\n    public constructor(proto: object, options: ReflectOptions) {\r\n        this.proto = proto;\r\n        this.options = options;\r\n    }\r\n\r\n    /**\r\n     * Returns descriptors for all own (and optionally inherited) members,\r\n     * excluding `constructor`.\r\n     */\r\n    public members(): readonly MemberDescriptor[] {\r\n        return this.collectDescriptors(this.proto);\r\n    }\r\n\r\n    /**\r\n     * Returns descriptors for all method members (function-valued own properties),\r\n     * excluding `constructor`.\r\n     */\r\n    public methods(): readonly MethodDescriptor[] {\r\n        return this.members().filter((d): d is MethodDescriptor => d.kind === \"method\");\r\n    }\r\n\r\n    /**\r\n     * Returns descriptors for all data members (non-function value properties).\r\n     */\r\n    public fields(): readonly DataDescriptor[] {\r\n        return this.members().filter((d): d is DataDescriptor => d.kind === \"data\");\r\n    }\r\n\r\n    /**\r\n     * Returns descriptors for all accessor members (get/set properties).\r\n     */\r\n    public accessors(): readonly AccessorDescriptor[] {\r\n        return this.members().filter((d): d is AccessorDescriptor => d.kind === \"accessor\");\r\n    }\r\n\r\n    /**\r\n     * Returns the descriptor for the named member, or `undefined` if not found.\r\n     */\r\n    public get(name: string | symbol): Maybe<MemberDescriptor> {\r\n        return this.findDescriptor(name);\r\n    }\r\n\r\n    /**\r\n     * Returns `true` if a member with the given name exists on the target.\r\n     */\r\n    public has(name: string | symbol): boolean {\r\n        return this.findDescriptor(name) !== undefined;\r\n    }\r\n\r\n    /**\r\n     * Returns the method descriptor for `name`, or throws {@link ReflectionError}\r\n     * if the member does not exist or is not a method.\r\n     *\r\n     * @throws {ReflectionError} when the member is absent or is not a method.\r\n     */\r\n    public getMethod(name: string | symbol): MethodDescriptor {\r\n        const descriptor = this.findDescriptor(name);\r\n        if (descriptor === undefined) {\r\n            const prototypeName = (this.proto as any)?.constructor?.name ?? \"unknown\";\r\n            throw new ReflectionError(\r\n                `Method \"${String(name)}\" not found on ${prototypeName}. ` +\r\n                \"Ensure the method is defined directly on the class, not inherited or deleted.\",\r\n                String(name),\r\n                prototypeName\r\n            );\r\n        }\r\n        if (descriptor.kind !== \"method\") {\r\n            const prototypeName = (this.proto as any)?.constructor?.name ?? \"unknown\";\r\n            throw new ReflectionError(\r\n                `Member \"${String(name)}\" on ${prototypeName} is a ${descriptor.kind}, not a method.`,\r\n                String(name),\r\n                prototypeName\r\n            );\r\n        }\r\n\r\n        return descriptor;\r\n    }\r\n\r\n    /**\r\n     * Returns the accessor descriptor for `name`, or throws {@link ReflectionError}\r\n     * if the member does not exist or is not an accessor.\r\n     *\r\n     * @throws {ReflectionError} when the member is absent or is not an accessor.\r\n     */\r\n    public getAccessor(name: string | symbol): AccessorDescriptor {\r\n        const descriptor = this.findDescriptor(name);\r\n        if (descriptor === undefined) {\r\n            const prototypeName = (this.proto as any)?.constructor?.name ?? \"unknown\";\r\n            throw new ReflectionError(\r\n                `Accessor \"${String(name)}\" not found on ${prototypeName}.`,\r\n                String(name),\r\n                prototypeName\r\n            );\r\n        }\r\n        if (descriptor.kind !== \"accessor\") {\r\n            const prototypeName = (this.proto as any)?.constructor?.name ?? \"unknown\";\r\n            throw new ReflectionError(\r\n                `Member \"${String(name)}\" on ${prototypeName} is a ${descriptor.kind}, not an accessor.`,\r\n                String(name),\r\n                prototypeName\r\n            );\r\n        }\r\n\r\n        return descriptor;\r\n    }\r\n\r\n    /**\r\n     * Returns `true` if a method with the given name exists on the target.\r\n     *\r\n     * Unlike {@link has}, this returns `false` if the member exists but is an accessor or data property.\r\n     */\r\n    public hasMethod(name: string | symbol): boolean {\r\n        return this.findDescriptor(name)?.kind === \"method\";\r\n    }\r\n\r\n    /**\r\n     * Returns the method descriptor for `name`, or `undefined` if the member does not\r\n     * exist or is not a method. Never throws.\r\n     */\r\n    public tryGetMethod(name: string | symbol): Maybe<MethodDescriptor> {\r\n        const descriptor = this.findDescriptor(name);\r\n        return descriptor?.kind === \"method\" ? descriptor : undefined;\r\n    }\r\n\r\n    private findDescriptor(name: string | symbol): Maybe<MemberDescriptor> {\r\n        let current: object | null = this.proto;\r\n        const stop = Object.prototype;\r\n\r\n        while (current !== null && current !== stop) {\r\n            const raw = Object.getOwnPropertyDescriptor(current, name);\r\n            if (raw !== undefined) {\r\n                return buildDescriptor(name, raw);\r\n            }\r\n            if (!this.options.inherited) break;\r\n\r\n            current = Object.getPrototypeOf(current);\r\n        }\r\n\r\n        return undefined;\r\n    }\r\n\r\n    private collectDescriptors(startProto: object): readonly MemberDescriptor[] {\r\n        const seen = new Set<string | symbol>();\r\n        const results: MemberDescriptor[] = [];\r\n        const stop = Object.prototype;\r\n\r\n        let current: object | null = startProto;\r\n        while (current !== null && current !== stop) {\r\n            const keys: (string | symbol)[] = this.options.symbols\r\n                ? Reflect.ownKeys(current)\r\n                : Object.getOwnPropertyNames(current);\r\n\r\n            for (const key of keys) {\r\n                if (key === \"constructor\") continue;\r\n                if (seen.has(key)) continue;\r\n\r\n                seen.add(key);\r\n\r\n                const raw = Object.getOwnPropertyDescriptor(current, key);\r\n                if (raw === undefined) continue;\r\n\r\n                const descriptor = buildDescriptor(key, raw);\r\n                if (descriptor !== undefined) {\r\n                    results.push(descriptor);\r\n                }\r\n            }\r\n\r\n            if (!this.options.inherited) break;\r\n\r\n            current = Object.getPrototypeOf(current);\r\n        }\r\n\r\n        return results;\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a {@link ReflectionContext} for the given target.\r\n *\r\n * The `target` can be:\r\n * - A **constructor function** - reflects the class prototype (instance members). Preferred form.\r\n * - A **prototype object** (`MyClass.prototype`) - reflects it directly.\r\n * - Any **object** - reflects the object's own properties directly.\r\n *\r\n * @example\r\n * ```ts\r\n * import { reflect } from \"tyneq/utility\";\r\n *\r\n * class Service {\r\n *     public name = \"svc\";\r\n *     public get label(): string { return this.name; }\r\n *     public run(): void { /* ... *\\/ }\r\n * }\r\n *\r\n * const ctx = reflect(Service);\r\n *\r\n * ctx.methods();   // -> [{ kind: \"method\", name: \"run\", ... }]\r\n * ctx.accessors(); // -> [{ kind: \"accessor\", name: \"label\", canRead: true, canWrite: false, ... }]\r\n *\r\n * const m = ctx.getMethod(\"run\");\r\n * m.invoke(new Service()); // calls run()\r\n * ```\r\n *\r\n * Walk the full prototype chain:\r\n *\r\n * ```ts\r\n * const ctx = reflect(DerivedClass, { inherited: true });\r\n * ctx.members(); // includes members from base classes too\r\n * ```\r\n *\r\n * @group Reflection\r\n */\r\nexport function reflect<T extends object>(\r\n    target: (new (...args: any[]) => T) | T,\r\n    options: ReflectOptions = {}\r\n): ReflectionContext<T> {\r\n    const proto = resolveProto(target);\r\n    return new ReflectionContext<T>(proto, options);\r\n}\r\n\r\nfunction resolveProto(target: (new (...args: any[]) => unknown) | object): object {\r\n    if (typeof target === \"function\") {\r\n        return (target as any).prototype as object;\r\n    }\r\n\r\n    return target;\r\n}\r\n\r\nfunction buildDescriptor(name: string | symbol, raw: PropertyDescriptor): Maybe<MemberDescriptor> {\r\n    if (\"get\" in raw || \"set\" in raw) {\r\n        return {\r\n            kind: \"accessor\",\r\n            name,\r\n            get: raw.get as Maybe<() => unknown>,\r\n            set: raw.set as Maybe<(value: unknown) => void>,\r\n            configurable: raw.configurable ?? false,\r\n            enumerable: raw.enumerable ?? false,\r\n            canRead: typeof raw.get === \"function\",\r\n            canWrite: typeof raw.set === \"function\",\r\n        };\r\n    }\r\n\r\n    if (typeof raw.value === \"function\") {\r\n        const fn = raw.value as Function;\r\n        return {\r\n            kind: \"method\",\r\n            name,\r\n            value: fn,\r\n            invoke: (thisArg, ...args) => fn.apply(thisArg, args),\r\n        };\r\n    }\r\n\r\n    if (\"value\" in raw) {\r\n        return {\r\n            kind: \"data\",\r\n            name,\r\n            value: raw.value,\r\n            writable: raw.writable ?? false,\r\n            configurable: raw.configurable ?? false,\r\n            enumerable: raw.enumerable ?? false,\r\n        };\r\n    }\r\n\r\n    return undefined;\r\n}\r\n","import { Factory, Maybe } from \"../types/utility\";\r\n\r\n/**\r\n * Utility class for lazy initialization of values.\r\n *\r\n * @group Utilities\r\n */\r\nexport class Lazy<T> {\r\n    /** The lazily initialized value, or `undefined` if not yet initialized. */\r\n    private lazyValue: Maybe<T> = undefined;\r\n    /** Indicates whether the value has been initialized. */\r\n    private initialized = false;\r\n\r\n    public constructor(private readonly factory: Factory<T, []>) { }\r\n\r\n    /** Returns the lazily initialized value, initializing it if necessary. */\r\n    public get value(): T {\r\n        if (!this.initialized) {\r\n            this.lazyValue = this.factory();\r\n            this.initialized = true;\r\n        }\r\n\r\n        return this.lazyValue!;\r\n    }\r\n}"],"mappings":"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"}