diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 0000000..9fcfde7
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,3 @@
+{
+    "printWidth": 120
+}
diff --git a/README.md b/README.md
index d92abaf..9dd6d5b 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,7 @@ A light-weight TypeScript-first library for dependency injection.
 
 * Stand-alone, no need to install other dependencies
 * Intended for both JavaScript and TypeScript projects
+* Supports three-shakeable injection tokens
 * Inspired by [Angular](https://angular.dev/) and [InversifyJS](https://github.com/inversify/InversifyJS)
 * Uses native [ECMAScript TC39 decorators](https://github.com/tc39/proposal-decorators) (currently stage 3)
 * No need for `experimentalDecorators` and `emitDecoratorMetadata`
@@ -64,6 +65,7 @@ Check out the [advanced examples](#advanced-examples) below to learn more!
   * Static values
   * Dynamic factories
   * Async factories
+  * Multi providers
 * Inheritance support
 
 ## Limitations
@@ -75,7 +77,6 @@ However, if you prefer a light-weight library that works out of the box and prov
 
 * Extend the Container API
 * Scoping
-* Multi-injection
 * ...
 
 Please file an issue if you like to propose new features.
diff --git a/src/container.test.ts b/src/container.test.ts
index 8baec6b..8096c48 100644
--- a/src/container.test.ts
+++ b/src/container.test.ts
@@ -1,11 +1,5 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import {
-  bootstrap,
-  bootstrapAsync,
-  Container,
-  inject,
-  injectAsync,
-} from "./container.js";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { bootstrap, bootstrapAsync, Container, inject, injectAsync } from "./container.js";
 import { injectable } from "./decorators.js";
 import { InjectionToken } from "./tokens.js";
 
diff --git a/src/container.ts b/src/container.ts
index 1c40614..9588668 100644
--- a/src/container.ts
+++ b/src/container.ts
@@ -1,9 +1,4 @@
-import {
-  type Token,
-  isClassToken,
-  toString,
-  isInjectionToken,
-} from "./tokens.js";
+import { type Token, isClassToken, toString, isInjectionToken } from "./tokens.js";
 import {
   isClassProvider,
   isFactoryProvider,
@@ -11,8 +6,10 @@ import {
   isValueProvider,
   type Provider,
   isAsyncFactoryProvider,
+  isMultiProvider,
+  isExistingProvider,
 } from "./providers.js";
-import { getInjectableTarget, isInjectable } from './decorators.js';
+import { getInjectableTargets, isInjectable } from "./decorators.js";
 
 export class Container {
   private providers: ProviderMap = new Map();
@@ -20,108 +17,157 @@ export class Container {
 
   bind<T>(provider: Provider<T>): this {
     const token = isConstructorProvider(provider) ? provider : provider.provide;
+    const multi = isMultiProvider(provider);
+
+    if (isExistingProvider(provider) && provider.provide === provider.useExisting) {
+      throw Error(`A provider with "useExisting" cannot refer to itself`);
+    }
 
-    if (this.providers.has(token)) {
-      // todo: log warning, since we're overwriting a provider?
-      //  alternatively, provide both .bind() and .rebind() semantics?
+    if (!isExistingProvider(provider) && this.singletons.has(token)) {
+      throw Error(
+        `Cannot bind a new provider for ${toString(token)}, since the existing provider was already constructed.`,
+      );
     }
 
-    this.providers.set(token, provider);
+    const existingProviders = this.providers.get(token) ?? [];
+
+    if (multi && existingProviders.some((it) => !isMultiProvider(it))) {
+      // todo: should we be this strict, or only throw an error in mismatches upon retrieving?
+      throw Error(
+        `Cannot bind ${toString(token)} as multi-provider, since there is already a provider which is not a multi-provider.`,
+      );
+    } else if (!multi && existingProviders.some((it) => isMultiProvider(it))) {
+      throw Error(
+        `Cannot bind ${toString(token)} as provider, since there are already provider(s) that are multi-providers.`,
+      );
+    }
+
+    if (multi) {
+      this.providers.set(token, [...existingProviders, provider]);
+    } else {
+      if (existingProviders.length > 0) {
+        // todo: log warning, since we're overwriting a provider?
+        //  alternatively, provide both .bind() and .rebind() semantics?
+      }
+
+      this.providers.set(token, [provider]);
+    }
 
     // todo: should support eagerly resolved providers or not?
 
     return this;
   }
 
+  get<T>(token: Token<T>, options: { multi: true }): T[];
   get<T>(token: Token<T>, options: { optional: true }): T | undefined;
-  get<T>(token: Token<T>, options?: { optional: boolean }): T;
-  get<T>(token: Token<T>, options?: { optional: boolean }): T | undefined {
+  get<T>(token: Token<T>, options: { multi: true; optional: true }): T[] | undefined;
+  get<T>(token: Token<T>, options?: { optional?: boolean; multi?: boolean }): T;
+  get<T>(token: Token<T>, options?: { optional?: boolean; multi?: boolean }): T | T[] | undefined {
     this.autoBindIfNeeded(token);
 
     if (!this.providers.has(token)) {
       if (options?.optional) {
         return undefined;
       }
-      throw Error(`No provider found for ${toString(token)}`);
+      throw Error(`No provider(s) found for ${toString(token)}`);
     }
 
-    const provider = assertNotNull(this.providers.get(token));
+    const providers = assertPresent(this.providers.get(token));
 
     if (!this.singletons.has(token)) {
-      if (isAsyncFactoryProvider(provider)) {
+      if (providers.some(isAsyncFactoryProvider)) {
         throw new Error(
-          `Provider for token ${toString(token)} is async, please use injectAsync() or container.getAsync() instead`,
+          `One or more providers for token ${toString(token)} are async, please use injectAsync() or container.getAsync() instead`,
         );
       }
 
-      this.singletons.set(token, construct(provider, this));
+      this.singletons.set(
+        token,
+        providers.map((it) => construct(it, this)),
+      );
     }
 
-    return assertNotNull(this.singletons.get(token));
+    if (options?.multi) {
+      return assertPresent(this.singletons.get(token));
+    } else {
+      return assertPresent(this.singletons.get(token)?.at(0));
+    }
   }
 
+  async getAsync<T>(token: Token<T>, options: { multi: true }): Promise<T[]>;
+  async getAsync<T>(token: Token<T>, options: { optional: true }): Promise<T | undefined>;
+  async getAsync<T>(token: Token<T>, options: { multi: true; optional: true }): Promise<T[] | undefined>;
+  async getAsync<T>(token: Token<T>, options?: { optional?: boolean; multi?: boolean }): Promise<T>;
   async getAsync<T>(
     token: Token<T>,
-    options: { optional: true },
-  ): Promise<T | undefined>;
-  async getAsync<T>(
-    token: Token<T>,
-    options?: { optional: boolean },
-  ): Promise<T>;
-  async getAsync<T>(
-    token: Token<T>,
-    options?: { optional: boolean },
-  ): Promise<T | undefined> {
+    options?: {
+      optional?: boolean;
+      multi?: boolean;
+    },
+  ): Promise<T | T[] | undefined> {
     this.autoBindIfNeeded(token);
 
     if (!this.providers.has(token)) {
       if (options?.optional) {
         return Promise.resolve(undefined);
       }
-      throw Error(`No provider found for ${toString(token)}`);
+      throw Error(`No provider(s) found for ${toString(token)}`);
     }
 
-    const provider = assertNotNull(this.providers.get(token));
+    const existingProviders = this.providers.get(token) ?? [];
 
     if (!this.singletons.has(token)) {
-      const value = await constructAsync(provider, this);
-      this.singletons.set(token, value);
+      const values = await Promise.all(existingProviders.map((it) => constructAsync(it, this)));
+      this.singletons.set(token, values);
     }
 
-    return await promisify(assertNotNull(this.singletons.get(token)));
+    if (options?.multi) {
+      return Promise.all(assertPresent(this.singletons.get(token)).map((it) => promisify(it)));
+    } else {
+      return promisify(assertPresent(this.singletons.get(token)?.at(0)));
+    }
   }
 
   private autoBindIfNeeded<T>(token: Token<T>) {
-    if (!this.providers.has(token)) {
-      if (isClassToken(token) && isInjectable(token)) {
-        this.bind({
-          provide: token,
-          useClass: getInjectableTarget(token),
-        });
+    if (this.singletons.has(token)) {
+      return;
+    }
+
+    if (isClassToken(token) && isInjectable(token)) {
+      const targetClasses = getInjectableTargets(token);
 
-        // inheritance support: also bind for its super classes
-        let superClass = Object.getPrototypeOf(token);
-        while (superClass.name) {
+      targetClasses
+        .filter((targetClass) => !this.providers.has(targetClass))
+        .forEach((targetClass) => {
           this.bind({
-            provide: superClass,
-            useClass: token,
+            provide: targetClass,
+            multi: true,
+            useClass: targetClass,
           });
-          superClass = Object.getPrototypeOf(superClass)
-        }
-      } else if (isInjectionToken(token) && token.options?.factory) {
-        if (!token.options.async) {
-          this.bind({
-            provide: token,
-            async: false,
-            useFactory: token.options.factory,
-          });
-        } else if (token.options.async) {
+        });
+
+      targetClasses
+        .filter((it) => it !== token)
+        .forEach((targetClass) => {
           this.bind({
             provide: token,
-            async: true,
-            useFactory: token.options.factory,
+            multi: true,
+            useExisting: targetClass,
           });
-        }
+        });
+    } else if (isInjectionToken(token) && token.options?.factory) {
+      if (!token.options.async) {
+        this.bind({
+          provide: token,
+          async: false,
+          useFactory: token.options.factory,
+        });
+      } else if (token.options.async) {
+        this.bind({
+          provide: token,
+          async: true,
+          useFactory: token.options.factory,
+        });
       }
     }
   }
@@ -129,34 +175,20 @@ export class Container {
 
 let currentScope: Container | undefined = undefined;
 
-export function inject<T>(
-  token: Token<T>,
-  options: { optional: true },
-): T | undefined;
+export function inject<T>(token: Token<T>, options: { optional: true }): T | undefined;
 export function inject<T>(token: Token<T>): T;
-export function inject<T>(
-  token: Token<T>,
-  options?: { optional: boolean },
-): T | undefined {
+export function inject<T>(token: Token<T>, options?: { optional: boolean }): T | undefined {
   if (currentScope === undefined) {
     throw new Error("You can only invoke inject() from the injection context");
   }
   return currentScope.get(token, options);
 }
 
-export function injectAsync<T>(
-  token: Token<T>,
-  options: { optional: true },
-): Promise<T | undefined>;
+export function injectAsync<T>(token: Token<T>, options: { optional: true }): Promise<T | undefined>;
 export function injectAsync<T>(token: Token<T>): Promise<T>;
-export function injectAsync<T>(
-  token: Token<T>,
-  options?: { optional: boolean },
-): Promise<T | undefined> {
+export function injectAsync<T>(token: Token<T>, options?: { optional: boolean }): Promise<T | undefined> {
   if (currentScope === undefined) {
-    throw new Error(
-      "You can only invoke injectAsync() from the injection context",
-    );
+    throw new Error("You can only invoke injectAsync() from the injection context");
   }
   return currentScope.getAsync(token, options);
 }
@@ -171,10 +203,7 @@ function construct<T>(provider: Provider<T>, scope: Container): Promise<T> | T {
   }
 }
 
-async function constructAsync<T>(
-  provider: Provider<T>,
-  scope: Container,
-): Promise<T> {
+async function constructAsync<T>(provider: Provider<T>, scope: Container): Promise<T> {
   const originalScope = currentScope;
   try {
     currentScope = scope;
@@ -189,10 +218,7 @@ async function promisify<T>(value: T | Promise<T>): Promise<T> {
   return new Promise<T>((resolve) => resolve(value));
 }
 
-function doConstruct<T>(
-  provider: Provider<T>,
-  scope: Container,
-): T | Promise<T> {
+function doConstruct<T>(provider: Provider<T>, scope: Container): T | Promise<T> {
   if (isConstructorProvider(provider)) {
     return new provider();
   } else if (isClassProvider(provider)) {
@@ -206,14 +232,16 @@ function doConstruct<T>(
   }
 }
 
-interface ProviderMap extends Map<Token<unknown>, Provider<unknown>> {
-  get<T>(key: Token<T>): Provider<T> | undefined
-  set<T>(key: Token<T>, value: Provider<T>): this
+interface ProviderMap extends Map<Token<unknown>, Provider<unknown>[]> {
+  get<T>(key: Token<T>): Provider<T>[] | undefined;
+
+  set<T>(key: Token<T>, value: Provider<T>[]): this;
 }
 
-interface SingletonMap extends Map<Token<unknown>, unknown> {
-  get<T>(token: Token<T>): T | undefined
-  set<T>(token: Token<T>, value: T): this
+interface SingletonMap extends Map<Token<unknown>, unknown[]> {
+  get<T>(token: Token<T>): T[] | undefined;
+
+  set<T>(token: Token<T>, value: T[]): this;
 }
 
 export function bootstrap<T>(token: Token<T>): T {
@@ -224,7 +252,7 @@ export function bootstrapAsync<T>(token: Token<T>): Promise<T> {
   return new Container().getAsync(token);
 }
 
-function assertNotNull<T>(value: T | null | undefined): T {
+function assertPresent<T>(value: T | null | undefined): T {
   if (value === null || value === undefined) {
     throw Error(`Expected value to be not null or undefined`);
   }
diff --git a/src/decorators.test.ts b/src/decorators.test.ts
new file mode 100644
index 0000000..b80cd6f
--- /dev/null
+++ b/src/decorators.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { getInjectableTargets, injectable, type InjectableClass } from './decorators.js';
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+abstract class AbstractService {}
+
+@injectable()
+class FooService extends AbstractService {}
+
+@injectable()
+class BarService extends AbstractService {}
+
+@injectable()
+class SpecialBarService extends BarService {}
+
+class BazService extends AbstractService {}
+
+@injectable()
+class SpecialBazService extends BazService {}
+
+describe("Decorators", () => {
+  it("should register every annotated class across its hierarchy", () => {
+
+    expect(getInjectableTargets(AbstractService as InjectableClass).map(it => it.name))
+        .toEqual(['FooService', 'BarService', 'SpecialBarService', 'SpecialBazService'])
+
+    expect(getInjectableTargets(FooService as InjectableClass).map(it => it.name))
+        .toEqual(['FooService'])
+
+    expect(getInjectableTargets(BarService as InjectableClass).map(it => it.name))
+        .toEqual(['BarService', 'SpecialBarService'])
+
+    expect(getInjectableTargets(SpecialBarService as InjectableClass).map(it => it.name))
+        .toEqual(['SpecialBarService'])
+
+    expect(getInjectableTargets(BazService as InjectableClass).map(it => it.name))
+        .toEqual(['SpecialBazService'])
+
+    expect(getInjectableTargets(SpecialBazService as InjectableClass).map(it => it.name))
+        .toEqual(['SpecialBazService'])
+  });
+});
diff --git a/src/decorators.ts b/src/decorators.ts
index dca7fbd..9c9fee7 100644
--- a/src/decorators.ts
+++ b/src/decorators.ts
@@ -5,31 +5,35 @@ type ClassDecorator<C extends Class<unknown>> = (target: C) => C | void;
 
 export const injectableSymbol = Symbol("injectable");
 
+export type InjectableClass<T = unknown> = Class<T> & { [injectableSymbol]: Class<unknown>[]};
+
 export function injectable<C extends Class<unknown>>(): ClassDecorator<C> {
   return (target) => {
     let superClass = Object.getPrototypeOf(target);
     while (superClass.name) {
-      Object.defineProperty(superClass, injectableSymbol, {
-        get: () => target,
-      });
+      if (!Object.getOwnPropertyDescriptor(superClass, injectableSymbol)) {
+        Object.defineProperty(superClass, injectableSymbol, {
+          value: [target],
+          writable: true,
+        });
+      } else {
+        superClass[injectableSymbol] = [...superClass[injectableSymbol], target];
+      }
       superClass = Object.getPrototypeOf(superClass);
     }
 
     Object.defineProperty(target, injectableSymbol, {
-      get: () => target,
+      value: [target],
+      writable: true,
     });
   };
 }
 
-export function isInjectable<T>(target: Class<T>): target is Class<T> & { [injectableSymbol]: Class<unknown> } {
+export function isInjectable<T>(target: Class<T>): target is InjectableClass<T> {
   // eslint-disable-next-line no-prototype-builtins
   return target.hasOwnProperty(injectableSymbol);
 }
 
-export function getInjectableTarget<T>(target: Class<T>): Class<unknown> {
-  if (!isInjectable(target)) {
-    throw Error(`Target ${target} nor any of its subclasses is not annotated with @injectable`)
-  }
-
+export function getInjectableTargets<T>(target: InjectableClass<T>): Class<unknown>[] {
   return target[injectableSymbol];
 }
diff --git a/src/examples.test.ts b/src/examples.test.ts
index d2a5a86..78372d1 100644
--- a/src/examples.test.ts
+++ b/src/examples.test.ts
@@ -150,13 +150,201 @@ describe("Container", () => {
     expect(factoryFn).toHaveBeenCalledTimes(1);
 
     expect(() => container.get(tokenWithoutProvider)).toThrowError();
-    expect(() =>
-      container.get(tokenWithoutProvider, { optional: false }),
-    ).toThrowError();
+    expect(() => container.get(tokenWithoutProvider, { optional: false })).toThrowError();
 
     expect(() => container.get(tokenProvidedAsync)).toThrowError();
 
     const fooAsync = await container.getAsync(tokenProvidedAsync);
     expect(fooAsync).toEqual({ foo: "async" });
   });
+
+  it("should support multi-providers (example without auto-binding)", () => {
+    abstract class AbstractService {
+      protected constructor(private name: string) {}
+    }
+
+    class FooService extends AbstractService {
+      constructor() {
+        super("Foo");
+      }
+    }
+
+    class BarService extends AbstractService {
+      constructor() {
+        super("Bar");
+      }
+    }
+
+    const container = new Container();
+
+    container
+      .bind({
+        provide: AbstractService,
+        multi: true,
+        useClass: FooService,
+      })
+      .bind({
+        provide: AbstractService,
+        multi: true,
+        useClass: BarService,
+      });
+
+    const services = container.get(AbstractService, { multi: true });
+
+    expect(services).not.toBeUndefined();
+    expect(services).toHaveLength(2);
+
+    const [serviceA, serviceB] = services;
+
+    expect(serviceA).toBeInstanceOf(FooService);
+    expect(serviceB).toBeInstanceOf(BarService);
+  });
+
+  it("should support multi-providers (example with auto-binding)", () => {
+    abstract class AbstractService {
+      protected constructor(private name: string) {}
+    }
+
+    @injectable()
+    class FooService extends AbstractService {
+      constructor() {
+        super("Foo");
+      }
+    }
+
+    @injectable()
+    class BarService extends AbstractService {
+      constructor() {
+        super("Bar");
+      }
+    }
+
+    const container = new Container();
+
+    const services = container.get(AbstractService, { multi: true });
+
+    expect(services).not.toBeUndefined();
+    expect(services).toHaveLength(2);
+
+    const [serviceA, serviceB] = services;
+
+    expect(serviceA).toBeInstanceOf(FooService);
+    expect(serviceB).toBeInstanceOf(BarService);
+  });
+
+  describe("should support multi-providers with multi-inheritance (example with auto-binding)", () => {
+    abstract class AbstractService {
+      protected constructor(private name: string) {}
+    }
+
+    @injectable()
+    class FooService extends AbstractService {
+      constructor() {
+        super("Foo");
+      }
+    }
+
+    @injectable()
+    class BarService extends AbstractService {
+      constructor() {
+        super("Bar");
+      }
+    }
+
+    @injectable()
+    class SpecialBarService extends BarService {
+      constructor(public age = 6) {
+        super();
+      }
+    }
+
+    class BazService extends AbstractService {
+      constructor() {
+        super("Bar");
+      }
+    }
+
+    @injectable()
+    class SpecialBazService extends BazService {
+      constructor(public age = 8) {
+        super();
+      }
+    }
+
+    it('first parent class, then child class ', () => {
+      const container = new Container();
+
+      const abstractServices = container.get(AbstractService, { multi: true });
+
+      expect(abstractServices).not.toBeUndefined();
+      expect(abstractServices).toHaveLength(4);
+
+      const [abstractServiceFoo, abstractServiceBar, abstractServiceSpecialBar, abstractServiceSpecialBaz] = abstractServices;
+
+      expect(abstractServiceFoo).toBeInstanceOf(FooService);
+      expect(abstractServiceBar).toBeInstanceOf(BarService);
+      expect(abstractServiceSpecialBar).toBeInstanceOf(SpecialBarService);
+      expect(abstractServiceSpecialBaz).toBeInstanceOf(SpecialBazService);
+
+      const barServices = container.get(BarService, { multi: true });
+
+      expect(barServices).not.toBeUndefined();
+      expect(barServices).toHaveLength(2);
+
+      const [barServicesBar, barServicesSpecialBar] = barServices;
+
+      expect(barServicesBar).toBeInstanceOf(BarService);
+      expect(barServicesBar).toBe(abstractServiceBar);
+      expect(barServicesSpecialBar).toBeInstanceOf(SpecialBarService);
+      expect(barServicesSpecialBar).toBe(abstractServiceSpecialBar);
+
+      const bazServices = container.get(BazService, { multi: true });
+
+      expect(bazServices).not.toBeUndefined();
+      expect(bazServices).toHaveLength(1);
+
+      const [barServiceSpecialBaz] = bazServices;
+
+      expect(barServiceSpecialBaz).toBeInstanceOf(SpecialBazService);
+      expect(barServiceSpecialBaz).toBe(abstractServiceSpecialBaz);
+    });
+
+    it('first child class, then parent class ', () => {
+      const container = new Container();
+
+      const bazServices = container.get(BazService, { multi: true });
+
+      expect(bazServices).not.toBeUndefined();
+      expect(bazServices).toHaveLength(1);
+
+      const [barServiceSpecialBaz] = bazServices;
+
+      expect(barServiceSpecialBaz).toBeInstanceOf(SpecialBazService);
+
+      const barServices = container.get(BarService, { multi: true });
+
+      expect(barServices).not.toBeUndefined();
+      expect(barServices).toHaveLength(2);
+
+      const [barServicesBar, barServicesSpecialBar] = barServices;
+
+      expect(barServicesBar).toBeInstanceOf(BarService);
+      expect(barServicesSpecialBar).toBeInstanceOf(SpecialBarService);
+
+      const abstractServices = container.get(AbstractService, { multi: true });
+
+      expect(abstractServices).not.toBeUndefined();
+      expect(abstractServices).toHaveLength(4);
+
+      const [abstractServiceFoo, abstractServiceBar, abstractServiceSpecialBar, abstractServiceSpecialBaz] = abstractServices;
+
+      expect(abstractServiceFoo).toBeInstanceOf(FooService);
+      expect(abstractServiceBar).toBeInstanceOf(BarService);
+      expect(abstractServiceBar).toBe(barServicesBar);
+      expect(abstractServiceSpecialBar).toBeInstanceOf(SpecialBarService);
+      expect(abstractServiceSpecialBar).toBe(barServicesSpecialBar);
+      expect(abstractServiceSpecialBaz).toBeInstanceOf(SpecialBazService);
+      expect(abstractServiceSpecialBaz).toBe(barServiceSpecialBaz);
+    });
+  });
 });
diff --git a/src/providers.test.ts b/src/providers.test.ts
index 197bbf5..aa4f601 100644
--- a/src/providers.test.ts
+++ b/src/providers.test.ts
@@ -32,6 +32,8 @@ describe("Providers", () => {
     expect(container.get(MyService)).toBe(myService);
     expect(container.get(MyService, { optional: true })).toBe(myService);
     expect(myServiceConstructorSpy).toHaveBeenCalledTimes(1);
+
+    expect(() => container.bind(MyService)).toThrowError();
   });
 
   it("Class providers should be provided once", () => {
@@ -180,11 +182,11 @@ describe("Providers", () => {
   });
 
   describe("abstract classes and inheritance", () => {
-    abstract class AbstractService {
-      protected constructor(public name = "AbstractService") {}
-    }
-
     it("should support annotated subclasses", () => {
+      abstract class AbstractService {
+        protected constructor(public name = "AbstractService") {}
+      }
+
       @injectable()
       class FooService extends AbstractService {
         constructor(public fooProp = "foo") {
@@ -196,12 +198,17 @@ describe("Providers", () => {
 
       expect(container.get(AbstractService)).toBeInstanceOf(FooService);
       expect(container.get(FooService)).toBeInstanceOf(FooService);
+      expect(container.get(FooService)).toBe(container.get(AbstractService));
       expect(container.get(FooService)).toBeInstanceOf(AbstractService);
 
       expect(container.get(AbstractService)).toBeInstanceOf(FooService);
     });
 
     it("should support binding subclasses", () => {
+      abstract class AbstractService {
+        protected constructor(public name = "AbstractService") {}
+      }
+
       class FooService extends AbstractService {
         constructor(public fooProp = "foo") {
           super("FooService");
@@ -238,4 +245,71 @@ describe("Providers", () => {
       expect(container.get(AbstractService)).toBeInstanceOf(FooService);
     });
   });
+
+  describe("Multi-provider injection", () => {
+    it("should support multi-value providers", () => {
+      const container = new Container();
+
+      const TOKEN = new InjectionToken<number>("TOKEN");
+      const OTHER_TOKEN = new InjectionToken<number>("OTHER_TOKEN");
+
+      container
+        .bind({
+          provide: TOKEN,
+          multi: true,
+          useValue: 1,
+        })
+        .bind({
+          provide: TOKEN,
+          multi: true,
+          useValue: 2,
+        });
+
+      expect(container.get(TOKEN, { multi: true })).toEqual([1, 2]);
+      expect(() => container.get(OTHER_TOKEN, { multi: true })).toThrowError();
+      expect(container.get(OTHER_TOKEN, { multi: true, optional: true })).toBeUndefined();
+
+      expect(() => {
+        container.bind({
+          provide: TOKEN,
+          multi: true,
+          useValue: 1,
+        });
+      }).toThrowError();
+    });
+
+    it("should support multi-value async providers", async () => {
+      const container = new Container();
+
+      const TOKEN = new InjectionToken<number>("TOKEN");
+      const OTHER_TOKEN = new InjectionToken<number>("OTHER_TOKEN");
+
+      container
+        .bind({
+          provide: TOKEN,
+          multi: true,
+          async: true,
+          useFactory: () => Promise.resolve(1),
+        })
+        .bind({
+          provide: TOKEN,
+          multi: true,
+          async: true,
+          useFactory: () => Promise.resolve(2),
+        });
+
+      expect(await container.getAsync(TOKEN, { multi: true })).toEqual([1, 2]);
+      expect(container.getAsync(OTHER_TOKEN, { multi: true })).rejects.toThrowError();
+      expect(await container.getAsync(OTHER_TOKEN, { multi: true, optional: true })).toBeUndefined();
+
+      expect(() => {
+        container.bind({
+          provide: TOKEN,
+          multi: true,
+          async: true,
+          useFactory: () => Promise.resolve(1),
+        });
+      }).toThrowError();
+    });
+  });
 });
diff --git a/src/providers.ts b/src/providers.ts
index 18cb20b..495164e 100644
--- a/src/providers.ts
+++ b/src/providers.ts
@@ -14,56 +14,59 @@ export type ConstructorProvider<T> = Class<T>;
 export interface ClassProvider<T> {
   provide: Token<T>;
   useClass: Class<T>;
+  multi?: true;
 }
 
 export interface ValueProvider<T> {
   provide: Token<T>;
   useValue: T;
+  multi?: true;
 }
 
 export interface FactoryProvider<T> {
   provide: Token<T>;
   async?: false;
+  multi?: true;
   useFactory: () => NoInfer<T>;
 }
 
 export interface AsyncFactoryProvider<T> {
   provide: Token<T>;
   async: true;
+  multi?: true;
   useFactory: () => Promise<NoInfer<T>>;
 }
 
 export interface ExistingProvider<T> {
   provide: Token<T>;
   useExisting: Token<T>;
+  multi?: boolean;
 }
 
-export function isConstructorProvider<T>(
-  provider: Provider<T>,
-): provider is ConstructorProvider<T> {
+export function isConstructorProvider<T>(provider: Provider<T>): provider is ConstructorProvider<T> {
   return isClass(provider);
 }
 
-export function isClassProvider<T>(
-  provider: Provider<T>,
-): provider is ClassProvider<T> {
+export function isClassProvider<T>(provider: Provider<T>): provider is ClassProvider<T> {
   return "provide" in provider && "useClass" in provider;
 }
 
-export function isValueProvider<T>(
-  provider: Provider<T>,
-): provider is ValueProvider<T> {
+export function isValueProvider<T>(provider: Provider<T>): provider is ValueProvider<T> {
   return "provide" in provider && "useValue" in provider;
 }
 
-export function isFactoryProvider<T>(
-  provider: Provider<T>,
-): provider is FactoryProvider<T> | AsyncFactoryProvider<T> {
+export function isFactoryProvider<T>(provider: Provider<T>): provider is FactoryProvider<T> | AsyncFactoryProvider<T> {
   return "provide" in provider && "useFactory" in provider;
 }
 
-export function isAsyncFactoryProvider<T>(
-  provider: Provider<T>,
-): provider is AsyncFactoryProvider<T> {
+export function isAsyncFactoryProvider<T>(provider: Provider<T>): provider is AsyncFactoryProvider<T> {
   return isFactoryProvider(provider) && (provider.async ?? false);
 }
+
+export function isMultiProvider<T>(provider: Provider<T>): boolean {
+  return "provide" in provider && "multi" in provider && provider.multi === true;
+}
+
+export function isExistingProvider<T>(provider: Provider<T>): provider is ExistingProvider<T> {
+  return "provide" in provider && "useExisting" in provider;
+}
diff --git a/src/tokens.ts b/src/tokens.ts
index 1e81527..fe4cdaa 100644
--- a/src/tokens.ts
+++ b/src/tokens.ts
@@ -1,20 +1,15 @@
 import { type AbstractClass, type Class, isClass } from "./utils.js";
 
-export type Token<T> =
-  | Class<T>
-  | AbstractClass<T>
-  | string
-  | symbol
-  | InjectionToken<T>;
+export type Token<T> = Class<T> | AbstractClass<T> | string | symbol | InjectionToken<T>;
 
 interface InjectionTokenOptions<T> {
-  async?: false,
-  factory: () => T
+  async?: false;
+  factory: () => T;
 }
 
 interface AsyncInjectionTokenOptions<T> {
-  async: true,
-  factory: () => Promise<T>
+  async: true;
+  factory: () => Promise<T>;
 }
 
 export class InjectionToken<T> {
@@ -32,9 +27,7 @@ export function isClassToken<T>(token: Token<T>): token is Class<T> {
   return isClass(token);
 }
 
-export function isInjectionToken<T>(
-  token: Token<T>,
-): token is InjectionToken<T> {
+export function isInjectionToken<T>(token: Token<T>): token is InjectionToken<T> {
   return token instanceof InjectionToken;
 }
 
diff --git a/src/utils.ts b/src/utils.ts
index e9b2805..26f6e08 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,6 +1,9 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Class<T> = new (...args: any[]) => T;
-export interface AbstractClass<T> { prototype: T; name: string }
+export interface AbstractClass<T> {
+  prototype: T;
+  name: string;
+}
 
 export function isClass(target: unknown): target is Class<unknown> | AbstractClass<unknown> {
   return typeof target === "function";