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

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

@@ -0,0 +1,13 @@
+//#region src/utils/reflection/PropertyDescriptorMap.d.ts
+/**
+ * A variant of TypeScript's ES5 PropertyDescriptorMap with an extra generic
+ * parameter for omitting inherited keys.
+ * @template T The type described by the {@link PropertyDescriptorMap}.
+ * @template [__proto__=null]
+ * The `null` or the `object`-like `[[Prototype]]` of {@link T}.
+ * @since 3.0.0
+ */
+type PropertyDescriptorMap<T, __proto__ extends object | null = null> = __proto__ extends null ? { [P0 in keyof T]: TypedPropertyDescriptor<T[P0]> } : Omit<{ [P0 in keyof T]: TypedPropertyDescriptor<T[P0]> }, keyof { [P1 in keyof __proto__]: TypedPropertyDescriptor<__proto__[P1]> }>;
+//#endregion
+export { PropertyDescriptorMap };
+//# sourceMappingURL=PropertyDescriptorMap.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PropertyDescriptorMap.d.mts","names":["PropertyDescriptorMap","T","__proto__","P0","TypedPropertyDescriptor","P1","Omit"],"sources":["../../../src/utils/reflection/PropertyDescriptorMap.d.ts"],"mappings":";;AAQA;;;;;;;KAAYA,qBAAAA,8CACRE,SAAAA,+BACiBD,CAAAA,GAAIG,uBAAAA,CAAwBH,CAAAA,CAAEE,EAAAA,OAC7CG,IAAAA,gBACeL,CAAAA,GAAIG,uBAAAA,CAAwBH,CAAAA,CAAEE,EAAAA,2BACxBD,SAAAA,GAAYE,uBAAAA,CAAwBF,SAAAA,CAAUG,EAAAA"}

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

@@ -0,0 +1,11 @@
+import { BaseClassProto, ClassLike, ConstructorConstraint, InstanceTypeOrSelf, SuperClassLike, WithProto, baseClassProto } from "./inheritance.mjs";
+import { InstancePropertyDescriptorMap } from "./InstancePropertyDescriptorMap.mjs";
+import { OwnGetterDescriptorMap } from "./OwnGetterDescriptorMap.mjs";
+import { OwnPropertyDescriptorMap } from "./OwnPropertyDescriptorMap.mjs";
+
+//#region src/utils/reflection/filterForGetters.d.ts
+declare function filterForGetters<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | typeof baseClassProto>>>(descriptorMap: InstancePropertyDescriptorMap<Class>): Partial<OwnGetterDescriptorMap<InstanceType<Class>, Class["__proto__"] extends BaseClassProto ? null : InstanceTypeOrSelf<Class["__proto__"]>>>;
+declare function filterForGetters<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>>(descriptorMap: OwnPropertyDescriptorMap<Class>): Partial<OwnGetterDescriptorMap<Class, Class["__proto__"]>>;
+//#endregion
+export { filterForGetters };
+//# sourceMappingURL=filterForGetters.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filterForGetters.d.mts","names":[],"sources":["../../../src/utils/reflection/filterForGetters.ts"],"mappings":";;;;;;iBAcgB,gBAAA,eACA,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,UAAwB,cAAA,GAAA,CAEzF,aAAA,EAAe,6BAAA,CAA8B,KAAA,IAC5C,OAAA,CAAQ,sBAAA,CACT,YAAA,CAAa,KAAA,GACb,KAAA,sBAA2B,cAAA,UAAwB,kBAAA,CAAmB,KAAA;AAAA,iBAExD,gBAAA,eACA,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,GAAA,CAElF,aAAA,EAAe,wBAAA,CAAyB,KAAA,IACvC,OAAA,CAAQ,sBAAA,CAAuB,KAAA,EAAO,KAAA"}

package/mjs/utils/reflection/filterForGetters.mjs

@@ -1,27 +1,2 @@
-/**
- * Iterates through the descriptors object, checking for property descriptors whose `get` is a function.
- * Returns an {@link OwnGetterDescriptorMap} of the getters.
- * If you want only own, non-inherited getters, you must filter sanitize the
- * type the `descriptors` parameter yourself e.g. `Omit<Class, keyof
- * SuperClass>`.
- * @param descriptorMap An object like the return value of Object.getOwnPropertyDescriptors
- * @template Class Any ClassLike type
- * @template T Any `object`-like type.
- * @template [__proto__=null] If {@link Class} is not {@link ClassLike}, the `__proto__` of {@link T}.
- * @returns An {@link OwnGetterDescriptorMap}.
- * @since 3.0.0
- */
-function filterForGetters(descriptorMap) {
-  let getterDescriptorMap = {};
-  for (const key in descriptorMap) {
-    const element = descriptorMap[key];
-    if (typeof element.get === 'function') {
-      getterDescriptorMap = Object.assign(getterDescriptorMap, {
-        [key]: element
-      });
-    }
-  }
-  return getterDescriptorMap;
-}
-export { filterForGetters };
-//# sourceMappingURL=filterForGetters.mjs.map
+function e(e){let t={};for(let n in e){let r=e[n];typeof r.get==`function`&&(t=Object.assign(t,{[n]:r}))}return t}export{e as filterForGetters};
+//# sourceMappingURL=filterForGetters.mjs.map

package/mjs/utils/reflection/filterForGetters.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"filterForGetters.mjs","sources":["../../../src/utils/reflection/filterForGetters.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,gBAAgB,CAAC,aAAa,EAAE;AAChD,EAAE,IAAI,mBAAmB,GAAG,EAAE;AAC9B,EAAE,KAAK,MAAM,GAAG,IAAI,aAAa,EAAE;AACnC,IAAI,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC;AACtC,IAAI,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,UAAU,EAAE;AAC3C,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE;AAC/D,QAAQ,CAAC,GAAG,GAAG;AACf,OAAO,CAAC;AACR,IAAI;AACJ,EAAE;AACF,EAAE,OAAO,mBAAmB;AAC5B;;;;"}
+{"version":3,"file":"filterForGetters.mjs","names":[],"sources":["../../../src/utils/reflection/filterForGetters.ts"],"sourcesContent":["import type {\n  BaseClassProto,\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 { OwnGetterDescriptorMap } from './OwnGetterDescriptorMap.d.ts';\nimport type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';\nimport type { PropertyDescriptorMap } from './PropertyDescriptorMap.d.ts';\n\nexport function filterForGetters<\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | typeof baseClassProto>>,\n>(\n  descriptorMap: InstancePropertyDescriptorMap<Class>,\n): Partial<OwnGetterDescriptorMap<\n  InstanceType<Class>,\n  Class['__proto__'] extends BaseClassProto ? null : InstanceTypeOrSelf<Class['__proto__']>\n>>;\nexport function filterForGetters<\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n>(\n  descriptorMap: OwnPropertyDescriptorMap<Class>,\n): Partial<OwnGetterDescriptorMap<Class, Class['__proto__']>>;\n/**\n * Iterates through the descriptors object, checking for property descriptors whose `get` is a function.\n * Returns an {@link OwnGetterDescriptorMap} of the getters.\n * If you want only own, non-inherited getters, you must filter sanitize the\n * type the `descriptors` parameter yourself e.g. `Omit<Class, keyof\n * SuperClass>`.\n * @param descriptorMap An object like the return value of Object.getOwnPropertyDescriptors\n * @template Class Any ClassLike type\n * @template T Any `object`-like type.\n * @template [__proto__=null] If {@link Class} is not {@link ClassLike}, the `__proto__` of {@link T}.\n * @returns An {@link OwnGetterDescriptorMap}.\n * @since 3.0.0\n */\nexport function filterForGetters<\n  T extends object,\n  __proto__ extends object | null = null,\n>(\n  descriptorMap: PropertyDescriptorMap<T, __proto__> | PropertyDescriptorMap<T>,\n): Partial<OwnGetterDescriptorMap<T, __proto__>> {\n  let getterDescriptorMap: Partial<OwnGetterDescriptorMap<T, __proto__>> = {};\n  for (const key in descriptorMap) {\n    const element = descriptorMap[key as keyof typeof descriptorMap];\n    if (typeof element.get === 'function') {\n      getterDescriptorMap = Object.assign(\n        getterDescriptorMap,\n        { [key]: element },\n      );\n    }\n  }\n\n  return getterDescriptorMap;\n}\n"],"mappings":"AAwCA,SAAgB,EAId,EAC+C,CAC/C,IAAI,EAAqE,EAAE,CAC3E,IAAK,IAAM,KAAO,EAAe,CAC/B,IAAM,EAAU,EAAc,GAC1B,OAAO,EAAQ,KAAQ,aACzB,EAAsB,OAAO,OAC3B,EACA,EAAG,GAAM,EAAS,CACnB,EAIL,OAAO"}

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

@@ -0,0 +1,26 @@
+import { InstanceOrStatic } from "../miscTypes.mjs";
+import { BaseClassProto, ClassLike, ConstructorConstraint, SuperClassLike, WithProto } from "./inheritance.mjs";
+import { InstancePropertyDescriptorMap } from "./InstancePropertyDescriptorMap.mjs";
+import { OwnPropertyDescriptorMap } from "./OwnPropertyDescriptorMap.mjs";
+
+//#region src/utils/reflection/getOwnPropertyDescriptors.d.ts
+/**
+* Get the property descriptors of the class or constructor similar to {@link Object.getOwnPropertyDescriptors}, but with more options--including recursion.
+* @template {InstanceOrStatic} _InstanceOrStatic 'Instance' or 'Static'. Determines the return type.
+* @param classDefinition A class or constructor, cast to {@link ClassLike}.
+* @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
+* @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class
+* The typeof {@link classDefinition}.
+* {@link WithProto}<{@link SuperClassLike}> is necessary for walking the
+* prototype chain for both Instance  and Static properties.
+* If unspecified, the return type may be incorrect.
+* @returns ({@link instanceOrStatic} === 'Instance') ? {@link InstancePropertyDescriptorMap<Class>}\
+* : ({@link instanceOrStatic} === 'Static') ? {@link OwnPropertyDescriptorMap<Class>}\
+* : never
+* @throws {TypeError}
+* @since 3.0.0
+*/
+declare function getOwnPropertyDescriptors<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>, _InstanceOrStatic extends InstanceOrStatic>(classDefinition: Class, instanceOrStatic: _InstanceOrStatic): [_InstanceOrStatic] extends ["Instance"] ? InstancePropertyDescriptorMap<Class> : [_InstanceOrStatic] extends ["Static"] ? OwnPropertyDescriptorMap<Class> : never;
+//#endregion
+export { getOwnPropertyDescriptors };
+//# sourceMappingURL=getOwnPropertyDescriptors.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getOwnPropertyDescriptors.d.mts","names":[],"sources":["../../../src/utils/reflection/getOwnPropertyDescriptors.ts"],"mappings":";;;;;;;;AAqBA;;;;;;;;;;;;;;iBAAgB,yBAAA,eACA,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,8BACxD,gBAAA,CAAA,CAE1B,eAAA,EAAiB,KAAA,EACjB,gBAAA,EAAkB,iBAAA,IAChB,iBAAA,yBACA,6BAAA,CAA8B,KAAA,KAC7B,iBAAA,uBACG,wBAAA,CAAyB,KAAA"}

package/mjs/utils/reflection/getOwnPropertyDescriptors.mjs

@@ -1,34 +1,2 @@
-/**
- * Get the property descriptors of the class or constructor similar to {@link Object.getOwnPropertyDescriptors}, but with more options--including recursion.
- * @template {InstanceOrStatic} _InstanceOrStatic 'Instance' or 'Static'. Determines the return type.
- * @param classDefinition A class or constructor, cast to {@link ClassLike}.
- * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
- * @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class
- * The typeof {@link classDefinition}.
- * {@link WithProto}<{@link SuperClassLike}> is necessary for walking the
- * prototype chain for both Instance  and Static properties.
- * If unspecified, the return type may be incorrect.
- * @returns ({@link instanceOrStatic} === 'Instance') ? {@link InstancePropertyDescriptorMap<Class>}\
- * : ({@link instanceOrStatic} === 'Static') ? {@link OwnPropertyDescriptorMap<Class>}\
- * : never
- * @throws {TypeError}
- * @since 3.0.0
- */
-function getOwnPropertyDescriptors(classDefinition, instanceOrStatic) {
-  switch (instanceOrStatic) {
-    case 'Instance':
-      {
-        return Object.getOwnPropertyDescriptors(classDefinition.prototype);
-      }
-    case 'Static':
-      {
-        return Object.getOwnPropertyDescriptors(classDefinition);
-      }
-    default:
-      {
-        throw new TypeError('Argument `instanceOrStatic` must be "Instance" or "Static".');
-      }
-  }
-}
-export { getOwnPropertyDescriptors };
-//# sourceMappingURL=getOwnPropertyDescriptors.mjs.map
+function e(e,t){switch(t){case`Instance`:return Object.getOwnPropertyDescriptors(e.prototype);case`Static`:return Object.getOwnPropertyDescriptors(e);default:throw TypeError('Argument `instanceOrStatic` must be "Instance" or "Static".')}}export{e as getOwnPropertyDescriptors};
+//# sourceMappingURL=getOwnPropertyDescriptors.mjs.map

package/mjs/utils/reflection/getOwnPropertyDescriptors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getOwnPropertyDescriptors.mjs","sources":["../../../src/utils/reflection/getOwnPropertyDescriptors.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,yBAAyB,CAAC,eAAe,EAAE,gBAAgB,EAAE;AAC7E,EAAE,QAAQ,gBAAgB;AAC1B,IAAI,KAAK,UAAU;AACnB,MAAM;AACN,QAAQ,OAAO,MAAM,CAAC,yBAAyB,CAAC,eAAe,CAAC,SAAS,CAAC;AAC1E,MAAM;AACN,IAAI,KAAK,QAAQ;AACjB,MAAM;AACN,QAAQ,OAAO,MAAM,CAAC,yBAAyB,CAAC,eAAe,CAAC;AAChE,MAAM;AACN,IAAI;AACJ,MAAM;AACN,QAAQ,MAAM,IAAI,SAAS,CAAC,6DAA6D,CAAC;AAC1F,MAAM;AACN;AACA;;;;"}
+{"version":3,"file":"getOwnPropertyDescriptors.mjs","names":[],"sources":["../../../src/utils/reflection/getOwnPropertyDescriptors.ts"],"sourcesContent":["import type { InstanceOrStatic } from '../miscTypes.ts';\nimport type { BaseClassProto, ClassLike, ConstructorConstraint, SuperClassLike, WithProto } from './inheritance.ts';\nimport type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.d.ts';\nimport type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';\n\n/**\n * Get the property descriptors of the class or constructor similar to {@link Object.getOwnPropertyDescriptors}, but with more options--including recursion.\n * @template {InstanceOrStatic} _InstanceOrStatic 'Instance' or 'Static'. Determines the return type.\n * @param classDefinition A class or constructor, cast to {@link ClassLike}.\n * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.\n * @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class\n * The typeof {@link classDefinition}.\n * {@link WithProto}<{@link SuperClassLike}> is necessary for walking the\n * prototype chain for both Instance  and Static properties.\n * If unspecified, the return type may be incorrect.\n * @returns ({@link instanceOrStatic} === 'Instance') ? {@link InstancePropertyDescriptorMap<Class>}\\\n * : ({@link instanceOrStatic} === 'Static') ? {@link OwnPropertyDescriptorMap<Class>}\\\n * : never\n * @throws {TypeError}\n * @since 3.0.0\n */\nexport function getOwnPropertyDescriptors<\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n  _InstanceOrStatic extends InstanceOrStatic,\n>(\n  classDefinition: Class,\n  instanceOrStatic: _InstanceOrStatic,\n): [_InstanceOrStatic] extends ['Instance']\n  ? InstancePropertyDescriptorMap<Class>\n  : [_InstanceOrStatic] extends ['Static']\n      ? OwnPropertyDescriptorMap<Class>\n      : never {\n  switch (instanceOrStatic) {\n    case 'Instance': {\n      return Object.getOwnPropertyDescriptors(classDefinition.prototype) as [Extract<typeof instanceOrStatic, 'Instance'>] extends ['Instance']\n        ? InstancePropertyDescriptorMap<Class>\n        : [_InstanceOrStatic] extends ['Static']\n            ? OwnPropertyDescriptorMap<Class>\n            : never;\n    }\n    case 'Static': {\n      return Object.getOwnPropertyDescriptors(classDefinition) as [Extract<typeof instanceOrStatic, 'Static'>] extends ['Instance']\n        ? InstancePropertyDescriptorMap<Class>\n        : [_InstanceOrStatic] extends ['Static']\n            ? OwnPropertyDescriptorMap<Class>\n            : never;\n    }\n    default: {\n      throw new TypeError('Argument `instanceOrStatic` must be \"Instance\" or \"Static\".');\n    }\n  }\n}\n"],"mappings":"AAqBA,SAAgB,EAId,EACA,EAKY,CACZ,OAAQ,EAAR,CACE,IAAK,WACH,OAAO,OAAO,0BAA0B,EAAgB,UAAU,CAMpE,IAAK,SACH,OAAO,OAAO,0BAA0B,EAAgB,CAM1D,QACE,MAAU,UAAU,8DAA8D"}

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

@@ -0,0 +1,51 @@
+import { Increment } from "../GracefulRecursion.mjs";
+import { InstanceOrStatic, Integer } from "../miscTypes.mjs";
+import { BaseClass, BaseClassProto, ClassLike, ConstructorConstraint, ConstructorLike, SuperClassLike, WithProto } from "./inheritance.mjs";
+import { InstanceTypeOrSelfPropertyDescriptorMap } from "./InstanceTypeOrSelfPropertyDescriptorMap.mjs";
+import { OwnPropertyDescriptorMap } from "./OwnPropertyDescriptorMap.mjs";
+
+//#region src/utils/reflection/getOwnPropertyDescriptorsRecursively.d.ts
+/**
+* A conditional wrapper for {@link InstanceTypeOrSelfPropertyDescriptorMap} and
+* {@link OwnPropertyDescriptorMap}.
+*
+* If {@link _InstanceOrStatic} is 'Instance', {@link InstanceTypeOrSelfPropertyDescriptorMap}.\
+* Else if {@link _InstanceOrStatic} is 'Static',
+* {@link OwnPropertyDescriptorMap }.\
+* Else, `never`.
+* @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class
+* A class definition cast to {@link ClassLike}.
+* @template {InstanceOrStatic} _InstanceOrStatic
+* 'Instance' or 'Static'. Determines the return type.
+* @since 3.0.0
+*/
+type RecursedPropertyDescriptorMap<Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>, _InstanceOrStatic extends InstanceOrStatic> = [_InstanceOrStatic] extends ["Instance"] ? InstanceTypeOrSelfPropertyDescriptorMap<Class, Class["__proto__"]> : [_InstanceOrStatic] extends ["Static"] ? OwnPropertyDescriptorMap<Class> : never;
+/**
+* An
+* ordered array of {@link OwnPropertyDescriptorMap} or
+* {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}
+* and ending with a {@link BaseClass}.
+* @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class
+* @template {'Instance' | 'Static'} InstanceOrStatic
+* @template {Integer<number>} [Limit=16]
+* @template {Integer<number>} [CurrentLevel=0]
+*/
+type RecursedPropertyDescriptorMapArray<Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>, InstanceOrStatic extends "Instance" | "Static", Limit extends Integer<number> = 16, CurrentLevel extends Integer<number> = 0> = Class["__proto__"] extends BaseClassProto["__proto__"] | BaseClassProto["__proto__"]["__proto__"] ? never : Class["__proto__"] extends BaseClassProto ? [RecursedPropertyDescriptorMap<BaseClass<Class>, InstanceOrStatic>] : Class["__proto__"] extends ConstructorLike<Class["__proto__"]> ? [RecursedPropertyDescriptorMap<Class, InstanceOrStatic>, ...RecursedPropertyDescriptorMapArray<ClassLike<Exclude<Class["__proto__"], BaseClassProto> & WithProto<SuperClassLike | BaseClassProto>>, InstanceOrStatic, Limit, Increment<CurrentLevel>>] : never;
+/**
+* Walks the class inheritance chain to get a PropertyDescriptorMap of each class.
+*
+* While you _can_ use this to get an array of getter names/keys, you should use {@link getPrototypeOf} and {@link listOwnGetters}, instead!
+* @template Class Any class definition type-cast to {@link ClassLike}
+* @template _InstanceOrStatic
+* @param classDefinition Any class definition type-cast to {@link ClassLike}
+* @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
+* @returns An
+* ordered array of {@link OwnPropertyDescriptorMap} or
+* {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}
+* and ending with a {@link BaseClass}.
+* @since 3.0.0
+*/
+declare function getOwnPropertyDescriptorsRecursively<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>, _InstanceOrStatic extends InstanceOrStatic, Limit extends Integer<number> = 16>(classDefinition: Class, instanceOrStatic: _InstanceOrStatic): RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic>;
+//#endregion
+export { RecursedPropertyDescriptorMap, RecursedPropertyDescriptorMapArray, getOwnPropertyDescriptorsRecursively };
+//# sourceMappingURL=getOwnPropertyDescriptorsRecursively.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getOwnPropertyDescriptorsRecursively.d.mts","names":[],"sources":["../../../src/utils/reflection/getOwnPropertyDescriptorsRecursively.ts"],"mappings":";;;;;;;;;AAuCA;;;;;;;;;;;;KAAY,6BAAA,eACI,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,6BAC9C,gBAAA,KACvB,iBAAA,yBAA0C,uCAAA,CAAwC,KAAA,EAAO,KAAA,kBACzF,iBAAA,uBAAwC,wBAAA,CAAyB,KAAA;;;;;;;;;;;KAa1D,kCAAA,eACI,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,iEAE1D,OAAA,oCACO,OAAA,gBACnB,KAAA,sBAA2B,cAAA,gBAA8B,cAAA,qCACzD,KAAA,sBAA2B,cAAA,IAAkB,6BAAA,CAA8B,SAAA,CAAU,KAAA,GAAQ,gBAAA,KAC3F,KAAA,sBAA2B,eAAA,CAAgB,KAAA,kBAEvC,6BAAA,CAA8B,KAAA,EAAO,gBAAA,MAClC,kCAAA,CACD,SAAA,CAAU,OAAA,CAAQ,KAAA,eAAoB,cAAA,IAAkB,SAAA,CAAU,cAAA,GAAiB,cAAA,IACnF,gBAAA,EACA,KAAA,EACA,SAAA,CAAU,YAAA;;;;AAdtB;;;;;;;;;;;iBAgCgB,oCAAA,eAEA,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,8BACxD,gBAAA,gBAEZ,OAAA,cAAA,CAEd,eAAA,EAAiB,KAAA,EACjB,gBAAA,EAAkB,iBAAA,GACjB,kCAAA,CAAmC,KAAA,EAAO,iBAAA"}

package/mjs/utils/reflection/getOwnPropertyDescriptorsRecursively.mjs

@@ -1,72 +1,2 @@
-import { getOwnPropertyDescriptors } from './getOwnPropertyDescriptors.mjs';
-import { getPrototypesChainOf } from './getPrototypeChainOf.mjs';
-
-/* eslint-disable jsdoc/check-tag-names */
-/**
- * JSDoc type imports
- * @typedef {import('./getPrototypeOf.js').getPrototypeOf} getPrototypeOf
- * @typedef {import('./listOwnGetters.js').listOwnGetters} listOwnGetters
- * @typedef {import('./InstancePropertyDescriptorMap.js').InstancePropertyDescriptorMap} InstancePropertyDescriptorMap
- */
-/* eslint-enable jsdoc/check-tag-names */
-
-/**
- * A conditional wrapper for {@link InstanceTypeOrSelfPropertyDescriptorMap} and
- * {@link OwnPropertyDescriptorMap}.
- *
- * If {@link _InstanceOrStatic} is 'Instance', {@link InstanceTypeOrSelfPropertyDescriptorMap}.\
- * Else if {@link _InstanceOrStatic} is 'Static',
- * {@link OwnPropertyDescriptorMap }.\
- * Else, `never`.
- * @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class
- * A class definition cast to {@link ClassLike}.
- * @template {InstanceOrStatic} _InstanceOrStatic
- * 'Instance' or 'Static'. Determines the return type.
- * @since 3.0.0
- */
-
-/**
- * An
- * ordered array of {@link OwnPropertyDescriptorMap} or
- * {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}
- * and ending with a {@link BaseClass}.
- * @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class
- * @template {'Instance' | 'Static'} InstanceOrStatic
- * @template {Integer<number>} [Limit=16]
- * @template {Integer<number>} [CurrentLevel=0]
- */
-
-/**
- * Walks the class inheritance chain to get a PropertyDescriptorMap of each class.
- *
- * While you _can_ use this to get an array of getter names/keys, you should use {@link getPrototypeOf} and {@link listOwnGetters}, instead!
- * @template Class Any class definition type-cast to {@link ClassLike}
- * @template _InstanceOrStatic
- * @param classDefinition Any class definition type-cast to {@link ClassLike}
- * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
- * @returns An
- * ordered array of {@link OwnPropertyDescriptorMap} or
- * {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}
- * and ending with a {@link BaseClass}.
- * @since 3.0.0
- */
-function getOwnPropertyDescriptorsRecursively(classDefinition, instanceOrStatic) {
-  const staticProtoChain = getPrototypesChainOf(classDefinition, 'classes');
-  if (isSingleTuple(staticProtoChain)) {
-    return [getOwnPropertyDescriptors(staticProtoChain[0], instanceOrStatic)];
-  }
-  const recursedPropertyDescriptorMapArray = staticProtoChain.map(classDefinition => getOwnPropertyDescriptors(classDefinition, instanceOrStatic));
-  return recursedPropertyDescriptorMapArray;
-}
-
-/**
- * Simple utility for single-tuple type assertion
- * @template {T} T T in T[]
- * @param array an array
- * @returns array is [T]
- */
-function isSingleTuple(array) {
-  return Array.isArray(array) && array.length === 1;
-}
-export { getOwnPropertyDescriptorsRecursively };
-//# sourceMappingURL=getOwnPropertyDescriptorsRecursively.mjs.map
+import{getOwnPropertyDescriptors as e}from"./getOwnPropertyDescriptors.mjs";import{getPrototypesChainOf as t}from"./getPrototypeChainOf.mjs";function n(n,i){let a=t(n,`classes`);return r(a)?[e(a[0],i)]:a.map(t=>e(t,i))}function r(e){return Array.isArray(e)&&e.length===1}export{n as getOwnPropertyDescriptorsRecursively};
+//# sourceMappingURL=getOwnPropertyDescriptorsRecursively.mjs.map

package/mjs/utils/reflection/getOwnPropertyDescriptorsRecursively.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getOwnPropertyDescriptorsRecursively.mjs","sources":["../../../src/utils/reflection/getOwnPropertyDescriptorsRecursively.ts"],"names":[],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,oCAAoC,CAAC,eAAe,EAAE,gBAAgB,EAAE;AACxF,EAAE,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,eAAe,EAAE,SAAS,CAAC;AAC3E,EAAE,IAAI,aAAa,CAAC,gBAAgB,CAAC,EAAE;AACvC,IAAI,OAAO,CAAC,yBAAyB,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;AAC7E,EAAE;AACF,EAAE,MAAM,kCAAkC,GAAG,gBAAgB,CAAC,GAAG,CAAC,eAAe,IAAI,yBAAyB,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;AAClJ,EAAE,OAAO,kCAAkC;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,aAAa,CAAC,KAAK,EAAE;AAC9B,EAAE,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;AACnD;;;;"}
+{"version":3,"file":"getOwnPropertyDescriptorsRecursively.mjs","names":[],"sources":["../../../src/utils/reflection/getOwnPropertyDescriptorsRecursively.ts"],"sourcesContent":["import type { Increment } from '../GracefulRecursion.d.ts';\nimport type { InstanceOrStatic, Integer } from '../miscTypes.ts';\nimport { getOwnPropertyDescriptors } from './getOwnPropertyDescriptors.ts';\nimport { getPrototypesChainOf } from './getPrototypeChainOf.ts';\nimport type {\n  BaseClass,\n  BaseClassProto,\n  ClassLike,\n  ConstructorConstraint,\n  ConstructorLike,\n  ProtoChainOfClass,\n  SuperClassLike,\n  WithProto,\n} from './inheritance.ts';\nimport type { InstanceTypeOrSelfPropertyDescriptorMap } from './InstanceTypeOrSelfPropertyDescriptorMap.d.ts';\nimport type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';\n/**\n * JSDoc type imports\n */\n/* eslint-disable @typescript-eslint/no-unused-vars */\nimport type { getPrototypeOf as _getPrototypeOf } from './getPrototypeOf.ts';\nimport type { listOwnGetters as _listOwnGetters } from './listOwnGetters.ts';\nimport type { InstancePropertyDescriptorMap as _InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.d.ts';\n/* eslint-enable @typescript-eslint/no-unused-vars */\n\n/**\n * A conditional wrapper for {@link InstanceTypeOrSelfPropertyDescriptorMap} and\n * {@link OwnPropertyDescriptorMap}.\n *\n * If {@link _InstanceOrStatic} is 'Instance', {@link InstanceTypeOrSelfPropertyDescriptorMap}.\\\n * Else if {@link _InstanceOrStatic} is 'Static',\n * {@link OwnPropertyDescriptorMap }.\\\n * Else, `never`.\n * @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class\n * A class definition cast to {@link ClassLike}.\n * @template {InstanceOrStatic} _InstanceOrStatic\n * 'Instance' or 'Static'. Determines the return type.\n * @since 3.0.0\n */\nexport type RecursedPropertyDescriptorMap<\n  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,\n  _InstanceOrStatic extends InstanceOrStatic,\n> = [_InstanceOrStatic] extends ['Instance'] ? InstanceTypeOrSelfPropertyDescriptorMap<Class, Class['__proto__']>\n  : [_InstanceOrStatic] extends ['Static'] ? OwnPropertyDescriptorMap<Class>\n      : never;\n\n/**\n * An\n * ordered array of {@link OwnPropertyDescriptorMap} or\n * {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}\n * and ending with a {@link BaseClass}.\n * @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class\n * @template {'Instance' | 'Static'} InstanceOrStatic\n * @template {Integer<number>} [Limit=16]\n * @template {Integer<number>} [CurrentLevel=0]\n */\nexport type RecursedPropertyDescriptorMapArray<\n  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,\n  InstanceOrStatic extends 'Instance' | 'Static',\n  Limit extends Integer<number> = 16,\n  CurrentLevel extends Integer<number> = 0,\n> = Class['__proto__'] extends BaseClassProto['__proto__'] | BaseClassProto['__proto__']['__proto__'] ? never\n  : Class['__proto__'] extends BaseClassProto ? [RecursedPropertyDescriptorMap<BaseClass<Class>, InstanceOrStatic>]\n    : Class['__proto__'] extends ConstructorLike<Class['__proto__']>\n      ? [\n          RecursedPropertyDescriptorMap<Class, InstanceOrStatic>,\n          ...RecursedPropertyDescriptorMapArray<\n            ClassLike<Exclude<Class['__proto__'], BaseClassProto> & WithProto<SuperClassLike | BaseClassProto>>,\n            InstanceOrStatic,\n            Limit,\n            Increment<CurrentLevel>\n          >,\n        ]\n      : never;\n/**\n * Walks the class inheritance chain to get a PropertyDescriptorMap of each class.\n *\n * While you _can_ use this to get an array of getter names/keys, you should use {@link getPrototypeOf} and {@link listOwnGetters}, instead!\n * @template Class Any class definition type-cast to {@link ClassLike}\n * @template _InstanceOrStatic\n * @param classDefinition Any class definition type-cast to {@link ClassLike}\n * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.\n * @returns An\n * ordered array of {@link OwnPropertyDescriptorMap} or\n * {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}\n * and ending with a {@link BaseClass}.\n * @since 3.0.0\n */\nexport function getOwnPropertyDescriptorsRecursively<\n  // Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n  _InstanceOrStatic extends InstanceOrStatic,\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  Limit extends Integer<number> = 16,\n>(\n  classDefinition: Class,\n  instanceOrStatic: _InstanceOrStatic,\n): RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic> {\n  const staticProtoChain: ProtoChainOfClass<Class> = getPrototypesChainOf(classDefinition, 'classes');\n  if (isSingleTuple(staticProtoChain)) {\n    return [\n      getOwnPropertyDescriptors(\n        staticProtoChain[0],\n        instanceOrStatic,\n      ) as RecursedPropertyDescriptorMap<Class, _InstanceOrStatic>,\n    ] as unknown as RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic, Limit>;\n  }\n\n  const recursedPropertyDescriptorMapArray = staticProtoChain.map(classDefinition =>\n    getOwnPropertyDescriptors(\n      classDefinition,\n      instanceOrStatic,\n    ),\n  );\n\n  return recursedPropertyDescriptorMapArray as RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic>;\n}\n\n/**\n * Simple utility for single-tuple type assertion\n * @template {T} T T in T[]\n * @param array an array\n * @returns array is [T]\n */\nfunction isSingleTuple<T>(array: T[]): array is [T] {\n  return Array.isArray(array) && array.length === 1;\n}\n"],"mappings":"6IAwFA,SAAgB,EAOd,EACA,EAC8D,CAC9D,IAAM,EAA6C,EAAqB,EAAiB,UAAU,CAiBnG,OAhBI,EAAc,EAAiB,CAC1B,CACL,EACE,EAAiB,GACjB,EACD,CACF,CAGwC,EAAiB,IAAI,GAC9D,EACE,EACA,EACD,CACF,CAWH,SAAS,EAAiB,EAA0B,CAClD,OAAO,MAAM,QAAQ,EAAM,EAAI,EAAM,SAAW"}

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

@@ -0,0 +1,19 @@
+import { BaseClassProto, ClassLike, ConstructorConstraint, ProtoChainOfClass, ProtoChainOfClassInstance, SuperClassLike, WithProto } from "./inheritance.mjs";
+
+//#region src/utils/reflection/getPrototypeChainOf.d.ts
+type ProtoChain<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>, ClassesOrInstances extends "classes" | "classInstances"> = [ClassesOrInstances] extends ["classInstances"] ? ProtoChainOfClassInstance<Class> : [ClassesOrInstances] extends ["classes"] ? ProtoChainOfClass<Class> : never;
+/**
+* Iterate through the class and its base/super classes until an anonymous function is reached. This is the default superclass all classes extend.
+* @template Class Any {@link ClassLike} type.
+* @template ClassesOrInstances 'classes' or 'classInstances'
+* @param classDefinition Any class type satisfying {@link Class}. This class (or its instance type) is included in the return value.
+* @param [returnType='classes'] Determines return type. If 'classInstances', the return type is an array of the classes' `.prototype`. Else, the classes themselves are returned.
+* @since 3.0.0
+* @returns
+* `returnType extends 'classInstances' ? ClassLike<T>[] : ClassLike<T>[].map(c => c.prototype)`
+* Excludes default superclasses e.g. anonymous functions, native code.
+*/
+declare function getPrototypesChainOf<Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>, ClassesOrInstances extends "classes" | "classInstances">(classDefinition: Class, returnType: ClassesOrInstances): ProtoChain<Class, ClassesOrInstances>;
+//#endregion
+export { getPrototypesChainOf };
+//# sourceMappingURL=getPrototypeChainOf.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPrototypeChainOf.d.mts","names":[],"sources":["../../../src/utils/reflection/getPrototypeChainOf.ts"],"mappings":";;;KAeK,UAAA,eACW,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,gEAE/E,kBAAA,+BAAiD,yBAAA,CAA0B,KAAA,KAC3E,kBAAA,wBAA0C,iBAAA,CAAkB,KAAA;;;;;;;;;;;;iBAcjD,oBAAA,eACA,SAAA,CAAU,qBAAA,CAAsB,KAAA,IAAS,SAAA,CAAU,cAAA,GAAiB,cAAA,4DAAA,CAGlF,eAAA,EAAiB,KAAA,EACjB,UAAA,EAAY,kBAAA,GACX,UAAA,CAAW,KAAA,EAAO,kBAAA"}

package/mjs/utils/reflection/getPrototypeChainOf.mjs

@@ -1,55 +1,2 @@
-import { getPrototypeOf } from './getPrototypeOf.mjs';
-import { baseClassProto } from './inheritance.mjs';
-import { isConstructor } from './isConstructor.mjs';
-
-/* eslint-disable jsdoc/no-defaults */
-
-/**
- * Iterate through the class and its base/super classes until an anonymous function is reached. This is the default superclass all classes extend.
- * @template Class Any {@link ClassLike} type.
- * @template ClassesOrInstances 'classes' or 'classInstances'
- * @param classDefinition Any class type satisfying {@link Class}. This class (or its instance type) is included in the return value.
- * @param [returnType='classes'] Determines return type. If 'classInstances', the return type is an array of the classes' `.prototype`. Else, the classes themselves are returned.
- * @since 3.0.0
- * @returns
- * `returnType extends 'classInstances' ? ClassLike<T>[] : ClassLike<T>[].map(c => c.prototype)`
- * Excludes default superclasses e.g. anonymous functions, native code.
- */
-function getPrototypesChainOf(classDefinition, returnType) {
-  // class definitions or their respective .prototype; exclude default superclasses.
-  let current = classDefinition;
-  let parent;
-  const returnValue = [];
-  let index = 0;
-  while (baseClassProto !== current) {
-    parent = getPrototypeOf(current);
-    // current is a Class symbol/constructor. Object.getOwnPropertyDescriptors on current will include static properties.
-    if (!isConstructor(current)) break;
-    if (returnType === 'classInstances') {
-      const instanceOfCurrent = current.prototype;
-      returnValue[index] = instanceOfCurrent;
-    } else {
-      returnValue[index] = current;
-    }
-
-    /**
-     * Assign the super class to current.
-     * If the argument is a class, Reflect.getPrototypeOf method returns the
-     * superclass.
-     */
-    if (isConstructor(parent) && 'name' in parent && typeof parent.name === 'string' && '' !== parent.name // it's possible for a Function/Constructor to be anonymous...
-    ) {
-      current = parent;
-    } else {
-      break;
-    }
-    index++;
-  }
-  return returnValue;
-  /*
-    assuming current is NugetProjectProperties...
-    Reflect.getPrototypeOf(current).name is 'MSBuildProjectProperties'
-   */
-}
-export { getPrototypesChainOf };
-//# sourceMappingURL=getPrototypeChainOf.mjs.map
+import{getPrototypeOf as e}from"./getPrototypeOf.mjs";import{baseClassProto as t}from"./inheritance.mjs";import{isConstructor as n}from"./isConstructor.mjs";function r(r,i){let a=r,o,s=[],c=0;for(;t!==a&&(o=e(a),n(a))&&(i===`classInstances`?s[c]=a.prototype:s[c]=a,n(o)&&`name`in o&&typeof o.name==`string`&&o.name!==``);)a=o,c++;return s}export{r as getPrototypesChainOf};
+//# sourceMappingURL=getPrototypeChainOf.mjs.map

package/mjs/utils/reflection/getPrototypeChainOf.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getPrototypeChainOf.mjs","sources":["../../../src/utils/reflection/getPrototypeChainOf.ts"],"names":[],"mappings":";;;;AAAA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,oBAAoB,CAAC,eAAe,EAAE,UAAU,EAAE;AAClE;AACA,EAAE,IAAI,OAAO,GAAG,eAAe;AAC/B,EAAE,IAAI,MAAM;AACZ,EAAE,MAAM,WAAW,GAAG,EAAE;AACxB,EAAE,IAAI,KAAK,GAAG,CAAC;AACf,EAAE,OAAO,cAAc,KAAK,OAAO,EAAE;AACrC,IAAI,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC;AACpC;AACA,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;AACjC,IAAI,IAAI,UAAU,KAAK,gBAAgB,EAAE;AACzC,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,SAAS;AACjD,MAAM,WAAW,CAAC,KAAK,CAAC,GAAG,iBAAiB;AAC5C,IAAI,CAAC,MAAM;AACX,MAAM,WAAW,CAAC,KAAK,CAAC,GAAG,OAAO;AAClC,IAAI;;AAEJ;AACA;AACA;AACA;AACA;AACA,IAAI,IAAI,aAAa,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,EAAE,KAAK,MAAM,CAAC,IAAI;AAC1G,MAAM;AACN,MAAM,OAAO,GAAG,MAAM;AACtB,IAAI,CAAC,MAAM;AACX,MAAM;AACN,IAAI;AACJ,IAAI,KAAK,EAAE;AACX,EAAE;AACF,EAAE,OAAO,WAAW;AACpB;AACA;AACA;AACA;AACA;;;;"}
+{"version":3,"file":"getPrototypeChainOf.mjs","names":[],"sources":["../../../src/utils/reflection/getPrototypeChainOf.ts"],"sourcesContent":["/* eslint-disable jsdoc/no-defaults */\nimport type { TupleIndices } from '../miscTypes.ts';\nimport { getPrototypeOf } from './getPrototypeOf.ts';\nimport {\n  baseClassProto,\n  type BaseClassProto,\n  type ClassLike,\n  type ConstructorConstraint,\n  type ProtoChainOfClass,\n  type ProtoChainOfClassInstance,\n  type SuperClassLike,\n  type WithProto,\n} from './inheritance.ts';\nimport { isConstructor } from './isConstructor.ts';\n\ntype ProtoChain<\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n  ClassesOrInstances extends 'classes' | 'classInstances',\n> = [ClassesOrInstances] extends ['classInstances'] ? ProtoChainOfClassInstance<Class>\n  : [ClassesOrInstances] extends ['classes'] ? ProtoChainOfClass<Class>\n      : never;\n\n/**\n * Iterate through the class and its base/super classes until an anonymous function is reached. This is the default superclass all classes extend.\n * @template Class Any {@link ClassLike} type.\n * @template ClassesOrInstances 'classes' or 'classInstances'\n * @param classDefinition Any class type satisfying {@link Class}. This class (or its instance type) is included in the return value.\n * @param [returnType='classes'] Determines return type. If 'classInstances', the return type is an array of the classes' `.prototype`. Else, the classes themselves are returned.\n * @since 3.0.0\n * @returns\n * `returnType extends 'classInstances' ? ClassLike<T>[] : ClassLike<T>[].map(c => c.prototype)`\n * Excludes default superclasses e.g. anonymous functions, native code.\n */\nexport function getPrototypesChainOf<\n  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,\n  ClassesOrInstances extends 'classes' | 'classInstances',\n>(\n  classDefinition: Class,\n  returnType: ClassesOrInstances,\n): ProtoChain<Class, ClassesOrInstances> {\n  // class definitions or their respective .prototype; exclude default superclasses.\n  let current: ProtoChainOfClass<Class>[TupleIndices<ProtoChainOfClass<Class>>] = classDefinition as ProtoChainOfClass<Class>[0 extends TupleIndices<ProtoChainOfClass<Class>> ? 0 : never];\n  let parent: typeof current & WithProto<SuperClassLike | BaseClassProto> | object;\n  const returnValue = [] as unknown as\n  ProtoChain<Class, ClassesOrInstances>;\n  let index: TupleIndices<typeof returnValue> = 0 as TupleIndices<typeof returnValue>;\n\n  while (baseClassProto !== current) {\n    parent = getPrototypeOf(current);\n    // current is a Class symbol/constructor. Object.getOwnPropertyDescriptors on current will include static properties.\n    if (!isConstructor(current))\n      break;\n    if (returnType === 'classInstances') {\n      const instanceOfCurrent = current.prototype as InstanceType<typeof current>;\n\n      returnValue[index] = instanceOfCurrent as typeof returnValue[typeof index];\n    }\n    else {\n      returnValue[index] = current as typeof returnValue[typeof index];\n    }\n\n    /**\n     * Assign the super class to current.\n     * If the argument is a class, Reflect.getPrototypeOf method returns the\n     * superclass.\n     */\n    if (\n      isConstructor(parent)\n      && 'name' in parent\n      && typeof parent.name === 'string'\n      && '' !== parent.name // it's possible for a Function/Constructor to be anonymous...\n    ) {\n      current = parent as ProtoChainOfClass<Class>[TupleIndices<ProtoChainOfClass<Class>>];\n    }\n    else {\n      break;\n    }\n    index++;\n  }\n  return returnValue;\n  /*\n    assuming current is NugetProjectProperties...\n    Reflect.getPrototypeOf(current).name is 'MSBuildProjectProperties'\n   */\n}\n"],"mappings":"6JAiCA,SAAgB,EAId,EACA,EACuC,CAEvC,IAAI,EAA4E,EAC5E,EACE,EAAc,EAAE,CAElB,EAA0C,EAE9C,KAAO,IAAmB,IACxB,EAAS,EAAe,EAAQ,CAE3B,EAAc,EAAQ,IAEvB,IAAe,iBAGjB,EAAY,GAFc,EAAQ,UAKlC,EAAY,GAAS,EASrB,EAAc,EAAO,EAClB,SAAU,GACV,OAAO,EAAO,MAAS,UAChB,EAAO,OAAd,KAEH,EAAU,EAKZ,IAEF,OAAO"}

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

@@ -0,0 +1,12 @@
+import { ProtoOrSuperClass, WithProto } from "./inheritance.mjs";
+
+//#region src/utils/reflection/getPrototypeOf.d.ts
+/**
+* A nearly useless wrapper for {@link Reflect.getPrototypeOf}
+* @param object An object with the internal `__proto__` property present in its type.
+* @returns The `__proto__` of the `object` param.
+*/
+declare function getPrototypeOf<T extends WithProto<ProtoOrSuperClass>>(object: T): T["__proto__"];
+//#endregion
+export { getPrototypeOf };
+//# sourceMappingURL=getPrototypeOf.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPrototypeOf.d.mts","names":[],"sources":["../../../src/utils/reflection/getPrototypeOf.ts"],"mappings":";;;;;AAOA;;;iBAAgB,cAAA,WACJ,SAAA,CAAU,iBAAA,EAAA,CACpB,MAAA,EAAQ,CAAA,GAAI,CAAA"}

package/mjs/utils/reflection/getPrototypeOf.mjs

@@ -1,10 +1,2 @@
-/**
- * A nearly useless wrapper for {@link Reflect.getPrototypeOf}
- * @param object An object with the internal `__proto__` property present in its type.
- * @returns The `__proto__` of the `object` param.
- */
-function getPrototypeOf(object) {
-  return Reflect.getPrototypeOf(object);
-}
-export { getPrototypeOf };
-//# sourceMappingURL=getPrototypeOf.mjs.map
+function e(e){return Reflect.getPrototypeOf(e)}export{e as getPrototypeOf};
+//# sourceMappingURL=getPrototypeOf.mjs.map

package/mjs/utils/reflection/getPrototypeOf.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getPrototypeOf.mjs","sources":["../../../src/utils/reflection/getPrototypeOf.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACO,SAAS,cAAc,CAAC,MAAM,EAAE;AACvC,EAAE,OAAO,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC;AACvC;;;;"}
+{"version":3,"file":"getPrototypeOf.mjs","names":[],"sources":["../../../src/utils/reflection/getPrototypeOf.ts"],"sourcesContent":["import type { ProtoOrSuperClass, WithProto } from './inheritance.ts';\n\n/**\n * A nearly useless wrapper for {@link Reflect.getPrototypeOf}\n * @param object An object with the internal `__proto__` property present in its type.\n * @returns The `__proto__` of the `object` param.\n */\nexport function getPrototypeOf<\n  T extends WithProto<ProtoOrSuperClass>,\n>(object: T): T['__proto__'] {\n  return Reflect.getPrototypeOf(object) as T['__proto__'];\n}\n"],"mappings":"AAOA,SAAgB,EAEd,EAA2B,CAC3B,OAAO,QAAQ,eAAe,EAAO"}