xml-model 1.3.0 → 1.3.1

package/dist/node_modules/typescript-rtti/dist.esm/lib/reflect.js

@@ -1,2225 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
-import { T_FUNCTION, T_OBJECT, T_TRUE, T_FALSE, T_ENUM, T_MAPPED, T_UNDEFINED, T_NULL, T_VOID, T_GENERIC, T_ARRAY, T_TUPLE, T_INTERSECTION, T_UNION, T_ANY, T_UNKNOWN, F_READONLY, F_ABSTRACT, F_PUBLIC, F_PRIVATE, F_PROTECTED, F_PROPERTY, F_METHOD, F_CLASS, F_INTERFACE, F_OPTIONAL, F_REST, F_ASYNC, F_EXPORTED, F_INFERRED, F_OMITTED, F_ARRAY_BINDING, F_OBJECT_BINDING, F_FUNCTION } from "../common/format.js";
-import { getParameterNames } from "./get-parameter-names.js";
-import { Sealed } from "./sealed.js";
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var ReflectedClass_1;
-const NotProvided = /* @__PURE__ */ Symbol();
-function reify(callSite) {
-  if (!isCallSite(callSite))
-    throw new Error(`reify<T>() can only be used when project is built with the typescript-rtti transformer`);
-  let param = reflect(callSite).typeParameters[0];
-  if (param.is("interface"))
-    return param.token;
-  throw new Error(`reify<${param}>(): Type parameter must be an interface reference, not an arbitrary type`);
-}
-__name(reify, "reify");
-function isCallSite(callSite) {
-  return (callSite === null || callSite === void 0 ? void 0 : callSite.TΦ) === "c";
-}
-__name(isCallSite, "isCallSite");
-function Flag(value) {
-  return (target, propertyKey) => {
-    if (!target.flagToProperty)
-      target.flagToProperty = {};
-    if (!target.propertyToFlag)
-      target.propertyToFlag = {};
-    target.flagToProperty[value] = propertyKey;
-    target.propertyToFlag[propertyKey] = value;
-  };
-}
-__name(Flag, "Flag");
-const TYPE_REF_KIND_EXPANSION = {
-  [T_UNKNOWN]: "unknown",
-  [T_ANY]: "any",
-  [T_UNION]: "union",
-  [T_INTERSECTION]: "intersection",
-  [T_TUPLE]: "tuple",
-  [T_ARRAY]: "array",
-  [T_GENERIC]: "generic",
-  [T_VOID]: "void",
-  [T_NULL]: "null",
-  [T_UNDEFINED]: "undefined",
-  [T_MAPPED]: "mapped",
-  [T_ENUM]: "enum",
-  [T_FALSE]: "false",
-  [T_TRUE]: "true",
-  [T_OBJECT]: "object",
-  [T_FUNCTION]: "function"
-};
-const _ReflectedTypeRef = class _ReflectedTypeRef {
-  /** @internal */
-  constructor(_ref) {
-    this._ref = _ref;
-  }
-  toString() {
-    return `[${this.kind} type]`;
-  }
-  /** @internal */
-  static Kind(kind) {
-    return (target) => {
-      _ReflectedTypeRef.kinds[kind] = target;
-    };
-  }
-  /**
-   * Check if the given value matches this type reference. Collects any errors into the `errors` list.
-   * @param value
-   * @param errors
-   * @param context
-   * @returns
-   */
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    options.errors.push(new Error(`No validation available for type with kind '${this.kind}'`));
-    return false;
-  }
-  /**
-   * Check if the given type reference is equivalent to this type reference.
-   * @param ref
-   * @returns
-   */
-  equals(ref) {
-    if (this === ref)
-      return true;
-    if (ref.constructor !== this.constructor)
-      return false;
-    return this.matches(ref);
-  }
-  matches(ref) {
-    return true;
-  }
-  get kind() {
-    let ref = this._ref;
-    if (ref === null || ["string", "number", "bigint"].includes(typeof ref))
-      return "literal";
-    if (typeof ref === "object" && "TΦ" in ref)
-      return TYPE_REF_KIND_EXPANSION[ref.TΦ];
-    if (typeof ref === "object")
-      return "interface";
-    return "class";
-  }
-  /** @internal */
-  get ref() {
-    return this._ref;
-  }
-  /**
-   * Checks if this type reference is a Promise, optionally a Promise of a specific type.
-   * If the type reference does not specify a type of Promise but you have provided a type
-   * to check for, this will return false.
-   * @param klass The type of promise to check for. Would be String when looking for Promise<string>
-   */
-  isPromise(klass) {
-    if (this.isClass(Promise))
-      return !klass;
-    if (this.isGeneric(Promise)) {
-      if (klass)
-        return this.typeParameters.length > 0 && this.typeParameters[0].isClass(klass);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Checks if this type reference is a class. Note: If the class reference has type parameters,
-   * (ie it is generic) this check will fail, and instead isGeneric() will succeed.
-   * @param klass
-   */
-  isClass(klass) {
-    let literalTypes = {
-      "string": String,
-      "number": Number,
-      "boolean": Boolean,
-      "object": Object,
-      "bigint": BigInt
-    };
-    if (this.kind === "function" && klass === Function)
-      return true;
-    if (this.kind === "literal")
-      return literalTypes[typeof this.ref] === klass;
-    if (this.kind === "null")
-      return Object === klass;
-    if (["true", "false"].includes(this.kind))
-      return Boolean === klass;
-    return this.kind === "class" && (!klass || this.ref === klass);
-  }
-  isInterface(interfaceType) {
-    if (interfaceType)
-      return this.isInterface() && this.ref.identity === interfaceType.identity;
-    else
-      return this.kind === "interface";
-  }
-  isLiteral(value = NotProvided) {
-    if (value === null)
-      return this.isNull();
-    if (value === true)
-      return this.isTrue();
-    if (value === false)
-      return this.isFalse();
-    return this.kind === "literal" && (value === NotProvided || this.ref === value);
-  }
-  is(kind) {
-    if (typeof kind === "function")
-      return this instanceof kind;
-    else if (typeof kind === "string")
-      return this.kind === kind;
-  }
-  as(subclass) {
-    if (typeof subclass === "function" && !(this instanceof subclass))
-      throw new TypeError(`Value of type ${this.constructor.name} cannot be converted to ${subclass.name}`);
-    else if (typeof subclass === "string" && this.kind !== subclass)
-      throw new TypeError(`Type has kind ${this.kind}, expected ${subclass}`);
-    return this;
-  }
-  isVoid() {
-    return this.kind === "void";
-  }
-  isNull() {
-    return this.kind === "null";
-  }
-  isUndefined() {
-    return this.kind === "undefined";
-  }
-  isTrue() {
-    return this.kind === "true";
-  }
-  isFalse() {
-    return this.kind === "false";
-  }
-  isStringLiteral() {
-    return this.kind === "literal" && typeof this.ref === "string";
-  }
-  isNumberLiteral() {
-    return this.kind === "literal" && typeof this.ref === "number";
-  }
-  isBigIntLiteral() {
-    return this.kind === "literal" && typeof this.ref === "bigint";
-  }
-  isBooleanLiteral() {
-    return this.isTrue() || this.isFalse();
-  }
-  /**
-   * Check if this type reference is a generic type, optionally checking if the generic's
-   * base type is the given class. For instance isGeneric(Promise) is true for Promise<string>.
-   * @param klass
-   */
-  isGeneric(klass) {
-    if (this.kind === "generic") {
-      let rtGeneric = this.ref;
-      if (!rtGeneric.t["TΦ"]) {
-        return !klass || rtGeneric.t === klass;
-      }
-      return true;
-    }
-    return false;
-  }
-  isUnion(elementDiscriminator) {
-    return elementDiscriminator ? this.isUnion() && this.types.every((e) => elementDiscriminator(e)) : this.kind === "union";
-  }
-  isIntersection(elementDiscriminator) {
-    return elementDiscriminator ? this.isIntersection() && this.types.every((e) => elementDiscriminator(e)) : this.kind === "intersection";
-  }
-  isArray(elementDiscriminator) {
-    return elementDiscriminator ? this.isArray() && elementDiscriminator(this.elementType) : this.kind === "array";
-  }
-  isTuple(elementDiscriminators) {
-    return elementDiscriminators ? this.isTuple() && this.elements.every((e, i) => elementDiscriminators[i](e)) : this.kind === "tuple";
-  }
-  isUnknown() {
-    return this.kind === "unknown";
-  }
-  isAny() {
-    return this.kind === "any";
-  }
-  /**
-   * Creates an "unknown"
-   * @internal
-   */
-  static createUnknown() {
-    return this.createFromRtRef({ TΦ: T_UNKNOWN });
-  }
-  /** @internal */
-  static createFromRtRef(ref) {
-    let kind;
-    if (ref === null || !["object", "function"].includes(typeof ref))
-      kind = "literal";
-    else if (typeof ref === "object" && "TΦ" in ref)
-      kind = TYPE_REF_KIND_EXPANSION[ref.TΦ];
-    else if (typeof ref === "object")
-      kind = "interface";
-    else
-      kind = "class";
-    return new (_ReflectedTypeRef.kinds[kind] || _ReflectedTypeRef)(ref);
-  }
-};
-__name(_ReflectedTypeRef, "ReflectedTypeRef");
-let ReflectedTypeRef = _ReflectedTypeRef;
-ReflectedTypeRef.kinds = {};
-let ReflectedClassRef = (_a = class extends ReflectedTypeRef {
-  get kind() {
-    return "class";
-  }
-  get class() {
-    return this.ref;
-  }
-  get reflectedClass() {
-    return ReflectedClass.for(this.class);
-  }
-  toString() {
-    return `class ${this.class.name}`;
-  }
-  matches(ref) {
-    return this.class === ref.class;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    if (this.ref === String)
-      return typeof value === "string";
-    else if (this.ref === Number)
-      return typeof value === "number";
-    else if (this.ref === Boolean)
-      return typeof value === "boolean";
-    else if (this.ref === Object)
-      return typeof value === "object";
-    else if (this.ref === Function)
-      return typeof value === "function";
-    else if (this.ref === Symbol)
-      return typeof value === "symbol";
-    else if (this.ref === BigInt)
-      return typeof value === "bigint";
-    return ReflectedClass.for(this.ref).matchesValue(value, options);
-  }
-}, __name(_a, "ReflectedClassRef"), _a);
-ReflectedClassRef = __decorate([
-  ReflectedTypeRef.Kind("class")
-], ReflectedClassRef);
-const _ReflectedObjectMember = class _ReflectedObjectMember {
-  constructor(ref) {
-    this.ref = ref;
-    this.name = ref.n;
-    this.type = ReflectedTypeRef.createFromRtRef(this.ref.t);
-  }
-  get flags() {
-    if (!this._flags)
-      this._flags = new ReflectedFlags(this.ref.f);
-    return this._flags;
-  }
-  get isOptional() {
-    return this.flags.isOptional;
-  }
-  equals(member) {
-    return this.name === member.name && this.type.equals(member.type);
-  }
-  toString() {
-    var _a2, _b2;
-    return `${this.name}: ${(_b2 = (_a2 = this.type) === null || _a2 === void 0 ? void 0 : _a2.toString()) !== null && _b2 !== void 0 ? _b2 : "<error>"}`;
-  }
-};
-__name(_ReflectedObjectMember, "ReflectedObjectMember");
-let ReflectedObjectMember = _ReflectedObjectMember;
-let ReflectedObjectRef = (_b = class extends ReflectedTypeRef {
-  get kind() {
-    return "object";
-  }
-  get members() {
-    if (!this._members)
-      this._members = this.ref.m.map((m) => new ReflectedObjectMember(m));
-    return this._members;
-  }
-  toString() {
-    return `{ ${this.members.map((m) => m.toString()).join(", ")} }`;
-  }
-  matches(ref) {
-    if (this.members.length !== ref.members.length)
-      return false;
-    for (let member of this.members) {
-      let matchingMember = ref.members.find((x) => x.name);
-      if (!member.equals(matchingMember))
-        return false;
-    }
-    return true;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    if (typeof value !== "object")
-      return false;
-    let matches = true;
-    for (let member of this.members) {
-      let hasValue = member.name in value;
-      if (!hasValue) {
-        if (!member.isOptional) {
-          options.errors.push(new TypeError(`Missing value for member ${member.toString()}`));
-          matches = false;
-        }
-        continue;
-      }
-      let memberValue = value[member.name];
-      let memberErrors = [];
-      if (!member.type.matchesValue(memberValue, Object.assign(Object.assign({}, options), { errors: memberErrors }))) {
-        options.errors.push(new TypeError(`Value for member ${member.toString()} is invalid`));
-        options.errors.push(...memberErrors);
-        matches = false;
-      }
-    }
-    let unaccountedProperties = Object.keys(value).filter((x) => !this.members.some((y) => y.name === x));
-    if (options.allowExtraProperties !== true && unaccountedProperties.length > 0) {
-      options.errors.push(new Error(`Object contains the following undeclared properties: ${unaccountedProperties.join(", ")}`));
-      matches = false;
-    }
-    return matches;
-  }
-}, __name(_b, "ReflectedObjectRef"), _b);
-ReflectedObjectRef = __decorate([
-  ReflectedTypeRef.Kind("object")
-], ReflectedObjectRef);
-let ReflectedInterfaceRef = (_c = class extends ReflectedTypeRef {
-  get kind() {
-    return "interface";
-  }
-  get token() {
-    return this.ref;
-  }
-  get reflectedInterface() {
-    return ReflectedClass.for(this.token);
-  }
-  toString() {
-    return `interface ${this.token.name}`;
-  }
-  matches(ref) {
-    return this.token === ref.token;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return ReflectedClass.for(this.ref).matchesValue(value);
-  }
-}, __name(_c, "ReflectedInterfaceRef"), _c);
-ReflectedInterfaceRef = __decorate([
-  ReflectedTypeRef.Kind("interface")
-], ReflectedInterfaceRef);
-let ReflectedLiteralRef = (_d = class extends ReflectedTypeRef {
-  get kind() {
-    return "literal";
-  }
-  get value() {
-    return this.ref;
-  }
-  toString() {
-    return JSON.stringify(this.value);
-  }
-  matches(ref) {
-    return this.value === ref.value;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return this.ref === value;
-  }
-}, __name(_d, "ReflectedLiteralRef"), _d);
-ReflectedLiteralRef = __decorate([
-  ReflectedTypeRef.Kind("literal")
-], ReflectedLiteralRef);
-let ReflectedUnionRef = (_e = class extends ReflectedTypeRef {
-  get kind() {
-    return "union";
-  }
-  toString() {
-    return `[${this.types.join(" | ")}]`;
-  }
-  get types() {
-    if (this._types)
-      return this._types;
-    return this._types = (this.ref.t || []).map((t) => ReflectedTypeRef.createFromRtRef(t));
-  }
-  matches(ref) {
-    if (this.types.length !== ref.types.length)
-      return false;
-    for (let type of this.types) {
-      if (!ref.types.some((x) => type.equals(x)))
-        return false;
-    }
-    return true;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return this.types.some((t) => t.matchesValue(value, options));
-  }
-}, __name(_e, "ReflectedUnionRef"), _e);
-ReflectedUnionRef = __decorate([
-  ReflectedTypeRef.Kind("union")
-], ReflectedUnionRef);
-let ReflectedIntersectionRef = (_f = class extends ReflectedTypeRef {
-  get kind() {
-    return "intersection";
-  }
-  toString() {
-    return `${this.types.join(" & ")}`;
-  }
-  get types() {
-    if (this._types)
-      return this._types;
-    return this._types = (this.ref.t || []).map((t) => ReflectedTypeRef.createFromRtRef(t));
-  }
-  matches(ref) {
-    if (this.types.length !== ref.types.length)
-      return false;
-    for (let type of this.types) {
-      if (!ref.types.some((x) => type.equals(x)))
-        return false;
-    }
-    return true;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return this.types.every((t) => t.matchesValue(value, options));
-  }
-}, __name(_f, "ReflectedIntersectionRef"), _f);
-ReflectedIntersectionRef = __decorate([
-  ReflectedTypeRef.Kind("intersection")
-], ReflectedIntersectionRef);
-let ReflectedArrayRef = (_g = class extends ReflectedTypeRef {
-  get kind() {
-    return "array";
-  }
-  toString() {
-    return `${this.elementType}[]`;
-  }
-  get elementType() {
-    if (this._elementType)
-      return this._elementType;
-    return this._elementType = ReflectedTypeRef.createFromRtRef(this.ref.e);
-  }
-  matches(ref) {
-    return this.elementType.equals(ref.elementType);
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    if (!Array.isArray(value)) {
-      options.errors.push(new TypeError(`Value should be an array`));
-      return false;
-    }
-    return value.every((value2) => this.elementType.matchesValue(value2, options));
-  }
-}, __name(_g, "ReflectedArrayRef"), _g);
-ReflectedArrayRef = __decorate([
-  ReflectedTypeRef.Kind("array")
-], ReflectedArrayRef);
-let ReflectedVoidRef = (_h = class extends ReflectedTypeRef {
-  get kind() {
-    return "void";
-  }
-  toString() {
-    return `void`;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    if (value !== void 0) {
-      options.errors.push(new Error(`Value must not be present`));
-      return false;
-    }
-    return true;
-  }
-}, __name(_h, "ReflectedVoidRef"), _h);
-ReflectedVoidRef = __decorate([
-  ReflectedTypeRef.Kind("void")
-], ReflectedVoidRef);
-let ReflectedNullRef = (_i = class extends ReflectedTypeRef {
-  get kind() {
-    return "null";
-  }
-  toString() {
-    return `null`;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return value === null;
-  }
-}, __name(_i, "ReflectedNullRef"), _i);
-ReflectedNullRef = __decorate([
-  ReflectedTypeRef.Kind("null")
-], ReflectedNullRef);
-let ReflectedUndefinedRef = (_j = class extends ReflectedTypeRef {
-  get kind() {
-    return "undefined";
-  }
-  toString() {
-    return `undefined`;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return value === void 0;
-  }
-}, __name(_j, "ReflectedUndefinedRef"), _j);
-ReflectedUndefinedRef = __decorate([
-  ReflectedTypeRef.Kind("undefined")
-], ReflectedUndefinedRef);
-let ReflectedFalseRef = (_k = class extends ReflectedTypeRef {
-  get kind() {
-    return "false";
-  }
-  toString() {
-    return `false`;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return value === false;
-  }
-}, __name(_k, "ReflectedFalseRef"), _k);
-ReflectedFalseRef = __decorate([
-  ReflectedTypeRef.Kind("false")
-], ReflectedFalseRef);
-let ReflectedTrueRef = (_l = class extends ReflectedTypeRef {
-  get kind() {
-    return "true";
-  }
-  toString() {
-    return `true`;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return value === true;
-  }
-}, __name(_l, "ReflectedTrueRef"), _l);
-ReflectedTrueRef = __decorate([
-  ReflectedTypeRef.Kind("true")
-], ReflectedTrueRef);
-let ReflectedUnknownRef = (_m = class extends ReflectedTypeRef {
-  get kind() {
-    return "unknown";
-  }
-  toString() {
-    return `unknown`;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return true;
-  }
-}, __name(_m, "ReflectedUnknownRef"), _m);
-ReflectedUnknownRef = __decorate([
-  ReflectedTypeRef.Kind("unknown")
-], ReflectedUnknownRef);
-let ReflectedAnyRef = (_n = class extends ReflectedTypeRef {
-  get kind() {
-    return "any";
-  }
-  toString() {
-    return `any`;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return true;
-  }
-}, __name(_n, "ReflectedAnyRef"), _n);
-ReflectedAnyRef = __decorate([
-  ReflectedTypeRef.Kind("any")
-], ReflectedAnyRef);
-let ReflectedTupleRef = (_o = class extends ReflectedTypeRef {
-  get kind() {
-    return "tuple";
-  }
-  toString() {
-    return `[${this.elements.join(", ")}]`;
-  }
-  get elements() {
-    if (this._elements)
-      return this._elements;
-    return this._elements = (this.ref.e || []).map((e) => new ReflectedTupleElement(e));
-  }
-  matches(ref) {
-    if (this.elements.length !== ref.elements.length)
-      return false;
-    return this.elements.every((x, i) => x.name === ref.elements[i].name && x.type.equals(ref.elements[i].type));
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    if (!Array.isArray(value)) {
-      options.errors.push(new Error(`Value must be an array`));
-      return false;
-    }
-    let array = value;
-    if (array.length !== this.elements.length) {
-      options.errors.push(new Error(`Array must have ${this.elements.length} values to match tuple type`));
-      return false;
-    }
-    return this.elements.every((v, i) => v.type.matchesValue(array[i], options));
-  }
-}, __name(_o, "ReflectedTupleRef"), _o);
-ReflectedTupleRef = __decorate([
-  ReflectedTypeRef.Kind("tuple")
-], ReflectedTupleRef);
-let ReflectedGenericRef = (_p = class extends ReflectedTypeRef {
-  get kind() {
-    return "generic";
-  }
-  toString() {
-    return `${this.baseType}<${this.typeParameters.join(", ")}>`;
-  }
-  get baseType() {
-    if (this._baseType)
-      return this._baseType;
-    return this._baseType = ReflectedTypeRef.createFromRtRef(this.ref.t);
-  }
-  get typeParameters() {
-    if (this._typeParameters)
-      return this._typeParameters;
-    return this._typeParameters = this.ref.p.map((p) => ReflectedTypeRef.createFromRtRef(p));
-  }
-  matches(ref) {
-    if (this.typeParameters.length !== ref.typeParameters.length)
-      return false;
-    return this.typeParameters.every((x, i) => x.equals(ref.typeParameters[i]));
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return this.baseType.matchesValue(value, options);
-  }
-}, __name(_p, "ReflectedGenericRef"), _p);
-ReflectedGenericRef = __decorate([
-  ReflectedTypeRef.Kind("generic")
-], ReflectedGenericRef);
-let ReflectedEnumRef = (_q = class extends ReflectedTypeRef {
-  get kind() {
-    return "enum";
-  }
-  toString() {
-    return `enum`;
-  }
-  // TODO: name of enum?
-  get enum() {
-    if (!this._enum)
-      this._enum = this.ref.e;
-    return this._enum;
-  }
-  get name() {
-    if (!this._name)
-      this._name = this.ref.n;
-    return this._name;
-  }
-  get values() {
-    if (!this._values) {
-      this._values = Object.keys(this.enum).filter((x) => !/^\d+$/.test(x)).map((name) => ({ name, value: this.enum[name] }));
-    }
-    return this._values;
-  }
-  matches(ref) {
-    return this.enum === ref.enum;
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return value in this.enum;
-  }
-}, __name(_q, "ReflectedEnumRef"), _q);
-ReflectedEnumRef = __decorate([
-  ReflectedTypeRef.Kind("enum")
-], ReflectedEnumRef);
-let ReflectedFunctionRef = (_r = class extends ReflectedTypeRef {
-  get kind() {
-    return "function";
-  }
-  toString() {
-    return `function`;
-  }
-  // TODO: details
-  get returnType() {
-    var _a2;
-    return (_a2 = this._returnType) !== null && _a2 !== void 0 ? _a2 : this._returnType = ReflectedTypeRef.createFromRtRef(this.ref.r);
-  }
-  get parameters() {
-    var _a2, _b2;
-    return (_a2 = this._parameters) !== null && _a2 !== void 0 ? _a2 : this._parameters = ((_b2 = this.ref.p) !== null && _b2 !== void 0 ? _b2 : []).map((p, i) => new ReflectedParameter(p, i));
-  }
-  /**
-   * No use for this yet, reserved for future use
-   * @internal
-   */
-  get flags() {
-    var _a2;
-    return (_a2 = this._flags) !== null && _a2 !== void 0 ? _a2 : this._flags = new ReflectedFlags(this.ref.f);
-  }
-  matches(ref) {
-    return this.returnType.equals(ref.returnType) && this.parameters.every((p, i) => p.equals(ref.parameters[i])) && this.flags.toString() === ref.flags.toString();
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return this.matches(ReflectedFunction.for(value));
-  }
-}, __name(_r, "ReflectedFunctionRef"), _r);
-ReflectedFunctionRef = __decorate([
-  ReflectedTypeRef.Kind("function")
-], ReflectedFunctionRef);
-let ReflectedMappedRef = (_s = class extends ReflectedTypeRef {
-  get kind() {
-    return "mapped";
-  }
-  toString() {
-    return `${this.baseType}<${this.typeParameters.join(", ")}>`;
-  }
-  get baseType() {
-    if (this._baseType)
-      return this._baseType;
-    return this._baseType = ReflectedTypeRef.createFromRtRef(this.ref.t);
-  }
-  get typeParameters() {
-    if (this._typeParameters)
-      return this._typeParameters;
-    return this._typeParameters = this.ref.p.map((p) => ReflectedTypeRef.createFromRtRef(p));
-  }
-  get members() {
-    if (!this._members)
-      this._members = this.ref.m.map((m) => new ReflectedObjectMember(m));
-    return this._members;
-  }
-  matches(ref) {
-    if (this.typeParameters.length !== ref.typeParameters.length)
-      return false;
-    return this.typeParameters.every((x, i) => x.equals(ref.typeParameters[i]));
-  }
-  matchesValue(value, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    if (!this.ref.m)
-      return this.baseType.matchesValue(value, options);
-    if (typeof value !== "object")
-      return false;
-    let matches = true;
-    for (let member of this.members) {
-      let hasValue = member.name in value;
-      if (!hasValue) {
-        if (!member.isOptional) {
-          options.errors.push(new TypeError(`Missing value for member ${member.toString()}`));
-          matches = false;
-        }
-        continue;
-      }
-      let memberValue = value[member.name];
-      let memberErrors = [];
-      if (!member.type.matchesValue(memberValue, Object.assign(Object.assign({}, options), { errors: memberErrors }))) {
-        options.errors.push(new TypeError(`Value for member ${member.toString()} is invalid`));
-        options.errors.push(...memberErrors);
-        matches = false;
-      }
-    }
-    return matches;
-  }
-}, __name(_s, "ReflectedMappedRef"), _s);
-ReflectedMappedRef = __decorate([
-  ReflectedTypeRef.Kind("mapped")
-], ReflectedMappedRef);
-const _ReflectedTupleElement = class _ReflectedTupleElement {
-  constructor(ref) {
-    this.ref = ref;
-  }
-  toString() {
-    return `${this.name} : ${this.type}`;
-  }
-  get name() {
-    return this.ref.n;
-  }
-  get type() {
-    if (this._type)
-      return this._type;
-    return this._type = ReflectedTypeRef.createFromRtRef(this.ref.t);
-  }
-};
-__name(_ReflectedTupleElement, "ReflectedTupleElement");
-let ReflectedTupleElement = _ReflectedTupleElement;
-const _ReflectedFlags = class _ReflectedFlags {
-  constructor(flags) {
-    if (!flags)
-      flags = "";
-    Object.keys(this.flagToProperty).forEach((flag) => this[this.flagToProperty[flag]] = flags.includes(flag));
-  }
-  toString() {
-    return Object.keys(this.propertyToFlag).map((property) => this[property] ? this.propertyToFlag[property] : "").join("");
-  }
-};
-__name(_ReflectedFlags, "ReflectedFlags");
-let ReflectedFlags = _ReflectedFlags;
-__decorate([
-  Flag(F_READONLY),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isReadonly", void 0);
-__decorate([
-  Flag(F_ABSTRACT),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isAbstract", void 0);
-__decorate([
-  Flag(F_PUBLIC),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isPublic", void 0);
-__decorate([
-  Flag(F_PRIVATE),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isPrivate", void 0);
-__decorate([
-  Flag(F_PROTECTED),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isProtected", void 0);
-__decorate([
-  Flag(F_PROPERTY),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isProperty", void 0);
-__decorate([
-  Flag(F_METHOD),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isMethod", void 0);
-__decorate([
-  Flag(F_CLASS),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isClass", void 0);
-__decorate([
-  Flag(F_INTERFACE),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isInterface", void 0);
-__decorate([
-  Flag(F_OPTIONAL),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isOptional", void 0);
-__decorate([
-  Flag(F_REST),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isRest", void 0);
-__decorate([
-  Flag(F_ASYNC),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isAsync", void 0);
-__decorate([
-  Flag(F_EXPORTED),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isExported", void 0);
-__decorate([
-  Flag(F_INFERRED),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isInferred", void 0);
-__decorate([
-  Flag(F_OMITTED),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isOmitted", void 0);
-__decorate([
-  Flag(F_ARRAY_BINDING),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isArrayBinding", void 0);
-__decorate([
-  Flag(F_OBJECT_BINDING),
-  __metadata("design:type", Boolean)
-], ReflectedFlags.prototype, "isObjectBinding", void 0);
-const _ReflectedParameter = class _ReflectedParameter {
-  constructor(rawMetadata, index) {
-    this.rawMetadata = rawMetadata;
-    this.index = index;
-  }
-  get isBinding() {
-    return this.isArrayBinding || this.isObjectBinding;
-  }
-  /**
-   * True if this parameter is an array binding expression (destructured assignment).
-   */
-  get isArrayBinding() {
-    return this.flags.isArrayBinding;
-  }
-  /**
-   * True if this parameter is an object binding expression (destructured assignment).
-   */
-  get isObjectBinding() {
-    return this.flags.isObjectBinding;
-  }
-  /**
-   * True if this parameter is an omitted slot within an array binding expression.
-   * ie, if the user declares [foo, ,bar], then the second binding will have isOmitted true.
-   * See: destructured assignment.
-   */
-  get isOmitted() {
-    return this.flags.isOmitted;
-  }
-  /**
-   * If this is an object/array binding (ie destructured assignment),
-   * this will return the individual bindings that are part of this declaration.
-   */
-  get bindings() {
-    if (!this.isBinding)
-      return void 0;
-    if (!this._bindings) {
-      (this.rawMetadata.b || []).map((bindingElement, i) => new _ReflectedParameter(bindingElement, i));
-    }
-    return this._bindings;
-  }
-  /**
-   * Get the unmangled original name for this parameter. This may be undefined if the parameter is an array/object
-   * binding expression (destructured assignment).
-   */
-  get name() {
-    return this.rawMetadata.n;
-  }
-  /**
-   * Get the reflected type of this parameter
-   */
-  get type() {
-    if (this._type)
-      return this._type;
-    return this._type = ReflectedTypeRef.createFromRtRef(this.rawMetadata.t());
-  }
-  /**
-   * Get flags that define aspects of this property.
-   */
-  get flags() {
-    if (this._flags)
-      return this._flags;
-    return this._flags = new ReflectedFlags(this.rawMetadata.f);
-  }
-  /**
-   * True if this parameter is optional
-   */
-  get isOptional() {
-    return this.flags.isOptional;
-  }
-  /**
-   * True if this parameter is a rest parameter
-   */
-  get isRest() {
-    return this.flags.isRest;
-  }
-  /**
-   * Retrieve the initializer for this parameter. Invoking the initializer produces the
-   * default value for the parameter. Caution: The initializer depends on the value of 'this'.
-   * Use evaluateInitializer() to properly invoke the initializer.
-   */
-  get initializer() {
-    return this.rawMetadata.v;
-  }
-  /**
-   * Evaluate the initializer for this parameter with the given value for 'this'. If not provided,
-   * 'this' is an empty object. This is suitable for constructor parameters but instance method parameters
-   * may reference properties of the object, and so getting the correct value may require passing an
-   * appropriate instance.
-   *
-   * @param thisObject
-   * @returns
-   */
-  evaluateInitializer(thisObject = {}) {
-    return this.initializer.apply(thisObject, []);
-  }
-  /**
-   * Check if this parameter declaration is identical to another parameter declaration (including its name).
-   *
-   * @param other The other parameter to check against
-   * @param checkName If true, the name is checked, otherwise it is ignored
-   * @returns
-   */
-  equals(other, checkName = true) {
-    return (!checkName || this.name === other.name) && this.type.equals(other.type) && this.flags.toString() === other.flags.toString();
-  }
-};
-__name(_ReflectedParameter, "ReflectedParameter");
-let ReflectedParameter = _ReflectedParameter;
-const _ReflectedMethodParameter = class _ReflectedMethodParameter extends ReflectedParameter {
-  constructor(method, rawMetadata, index) {
-    super(rawMetadata, index);
-    this.method = method;
-    this.rawMetadata = rawMetadata;
-    this.index = index;
-  }
-  get parent() {
-    return this.method;
-  }
-  get class() {
-    return this.method.class;
-  }
-};
-__name(_ReflectedMethodParameter, "ReflectedMethodParameter");
-let ReflectedMethodParameter = _ReflectedMethodParameter;
-const _ReflectedFunctionParameter = class _ReflectedFunctionParameter extends ReflectedParameter {
-  constructor(func, rawMetadata, index) {
-    super(rawMetadata, index);
-    this.func = func;
-    this.rawMetadata = rawMetadata;
-    this.index = index;
-  }
-  get parent() {
-    return this.func;
-  }
-};
-__name(_ReflectedFunctionParameter, "ReflectedFunctionParameter");
-let ReflectedFunctionParameter = _ReflectedFunctionParameter;
-const _ReflectedConstructorParameter = class _ReflectedConstructorParameter extends ReflectedParameter {
-  constructor(reflectedClass, rawMetadata, index) {
-    super(rawMetadata, index);
-    this.reflectedClass = reflectedClass;
-    this.rawMetadata = rawMetadata;
-    this.index = index;
-    this._class = reflectedClass;
-  }
-  get parent() {
-    return this.class;
-  }
-  /**
-   * Retrieve the reflected class that this constructor parameter is defined on.
-   */
-  get class() {
-    return this._class;
-  }
-  /**
-   * True if this constructor parameter is declared readonly, meaning it is
-   * also an instance property of the class.
-   */
-  get isReadonly() {
-    return this.flags.isReadonly;
-  }
-  /**
-   * True if this constructor parameter is declared public, meaning it is
-   * also an instance property of the class.
-   */
-  get isPublic() {
-    return this.flags.isPublic;
-  }
-  /**
-   * True if this constructor parameter is declared protected, meaning it is
-   * also an instance property of the class.
-   */
-  get isProtected() {
-    return this.flags.isProtected;
-  }
-  /**
-   * True if this constructor parameter is declared private, meaning it is
-   * also an instance property of the class.
-   */
-  get isPrivate() {
-    return this.flags.isPrivate;
-  }
-  /**
-   * Get visibility of this constructor parameter. If the constructor
-   * parameter has no visibility modifiers, this is null.
-   */
-  get visibility() {
-    return this.isPublic ? "public" : this.isProtected ? "protected" : this.isPrivate ? "private" : null;
-  }
-  /**
-   * True if the constructor parameter is also a property.
-   */
-  get isProperty() {
-    return this.visibility !== null || this.isReadonly;
-  }
-};
-__name(_ReflectedConstructorParameter, "ReflectedConstructorParameter");
-let ReflectedConstructorParameter = _ReflectedConstructorParameter;
-const _ReflectedMember = class _ReflectedMember {
-  constructor(reflectedClass, name, isStatic) {
-    this.name = name;
-    this.isStatic = isStatic;
-    this._class = reflectedClass;
-  }
-  /**
-   * Get the given metadata key for this member. This is equivalent to
-   * Reflect.getMetadata(key, this.host, this.name)
-   * @param key
-   * @returns
-   */
-  getMetadata(key) {
-    return Reflect.getMetadata(key, this.host, this.name);
-  }
-  /**
-   * Define a metadata key for this member. This is equivalent to
-   * Reflect.defineMetadata(key, value, this.host, this.name)
-   * @param key
-   * @returns
-   */
-  defineMetadata(key, value) {
-    Reflect.defineMetadata(key, value, this.host, this.name);
-    return value;
-  }
-  /**
-   * Get or define a metadata item for this member. If the key already exists, its
-   * value is returned without calling the passed function. Otherwise the passed function
-   * is called and its value is saved to the given metadata key.
-   *
-   * @param key The metadata key to fetch
-   * @param definer A function which will define the value of the metadata
-   * @returns The value of the existing metadata key or the new value returned by the definer function
-   *          which will also be defined as the appropriate metadata item on this member.
-   */
-  metadata(key, definer) {
-    if (this.hasMetadata(key))
-      return this.getMetadata(key);
-    let value = definer();
-    this.defineMetadata(key, value);
-    return value;
-  }
-  /**
-   * Check if a metadata key exists for this member. This is equivalent to
-   * Reflect.hasMetadata(key, this.host, this.name)
-   * @param key
-   * @returns
-   */
-  hasMetadata(key) {
-    return Reflect.hasMetadata(key, this.host, this.name);
-  }
-  /**
-   * Get the host object for this method. For static members this is the
-   * class constructor. For instance members this is the class's prototype.
-   */
-  get host() {
-    return this.isStatic ? this.class.class : this.class.prototype;
-  }
-  /**
-   * Get the reflected class that hosts this member
-   */
-  get class() {
-    return this._class;
-  }
-  /**
-   * Get the flags for this member. Includes modifiers and other properties about
-   * the member.
-   */
-  get flags() {
-    if (this._flags)
-      return this._flags;
-    return this._flags = new ReflectedFlags(this.getMetadata("rt:f"));
-  }
-  /**
-   * True if this member is abstract.
-   */
-  get isAbstract() {
-    return this.flags.isAbstract;
-  }
-  /**
-   * True if this member has private visibility.
-   */
-  get isPrivate() {
-    return this.flags.isPrivate;
-  }
-  /**
-   * True if this member has public visibility.
-   */
-  get isPublic() {
-    return this.visibility === "public";
-  }
-  /**
-   * True if this member is specifically marked as public
-   * (as opposed to default visibility).
-   */
-  get isMarkedPublic() {
-    return this.flags.isPublic;
-  }
-  /**
-   * True if this member has protected visibility.
-   */
-  get isProtected() {
-    return this.flags.isProtected;
-  }
-  /**
-   * Get the visibility (accessibility) of this member.
-   * Can be 'public', 'protected', or 'private'
-   */
-  get visibility() {
-    return this.isMarkedPublic ? "public" : this.isProtected ? "protected" : this.isPrivate ? "private" : "public";
-  }
-  /**
-   * Whether this member is marked as optional.
-   */
-  get isOptional() {
-    return this.flags.isOptional;
-  }
-};
-__name(_ReflectedMember, "ReflectedMember");
-let ReflectedMember = _ReflectedMember;
-const _ReflectedFunction = class _ReflectedFunction {
-  constructor(func) {
-    this.func = func;
-  }
-  static for(func) {
-    if (typeof func !== "function")
-      throw new TypeError(`Passed value is not a function`);
-    let existing = this.reflectedFunctions.get(func);
-    if (!existing) {
-      this.reflectedFunctions.set(func, existing = new _ReflectedFunction(func));
-    }
-    return existing;
-  }
-  /**
-   * Create a new ReflectedClass instance for the given type without sharing. Used during testing.
-   * @internal
-   **/
-  static new(func) {
-    return new _ReflectedFunction(func);
-  }
-  matchesValue(object, errors = [], context) {
-    return object === this.func;
-  }
-  /**
-   * Check if the function has the given metadata key defined. This is equivalent
-   * to Reflect.hasMetadata(key, value, this.func)
-   * @param key
-   * @returns
-   */
-  hasMetadata(key) {
-    return Reflect.hasMetadata(key, this.func);
-  }
-  /**
-   * Get the specified metadata key for this function. This is equivalent
-   * to Reflect.getMetadata(key, value, this.func)
-   * @param key
-   * @returns
-   */
-  getMetadata(key) {
-    return Reflect.getMetadata(key, this.func);
-  }
-  /**
-   * Define a metadata key for this function. This is equivalent
-   * to Reflect.defineMetadata(key, value, this.func)
-   * @param key The metadata key to define.
-   * @param value
-   */
-  defineMetadata(key, value) {
-    Reflect.defineMetadata(key, value, this.func);
-    return value;
-  }
-  /**
-   * Get or define a metadata item for this function. If the key already exists, its
-   * value is returned without calling the passed function. Otherwise the passed function
-   * is called and its value is saved to the given metadata key.
-   *
-   * @param key The metadata key to fetch
-   * @param definer A function which will define the value of the metadata
-   * @returns The value of the existing metadata key or the new value returned by the definer function
-   *          which will also be defined as the appropriate metadata item on this function.
-   */
-  metadata(key, definer) {
-    if (this.hasMetadata(key))
-      return this.getMetadata(key);
-    let value = definer();
-    this.defineMetadata(key, value);
-    return value;
-  }
-  /**
-   * Get the flags for this function.
-   */
-  get flags() {
-    if (this._flags)
-      return this._flags;
-    return this._flags = new ReflectedFlags(this.getMetadata("rt:f"));
-  }
-  /**
-   * @internal
-   */
-  get rawParameterMetadata() {
-    if (this._rawParameterMetadata)
-      return this._rawParameterMetadata;
-    return this._rawParameterMetadata = this.getMetadata("rt:p") || [];
-  }
-  /**
-   * Names of the parameters for this function.
-   */
-  get parameterNames() {
-    return this.rawParameterMetadata.map((x) => x.n);
-  }
-  /**
-   * Types for the parameter types of this function.
-   */
-  get parameterTypes() {
-    if (this._parameterTypes !== void 0)
-      return this._parameterTypes;
-    if (this.rawParameterMetadata !== void 0) {
-      return this._parameterTypes = this.rawParameterMetadata.map((param) => {
-        return param.t ? ReflectedTypeRef.createFromRtRef(param.t()) : ReflectedTypeRef.createUnknown();
-      });
-    } else if (this.hasMetadata("design:paramtypes")) {
-      let params = this.getMetadata("design:paramtypes");
-      return this._parameterTypes = (params || []).map((t) => ReflectedTypeRef.createFromRtRef(() => t));
-    }
-    return [];
-  }
-  /**
-   * Retrieve the set of reflected parameters for this method.
-   */
-  get parameters() {
-    if (this._parameters)
-      return this._parameters;
-    return this._parameters = this.rawParameterMetadata.map((x, i) => new ReflectedFunctionParameter(this, x, i));
-  }
-  /**
-   * Get the parameter with the specified name
-   * @param name
-   * @returns The reflected parameter
-   */
-  getParameter(name) {
-    return this.parameters.find((x) => x.name === name);
-  }
-  /**
-   * Retrieve the return type of this function.
-   */
-  get returnType() {
-    if (this._returnType !== void 0)
-      return this._returnType;
-    let typeResolver = this.getMetadata("rt:t");
-    if (!typeResolver && this.hasMetadata("design:returntype")) {
-      let designReturnType = this.getMetadata("design:returntype");
-      typeResolver = /* @__PURE__ */ __name(() => designReturnType || null, "typeResolver");
-    }
-    if (!typeResolver)
-      return ReflectedTypeRef.createUnknown();
-    return this._returnType = ReflectedTypeRef.createFromRtRef(typeResolver());
-  }
-  /**
-   * True if the return type was inferred using the Typescript type checker. False if
-   * the return type was defined explicitly.
-   */
-  get returnTypeInferred() {
-    return this.flags.isInferred;
-  }
-  /**
-   * True if this function is declared as async.
-   */
-  get isAsync() {
-    return this.flags.isAsync;
-  }
-  /**
-   * True if this function is a variadic function.
-   */
-  get isVariadic() {
-    return this.parameters.find((v) => v.isRest) !== void 0;
-  }
-};
-__name(_ReflectedFunction, "ReflectedFunction");
-let ReflectedFunction = _ReflectedFunction;
-ReflectedFunction.reflectedFunctions = /* @__PURE__ */ new WeakMap();
-const _ReflectedMethod = class _ReflectedMethod extends ReflectedMember {
-  matchesValue(object, errors = [], context) {
-    return object === this.func;
-  }
-  get func() {
-    if (this.isStatic)
-      return this.class[this.name];
-    else
-      return this.class.prototype[this.name];
-  }
-  /**
-   * @internal
-   */
-  get rawParameterMetadata() {
-    if (this._rawParameterMetadata)
-      return this._rawParameterMetadata;
-    return this._rawParameterMetadata = this.getMetadata("rt:p") || [];
-  }
-  /**
-   * Retrieve the reflected method for the given method function.
-   * If the function is not a method, a TypeError is thrown.
-   * @param method
-   */
-  static for(method) {
-    if (!hasAnyFlag(method, [F_METHOD]))
-      throw new TypeError(`The function is not a method, or the class is not annotated with runtime type metadata`);
-    if (!Reflect.hasMetadata("rt:h", method))
-      throw new TypeError(`The function is a method, but is not annotated with a host class`);
-    let host = Reflect.getMetadata("rt:h", method);
-    if (!host)
-      throw new TypeError(`The method has a defined host, but it is null/undefined`);
-    return ReflectedClass.for(host()).getMethod(method.name);
-  }
-  /**
-   * Retrieve an array with the parameter names for this method.
-   */
-  get parameterNames() {
-    return this.rawParameterMetadata.map((x) => x.n);
-  }
-  /**
-   * Retrieve an array with the parameter types for this method.
-   */
-  get parameterTypes() {
-    if (this._parameterTypes !== void 0)
-      return this._parameterTypes;
-    if (this.rawParameterMetadata !== void 0) {
-      return this._parameterTypes = this.rawParameterMetadata.map((param) => {
-        return param.t ? ReflectedTypeRef.createFromRtRef(param.t()) : ReflectedTypeRef.createUnknown();
-      });
-    } else if (this.hasMetadata("design:paramtypes")) {
-      let params = this.getMetadata("design:paramtypes");
-      return this._parameterTypes = (params || []).map((t) => ReflectedTypeRef.createFromRtRef(() => t));
-    }
-    return [];
-  }
-  /**
-   * Retrieve the set of reflected parameters for this method.
-   */
-  get parameters() {
-    if (this._parameters)
-      return this._parameters;
-    return this._parameters = this.rawParameterMetadata.map((x, i) => new ReflectedMethodParameter(this, x, i));
-  }
-  /**
-   * Get a reflected parameter by name
-   * @param name
-   * @returns The reflected parameter
-   */
-  getParameter(name) {
-    return this.parameters.find((x) => x.name === name);
-  }
-  /**
-   * Get the return type of this method.
-   */
-  get returnType() {
-    if (this._returnType !== void 0)
-      return this._returnType;
-    let typeResolver = this.getMetadata("rt:t");
-    if (!typeResolver && this.hasMetadata("design:returntype")) {
-      let designReturnType = this.getMetadata("design:returntype");
-      typeResolver = /* @__PURE__ */ __name(() => designReturnType || null, "typeResolver");
-    }
-    if (!typeResolver)
-      return ReflectedTypeRef.createUnknown();
-    return this._returnType = ReflectedTypeRef.createFromRtRef(typeResolver());
-  }
-  /**
-   * True if the return type was inferred using the Typescript type checker. False if
-   * the return type was defined explicitly.
-   */
-  get returnTypeInferred() {
-    return this.flags.isInferred;
-  }
-  /**
-   * True if this method is declared as async.
-   */
-  get isAsync() {
-    return this.flags.isAsync;
-  }
-  /**
-   * True if this function is a variadic function.
-   */
-  get isVariadic() {
-    return this.parameters.find((v) => v.isRest) !== void 0;
-  }
-};
-__name(_ReflectedMethod, "ReflectedMethod");
-let ReflectedMethod = _ReflectedMethod;
-const _ReflectedProperty = class _ReflectedProperty extends ReflectedMember {
-  /**
-   * Get the type of this property.
-   */
-  get type() {
-    if (this._type !== void 0)
-      return this._type;
-    let typeResolver;
-    if (this.hasMetadata("rt:t")) {
-      typeResolver = this.getMetadata("rt:t");
-    } else if (this.hasMetadata("design:type")) {
-      let designType = this.getMetadata("design:type");
-      typeResolver = /* @__PURE__ */ __name(() => designType, "typeResolver");
-    }
-    if (!typeResolver)
-      return this._type = ReflectedTypeRef.createUnknown();
-    return this._type = ReflectedTypeRef.createFromRtRef(typeResolver());
-  }
-  /**
-   * True if this property is marked readonly.
-   */
-  get isReadonly() {
-    return this.flags.isReadonly;
-  }
-  /**
-   * Check if the given value matches the type of this property, and would
-   * thus be a valid assignment.
-   * @param object
-   * @param errors
-   * @returns
-   */
-  matchesValue(object, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    return this.type.matchesValue(object, options);
-  }
-};
-__name(_ReflectedProperty, "ReflectedProperty");
-let ReflectedProperty = _ReflectedProperty;
-function getFlags(value) {
-  if (!Reflect.hasMetadata("rt:f", value))
-    return "";
-  let flagsValue = Reflect.getMetadata("rt:f", value);
-  if (typeof flagsValue === "string")
-    return flagsValue;
-  return "";
-}
-__name(getFlags, "getFlags");
-function hasAnyFlag(value, desiredFlags) {
-  let flags = getFlags(value);
-  return desiredFlags.some((x) => flags.includes(x));
-}
-__name(hasAnyFlag, "hasAnyFlag");
-function hasAllFlags(value, desiredFlags) {
-  let flags = getFlags(value);
-  return desiredFlags.every((x) => flags.includes(x));
-}
-__name(hasAllFlags, "hasAllFlags");
-let ReflectedClass = ReflectedClass_1 = (_t = class {
-  /**
-   * Constructs a new ReflectedClass. Use ReflectedClass.for() to obtain a ReflectedClass.
-   */
-  constructor(klass) {
-    this._hasPropertyNamesMeta = false;
-    this._hasStaticPropertyNameMeta = false;
-    this._dynamicStaticProperties = /* @__PURE__ */ new Map();
-    this._dynamicProperties = /* @__PURE__ */ new Map();
-    this._class = klass;
-  }
-  /**
-   * Obtain a ReflectedClass for the given class constructor, Interface value or instance.
-   * @param constructorOrValue Can be a class constructor, Interface, or an instance of a class (in which case the
-   *                           instance's constructor will be used)
-   * @returns The ReflectedClass.
-   */
-  static for(constructorOrValue) {
-    let flags = getFlags(constructorOrValue);
-    if (flags.includes(F_INTERFACE))
-      return this.forConstructorOrInterface(constructorOrValue);
-    else if (flags.includes(F_CLASS))
-      return this.forConstructorOrInterface(constructorOrValue);
-    else if (flags.includes(F_FUNCTION))
-      throw new TypeError(`Value is a function, use ReflectedFunction.for() or reflect(func) instead`);
-    if (typeof constructorOrValue === "function" || "name" in constructorOrValue && "prototype" in constructorOrValue && typeof constructorOrValue.identity === "symbol")
-      return this.forConstructorOrInterface(constructorOrValue);
-    return this.forConstructorOrInterface(constructorOrValue.constructor);
-  }
-  /**
-   * Create a new ReflectedClass instance for the given type without sharing. Used during testing.
-   * @internal
-   **/
-  static new(constructorOrInterface) {
-    return new ReflectedClass_1(constructorOrInterface);
-  }
-  static forConstructorOrInterface(constructorOrInterface) {
-    let existing = this.reflectedClasses.get(constructorOrInterface);
-    if (!existing) {
-      this.reflectedClasses.set(constructorOrInterface, existing = new ReflectedClass_1(constructorOrInterface));
-    }
-    return existing;
-  }
-  /**
-   * Get the interfaces that this class implements, or that this interface extends.
-   * Note that if the class implements another class as an interface, you will receive
-   * a class type reference for that, not an interface type reference.
-   */
-  get interfaces() {
-    if (this._interfaces !== void 0)
-      return this._interfaces;
-    if (this.hasMetadata("rt:i")) {
-      return this._interfaces = this.getMetadata("rt:i").map((resolver) => resolver()).filter((x) => !!x).map((ref) => ReflectedTypeRef.createFromRtRef(ref));
-    }
-    return [];
-  }
-  /**
-   * Check if this class implements the given interface. The parameter can be a reified interface
-   * reference or a class reference. Note that implementing a class is not the same as extending a class.
-   * Note that this will return true only if this class explicitly declares that an interface is implemented.
-   *
-   * @param interfaceType
-   * @returns boolean
-   */
-  implements(interfaceType) {
-    return !!this.interfaces.find((i) => typeof interfaceType === "function" ? i.isClass(interfaceType) : i.isInterface(interfaceType));
-  }
-  /**
-   * Check if the given value matches the shape of this type, and thus would be a valid assignment.
-   * @param object
-   * @param errors
-   * @returns
-   */
-  matchesValue(object, options) {
-    var _a2;
-    options !== null && options !== void 0 ? options : options = {};
-    (_a2 = options.errors) !== null && _a2 !== void 0 ? _a2 : options.errors = [];
-    if (object === null || object === void 0) {
-      options.errors.push(new Error(`Value is undefined`));
-      return false;
-    }
-    if (typeof object !== "object") {
-      options.errors.push(new Error(`Value must be an object`));
-      return false;
-    }
-    let matches = true;
-    if (globalThis.RTTI_TRACE === true)
-      console.log(`Type checking value against type '${this.class.name}'`);
-    for (let prop of this.properties) {
-      let hasValue = prop.name in object;
-      let value = object[prop.name];
-      if (!hasValue && !prop.isOptional) {
-        options.errors.push(new Error(`Property '${prop.name}' is missing in value`));
-        matches = false;
-      }
-      if (!hasValue)
-        continue;
-      let propMatch = prop.matchesValue(value, options);
-      if (globalThis.RTTI_TRACE === true)
-        console.log(` - ${this.class.name}#${prop.name} : ${prop.type} | valid(${JSON.stringify(value)}) => ${propMatch}`);
-      matches && (matches = propMatch);
-    }
-    let unaccountedProperties = Object.keys(object).filter((x) => !this.properties.some((y) => y.name === x) && !this.methods.some((y) => y.name === x));
-    if (options.allowExtraProperties !== true && unaccountedProperties.length > 0) {
-      options.errors.push(new Error(`Object contains the following undeclared properties: ${unaccountedProperties.join(", ")}`));
-      matches = false;
-    }
-    return matches;
-  }
-  /**
-   * Get the prototype object for this reflected class.
-   */
-  get prototype() {
-    return this._class.prototype;
-  }
-  /**
-   * Get the class constructor for this reflected class.
-   */
-  get class() {
-    return this._class;
-  }
-  /**
-   * Get the reflected superclass for this class. If this is an interface,
-   * this will always be undefined. If you are looking to access the classes/interfaces that
-   * an interface extends, use the "interfaces" property.
-   */
-  get super() {
-    var _a2, _b2;
-    if (this._super !== void 0)
-      return this._super;
-    let parentClass = (_b2 = (_a2 = Object.getPrototypeOf(this.class.prototype)) === null || _a2 === void 0 ? void 0 : _a2.constructor) !== null && _b2 !== void 0 ? _b2 : Object;
-    if (parentClass === Object)
-      return this._super = null;
-    else
-      return this._super = ReflectedClass_1.for(parentClass);
-  }
-  /**
-   * Check if the function has the given metadata key defined. This is equivalent
-   * to Reflect.hasMetadata(key, this.class)
-   * @param key
-   * @returns
-   */
-  hasMetadata(key) {
-    return Reflect.hasMetadata(key, this.class);
-  }
-  /**
-   * Get the specified metadata key. This is equivalent to Reflect.getMetadata(key, this.class).
-   * @param key
-   * @returns
-   */
-  getMetadata(key) {
-    return Reflect.getMetadata(key, this.class);
-  }
-  /**
-   * Define a metadata key on this class. This is equivalent to Reflect.defineMetadata(key, value, this.class).
-   * @param key
-   * @param value
-   * @returns
-   */
-  defineMetadata(key, value) {
-    Reflect.defineMetadata(key, value, this.class);
-    return value;
-  }
-  /**
-   * Get or define a metadata item for this class/interface. If the key already exists, its
-   * value is returned without calling the passed function. Otherwise the passed function
-   * is called and its value is saved to the given metadata key.
-   *
-   * @param key The metadata key to fetch
-   * @param definer A function which will define the value of the metadata
-   * @returns The value of the existing metadata key or the new value returned by the definer function
-   *          which will also be defined as the appropriate metadata item on this class/interface.
-   */
-  metadata(key, definer) {
-    if (this.hasMetadata(key))
-      return this.getMetadata(key);
-    let value = definer();
-    this.defineMetadata(key, value);
-    return value;
-  }
-  /**
-   * Define a metadata key on this class's prototype object. This is equivalent to Reflect.defineMetadata(key, value, this.class.prototype)
-   * @param key
-   * @param value
-   * @returns
-   */
-  definePrototypeMetadata(key, value) {
-    Reflect.defineMetadata(key, value, this.class.prototype);
-    return value;
-  }
-  /**
-   * Retrieve the set of property names that are defined directly on this class, excluding
-   * those which are inherited.
-   */
-  get ownPropertyNames() {
-    if (this._ownPropertyNames)
-      return this._ownPropertyNames;
-    let propertyNames;
-    if (this.hasMetadata("rt:P")) {
-      propertyNames = this.getMetadata("rt:P");
-      this._hasPropertyNamesMeta = !!propertyNames;
-    } else {
-      propertyNames = Object.getOwnPropertyNames(this.class.prototype).filter((x) => x !== "constructor").filter((x) => {
-        let descriptor = Object.getOwnPropertyDescriptor(this.class.prototype, x);
-        if (descriptor.get)
-          return true;
-        return typeof this.class.prototype[x] === "function";
-      });
-    }
-    return this._ownPropertyNames = propertyNames || [];
-  }
-  /**
-   * Retrieve the set of method names that are defined directly on this class, excluding
-   * those which are inherited.
-   */
-  get ownMethodNames() {
-    if (this._ownMethodNames)
-      return this._ownMethodNames;
-    let methodNames = this.getMetadata("rt:m");
-    if (!methodNames) {
-      methodNames = Object.getOwnPropertyNames(this.class.prototype).filter((x) => x !== "constructor").filter((x) => {
-        let descriptor = Object.getOwnPropertyDescriptor(this.class.prototype, x);
-        if (descriptor.get)
-          return false;
-        return typeof this.class.prototype[x] === "function";
-      });
-    }
-    return this._ownMethodNames = methodNames;
-  }
-  /**
-   * Retrieve the set of static property names that are defined directly on this class, excluding
-   * those which are inherited. Always empty for interfaces.
-   */
-  get ownStaticPropertyNames() {
-    if (this._ownStaticPropertyNames)
-      return this._ownStaticPropertyNames;
-    let ownStaticPropertyNames = this.getMetadata("rt:SP");
-    this._hasStaticPropertyNameMeta = !!ownStaticPropertyNames;
-    if (!ownStaticPropertyNames) {
-      this._hasStaticPropertyNameMeta = false;
-      ownStaticPropertyNames = Object.getOwnPropertyNames(this.class).filter((x) => !["length", "prototype", "name"].includes(x)).filter((x) => typeof this.class[x] !== "function");
-    }
-    return this._ownStaticPropertyNames = ownStaticPropertyNames;
-  }
-  /**
-   * Retrieve the set of static method names that are defined directly on this class,
-   * excluding those which are inherited. Always empty for interfaces
-   */
-  get ownStaticMethodNames() {
-    if (this._ownStaticMethodNames)
-      return this._ownStaticMethodNames;
-    let ownStaticMethodNames = this.getMetadata("rt:Sm");
-    if (!ownStaticMethodNames) {
-      ownStaticMethodNames = Object.getOwnPropertyNames(this.class).filter((x) => !["length", "prototype", "name"].includes(x)).filter((x) => typeof this.class[x] === "function");
-    }
-    return this._ownStaticMethodNames = ownStaticMethodNames;
-  }
-  /**
-   * Retrieve the set of flags for this class/interface. Use this to check for modifiers or other properties
-   * of the class/interface.
-   */
-  get flags() {
-    if (this._flags)
-      return this._flags;
-    return this._flags = new ReflectedFlags(this.getMetadata("rt:f"));
-  }
-  /**
-   * True if the class is marked abstract.
-   */
-  get isAbstract() {
-    return this.flags.isAbstract;
-  }
-  /**
-   * Get the instance method names for this reflected class/interface.
-   */
-  get methodNames() {
-    var _a2, _b2;
-    if (this._methodNames)
-      return this._methodNames;
-    return this._methodNames = superMergeNames(this.ownMethodNames, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.methodNames) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  /**
-   * Get the static property names defined for this reflected class. Always empty for interfaces.
-   */
-  get staticPropertyNames() {
-    var _a2, _b2;
-    if (this._staticPropertyNames)
-      return this._staticPropertyNames;
-    return this._staticPropertyNames = superMergeNames(this.ownStaticPropertyNames, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.staticPropertyNames) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  /**
-   * Retrieve an array of the names of static methods defined on this reflected class.
-   * Always empty for interfaces.
-   */
-  get staticMethodNames() {
-    var _a2, _b2;
-    if (this._staticMethodNames)
-      return this._staticMethodNames;
-    return this._staticMethodNames = superMergeNames(this.ownStaticMethodNames, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.staticMethodNames) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  /**
-   * Retrieve an array of the names of instance properties defined on this class/interface
-   */
-  get propertyNames() {
-    var _a2, _b2;
-    if (this._propertyNames)
-      return this._propertyNames;
-    return this._propertyNames = superMergeNames(this.ownPropertyNames, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.propertyNames) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  /**
-   * Retrieve the set of reflected methods defined directly on this class/interface.
-   */
-  get ownMethods() {
-    if (this._ownMethods)
-      return this._ownMethods;
-    return this._ownMethods = this.ownMethodNames.map((name) => new ReflectedMethod(this, name, false));
-  }
-  /**
-   * Retrieve the set of reflected static properties defined directly on this class. Always empty
-   * for interfaces.
-   */
-  get ownStaticProperties() {
-    if (this._ownStaticProperties)
-      return this._ownStaticProperties;
-    return this._ownStaticProperties = this.staticPropertyNames.map((x) => new ReflectedProperty(this, x, true));
-  }
-  /**
-   * Retrieve the set of reflected static methods defined directly on this class. Always
-   * empty for interfaces.
-   */
-  get ownStaticMethods() {
-    if (this._ownStaticMethods)
-      return this._ownStaticMethods;
-    return this._ownStaticMethods = this.ownStaticMethodNames.map((name) => new ReflectedMethod(this, name, true));
-  }
-  /**
-   * Retrieve the set of reflected instance methods defined on this class/interface.
-   */
-  get methods() {
-    var _a2, _b2;
-    if (this._methods)
-      return this._methods;
-    return this._methods = superMergeElements(this.ownMethods, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.methods) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  /**
-   * Retrieve the set of reflected static properties defined on this class. Always
-   * empty for interfaces.
-   */
-  get staticProperties() {
-    var _a2, _b2;
-    if (this._staticProperties)
-      return this._staticProperties;
-    return this._staticProperties = superMergeElements(this.ownStaticProperties, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.staticProperties) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  /**
-   * Retrieve the set of reflected static methods defined on this class. Always
-   * empty for interfaces
-   */
-  get staticMethods() {
-    var _a2, _b2;
-    if (this._staticMethods)
-      return this._staticMethods;
-    return this._staticMethods = superMergeElements(this.ownStaticMethods, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.staticMethods) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  /**
-   * Retrieve the set of reflected instance properties defined directly on this class/interface
-   */
-  get ownProperties() {
-    if (this._ownProperties)
-      return this._ownProperties;
-    return this._ownProperties = this.ownPropertyNames.map((name) => new ReflectedProperty(this, name, false));
-  }
-  /**
-   * Retrieve the set of reflected instance methods defined on this class/interface
-   */
-  get properties() {
-    var _a2, _b2;
-    if (this._properties)
-      return this._properties;
-    return this._properties = superMergeElements(this.ownProperties, (_b2 = (_a2 = this.super) === null || _a2 === void 0 ? void 0 : _a2.properties) !== null && _b2 !== void 0 ? _b2 : []);
-  }
-  get rawParameterMetadata() {
-    if (this._rawParameterMetadata)
-      return this._rawParameterMetadata;
-    let rawParams = this.getMetadata("rt:p");
-    if (rawParams === void 0 && this.hasMetadata("design:paramtypes")) {
-      let types = this.getMetadata("design:paramtypes");
-      let names = getParameterNames(this.class);
-      rawParams = names.map((n, i) => ({ n, t: /* @__PURE__ */ __name(() => types[i], "t") }));
-    }
-    return this._rawParameterMetadata = rawParams || [];
-  }
-  /**
-   * Retrieve an array of the parameter names for this class's constructor.
-   */
-  get parameterNames() {
-    return this.rawParameterMetadata.map((x) => x.n);
-  }
-  /**
-   * Retrieve an array of the types for the parameters of this class's
-   * constructor.
-   */
-  get parameterTypes() {
-    return this.rawParameterMetadata.map((x) => x.t);
-  }
-  /**
-   * Retrieve the set of reflected parameters for this class's constructor.
-   */
-  get parameters() {
-    if (this._parameters)
-      return this._parameters;
-    return this._parameters = this.rawParameterMetadata.map((x, i) => new ReflectedConstructorParameter(this, x, i));
-  }
-  /**
-   * Get a reflected constructor parameter by name.
-   * @param name
-   * @returns
-   */
-  getParameter(name) {
-    return this.parameters.find((x) => x.name === name);
-  }
-  /**
-   * Get a reflected instance method (declared directly on this class) by name
-   * @param name
-   * @returns
-   */
-  getOwnMethod(name) {
-    return this.ownMethods.find((x) => x.name === name);
-  }
-  /**
-   * Get a reflected instance method by name
-   * @param name
-   * @returns
-   */
-  getMethod(name) {
-    return this.methods.find((x) => x.name === name);
-  }
-  /**
-   * Get a reflected static method by name
-   * @param name
-   * @returns
-   */
-  getStaticMethod(name) {
-    return this.staticMethods.find((x) => x.name === name);
-  }
-  /**
-   * Get a reflected static property (declared directly on this class) by name
-   * @param name
-   * @returns
-   */
-  getOwnStaticProperty(name) {
-    let matchingProp = this.ownStaticProperties.find((x) => x.name === name);
-    if (matchingProp)
-      return matchingProp;
-    if (!this._hasStaticPropertyNameMeta) {
-      if (this._dynamicStaticProperties.has(name))
-        return this._dynamicStaticProperties.get(name);
-      let prop = new ReflectedProperty(this, name, true);
-      this._dynamicStaticProperties.set(name, prop);
-      return prop;
-    }
-  }
-  /**
-   * Get a reflected static property by name
-   * @param name
-   * @returns
-   */
-  getStaticProperty(name) {
-    let matchingProp = this.staticProperties.find((x) => x.name === name);
-    if (matchingProp)
-      return matchingProp;
-    if (!this._hasStaticPropertyNameMeta) {
-      if (this._dynamicStaticProperties.has(name))
-        return this._dynamicStaticProperties.get(name);
-      let prop = new ReflectedProperty(this, name, true);
-      this._dynamicStaticProperties.set(name, prop);
-      return prop;
-    }
-  }
-  /**
-   * Get a reflected instance property (declared directly on this class) by name
-   * @param name
-   * @returns
-   */
-  getOwnProperty(name) {
-    let matchingProp = this.ownProperties.find((x) => x.name === name);
-    if (matchingProp)
-      return matchingProp;
-    if (!this._hasPropertyNamesMeta) {
-      if (this._dynamicProperties.has(name))
-        return this._dynamicProperties.get(name);
-      let prop = new ReflectedProperty(this, name, false);
-      this._dynamicProperties.set(name, prop);
-      return prop;
-    }
-  }
-  /**
-   * Get a reflected instance property by name
-   * @param name
-   * @returns
-   */
-  getProperty(name) {
-    let matchingProp = this.properties.find((x) => x.name === name);
-    if (matchingProp)
-      return matchingProp;
-    if (!this._hasPropertyNamesMeta) {
-      if (this._dynamicProperties.has(name))
-        return this._dynamicProperties.get(name);
-      let prop = new ReflectedProperty(this, name, false);
-      this._dynamicProperties.set(name, prop);
-      return prop;
-    }
-  }
-}, __name(_t, "ReflectedClass"), _t);
-ReflectedClass.reflectedClasses = /* @__PURE__ */ new WeakMap();
-ReflectedClass = ReflectedClass_1 = __decorate([
-  Sealed(),
-  __metadata("design:paramtypes", [Object])
-], ReflectedClass);
-function implementsInterface(value, interfaceType) {
-  if (value === null || value === void 0 || !["object", "function"].includes(typeof value))
-    return false;
-  if (interfaceType === null || interfaceType === void 0)
-    throw new TypeError(`Interface type must not be undefined`);
-  if (typeof value === "object")
-    return ReflectedClass.for(value.constructor).implements(interfaceType);
-  else if (typeof value === "function")
-    return ReflectedClass.for(value).implements(interfaceType);
-}
-__name(implementsInterface, "implementsInterface");
-function matchesShape(value, interfaceType) {
-  if (interfaceType === null || interfaceType === void 0)
-    throw new TypeError(`Interface type must not be undefined`);
-  return ReflectedClass.for(interfaceType).matchesValue(value);
-}
-__name(matchesShape, "matchesShape");
-function reflect(value = NotProvided, callSite) {
-  if (value === NotProvided && !callSite) {
-    throw new Error(`reflect<T>() can only be used when project is built with the typescript-rtti transformer`);
-  }
-  if (!value)
-    throw new TypeError(`Could not reflect on null/undefined`);
-  if (isCallSite(value))
-    return new ReflectedCallSite(value);
-  if (value === NotProvided && isCallSite(callSite))
-    return new ReflectedCallSite(callSite).typeParameters[0];
-  if (!["object", "function"].includes(typeof value)) {
-    return reflect(value.constructor);
-  }
-  let flags = getFlags(value);
-  if (flags.includes(F_FUNCTION))
-    return ReflectedFunction.for(value);
-  if (flags.includes(F_METHOD))
-    return ReflectedMethod.for(value);
-  if (typeof value === "function" && !value.prototype)
-    return ReflectedFunction.for(value);
-  return ReflectedClass.for(value);
-}
-__name(reflect, "reflect");
-const _ReflectedCallSite = class _ReflectedCallSite {
-  constructor(callSite) {
-    this.callSite = callSite;
-  }
-  get parameters() {
-    if (!this._parameters)
-      this._parameters = this.callSite.p.map((x) => ReflectedTypeRef.createFromRtRef(x));
-    return this._parameters;
-  }
-  get typeParameters() {
-    if (!this._typeParameters) {
-      this._typeParameters = this.callSite.tp.map((x) => ReflectedTypeRef.createFromRtRef(x));
-    }
-    return this._typeParameters;
-  }
-};
-__name(_ReflectedCallSite, "ReflectedCallSite");
-let ReflectedCallSite = _ReflectedCallSite;
-function superMergeElements(ownSet, superSet) {
-  return superSet.map((superItem) => {
-    var _a2;
-    return (_a2 = ownSet.find((ownItem) => ownItem.name === superItem.name)) !== null && _a2 !== void 0 ? _a2 : superItem;
-  }).concat(ownSet.filter((ownItem) => !superSet.some((superItem) => ownItem.name === superItem.name)));
-}
-__name(superMergeElements, "superMergeElements");
-function superMergeNames(ownSet, superSet) {
-  return superSet.concat(ownSet.filter((x) => !superSet.includes(x)));
-}
-__name(superMergeNames, "superMergeNames");
-export {
-  ReflectedAnyRef,
-  ReflectedArrayRef,
-  ReflectedCallSite,
-  ReflectedClass,
-  ReflectedClassRef,
-  ReflectedConstructorParameter,
-  ReflectedEnumRef,
-  ReflectedFalseRef,
-  ReflectedFlags,
-  ReflectedFunction,
-  ReflectedFunctionParameter,
-  ReflectedFunctionRef,
-  ReflectedGenericRef,
-  ReflectedInterfaceRef,
-  ReflectedIntersectionRef,
-  ReflectedLiteralRef,
-  ReflectedMappedRef,
-  ReflectedMember,
-  ReflectedMethod,
-  ReflectedMethodParameter,
-  ReflectedNullRef,
-  ReflectedObjectMember,
-  ReflectedObjectRef,
-  ReflectedParameter,
-  ReflectedProperty,
-  ReflectedTrueRef,
-  ReflectedTupleElement,
-  ReflectedTupleRef,
-  ReflectedTypeRef,
-  ReflectedUndefinedRef,
-  ReflectedUnionRef,
-  ReflectedUnknownRef,
-  ReflectedVoidRef,
-  TYPE_REF_KIND_EXPANSION,
-  implementsInterface,
-  isCallSite,
-  matchesShape,
-  reflect,
-  reify
-};
-//# sourceMappingURL=reflect.js.map