@halospv3/hce.shared-config 3.5.3-develop.2 → 3.6.0

package/src/utils/reflection/InstanceTypeOrSelfPropertyDescriptorMap.d.ts

@@ -1,4 +1,4 @@
-import type { BaseClassProto, ConstructorLike, InstanceTypeOrSelf, ProtoOrSuperClass, SuperClassLike, WithProto } from './inheritance.ts';
+import type { BaseClassProto as BaseClassPrototype, ConstructorLike, InstanceTypeOrSelf, ProtoOrSuperClass as PrototypeOrSuperClass, SuperClassLike, WithProto as WithPrototype } from './inheritance.ts';
 import type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.d.ts';
 import type { PropertyDescriptorMap } from './PropertyDescriptorMap.d.ts';
 
@@ -12,9 +12,9 @@ import type { PropertyDescriptorMap } from './PropertyDescriptorMap.d.ts';
  */
 export type InstanceTypeOrSelfPropertyDescriptorMap<
   T extends object | null,
-  __proto__ extends ProtoOrSuperClass,
+  __prototype__ extends PrototypeOrSuperClass,
 > = T extends ConstructorLike<T>
-  ? __proto__ extends SuperClassLike | BaseClassProto
-    ? InstancePropertyDescriptorMap<T & WithProto<__proto__>>
-    : PropertyDescriptorMap<InstanceType<T>, InstanceTypeOrSelf<__proto__>>
-  : PropertyDescriptorMap<InstanceTypeOrSelf<T>, InstanceTypeOrSelf<__proto__>>;
+  ? __prototype__ extends SuperClassLike | BaseClassPrototype
+    ? InstancePropertyDescriptorMap<T & WithPrototype<__prototype__>>
+    : PropertyDescriptorMap<InstanceType<T>, InstanceTypeOrSelf<__prototype__>>
+  : PropertyDescriptorMap<InstanceTypeOrSelf<T>, InstanceTypeOrSelf<__prototype__>>;

package/src/utils/reflection/OwnGetterDescriptorMap.d.ts

@@ -13,5 +13,5 @@ import type { OwnKeyOf } from './OwnKeyOf.d.ts';
  */
 export type OwnGetterDescriptorMap<
   T,
-  __proto__ extends object | null,
-> = { [P in OwnKeyOf<T, __proto__>]: GetterDescriptor<T[P]> };
+  __prototype__ extends object | null,
+> = { [P in OwnKeyOf<T, __prototype__>]: GetterDescriptor<T[P]> };

package/src/utils/reflection/OwnKeyOf.d.ts

@@ -8,13 +8,13 @@
  * OwnKeyOf<typeof NPP, null> === "prototype" | "GetFullPath"
  * @since 3.0.0
  */
-export type OwnKeyOf<T, __proto__ extends object | null>
+export type OwnKeyOf<T, __prototype__ extends object | null>
   = Exclude<
-    __proto__ extends null
+    __prototype__ extends null
       ? keyof T
       : Exclude<
         keyof T,
-        keyof __proto__
+        keyof __prototype__
       >,
     '__proto__'
   >;

package/src/utils/reflection/OwnPropertyDescriptorMap.d.ts

@@ -2,8 +2,8 @@ import type {
   BaseClass,
   ClassLike,
   ClassLike_Unknown,
-  ProtoOrSuperClass,
-  WithProto,
+  ProtoOrSuperClass as PrototypeOrSuperClass,
+  WithProto as WithPrototype,
 } from './inheritance.ts';
 
 // todo: Omit [P in keyof T] where T['__proto__'][P] === T[P].
@@ -15,7 +15,7 @@ import type {
  * @template T Any type with its `[[Prototype]]` attached via a type-only `__proto__` property. The type of `__proto__` must extends {@link ProtoOrSuperClass}.
  * @since 3.0.0
  */
-export type OwnPropertyDescriptorMap<T extends WithProto<ProtoOrSuperClass>>
+export type OwnPropertyDescriptorMap<T extends WithPrototype<PrototypeOrSuperClass>>
   = T['__proto__'] extends null
     ? { [P0 in keyof T]: TypedPropertyDescriptor<T[P0]>; }
     : Omit<

package/src/utils/reflection/PropertyDescriptorMap.d.ts

@@ -6,10 +6,10 @@
  * The `null` or the `object`-like `[[Prototype]]` of {@link T}.
  * @since 3.0.0
  */
-export type PropertyDescriptorMap<T, __proto__ extends object | null = null>
-  = __proto__ extends null
+export type PropertyDescriptorMap<T, __prototype__ extends object | null = null>
+  = __prototype__ 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]> }
+      keyof { [P1 in keyof __prototype__]: TypedPropertyDescriptor<__prototype__[P1]> }
     >;

package/src/utils/reflection/filterForGetters.ts

@@ -1,11 +1,11 @@
 import type {
-  BaseClassProto,
-  baseClassProto,
+  BaseClassProto as BaseClassPrototype,
+  baseClassProto as baseClassPrototype,
   ClassLike,
   ConstructorConstraint,
   InstanceTypeOrSelf,
   SuperClassLike,
-  WithProto,
+  WithProto as WithPrototype,
 } from './inheritance.ts';
 import type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.d.ts';
 import type { OwnGetterDescriptorMap } from './OwnGetterDescriptorMap.d.ts';
@@ -13,15 +13,15 @@ import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';
 import type { PropertyDescriptorMap } from './PropertyDescriptorMap.d.ts';
 
 export function filterForGetters<
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | typeof baseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | typeof baseClassPrototype>>,
 >(
   descriptorMap: InstancePropertyDescriptorMap<Class>,
 ): Partial<OwnGetterDescriptorMap<
   InstanceType<Class>,
-  Class['__proto__'] extends BaseClassProto ? null : InstanceTypeOrSelf<Class['__proto__']>
+  Class['__proto__'] extends BaseClassPrototype ? null : InstanceTypeOrSelf<Class['__proto__']>
 >>;
 export function filterForGetters<
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
 >(
   descriptorMap: OwnPropertyDescriptorMap<Class>,
 ): Partial<OwnGetterDescriptorMap<Class, Class['__proto__']>>;
@@ -40,11 +40,11 @@ export function filterForGetters<
  */
 export function filterForGetters<
   T extends object,
-  __proto__ extends object | null = null,
+  __prototype__ extends object | null = null,
 >(
-  descriptorMap: PropertyDescriptorMap<T, __proto__> | PropertyDescriptorMap<T>,
-): Partial<OwnGetterDescriptorMap<T, __proto__>> {
-  let getterDescriptorMap: Partial<OwnGetterDescriptorMap<T, __proto__>> = {};
+  descriptorMap: PropertyDescriptorMap<T, __prototype__> | PropertyDescriptorMap<T>,
+): Partial<OwnGetterDescriptorMap<T, __prototype__>> {
+  let getterDescriptorMap: Partial<OwnGetterDescriptorMap<T, __prototype__>> = {};
   for (const key in descriptorMap) {
     const element = descriptorMap[key as keyof typeof descriptorMap];
     if (typeof element.get === 'function') {

package/src/utils/reflection/getOwnPropertyDescriptors.ts

@@ -1,5 +1,5 @@
 import type { InstanceOrStatic } from '../miscTypes.ts';
-import type { BaseClassProto, ClassLike, ConstructorConstraint, SuperClassLike, WithProto } from './inheritance.ts';
+import type { BaseClassProto as BaseClassPrototype, ClassLike, ConstructorConstraint, SuperClassLike, WithProto as WithPrototype } from './inheritance.ts';
 import type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.d.ts';
 import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';
 
@@ -20,7 +20,7 @@ import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';
  * @since 3.0.0
  */
 export function getOwnPropertyDescriptors<
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
   _InstanceOrStatic extends InstanceOrStatic,
 >(
   classDefinition: Class,

package/src/utils/reflection/getOwnPropertyDescriptorsRecursively.ts

@@ -4,13 +4,13 @@ import { getOwnPropertyDescriptors } from './getOwnPropertyDescriptors.ts';
 import { getPrototypesChainOf } from './getPrototypeChainOf.ts';
 import type {
   BaseClass,
-  BaseClassProto,
+  BaseClassProto as BaseClassPrototype,
   ClassLike,
   ConstructorConstraint,
   ConstructorLike,
-  ProtoChainOfClass,
+  ProtoChainOfClass as PrototypeChainOfClass,
   SuperClassLike,
-  WithProto,
+  WithProto as WithPrototype,
 } from './inheritance.ts';
 import type { InstanceTypeOrSelfPropertyDescriptorMap } from './InstanceTypeOrSelfPropertyDescriptorMap.d.ts';
 import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';
@@ -38,7 +38,7 @@ import type { InstancePropertyDescriptorMap as _InstancePropertyDescriptorMap }
  * @since 3.0.0
  */
 export type RecursedPropertyDescriptorMap<
-  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,
+  Class extends ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>,
   _InstanceOrStatic extends InstanceOrStatic,
 > = [_InstanceOrStatic] extends ['Instance'] ? InstanceTypeOrSelfPropertyDescriptorMap<Class, Class['__proto__']>
   : [_InstanceOrStatic] extends ['Static'] ? OwnPropertyDescriptorMap<Class>
@@ -55,17 +55,17 @@ export type RecursedPropertyDescriptorMap<
  * @template {Integer<number>} [CurrentLevel=0]
  */
 export type RecursedPropertyDescriptorMapArray<
-  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,
+  Class extends ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>,
   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 BaseClassPrototype['__proto__'] | BaseClassPrototype['__proto__']['__proto__'] ? never
+  : Class['__proto__'] extends BaseClassPrototype ? [RecursedPropertyDescriptorMap<BaseClass<Class>, InstanceOrStatic>]
     : Class['__proto__'] extends ConstructorLike<Class['__proto__']>
       ? [
           RecursedPropertyDescriptorMap<Class, InstanceOrStatic>,
           ...RecursedPropertyDescriptorMapArray<
-            ClassLike<Exclude<Class['__proto__'], BaseClassProto> & WithProto<SuperClassLike | BaseClassProto>>,
+            ClassLike<Exclude<Class['__proto__'], BaseClassPrototype> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
             InstanceOrStatic,
             Limit,
             Increment<CurrentLevel>
@@ -88,7 +88,7 @@ export type RecursedPropertyDescriptorMapArray<
  */
 export function getOwnPropertyDescriptorsRecursively<
   // Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
   _InstanceOrStatic extends InstanceOrStatic,
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
   Limit extends Integer<number> = 16,
@@ -96,17 +96,17 @@ export function getOwnPropertyDescriptorsRecursively<
   classDefinition: Class,
   instanceOrStatic: _InstanceOrStatic,
 ): RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic> {
-  const staticProtoChain: ProtoChainOfClass<Class> = getPrototypesChainOf(classDefinition, 'classes');
-  if (isSingleTuple(staticProtoChain)) {
+  const staticPrototypeChain: PrototypeChainOfClass<Class> = getPrototypesChainOf(classDefinition, 'classes');
+  if (isSingleTuple(staticPrototypeChain)) {
     return [
       getOwnPropertyDescriptors(
-        staticProtoChain[0],
+        staticPrototypeChain[0],
         instanceOrStatic,
       ) as RecursedPropertyDescriptorMap<Class, _InstanceOrStatic>,
     ] as unknown as RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic, Limit>;
   }
 
-  const recursedPropertyDescriptorMapArray = staticProtoChain.map(classDefinition =>
+  const recursedPropertyDescriptorMapArray = staticPrototypeChain.map(classDefinition =>
     getOwnPropertyDescriptors(
       classDefinition,
       instanceOrStatic,

package/src/utils/reflection/getPrototypeChainOf.ts

@@ -2,22 +2,22 @@
 import type { TupleIndices } from '../miscTypes.ts';
 import { getPrototypeOf } from './getPrototypeOf.ts';
 import {
-  baseClassProto,
-  type BaseClassProto,
+  baseClassProto as baseClassPrototype,
+  type BaseClassProto as BaseClassPrototype,
   type ClassLike,
   type ConstructorConstraint,
-  type ProtoChainOfClass,
-  type ProtoChainOfClassInstance,
+  type ProtoChainOfClass as PrototypeChainOfClass,
+  type ProtoChainOfClassInstance as PrototypeChainOfClassInstance,
   type SuperClassLike,
-  type WithProto,
+  type WithProto as WithPrototype,
 } from './inheritance.ts';
 import { isConstructor } from './isConstructor.ts';
 
-type ProtoChain<
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+type PrototypeChain<
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
   ClassesOrInstances extends 'classes' | 'classInstances',
-> = [ClassesOrInstances] extends ['classInstances'] ? ProtoChainOfClassInstance<Class>
-  : [ClassesOrInstances] extends ['classes'] ? ProtoChainOfClass<Class>
+> = [ClassesOrInstances] extends ['classInstances'] ? PrototypeChainOfClassInstance<Class>
+  : [ClassesOrInstances] extends ['classes'] ? PrototypeChainOfClass<Class>
       : never;
 
 /**
@@ -32,21 +32,21 @@ type ProtoChain<
  * Excludes default superclasses e.g. anonymous functions, native code.
  */
 export function getPrototypesChainOf<
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
   ClassesOrInstances extends 'classes' | 'classInstances',
 >(
   classDefinition: Class,
   returnType: ClassesOrInstances,
-): ProtoChain<Class, ClassesOrInstances> {
+): PrototypeChain<Class, ClassesOrInstances> {
   // class definitions or their respective .prototype; exclude default superclasses.
-  let current: ProtoChainOfClass<Class>[TupleIndices<ProtoChainOfClass<Class>>] = classDefinition as ProtoChainOfClass<Class>[0 extends TupleIndices<ProtoChainOfClass<Class>> ? 0 : never];
-  let parent: typeof current & WithProto<SuperClassLike | BaseClassProto> | object;
+  let current: PrototypeChainOfClass<Class>[TupleIndices<PrototypeChainOfClass<Class>>] = classDefinition as PrototypeChainOfClass<Class>[0 extends TupleIndices<PrototypeChainOfClass<Class>> ? 0 : never];
   const returnValue = [] as unknown as
-  ProtoChain<Class, ClassesOrInstances>;
+  PrototypeChain<Class, ClassesOrInstances>;
   let index: TupleIndices<typeof returnValue> = 0 as TupleIndices<typeof returnValue>;
 
-  while (baseClassProto !== current) {
-    parent = getPrototypeOf(current);
+  while (baseClassPrototype !== current) {
+    const parent: typeof current & WithPrototype<SuperClassLike | BaseClassPrototype> | object
+      = getPrototypeOf(current);
     // current is a Class symbol/constructor. Object.getOwnPropertyDescriptors on current will include static properties.
     if (!isConstructor(current))
       break;
@@ -70,7 +70,7 @@ export function getPrototypesChainOf<
       && typeof parent.name === 'string'
       && '' !== parent.name // it's possible for a Function/Constructor to be anonymous...
     ) {
-      current = parent as ProtoChainOfClass<Class>[TupleIndices<ProtoChainOfClass<Class>>];
+      current = parent as PrototypeChainOfClass<Class>[TupleIndices<PrototypeChainOfClass<Class>>];
     }
     else {
       break;

package/src/utils/reflection/getPrototypeOf.ts

@@ -1,4 +1,4 @@
-import type { ProtoOrSuperClass, WithProto } from './inheritance.ts';
+import type { ProtoOrSuperClass as PrototypeOrSuperClass, WithProto as WithPrototype } from './inheritance.ts';
 
 /**
  * A nearly useless wrapper for {@link Reflect.getPrototypeOf}
@@ -6,7 +6,7 @@ import type { ProtoOrSuperClass, WithProto } from './inheritance.ts';
  * @returns The `__proto__` of the `object` param.
  */
 export function getPrototypeOf<
-  T extends WithProto<ProtoOrSuperClass>,
+  T extends WithPrototype<PrototypeOrSuperClass>,
 >(object: T): T['__proto__'] {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
   return Reflect.getPrototypeOf(object) as T['__proto__'];

package/src/utils/reflection/inheritance.ts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/name-replacements */
 import type { Increment } from '../GracefulRecursion.d.ts';
 import type { Integer } from '../miscTypes.ts';
 import type { FunctionLike } from './FunctionLike.d.ts';
@@ -54,7 +55,7 @@ export type BaseClass<Class extends ConstructorConstraint<Class>>
  * @since 3.0.0
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Constructor_Unknown = abstract new (...args: any[]) => any;
+export type Constructor_Unknown = abstract new (...arguments_: any[]) => any;
 
 /**
  * The constraint for constructor types.
@@ -63,7 +64,7 @@ export type Constructor_Unknown = abstract new (...args: any[]) => any;
  * @template T Any newable constructor type
  * @since 3.0.0
  */
-export type ConstructorConstraint<T extends abstract new (...args: ConstructorParameters<T>) => InstanceType<T>> = abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>;
+export type ConstructorConstraint<T extends abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>> = abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>;
 
 /**
  * {@link T} is a class constructor or unknown constructor. Else, `never`.
@@ -257,6 +258,6 @@ export type InstanceTypeOrSelf<T extends object | null> = T extends ConstructorL
  * @template __proto__ the type of the an object's `[[Prototype]]`.
  * @since 3.0.0
  */
-export interface WithProto<__proto__ extends ProtoOrSuperClass> {
-  ['__proto__']: __proto__;
+export interface WithProto<__prototype__ extends ProtoOrSuperClass> {
+  ['__proto__']: __prototype__;
 }

package/src/utils/reflection/isConstructor.ts

@@ -8,20 +8,20 @@
  * 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`.
+ * @param object Anything.
+ * @returns `true` if the {@link object} is a constructor. Else, `false`.
  * @since 3.0.0
  * @see https://stackoverflow.com/a/49510834
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isConstructor(obj: unknown): obj is abstract new (...args: any[]) => any {
+export function isConstructor(object: unknown): object is abstract new (...arguments_: any[]) => any {
   // Method 0 - filter
-  if (typeof obj !== 'function')
+  if (typeof object !== 'function')
     return false;
 
   // Method 1
   // statically-defined class
-  if (/^class\s/.test(obj.toString()))
+  if (/^class\s/.test(object.toString()))
     return true;
 
   /* Method 2
@@ -38,7 +38,7 @@ export function isConstructor(obj: unknown): obj is abstract new (...args: any[]
    * typeof Function.prototype
    * > 'function'
    */
-  const prototype: unknown = obj.prototype;
+  const prototype: unknown = object.prototype;
   if ((typeof prototype === 'object' || typeof prototype === 'function')
     && prototype !== null
     && 'constructor' in prototype
@@ -50,7 +50,7 @@ export function isConstructor(obj: unknown): obj is abstract new (...args: any[]
     );
     // short-circuit if `obj.prototype.constructor` is a function, but not a constructor. Return false.
     return (
-      _ctor === obj
+      _ctor === object
       && _name?.writable === false
       && _name.enumerable === false
       && _name.configurable === true

package/src/utils/reflection/listOwnGetters.ts

@@ -2,12 +2,12 @@ import type { InstanceOrStatic } from '../miscTypes.ts';
 import { filterForGetters } from './filterForGetters.ts';
 import { getOwnPropertyDescriptors } from './getOwnPropertyDescriptors.ts';
 import type {
-  BaseClassProto,
+  BaseClassProto as BaseClassPrototype,
   ClassLike,
   ConstructorConstraint,
   InstanceTypeOrSelf,
   SuperClassLike,
-  WithProto,
+  WithProto as WithPrototype,
 } from './inheritance.ts';
 import type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.d.ts';
 import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';
@@ -19,16 +19,16 @@ import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.d.ts';
  * @since 3.0.0
  */
 type OwnGetters<
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
   _InstanceOrStatic extends InstanceOrStatic,
 >
   = [_InstanceOrStatic] extends ['Instance']
     ? Exclude<
-      (Class['__proto__'] extends BaseClassProto ? null : InstanceTypeOrSelf<Class['__proto__']>) extends null
+      (Class['__proto__'] extends BaseClassPrototype ? null : InstanceTypeOrSelf<Class['__proto__']>) extends null
         ? keyof InstanceType<Class>
         : Exclude<
           keyof InstanceType<Class>,
-          keyof (Class['__proto__'] extends BaseClassProto ? null : InstanceTypeOrSelf<Class['__proto__']>)
+          keyof (Class['__proto__'] extends BaseClassPrototype ? null : InstanceTypeOrSelf<Class['__proto__']>)
         >,
       '__proto__'
     >[]
@@ -54,7 +54,7 @@ type OwnGetters<
  * 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;
  */
 export function listOwnGetters<
-  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>>,
   _InstanceOrStatic extends InstanceOrStatic,
 >(
   classDefinition: Class,
@@ -66,7 +66,7 @@ export function listOwnGetters<
     const keyArray = Reflect.ownKeys(getterDescriptorMap) as (keyof typeof getterDescriptorMap)[];
     return keyArray as [typeof instanceOrStatic & 'Instance'] extends ['Instance'] ? typeof keyArray : never;
   }
-  else if (instanceOrStatic === 'Static') {
+  if (instanceOrStatic === 'Static') {
     const descriptorMap: OwnPropertyDescriptorMap<Class> = getOwnPropertyDescriptors(classDefinition, instanceOrStatic as 'Static');
     const getterDescriptorMap = filterForGetters(descriptorMap);
     const keyArray = Reflect.ownKeys(getterDescriptorMap) as (keyof typeof getterDescriptorMap)[];
@@ -76,5 +76,5 @@ export function listOwnGetters<
           ? typeof keyArray
           : never;
   }
-  else throw new TypeError('Argument `instanceOrStatic` must be "Instance" or "Static".');
+  throw new TypeError('Argument `instanceOrStatic` must be "Instance" or "Static".');
 }

package/tsconfig.base.json

@@ -26,9 +26,11 @@
   "extends": "./tsconfig.node.json",
   "compilerOptions": {
     "allowImportingTsExtensions": true,
+    "allowJs": false,
     "composite": true,
     "declarationMap": true,
     "emitDeclarationOnly": true,
+    "erasableSyntaxOnly": true,
     "forceConsistentCasingInFileNames": true,
     "isolatedDeclarations": true,
     "isolatedModules": true,