Mapping class names against corresponding class instances in Typescript

In a Typescript project that I'm working on, there are a ton of classes that share the same constructor definition. Instead of initializing them line by line, I thought about storing the classes inside an array, and then loop through it to initialize all of them like so:

class A { ... }
class B { ... }

const arr = [A, B];
const instances: ___ = {};

arr.forEach((Class) => {
    instances[uncapitalize(Class.name)] = new Class();
});

function uncapitalize<T extends string>(str: T): Uncapitalize<T> {
    ...
}

Right now, I'm having trouble coming up with a type declaration for instances that would map 'uncapitalized' class names to their corresponding instances.

I've tried the following as a type declaration for instances:

[K in typeof arr[number]['name'] as `${Uncapitalize<K>}`]: InstanceType<typeof arr[number]>

but this type declaration would allow any instance to be assigned to any class name key. Also, Typescript intellisense isn't picking up on the properties of instances for some reason.

Classes themselves don't have names in TS:

class A { #private = true }
A.name
// ^?
// (property) Function.name: string

so you need a Record of classes rather then array to keep their names:

class A { #private = true }
class B { #private = true }
function uncapitalize<T extends string>(str: T): Uncapitalize<T> {
    return str.toLowerCase() as any;
}

const classMap = { A, B };
// satisfies Record<string, new () => object>; if you want to check them
const instances: {
    [K in keyof typeof classMap as Uncapitalize<K>]: InstanceType<typeof classMap[K]>
} = Object.fromEntries(
    Object.entries(classMap)
        .map(([k, v]) => [uncapitalize(k), new v()])
) as any;
// const instances: {
//     a: A;
//     b: B;
// }