tyneq 1.0.0

package/dist/Lazy.js

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