tyneq 1.0.0 → 1.0.2

package/dist/chunk-5R4AALC7.js

@@ -0,0 +1,680 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => {
+  var _a;
+  return [, , , __create((_a = base == null ? void 0 : base[__knownSymbol("metadata")]) != null ? _a : null)];
+};
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+
+// src/core/errors/TyneqError.ts
+var TyneqError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = new.target.name;
+    this.inner = options == null ? void 0 : options.inner;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/core/errors/argument/ArgumentError.ts
+var ArgumentError = class extends TyneqError {
+  constructor(message, paramName, inner) {
+    super(message, { inner });
+    this.paramName = paramName;
+  }
+};
+
+// src/core/errors/argument/ArgumentNullError.ts
+var ArgumentNullError = class extends ArgumentError {
+  constructor(paramName, inner) {
+    super(`${paramName} cannot be null.`, paramName, inner);
+  }
+};
+
+// src/core/errors/argument/ArgumentOutOfRangeError.ts
+var ArgumentOutOfRangeError = class extends ArgumentError {
+  constructor(paramName, message, actualValue, inner) {
+    super(message != null ? message : `${paramName} was out of range.`, paramName, inner);
+    this.actualValue = actualValue;
+  }
+};
+
+// src/core/errors/argument/ArgumentTypeError.ts
+var ArgumentTypeError = class extends ArgumentError {
+  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;
+  }
+};
+
+// src/utility/TypeGuardUtility.ts
+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";
+  }
+};
+
+// src/utility/nameof.ts
+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]];
+}
+
+// src/utility/guards/extractParameter.ts
+function extractParameter(param, paramName) {
+  const [extractedParamName, value] = paramName ? [paramName, param] : nameof(param);
+  return { key: extractedParamName, value };
+}
+
+// src/utility/guards/NullGuards.ts
+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);
+    }
+  }
+};
+
+// src/utility/guards/StringGuards.ts
+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);
+    }
+  }
+};
+
+// src/utility/guards/NumericGuards.ts
+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 != null ? arrayLength : Number.MAX_SAFE_INTEGER;
+    if (value < 0 || value >= maxLength) {
+      throw new ArgumentOutOfRangeError(
+        paramName,
+        `'${paramName}' must be in range [0, ${maxLength}).`,
+        value
+      );
+    }
+  }
+};
+
+// src/utility/guards/TypeGuards.ts
+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)) {
+      const actualType = value === null ? "null" : value === void 0 ? "undefined" : typeof value;
+      throw new ArgumentTypeError(paramName, "iterable", actualType);
+    }
+  }
+  static checkIterator(value, paramName) {
+    if (!TypeGuardUtility.isIterator(value)) {
+      const actualType = value === null ? "null" : value === void 0 ? "undefined" : typeof value;
+      throw new ArgumentTypeError(paramName, "iterator", actualType);
+    }
+  }
+  static checkEnumerable(value, paramName) {
+    if (!TypeGuardUtility.isEnumerable(value)) {
+      const actualType = value === null ? "null" : value === void 0 ? "undefined" : typeof value;
+      throw new ArgumentTypeError(paramName, "Enumerable", actualType);
+    }
+  }
+  static checkEnumerator(value, paramName) {
+    if (!TypeGuardUtility.isEnumerator(value)) {
+      const actualType = value === null ? "null" : value === void 0 ? "undefined" : typeof value;
+      throw new ArgumentTypeError(paramName, "Enumerator", actualType);
+    }
+  }
+  static checkInstanceOf(value, constructor, paramName) {
+    if (!(value instanceof constructor)) {
+      const constructorName = constructor.name || "unknown";
+      const actualType = value === null ? "null" : value === void 0 ? "undefined" : typeof value;
+      throw new ArgumentTypeError(paramName, constructorName, actualType);
+    }
+  }
+  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);
+    }
+  }
+};
+
+// src/utility/ArgumentUtility.ts
+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);
+  }
+};
+
+// src/core/errors/ReflectionError.ts
+var ReflectionError = class extends TyneqError {
+  constructor(message, methodName, prototypeName, inner) {
+    super(message, { inner });
+    this.methodName = methodName;
+    this.prototypeName = prototypeName;
+  }
+};
+
+// src/utility/reflect.ts
+var ReflectionContext = class {
+  /** @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) {
+    var _a, _b, _c, _d, _e, _f;
+    const descriptor = this.findDescriptor(name);
+    if (descriptor === void 0) {
+      const prototypeName = (_c = (_b = (_a = this.proto) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name) != null ? _c : "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 = (_f = (_e = (_d = this.proto) == null ? void 0 : _d.constructor) == null ? void 0 : _e.name) != null ? _f : "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) {
+    var _a, _b, _c, _d, _e, _f;
+    const descriptor = this.findDescriptor(name);
+    if (descriptor === void 0) {
+      const prototypeName = (_c = (_b = (_a = this.proto) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name) != null ? _c : "unknown";
+      throw new ReflectionError(
+        `Accessor "${String(name)}" not found on ${prototypeName}.`,
+        String(name),
+        prototypeName
+      );
+    }
+    if (descriptor.kind !== "accessor") {
+      const prototypeName = (_f = (_e = (_d = this.proto) == null ? void 0 : _d.constructor) == null ? void 0 : _e.name) != null ? _f : "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) {
+    var _a;
+    return ((_a = this.findDescriptor(name)) == null ? void 0 : _a.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 == null ? void 0 : 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);
+    }
+    return void 0;
+  }
+  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;
+  }
+};
+function reflect(target, options = {}) {
+  const proto = resolveProto(target);
+  return new ReflectionContext(proto, options);
+}
+function resolveProto(target) {
+  if (typeof target === "function") {
+    return target.prototype;
+  }
+  return target;
+}
+function buildDescriptor(name, raw) {
+  var _a, _b, _c, _d, _e;
+  if ("get" in raw || "set" in raw) {
+    return {
+      kind: "accessor",
+      name,
+      get: raw.get,
+      set: raw.set,
+      configurable: (_a = raw.configurable) != null ? _a : false,
+      enumerable: (_b = raw.enumerable) != null ? _b : 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: (_c = raw.writable) != null ? _c : false,
+      configurable: (_d = raw.configurable) != null ? _d : false,
+      enumerable: (_e = raw.enumerable) != null ? _e : false
+    };
+  }
+  return void 0;
+}
+
+// src/utility/Lazy.ts
+var Lazy = class {
+  constructor(factory) {
+    this.factory = factory;
+    /** The lazily initialized value, or `undefined` if not yet initialized. */
+    this.lazyValue = void 0;
+    /** Indicates whether the value has been initialized. */
+    this.initialized = false;
+  }
+  /** Returns the lazily initialized value, initializing it if necessary. */
+  get value() {
+    if (!this.initialized) {
+      this.lazyValue = this.factory();
+      this.initialized = true;
+    }
+    return this.lazyValue;
+  }
+};
+
+export {
+  __decoratorStart,
+  __decoratorMetadata,
+  __runInitializers,
+  __decorateElement,
+  __asyncGenerator,
+  nameof,
+  TyneqError,
+  ArgumentError,
+  ArgumentNullError,
+  ArgumentOutOfRangeError,
+  ArgumentTypeError,
+  TypeGuardUtility,
+  ArgumentUtility,
+  ReflectionError,
+  ReflectionContext,
+  reflect,
+  Lazy
+};