@halospv3/hce.shared-config 3.4.6-develop.1 → 3.4.6-develop.2

package/mjs/utils/reflection/inheritance.d.mts

@@ -0,0 +1,173 @@
+import { Increment } from "../GracefulRecursion.mjs";
+import { FunctionLike } from "./FunctionLike.mjs";
+import { PropertyDescriptorMap } from "./PropertyDescriptorMap.mjs";
+import { Integer } from "../miscTypes.mjs";
+
+//#region src/utils/reflection/inheritance.d.ts
+/**
+* The `[[Prototype]]` (i.e. `__proto__`) of any base class.
+* @since 3.0.0
+*/
+type BaseClassProto = (() => object) & {
+  /** @example BaseClass.__proto__.__proto__.toString() === '[object Object]' */["__proto__"]: ObjectConstructor["prototype"] & {
+    ["__proto__"]: null;
+    constructor: ObjectConstructor;
+  };
+  constructor: IBaseClass;
+  length: 0;
+  name: "";
+};
+/**
+* The `[[Prototype]]` of all base classes.
+* @since 3.0.0
+*/
+declare const baseClassProto: BaseClassProto;
+/**
+* [INTERNAL]
+* An interface representing for attaching base class properties to a class type.
+* This kept separate from {@link BaseClass} so it can be used by {@link BaseClassProto}.
+* @since 3.0.0
+*/
+interface IBaseClass {
+  /**
+  * Readable for compatibility reasons, but invisible and non-enumerable in Node.js runtime.
+  * @example BaseClass.__proto__.toString() === 'function () { [native code] }'
+  */
+  ["__proto__"]: BaseClassProto;
+  constructor: FunctionConstructor & {
+    name: "Function";
+  };
+}
+/**
+* Type a class type as a base class.
+* Note: is `Class & ...`
+* @since 3.0.0
+*/
+type BaseClass<Class extends ConstructorConstraint<Class>> = IClass<Class> & IBaseClass;
+/**
+* A type representing any unknown constructor.
+* @since 3.0.0
+*/
+type Constructor_Unknown = abstract new (...args: any[]) => any;
+/**
+* The constraint for constructor types.
+* This is intended for generic type constraints.
+* For conditional return types, use `T extends Constructor<T>` instead.
+* @template T Any newable constructor type
+* @since 3.0.0
+*/
+type ConstructorConstraint<T extends abstract new (...args: ConstructorParameters<T>) => InstanceType<T>> = abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>;
+/**
+* {@link T} is a class constructor or unknown constructor. Else, `never`.
+*
+* Consider using {@link ClassLike} where walking the inheritance chain is necessary.
+* @template [T=Constructor_Unknown]
+* @since 3.0.0
+*/
+type ConstructorLike<T = Constructor_Unknown> = T extends Constructor_Unknown ? T extends ConstructorConstraint<T> ? T & ConstructorConstraint<T> : T & Constructor_Unknown : never;
+/**
+* A type representing unknown {@link ClassLike} types.
+* @since 3.0.0
+*/
+type ClassLike_Unknown = IClass<Constructor_Unknown & WithProto<SuperClassLike | BaseClassProto>>;
+/**
+* A subset of {@link ProtoOrSuperClass} suitable for a class's `[[Prototype]]`
+* @since 3.0.0
+*/
+type SuperClassLike = BaseClass<Constructor_Unknown> | ClassLike_Unknown;
+/**
+* A terrible type. Use it if you must, but prefer other types when possible.
+*
+* Covers most SuperClass/Prototype types.
+* A class that does not extend another class will satisfy {@link BaseClass}.
+*
+* If a type extends {@link ProtoOrSuperClass} and is `null`, you cannot get the
+* type's keys. See {@link ./OwnKeyOf.ts}.
+* @template [T=ReturnType<typeof Reflect.getPrototypeOf>] `null` or an `object`-like type.
+* @since 3.0.0
+*/
+type ProtoOrSuperClass<T extends object | null = ReturnType<typeof Reflect.getPrototypeOf>> = T extends null ? null : T extends object ? T extends ConstructorLike<T> ? T extends ClassLike<T & WithProto<SuperClassLike | BaseClassProto>> ? T extends BaseClass<T> ? ClassLike<BaseClass<T>> : ClassLike<T> : T extends BaseClass<T> ? BaseClass<T> : ConstructorLike<T> : T extends FunctionLike<infer FunctionConstraint> ? T extends FunctionConstraint ? FunctionLike<T> : T & FunctionLike<FunctionConstraint> : T extends object ? T & object : never : never;
+/**
+* The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of any `object`-like type.
+* Not to be confused with the _instance_ `.prototype` chain!
+* ```
+* > util.isDeepStrictEqual(Object.getOwnPropertyDescriptors({}.__proto__), Object.getOwnPropertyDescriptors(Object.prototype))
+* true
+* ```
+* @template Object0 Any type with its `[[Prototype]]` attached as a `__proto__` property. The type of `__proto__` must extend {@link ProtoOrSuperClass}.
+* @template [Limit=16]
+* The maximum depth of recursion.
+* Affects the maximum length of the returned type.\
+* CAUTION: Larger values will severely degrade performance.
+* 50 or more will trigger infinite-or-near-infinite-recursion errors.
+* @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
+* @since 3.0.0
+*/
+type ProtoChainOfObject<Object0 extends WithProto<ProtoOrSuperClass>, Limit extends Integer<number> = 16, CurrentLevel extends Integer<number> = 0> = PropertyDescriptorMap<Object0["__proto__"]> extends PropertyDescriptorMap<ObjectConstructor["prototype"]> ? [Object0] : Object0["__proto__"] extends WithProto<ProtoOrSuperClass> ? CurrentLevel extends Limit ? [Object0] : [Object0, ...ProtoChainOfObject<Object0["__proto__"], Limit, Increment<CurrentLevel>>] : never;
+/**
+* The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of an object (particularly, a class).
+* @template Class Any type with its `[[Prototype]]` attached as a `__proto__` property.
+* The type of `__proto__` must extend {@link SuperClassLike} or {@link BaseClassProto}.
+* @template [Limit=16]
+* The maximum depth of recursion.
+* Affects the maximum length of the returned type.\
+* CAUTION: Larger values will severely degrade performance.
+* 50 or more will trigger infinite-or-near-infinite-recursion errors.
+* @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
+* @since 3.0.0
+*/
+type ProtoChainOfClass<Class extends WithProto<SuperClassLike | BaseClassProto>, Limit extends Integer<number> = 16, CurrentLevel extends Integer<number> = 0> = Class["__proto__"] extends BaseClassProto ? [Class] : Class["__proto__"] extends SuperClassLike ? CurrentLevel extends Limit ? [Class] : [Class, ...ProtoChainOfClass<Class["__proto__"], Limit, Increment<CurrentLevel>>] : never;
+/**
+* The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of a class instance.
+* @template Class A constructor type with its `[[Prototype]]` attached as a `__proto__` property.
+* @template [Limit=16]
+* The maximum depth of recursion.
+* Affects the maximum length of the returned type.\
+* CAUTION: Larger values will severely degrade performance.
+* 50 or more will trigger infinite-or-near-infinite-recursion errors.
+* @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
+* @since 3.0.0
+*/
+type ProtoChainOfClassInstance<Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>, Limit extends Integer<number> = 16, CurrentLevel extends Integer<number> = 0> = Class["__proto__"] extends BaseClassProto ? [InstanceType<Class>] : Class["__proto__"] extends SuperClassLike ? CurrentLevel extends Limit ? [InstanceType<Class>] : [InstanceType<Class>, ...ProtoChainOfClassInstance<Class["__proto__"], Limit, Increment<CurrentLevel>>] : never;
+/**
+* Augment a class type to expose properties not exposed by TypeScript by default.
+* Note: is `Class & ...`
+* @template Class The typeof any class. If the type is unknown, wrap it with {@link ConstructorConstraint}.
+* @since 3.0.0
+*/
+type IClass<Class extends ConstructorConstraint<Class>> = Class & {
+  prototype: InstanceType<Class>;
+  name: ConstructorConstraint<Class>["name"];
+  length: ConstructorConstraint<Class>["length"];
+};
+/**
+* A more fleshed-out Class type.
+*
+* Note: is `Class & ...`
+*
+* In addition to the Constructor constraint, this type...
+* - Sets the type of the immediate superclass.
+* - Sets `prototype` to {@link InstanceType}
+* @template Class The `typeof MyClass`. If this class extends a class, pass `typeof MySuperClass` to the generic argument {@link Class}.
+* @example
+* type Class_MyClass = ClassLike<typeof MyClass & WithProto<BaseClass<typeof MyBaseClass>>;
+* @since 3.0.0
+*/
+type ClassLike<Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>> = Class extends BaseClass<Class> ? Class : Class["__proto__"] extends BaseClassProto ? BaseClass<Class> : Class["__proto__"] extends ConstructorLike<Class["__proto__"]> ? IClass<Class> & WithProto<ConstructorLike<Class["__proto__"]>> : IClass<Class>;
+/**
+* If {@link T} is a class or constructor, {@link InstanceType}<{@link T}>. Else, {@link T}.
+* @template T `null` or any `object`-like type.
+* @since 3.0.0
+*/
+type InstanceTypeOrSelf<T extends object | null> = T extends ConstructorLike ? T extends ConstructorLike<T> ? InstanceType<T> : T : T;
+/**
+* Interface for attaching a `__proto__` to an object e.g. `T0 & WithProto<T1>`
+* @template __proto__ the type of the an object's `[[Prototype]]`.
+* @since 3.0.0
+*/
+interface WithProto<__proto__ extends ProtoOrSuperClass> {
+  ["__proto__"]: __proto__;
+}
+//#endregion
+export { BaseClass, BaseClassProto, ClassLike, ClassLike_Unknown, ConstructorConstraint, ConstructorLike, Constructor_Unknown, IClass, InstanceTypeOrSelf, ProtoChainOfClass, ProtoChainOfClassInstance, ProtoChainOfObject, ProtoOrSuperClass, SuperClassLike, WithProto, baseClassProto };
+//# sourceMappingURL=inheritance.d.mts.map

package/mjs/utils/reflection/inheritance.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inheritance.d.mts","names":[],"sources":["../../../src/utils/reflection/inheritance.ts"],"mappings":"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"}

package/mjs/utils/reflection/inheritance.mjs

@@ -1,148 +1,2 @@
-import { getPrototypeOf } from './getPrototypeOf.mjs';
-
-/**
- * The `[[Prototype]]` (i.e. `__proto__`) of any base class.
- * @since 3.0.0
- */
-
-/**
- * The `[[Prototype]]` of all base classes.
- * @since 3.0.0
- */
-const baseClassProto = getPrototypeOf(Object);
-
-/**
- * [INTERNAL]
- * An interface representing for attaching base class properties to a class type.
- * This kept separate from {@link BaseClass} so it can be used by {@link BaseClassProto}.
- * @since 3.0.0
- */
-
-/**
- * Type a class type as a base class.
- * Note: is `Class & ...`
- * @since 3.0.0
- */
-
-/**
- * A type representing any unknown constructor.
- * @since 3.0.0
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-/**
- * The constraint for constructor types.
- * This is intended for generic type constraints.
- * For conditional return types, use `T extends Constructor<T>` instead.
- * @template T Any newable constructor type
- * @since 3.0.0
- */
-
-/**
- * {@link T} is a class constructor or unknown constructor. Else, `never`.
- *
- * Consider using {@link ClassLike} where walking the inheritance chain is necessary.
- * @template [T=Constructor_Unknown]
- * @since 3.0.0
- */
-
-/**
- * A type representing unknown {@link ClassLike} types.
- * @since 3.0.0
- */
-
-/**
- * A subset of {@link ProtoOrSuperClass} suitable for a class's `[[Prototype]]`
- * @since 3.0.0
- */
-
-/**
- * A terrible type. Use it if you must, but prefer other types when possible.
- *
- * Covers most SuperClass/Prototype types.
- * A class that does not extend another class will satisfy {@link BaseClass}.
- *
- * If a type extends {@link ProtoOrSuperClass} and is `null`, you cannot get the
- * type's keys. See {@link ./OwnKeyOf.ts}.
- * @template [T=ReturnType<typeof Reflect.getPrototypeOf>] `null` or an `object`-like type.
- * @since 3.0.0
- */
-
-/**
- * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of any `object`-like type.
- * Not to be confused with the _instance_ `.prototype` chain!
- * ```
- * > util.isDeepStrictEqual(Object.getOwnPropertyDescriptors({}.__proto__), Object.getOwnPropertyDescriptors(Object.prototype))
- * true
- * ```
- * @template Object0 Any type with its `[[Prototype]]` attached as a `__proto__` property. The type of `__proto__` must extend {@link ProtoOrSuperClass}.
- * @template [Limit=16]
- * The maximum depth of recursion.
- * Affects the maximum length of the returned type.\
- * CAUTION: Larger values will severely degrade performance.
- * 50 or more will trigger infinite-or-near-infinite-recursion errors.
- * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
- * @since 3.0.0
- */
-
-/**
- * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of an object (particularly, a class).
- * @template Class Any type with its `[[Prototype]]` attached as a `__proto__` property.
- * The type of `__proto__` must extend {@link SuperClassLike} or {@link BaseClassProto}.
- * @template [Limit=16]
- * The maximum depth of recursion.
- * Affects the maximum length of the returned type.\
- * CAUTION: Larger values will severely degrade performance.
- * 50 or more will trigger infinite-or-near-infinite-recursion errors.
- * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
- * @since 3.0.0
- */
-
-/**
- * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of a class instance.
- * @template Class A constructor type with its `[[Prototype]]` attached as a `__proto__` property.
- * @template [Limit=16]
- * The maximum depth of recursion.
- * Affects the maximum length of the returned type.\
- * CAUTION: Larger values will severely degrade performance.
- * 50 or more will trigger infinite-or-near-infinite-recursion errors.
- * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
- * @since 3.0.0
- */
-
-/**
- * Augment a class type to expose properties not exposed by TypeScript by default.
- * Note: is `Class & ...`
- * @template Class The typeof any class. If the type is unknown, wrap it with {@link ConstructorConstraint}.
- * @since 3.0.0
- */
-// defined as `type` because interfaces cannot extend their generic parameters
-
-/**
- * A more fleshed-out Class type.
- *
- * Note: is `Class & ...`
- *
- * In addition to the Constructor constraint, this type...
- * - Sets the type of the immediate superclass.
- * - Sets `prototype` to {@link InstanceType}
- * @template Class The `typeof MyClass`. If this class extends a class, pass `typeof MySuperClass` to the generic argument {@link Class}.
- * @example
- * type Class_MyClass = ClassLike<typeof MyClass & WithProto<BaseClass<typeof MyBaseClass>>;
- * @since 3.0.0
- */
-
-/**
- * If {@link T} is a class or constructor, {@link InstanceType}<{@link T}>. Else, {@link T}.
- * @template T `null` or any `object`-like type.
- * @since 3.0.0
- */
-
-/**
- * Interface for attaching a `__proto__` to an object e.g. `T0 & WithProto<T1>`
- * @template __proto__ the type of the an object's `[[Prototype]]`.
- * @since 3.0.0
- */
-
-export { baseClassProto };
-//# sourceMappingURL=inheritance.mjs.map
+import{getPrototypeOf as e}from"./getPrototypeOf.mjs";const t=e(Object);export{t as baseClassProto};
+//# sourceMappingURL=inheritance.mjs.map

package/mjs/utils/reflection/inheritance.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"inheritance.mjs","sources":["../../../src/utils/reflection/inheritance.ts"],"names":[],"mappings":";;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACY,MAAC,cAAc,GAAG,cAAc,CAAC,MAAM;;AAEnD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;;"}
+{"version":3,"file":"inheritance.mjs","names":[],"sources":["../../../src/utils/reflection/inheritance.ts"],"sourcesContent":["import type { Increment } from '../GracefulRecursion.d.ts';\nimport type { Integer } from '../miscTypes.ts';\nimport type { FunctionLike } from './FunctionLike.d.ts';\nimport { getPrototypeOf } from './getPrototypeOf.ts';\nimport type { PropertyDescriptorMap } from './PropertyDescriptorMap.d.ts';\n\n/**\n * The `[[Prototype]]` (i.e. `__proto__`) of any base class.\n * @since 3.0.0\n */\nexport type BaseClassProto = (() => object) & {\n  /** @example BaseClass.__proto__.__proto__.toString() === '[object Object]' */\n  ['__proto__']: ObjectConstructor['prototype'] & {\n    ['__proto__']: null;\n    constructor: ObjectConstructor;\n  };\n  constructor: IBaseClass;\n  length: 0;\n  name: '';\n};\n\n/**\n * The `[[Prototype]]` of all base classes.\n * @since 3.0.0\n */\nexport const baseClassProto: BaseClassProto = getPrototypeOf(Object as BaseClass<ObjectConstructor>);\n\n/**\n * [INTERNAL]\n * An interface representing for attaching base class properties to a class type.\n * This kept separate from {@link BaseClass} so it can be used by {@link BaseClassProto}.\n * @since 3.0.0\n */\ninterface IBaseClass {\n  /**\n   * Readable for compatibility reasons, but invisible and non-enumerable in Node.js runtime.\n   * @example BaseClass.__proto__.toString() === 'function () { [native code] }'\n   */\n  ['__proto__']: BaseClassProto;\n\n  constructor: FunctionConstructor & { name: 'Function' };\n}\n\n/**\n * Type a class type as a base class.\n * Note: is `Class & ...`\n * @since 3.0.0\n */\nexport type BaseClass<Class extends ConstructorConstraint<Class>>\n  = IClass<Class> & IBaseClass;\n\n/**\n * A type representing any unknown constructor.\n * @since 3.0.0\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Constructor_Unknown = abstract new (...args: any[]) => any;\n\n/**\n * The constraint for constructor types.\n * This is intended for generic type constraints.\n * For conditional return types, use `T extends Constructor<T>` instead.\n * @template T Any newable constructor type\n * @since 3.0.0\n */\nexport type ConstructorConstraint<T extends abstract new (...args: ConstructorParameters<T>) => InstanceType<T>> = abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>;\n\n/**\n * {@link T} is a class constructor or unknown constructor. Else, `never`.\n *\n * Consider using {@link ClassLike} where walking the inheritance chain is necessary.\n * @template [T=Constructor_Unknown]\n * @since 3.0.0\n */\nexport type ConstructorLike<T = Constructor_Unknown>\n  = T extends Constructor_Unknown\n    ? T extends ConstructorConstraint<T>\n      ? T & ConstructorConstraint<T>\n      : T & Constructor_Unknown\n    : never;\n\n/**\n * A type representing unknown {@link ClassLike} types.\n * @since 3.0.0\n */\nexport type ClassLike_Unknown\n  = IClass<\n    Constructor_Unknown\n    & WithProto<SuperClassLike | BaseClassProto>\n  >;\n\n/**\n * A subset of {@link ProtoOrSuperClass} suitable for a class's `[[Prototype]]`\n * @since 3.0.0\n */\nexport type SuperClassLike = BaseClass<Constructor_Unknown> | ClassLike_Unknown;\n\n/**\n * A terrible type. Use it if you must, but prefer other types when possible.\n *\n * Covers most SuperClass/Prototype types.\n * A class that does not extend another class will satisfy {@link BaseClass}.\n *\n * If a type extends {@link ProtoOrSuperClass} and is `null`, you cannot get the\n * type's keys. See {@link ./OwnKeyOf.ts}.\n * @template [T=ReturnType<typeof Reflect.getPrototypeOf>] `null` or an `object`-like type.\n * @since 3.0.0\n */\nexport type ProtoOrSuperClass<T extends object | null = ReturnType<typeof Reflect.getPrototypeOf>>\n  = T extends null ? null\n    : T extends object\n      ? T extends ConstructorLike<T>\n        ? T extends ClassLike<T & WithProto<SuperClassLike | BaseClassProto>>\n          ? T extends BaseClass<T> ? ClassLike<BaseClass<T>>\n            : ClassLike<T>\n          : T extends BaseClass<T>\n            ? BaseClass<T>\n            : ConstructorLike<T>\n        : T extends FunctionLike<infer FunctionConstraint>\n          ? T extends FunctionConstraint\n            ? FunctionLike<T>\n            : T & FunctionLike<FunctionConstraint>\n          : T extends object\n            ? T & object\n            : never\n      : never;\n\n/**\n * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of any `object`-like type.\n * Not to be confused with the _instance_ `.prototype` chain!\n * ```\n * > util.isDeepStrictEqual(Object.getOwnPropertyDescriptors({}.__proto__), Object.getOwnPropertyDescriptors(Object.prototype))\n * true\n * ```\n * @template Object0 Any type with its `[[Prototype]]` attached as a `__proto__` property. The type of `__proto__` must extend {@link ProtoOrSuperClass}.\n * @template [Limit=16]\n * The maximum depth of recursion.\n * Affects the maximum length of the returned type.\\\n * CAUTION: Larger values will severely degrade performance.\n * 50 or more will trigger infinite-or-near-infinite-recursion errors.\n * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.\n * @since 3.0.0\n */\nexport type ProtoChainOfObject<\n  Object0 extends WithProto<ProtoOrSuperClass>,\n  Limit extends Integer<number> = 16,\n  CurrentLevel extends Integer<number> = 0,\n> = PropertyDescriptorMap<Object0['__proto__']> extends PropertyDescriptorMap<ObjectConstructor['prototype']>\n  ? [Object0]\n  : Object0['__proto__'] extends WithProto<ProtoOrSuperClass>\n    ? CurrentLevel extends Limit ? [Object0]\n      : [\n          Object0,\n          ...ProtoChainOfObject<Object0['__proto__'], Limit, Increment<CurrentLevel>>,\n        ]\n    : never;\n\n/**\n * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of an object (particularly, a class).\n * @template Class Any type with its `[[Prototype]]` attached as a `__proto__` property.\n * The type of `__proto__` must extend {@link SuperClassLike} or {@link BaseClassProto}.\n * @template [Limit=16]\n * The maximum depth of recursion.\n * Affects the maximum length of the returned type.\\\n * CAUTION: Larger values will severely degrade performance.\n * 50 or more will trigger infinite-or-near-infinite-recursion errors.\n * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.\n * @since 3.0.0\n */\nexport type ProtoChainOfClass<\n  Class extends WithProto<SuperClassLike | BaseClassProto>,\n  Limit extends Integer<number> = 16,\n  CurrentLevel extends Integer<number> = 0,\n> = Class['__proto__'] extends BaseClassProto ? [Class]\n  : Class['__proto__'] extends SuperClassLike\n    ? CurrentLevel extends Limit ? [Class]\n      : [\n          Class,\n          ...ProtoChainOfClass<Class['__proto__'], Limit, Increment<CurrentLevel>>,\n        ]\n    : never;\n\n/**\n * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of a class instance.\n * @template Class A constructor type with its `[[Prototype]]` attached as a `__proto__` property.\n * @template [Limit=16]\n * The maximum depth of recursion.\n * Affects the maximum length of the returned type.\\\n * CAUTION: Larger values will severely degrade performance.\n * 50 or more will trigger infinite-or-near-infinite-recursion errors.\n * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.\n * @since 3.0.0\n */\nexport type ProtoChainOfClassInstance<\n  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,\n  Limit extends Integer<number> = 16,\n  CurrentLevel extends Integer<number> = 0,\n> = Class['__proto__'] extends BaseClassProto ? [InstanceType<Class>]\n  : Class['__proto__'] extends SuperClassLike\n    ? CurrentLevel extends Limit ? [InstanceType<Class>]\n      : [\n          InstanceType<Class>,\n          ...ProtoChainOfClassInstance<Class['__proto__'], Limit, Increment<CurrentLevel>>,\n        ]\n    : never;\n\n/**\n * Augment a class type to expose properties not exposed by TypeScript by default.\n * Note: is `Class & ...`\n * @template Class The typeof any class. If the type is unknown, wrap it with {@link ConstructorConstraint}.\n * @since 3.0.0\n */\n// defined as `type` because interfaces cannot extend their generic parameters\nexport type IClass<Class extends ConstructorConstraint<Class>>\n  = Class\n    & {\n      prototype: InstanceType<Class>;\n      name: ConstructorConstraint<Class>['name'];\n      length: ConstructorConstraint<Class>['length'];\n    };\n\n/**\n * A more fleshed-out Class type.\n *\n * Note: is `Class & ...`\n *\n * In addition to the Constructor constraint, this type...\n * - Sets the type of the immediate superclass.\n * - Sets `prototype` to {@link InstanceType}\n * @template Class The `typeof MyClass`. If this class extends a class, pass `typeof MySuperClass` to the generic argument {@link Class}.\n * @example\n * type Class_MyClass = ClassLike<typeof MyClass & WithProto<BaseClass<typeof MyBaseClass>>;\n * @since 3.0.0\n */\nexport type ClassLike<\n  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,\n> = Class extends BaseClass<Class> ? Class\n  : Class['__proto__'] extends BaseClassProto ? BaseClass<Class>\n    : Class['__proto__'] extends ConstructorLike<Class['__proto__']>\n      ? IClass<Class> & WithProto<ConstructorLike<Class['__proto__']>>\n      // Here, __proto__ is retained via Class\n      : IClass<Class>;\n\n/**\n * If {@link T} is a class or constructor, {@link InstanceType}<{@link T}>. Else, {@link T}.\n * @template T `null` or any `object`-like type.\n * @since 3.0.0\n */\nexport type InstanceTypeOrSelf<T extends object | null> = T extends ConstructorLike\n  ? T extends ConstructorLike<T>\n    ? InstanceType<T>\n    : T\n  : T;\n\n/**\n * Interface for attaching a `__proto__` to an object e.g. `T0 & WithProto<T1>`\n * @template __proto__ the type of the an object's `[[Prototype]]`.\n * @since 3.0.0\n */\nexport interface WithProto<__proto__ extends ProtoOrSuperClass> {\n  ['__proto__']: __proto__;\n}\n"],"mappings":"sDAyBA,MAAa,EAAiC,EAAe,OAAuC"}

package/mjs/utils/reflection/isConstructor.d.mts

@@ -0,0 +1,20 @@
+//#region src/utils/reflection/isConstructor.d.ts
+/**
+* A very jank function to determine if an object can be the target of Reflect.construct.
+* Unfortunately, many functions have a constructor in their prototype. These
+* functions are treated like classes due to JavaScript's poor distinction between
+* classes and functions.\
+* Typescript can enforce "new" keyword usage, but overriding the type
+* allows you to `new isConstructor()` despite this function not intended to be
+* used with the `new` keyword.
+* #### NOTE: Only works when targeting ES6/ES2015 or later.
+* > If your project or a dependent project is compiled to < ES6, this function will always return `false`; classes and constructors were introduced in ES6/ES2015.
+* @param obj Anything.
+* @returns `true` if the obj is a constructor. Else, `false`.
+* @since 3.0.0
+* @see https://stackoverflow.com/a/49510834
+*/
+declare function isConstructor(obj: unknown): obj is abstract new (...args: any[]) => any;
+//#endregion
+export { isConstructor };
+//# sourceMappingURL=isConstructor.d.mts.map

package/mjs/utils/reflection/isConstructor.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isConstructor.d.mts","names":[],"sources":["../../../src/utils/reflection/isConstructor.ts"],"mappings":";;AAgBA;;;;;;;;;;;;;;iBAAgB,aAAA,CAAc,GAAA,YAAe,GAAA,qBAAwB,IAAA"}

package/mjs/utils/reflection/isConstructor.mjs

@@ -1,63 +1,2 @@
-/**
- * A very jank function to determine if an object can be the target of Reflect.construct.
- * Unfortunately, many functions have a constructor in their prototype. These
- * functions are treated like classes due to JavaScript's poor distinction between
- * classes and functions.\
- * Typescript can enforce "new" keyword usage, but overriding the type
- * allows you to `new isConstructor()` despite this function not intended to be
- * used with the `new` keyword.
- * #### NOTE: Only works when targeting ES6/ES2015 or later.
- * > If your project or a dependent project is compiled to < ES6, this function will always return `false`; classes and constructors were introduced in ES6/ES2015.
- * @param obj Anything.
- * @returns `true` if the obj is a constructor. Else, `false`.
- * @since 3.0.0
- * @see https://stackoverflow.com/a/49510834
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isConstructor(obj) {
-  // Method 0 - filter
-  if (typeof obj !== 'function') return false;
-
-  // Method 1
-  // statically-defined class
-  if (/^class\s/.test(obj.toString())) return true;
-
-  /* Method 2
-   * > class class_ {}; function func(){}
-   * undefined
-   * > class_.prototype.constructor.name === class_.name
-   * true
-   * > func.prototype?.constructor?.name === func.name
-   * false
-   * typeof String.prototype ==='object'
-   * > true
-   * typeof Function.prototype === 'object';
-   * > false
-   * typeof Function.prototype
-   * > 'function'
-   */
-  const prototype = obj.prototype;
-  if ((typeof prototype === 'object' || typeof prototype === 'function') && prototype !== null && 'constructor' in prototype && typeof prototype.constructor === 'function') {
-    const _ctor = prototype.constructor;
-    const _name = Reflect.getOwnPropertyDescriptor(_ctor, 'name');
-    // short-circuit if `obj.prototype.constructor` is a function, but not a constructor. Return false.
-    return _ctor === obj && _name?.writable === false && _name.enumerable === false && _name.configurable === true;
-  }
-
-  // Short-circuit
-  // Method 3 catches exceptions when !isConstructor. When debugging, that's annoying.
-  return false;
-
-  // Method 3
-  // isConstructable (See https://stackoverflow.com/a/49510834)
-  // try {
-  //   // @ts-expect-error ts(2351): Type 'Function' has no construct signatures.
-  //   new new Proxy(obj, { construct: () => ({}) })()
-  //   return true
-  // }
-  // catch {
-  //   return false
-  // }
-}
-export { isConstructor };
-//# sourceMappingURL=isConstructor.mjs.map
+function e(e){if(typeof e!=`function`)return!1;if(/^class\s/.test(e.toString()))return!0;let t=e.prototype;if((typeof t==`object`||typeof t==`function`)&&t!==null&&`constructor`in t&&typeof t.constructor==`function`){let n=t.constructor,r=Reflect.getOwnPropertyDescriptor(n,`name`);return n===e&&r?.writable===!1&&r.enumerable===!1&&r.configurable===!0}return!1}export{e as isConstructor};
+//# sourceMappingURL=isConstructor.mjs.map

package/mjs/utils/reflection/isConstructor.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"isConstructor.mjs","sources":["../../../src/utils/reflection/isConstructor.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,aAAa,CAAC,GAAG,EAAE;AACnC;AACA,EAAE,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,OAAO,KAAK;;AAE7C;AACA;AACA,EAAE,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,IAAI;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,MAAM,SAAS,GAAG,GAAG,CAAC,SAAS;AACjC,EAAE,IAAI,CAAC,OAAO,SAAS,KAAK,QAAQ,IAAI,OAAO,SAAS,KAAK,UAAU,KAAK,SAAS,KAAK,IAAI,IAAI,aAAa,IAAI,SAAS,IAAI,OAAO,SAAS,CAAC,WAAW,KAAK,UAAU,EAAE;AAC7K,IAAI,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW;AACvC,IAAI,MAAM,KAAK,GAAG,OAAO,CAAC,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC;AACjE;AACA,IAAI,OAAO,KAAK,KAAK,GAAG,IAAI,KAAK,EAAE,QAAQ,KAAK,KAAK,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK,IAAI,KAAK,CAAC,YAAY,KAAK,IAAI;AAClH,EAAE;;AAEF;AACA;AACA,EAAE,OAAO,KAAK;;AAEd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;"}
+{"version":3,"file":"isConstructor.mjs","names":[],"sources":["../../../src/utils/reflection/isConstructor.ts"],"sourcesContent":["/**\n * A very jank function to determine if an object can be the target of Reflect.construct.\n * Unfortunately, many functions have a constructor in their prototype. These\n * functions are treated like classes due to JavaScript's poor distinction between\n * classes and functions.\\\n * Typescript can enforce \"new\" keyword usage, but overriding the type\n * allows you to `new isConstructor()` despite this function not intended to be\n * used with the `new` keyword.\n * #### NOTE: Only works when targeting ES6/ES2015 or later.\n * > If your project or a dependent project is compiled to < ES6, this function will always return `false`; classes and constructors were introduced in ES6/ES2015.\n * @param obj Anything.\n * @returns `true` if the obj is a constructor. Else, `false`.\n * @since 3.0.0\n * @see https://stackoverflow.com/a/49510834\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isConstructor(obj: unknown): obj is abstract new (...args: any[]) => any {\n  // Method 0 - filter\n  if (typeof obj !== 'function')\n    return false;\n\n  // Method 1\n  // statically-defined class\n  if (/^class\\s/.test(obj.toString()))\n    return true;\n\n  /* Method 2\n   * > class class_ {}; function func(){}\n   * undefined\n   * > class_.prototype.constructor.name === class_.name\n   * true\n   * > func.prototype?.constructor?.name === func.name\n   * false\n   * typeof String.prototype ==='object'\n   * > true\n   * typeof Function.prototype === 'object';\n   * > false\n   * typeof Function.prototype\n   * > 'function'\n   */\n  const prototype: unknown = obj.prototype;\n  if ((typeof prototype === 'object' || typeof prototype === 'function')\n    && prototype !== null\n    && 'constructor' in prototype\n    && typeof prototype.constructor === 'function') {\n    const _ctor = prototype.constructor as (new (...arguments_: unknown[]) => unknown);\n    const _name = Reflect.getOwnPropertyDescriptor(\n      _ctor,\n      'name',\n    );\n    // short-circuit if `obj.prototype.constructor` is a function, but not a constructor. Return false.\n    return (\n      _ctor === obj\n      && _name?.writable === false\n      && _name.enumerable === false\n      && _name.configurable === true\n    );\n  }\n\n  // Short-circuit\n  // Method 3 catches exceptions when !isConstructor. When debugging, that's annoying.\n  return false;\n\n  // Method 3\n  // isConstructable (See https://stackoverflow.com/a/49510834)\n  // try {\n  //   // @ts-expect-error ts(2351): Type 'Function' has no construct signatures.\n  //   new new Proxy(obj, { construct: () => ({}) })()\n  //   return true\n  // }\n  // catch {\n  //   return false\n  // }\n}\n"],"mappings":"AAgBA,SAAgB,EAAc,EAA2D,CAEvF,GAAI,OAAO,GAAQ,WACjB,MAAO,GAIT,GAAI,WAAW,KAAK,EAAI,UAAU,CAAC,CACjC,MAAO,GAgBT,IAAM,EAAqB,EAAI,UAC/B,IAAK,OAAO,GAAc,UAAY,OAAO,GAAc,aACtD,IAAc,MACd,gBAAiB,GACjB,OAAO,EAAU,aAAgB,WAAY,CAChD,IAAM,EAAQ,EAAU,YAClB,EAAQ,QAAQ,yBACpB,EACA,OACD,CAED,OACE,IAAU,GACP,GAAO,WAAa,IACpB,EAAM,aAAe,IACrB,EAAM,eAAiB,GAM9B,MAAO"}

package/mjs/utils/reflection/isGetterDescriptor.d.mts

@@ -0,0 +1,13 @@
+import { GetterDescriptor } from "./GetterDescriptor.mjs";
+
+//#region src/utils/reflection/isGetterDescriptor.d.ts
+/**
+* A function for inferring a {@link TypedPropertyDescriptor} is a {@link GetterDescriptor}
+* @param propertyDescriptor The {@link TypedPropertyDescriptor} to inspect.
+* @returns `true` if {@link propertyDescriptor} describes a getter. Else, `false.
+* @since 3.0.0
+*/
+declare function isGetterDescriptor<T>(propertyDescriptor: TypedPropertyDescriptor<T>): propertyDescriptor is GetterDescriptor<T>;
+//#endregion
+export { isGetterDescriptor };
+//# sourceMappingURL=isGetterDescriptor.d.mts.map

package/mjs/utils/reflection/isGetterDescriptor.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGetterDescriptor.d.mts","names":[],"sources":["../../../src/utils/reflection/isGetterDescriptor.ts"],"mappings":";;;;;AAQA;;;;iBAAgB,kBAAA,GAAA,CAAsB,kBAAA,EAAoB,uBAAA,CAAwB,CAAA,IAAK,kBAAA,IAAsB,gBAAA,CAAiB,CAAA"}

package/mjs/utils/reflection/isGetterDescriptor.mjs

@@ -1,12 +1,2 @@
-/**
- * A function for inferring a {@link TypedPropertyDescriptor} is a {@link GetterDescriptor}
- * @param propertyDescriptor The {@link TypedPropertyDescriptor} to inspect.
- * @returns `true` if {@link propertyDescriptor} describes a getter. Else, `false.
- * @since 3.0.0
- */
-function isGetterDescriptor(propertyDescriptor) {
-  return typeof propertyDescriptor.get === 'function';
-}
-;
-export { isGetterDescriptor };
-//# sourceMappingURL=isGetterDescriptor.mjs.map
+function e(e){return typeof e.get==`function`}export{e as isGetterDescriptor};
+//# sourceMappingURL=isGetterDescriptor.mjs.map

package/mjs/utils/reflection/isGetterDescriptor.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"isGetterDescriptor.mjs","sources":["../../../src/utils/reflection/isGetterDescriptor.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,kBAAkB,CAAC,kBAAkB,EAAE;AACvD,EAAE,OAAO,OAAO,kBAAkB,CAAC,GAAG,KAAK,UAAU;AACrD;AACA;;;;"}
+{"version":3,"file":"isGetterDescriptor.mjs","names":[],"sources":["../../../src/utils/reflection/isGetterDescriptor.ts"],"sourcesContent":["import type { GetterDescriptor } from './GetterDescriptor.d.ts';\n\n/**\n * A function for inferring a {@link TypedPropertyDescriptor} is a {@link GetterDescriptor}\n * @param propertyDescriptor The {@link TypedPropertyDescriptor} to inspect.\n * @returns `true` if {@link propertyDescriptor} describes a getter. Else, `false.\n * @since 3.0.0\n */\nexport function isGetterDescriptor<T>(propertyDescriptor: TypedPropertyDescriptor<T>): propertyDescriptor is GetterDescriptor<T> {\n  return typeof propertyDescriptor.get === 'function';\n};\n"],"mappings":"AAQA,SAAgB,EAAsB,EAA2F,CAC/H,OAAO,OAAO,EAAmB,KAAQ"}

package/mjs/utils/reflection/listOwnGetters.d.mts

@@ -0,0 +1,29 @@
+import { InstanceOrStatic } from "../miscTypes.mjs";
+import { BaseClassProto, ClassLike, ConstructorConstraint, InstanceTypeOrSelf, SuperClassLike, WithProto } from "./inheritance.mjs";
+
+//#region src/utils/reflection/listOwnGetters.d.ts
+/**
+* Description placeholder
+* @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class
+* @template {InstanceOrStatic} _InstanceOrStatic
+* @since 3.0.0
+*/
+type OwnGetters<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>, _InstanceOrStatic extends InstanceOrStatic> = [_InstanceOrStatic] extends ["Instance"] ? Exclude<(Class["__proto__"] extends BaseClassProto ? null : InstanceTypeOrSelf<Class["__proto__"]>) extends null ? keyof InstanceType<Class> : Exclude<keyof InstanceType<Class>, keyof (Class["__proto__"] extends BaseClassProto ? null : InstanceTypeOrSelf<Class["__proto__"]>)>, "__proto__">[] : [_InstanceOrStatic] extends ["Static"] ? Exclude<Class["__proto__"] extends null ? keyof Class : Exclude<keyof Class, keyof Class["__proto__"]>, "__proto__">[] : never;
+/**
+* # !WARNING!
+* > If you don't specify the Class's SuperClass (or `BaseClassProto`) via WithProto, the return type will wrongly include inherited property names! This is a design limitation of TypeScript.
+*
+* Returns the names of the instantiated (or static), noninherited getters derived from the
+* given prototype or prototype of the given object.
+* @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class
+* @template {InstanceOrStatic} _InstanceOrStatic 'Instance' or 'Static'. Determines the return type.
+* @param classDefinition Any class cast to ClassLike
+* @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
+* @since 3.0.0
+* @returns
+* An array of names of getters that were not inherited from a parent class. If {@link classDefinition} is a class instance, the names of instanced getters are returned. Otherwise, the names of static getters are returned;
+*/
+declare function listOwnGetters<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>, _InstanceOrStatic extends InstanceOrStatic>(classDefinition: Class, instanceOrStatic: Extract<_InstanceOrStatic, InstanceOrStatic>): OwnGetters<Class, _InstanceOrStatic>;
+//#endregion
+export { listOwnGetters };
+//# sourceMappingURL=listOwnGetters.d.mts.map

package/mjs/utils/reflection/listOwnGetters.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listOwnGetters.d.mts","names":[],"sources":["../../../src/utils/reflection/listOwnGetters.ts"],"mappings":";;;;;;AAUO;;;;KAUF,UAAA,eACW,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,8BACxD,gBAAA,KAEvB,iBAAA,yBACC,OAAA,EACC,KAAA,sBAA2B,cAAA,UAAwB,kBAAA,CAAmB,KAAA,qCAC7D,YAAA,CAAa,KAAA,IACnB,OAAA,OACM,YAAA,CAAa,KAAA,UACZ,KAAA,sBAA2B,cAAA,UAAwB,kBAAA,CAAmB,KAAA,oCAIhF,iBAAA,uBACG,OAAA,CACA,KAAA,mCAAwC,KAAA,GAAQ,OAAA,OAAc,KAAA,QAAa,KAAA;;;;;;;;;;;;;;;iBAmBrE,cAAA,eACA,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,8BACxD,gBAAA,CAAA,CAE1B,eAAA,EAAiB,KAAA,EACjB,gBAAA,EAAkB,OAAA,CAAQ,iBAAA,EAAmB,gBAAA,IAC5C,UAAA,CAAW,KAAA,EAAO,iBAAA"}

package/mjs/utils/reflection/listOwnGetters.mjs

@@ -1,39 +1,2 @@
-import { filterForGetters } from './filterForGetters.mjs';
-import { getOwnPropertyDescriptors } from './getOwnPropertyDescriptors.mjs';
-
-/**
- * Description placeholder
- * @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class
- * @template {InstanceOrStatic} _InstanceOrStatic
- * @since 3.0.0
- */
-
-/**
- * # !WARNING!
- * > If you don't specify the Class's SuperClass (or `BaseClassProto`) via WithProto, the return type will wrongly include inherited property names! This is a design limitation of TypeScript.
- *
- * Returns the names of the instantiated (or static), noninherited getters derived from the
- * given prototype or prototype of the given object.
- * @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class
- * @template {InstanceOrStatic} _InstanceOrStatic 'Instance' or 'Static'. Determines the return type.
- * @param classDefinition Any class cast to ClassLike
- * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
- * @since 3.0.0
- * @returns
- * An array of names of getters that were not inherited from a parent class. If {@link classDefinition} is a class instance, the names of instanced getters are returned. Otherwise, the names of static getters are returned;
- */
-function listOwnGetters(classDefinition, instanceOrStatic) {
-  if (instanceOrStatic === 'Instance') {
-    const descriptorMap = getOwnPropertyDescriptors(classDefinition, instanceOrStatic);
-    const getterDescriptorMap = filterForGetters(descriptorMap);
-    const keyArray = Reflect.ownKeys(getterDescriptorMap);
-    return keyArray;
-  } else if (instanceOrStatic === 'Static') {
-    const descriptorMap = getOwnPropertyDescriptors(classDefinition, instanceOrStatic);
-    const getterDescriptorMap = filterForGetters(descriptorMap);
-    const keyArray = Reflect.ownKeys(getterDescriptorMap);
-    return keyArray;
-  } else throw new TypeError('Argument `instanceOrStatic` must be "Instance" or "Static".');
-}
-export { listOwnGetters };
-//# sourceMappingURL=listOwnGetters.mjs.map
+import{filterForGetters as e}from"./filterForGetters.mjs";import{getOwnPropertyDescriptors as t}from"./getOwnPropertyDescriptors.mjs";function n(n,r){if(r===`Instance`){let i=e(t(n,r));return Reflect.ownKeys(i)}else if(r===`Static`){let i=e(t(n,r));return Reflect.ownKeys(i)}else throw TypeError('Argument `instanceOrStatic` must be "Instance" or "Static".')}export{n as listOwnGetters};
+//# sourceMappingURL=listOwnGetters.mjs.map

package/mjs/utils/reflection/listOwnGetters.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"listOwnGetters.mjs","sources":["../../../src/utils/reflection/listOwnGetters.ts"],"names":[],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,cAAc,CAAC,eAAe,EAAE,gBAAgB,EAAE;AAClE,EAAE,IAAI,gBAAgB,KAAK,UAAU,EAAE;AACvC,IAAI,MAAM,aAAa,GAAG,yBAAyB,CAAC,eAAe,EAAE,gBAAgB,CAAC;AACtF,IAAI,MAAM,mBAAmB,GAAG,gBAAgB,CAAC,aAAa,CAAC;AAC/D,IAAI,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC;AACzD,IAAI,OAAO,QAAQ;AACnB,EAAE,CAAC,MAAM,IAAI,gBAAgB,KAAK,QAAQ,EAAE;AAC5C,IAAI,MAAM,aAAa,GAAG,yBAAyB,CAAC,eAAe,EAAE,gBAAgB,CAAC;AACtF,IAAI,MAAM,mBAAmB,GAAG,gBAAgB,CAAC,aAAa,CAAC;AAC/D,IAAI,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC;AACzD,IAAI,OAAO,QAAQ;AACnB,EAAE,CAAC,MAAM,MAAM,IAAI,SAAS,CAAC,6DAA6D,CAAC;AAC3F;;;;"}
+{"version":3,"file":"listOwnGetters.mjs","names":[],"sources":["../../../src/utils/reflection/listOwnGetters.ts"],"sourcesContent":["import type { InstanceOrStatic } from '../miscTypes.ts';\nimport { filterForGetters } from './filterForGetters.ts';\nimport { getOwnPropertyDescriptors } from './getOwnPropertyDescriptors.ts';\nimport type {\n  BaseClassProto,\n  ClassLike,\n  ConstructorConstraint,\n  InstanceTypeOrSelf,\n  SuperClassLike,\n  WithProto,\n} from './inheritance.ts';\nimport type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.d.ts';\nimport type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';\n\n/**\n * Description placeholder\n * @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class\n * @template {InstanceOrStatic} _InstanceOrStatic\n * @since 3.0.0\n */\ntype OwnGetters<\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n  _InstanceOrStatic extends InstanceOrStatic,\n>\n  = [_InstanceOrStatic] extends ['Instance']\n    ? Exclude<\n      (Class['__proto__'] extends BaseClassProto ? null : InstanceTypeOrSelf<Class['__proto__']>) extends null\n        ? keyof InstanceType<Class>\n        : Exclude<\n          keyof InstanceType<Class>,\n          keyof (Class['__proto__'] extends BaseClassProto ? null : InstanceTypeOrSelf<Class['__proto__']>)\n        >,\n      '__proto__'\n    >[]\n    : [_InstanceOrStatic] extends ['Static']\n        ? Exclude<\n          Class['__proto__'] extends null ? keyof Class : Exclude<keyof Class, keyof Class['__proto__']>,\n          '__proto__'\n        >[]\n        : never;\n\n/**\n * # !WARNING!\n * > If you don't specify the Class's SuperClass (or `BaseClassProto`) via WithProto, the return type will wrongly include inherited property names! This is a design limitation of TypeScript.\n *\n * Returns the names of the instantiated (or static), noninherited getters derived from the\n * given prototype or prototype of the given object.\n * @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class\n * @template {InstanceOrStatic} _InstanceOrStatic 'Instance' or 'Static'. Determines the return type.\n * @param classDefinition Any class cast to ClassLike\n * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.\n * @since 3.0.0\n * @returns\n * An array of names of getters that were not inherited from a parent class. If {@link classDefinition} is a class instance, the names of instanced getters are returned. Otherwise, the names of static getters are returned;\n */\nexport function listOwnGetters<\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n  _InstanceOrStatic extends InstanceOrStatic,\n>(\n  classDefinition: Class,\n  instanceOrStatic: Extract<_InstanceOrStatic, InstanceOrStatic>,\n): OwnGetters<Class, _InstanceOrStatic> {\n  if (instanceOrStatic === 'Instance') {\n    const descriptorMap: InstancePropertyDescriptorMap<Class> = getOwnPropertyDescriptors(classDefinition, instanceOrStatic as 'Instance');\n    const getterDescriptorMap = filterForGetters(descriptorMap);\n    const keyArray = Reflect.ownKeys(getterDescriptorMap) as (keyof typeof getterDescriptorMap)[];\n    return keyArray as [typeof instanceOrStatic & 'Instance'] extends ['Instance'] ? typeof keyArray : never;\n  }\n  else if (instanceOrStatic === 'Static') {\n    const descriptorMap: OwnPropertyDescriptorMap<Class> = getOwnPropertyDescriptors(classDefinition, instanceOrStatic as 'Static');\n    const getterDescriptorMap = filterForGetters(descriptorMap);\n    const keyArray = Reflect.ownKeys(getterDescriptorMap) as (keyof typeof getterDescriptorMap)[];\n    return keyArray as [_InstanceOrStatic] extends ['Instance']\n      ? never\n      : [_InstanceOrStatic] extends ['Static']\n          ? typeof keyArray\n          : never;\n  }\n  else throw new TypeError('Argument `instanceOrStatic` must be \"Instance\" or \"Static\".');\n}\n"],"mappings":"sIAuDA,SAAgB,EAId,EACA,EACsC,CACtC,GAAI,IAAqB,WAAY,CAEnC,IAAM,EAAsB,EADgC,EAA0B,EAAiB,EAA+B,CAC3E,CAE3D,OADiB,QAAQ,QAAQ,EAAoB,SAG9C,IAAqB,SAAU,CAEtC,IAAM,EAAsB,EAD2B,EAA0B,EAAiB,EAA6B,CACpE,CAE3D,OADiB,QAAQ,QAAQ,EAAoB,MAOlD,MAAU,UAAU,8DAA8D"}

package/mjs/utils/reflection.d.mts

@@ -0,0 +1,18 @@
+import { FunctionLike } from "./reflection/FunctionLike.mjs";
+import { GetterDescriptor } from "./reflection/GetterDescriptor.mjs";
+import { PropertyDescriptorMap } from "./reflection/PropertyDescriptorMap.mjs";
+import { BaseClass, BaseClassProto, ClassLike, ClassLike_Unknown, ConstructorConstraint, ConstructorLike, Constructor_Unknown, IClass, InstanceTypeOrSelf, ProtoChainOfClass, ProtoChainOfClassInstance, ProtoChainOfObject, ProtoOrSuperClass, SuperClassLike, WithProto, baseClassProto } from "./reflection/inheritance.mjs";
+import { InstancePropertyDescriptorMap } from "./reflection/InstancePropertyDescriptorMap.mjs";
+import { InstanceTypeOrSelfPropertyDescriptorMap } from "./reflection/InstanceTypeOrSelfPropertyDescriptorMap.mjs";
+import { OwnKeyOf } from "./reflection/OwnKeyOf.mjs";
+import { OwnGetterDescriptorMap } from "./reflection/OwnGetterDescriptorMap.mjs";
+import { OwnPropertyDescriptorMap } from "./reflection/OwnPropertyDescriptorMap.mjs";
+import { filterForGetters } from "./reflection/filterForGetters.mjs";
+import { getOwnPropertyDescriptors } from "./reflection/getOwnPropertyDescriptors.mjs";
+import { RecursedPropertyDescriptorMap, RecursedPropertyDescriptorMapArray, getOwnPropertyDescriptorsRecursively } from "./reflection/getOwnPropertyDescriptorsRecursively.mjs";
+import { getPrototypesChainOf } from "./reflection/getPrototypeChainOf.mjs";
+import { getPrototypeOf } from "./reflection/getPrototypeOf.mjs";
+import { isConstructor } from "./reflection/isConstructor.mjs";
+import { isGetterDescriptor } from "./reflection/isGetterDescriptor.mjs";
+import { listOwnGetters } from "./reflection/listOwnGetters.mjs";
+export { BaseClass, BaseClassProto, ClassLike, ClassLike_Unknown, ConstructorConstraint, ConstructorLike, Constructor_Unknown, FunctionLike, GetterDescriptor, IClass, InstancePropertyDescriptorMap, InstanceTypeOrSelf, InstanceTypeOrSelfPropertyDescriptorMap, OwnGetterDescriptorMap, OwnKeyOf, OwnPropertyDescriptorMap, PropertyDescriptorMap, ProtoChainOfClass, ProtoChainOfClassInstance, ProtoChainOfObject, ProtoOrSuperClass, RecursedPropertyDescriptorMap, RecursedPropertyDescriptorMapArray, SuperClassLike, WithProto, baseClassProto, filterForGetters, getOwnPropertyDescriptors, getOwnPropertyDescriptorsRecursively, getPrototypeOf, getPrototypesChainOf, isConstructor, isGetterDescriptor, listOwnGetters };