@tstdl/base 0.90.61 → 0.90.63

package/api/server/api-controller.d.ts

@@ -1,4 +1,4 @@
-import type { InjectableOptionsWithoutLifecycle } from '../../injector/decorators.js';
+import { type InjectableOptionsWithoutLifecycle } from '../../injector/decorators.js';
 import type { Constructor, Type } from '../../types.js';
 import type { ApiController, ApiDefinition } from '../types.js';
 type ApiDefinitionProvider = () => ApiDefinition;

package/api/server/api-controller.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-classes-per-file */
 import { Singleton } from '../../injector/decorators.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { isFunction } from '../../utils/type-guards.js';

package/core.d.ts

@@ -1,8 +1,7 @@
 import type { CancellationSignal } from './cancellation/token.js';
 import { Injector } from './injector/injector.js';
-import type { InjectionToken } from './injector/token.js';
-import type { LoggerArgument } from './logger/index.js';
-import { LogLevel, Logger } from './logger/index.js';
+import { type InjectionToken } from './injector/token.js';
+import { LogLevel, Logger, type LoggerArgument } from './logger/index.js';
 declare global {
     var tstdlLoaded: boolean | undefined;
 }

package/http/http-query.d.ts

@@ -1,5 +1,4 @@
-import type { HttpValueMapInput } from './http-value-map.js';
-import { HttpValueMap } from './http-value-map.js';
+import { HttpValueMap, type HttpValueMapInput } from './http-value-map.js';
 import type { HttpValueObject, NormalizedHttpValueObject } from './types.js';
 export type HttpQueryObject = HttpValueObject;
 export type NormalizedHttpQueryObject = NormalizedHttpValueObject;

package/http/server/node/node-http-server.d.ts

@@ -1,10 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import * as Http from 'node:http';
-import type { AsyncDisposable } from '../../../disposable/index.js';
-import { disposeAsync } from '../../../disposable/index.js';
+import { disposeAsync, type AsyncDisposable } from '../../../disposable/index.js';
 import { Logger } from '../../../logger/index.js';
-import type { HttpServerRequestContext } from '../http-server.js';
-import { HttpServer } from '../http-server.js';
+import { HttpServer, type HttpServerRequestContext } from '../http-server.js';
 export type NodeHttpServerContext = {
     nodeRequest: Http.IncomingMessage;
     nodeResponse: Http.ServerResponse;

package/injector/inject.d.ts

@@ -1,5 +1,4 @@
-import type { ResolveManyItem, ResolveManyReturnType } from './injector.js';
-import { Injector } from './injector.js';
+import { Injector, type ResolveManyItem, type ResolveManyReturnType } from './injector.js';
 import type { Resolvable, ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 import type { ResolveOptions } from './types.js';

package/injector/injector.d.ts

@@ -1,13 +1,18 @@
-import type { AsyncDisposable } from '../disposable/disposable.js';
+import { type AsyncDisposable } from '../disposable/disposable.js';
 import type { OneOrMany, Record, TypedOmit } from '../types.js';
-import type { InjectOptions } from './inject.js';
-import type { ResolveArgument } from './interfaces.js';
+import { type InjectOptions } from './inject.js';
+import { type ResolveArgument } from './interfaces.js';
 import { type Provider } from './provider.js';
 import { type InjectionToken } from './token.js';
 import type { RegistrationOptions, ResolveOptions } from './types.js';
+export type ProvidersItem<T = any, A = any, D extends Record = Record> = Provider<T, A, D> & {
+    provide: InjectionToken<T, A>;
+    multi?: boolean;
+};
 export type GlobalRegistration<T = any, A = any> = {
     token: InjectionToken<T, A>;
     provider: Provider<T, A>;
+    providers: ProvidersItem[];
     options: RegistrationOptions<T, A>;
 };
 export type Registration<T = any, A = any> = GlobalRegistration<T, A> & {
@@ -37,7 +42,7 @@ export declare class Injector implements AsyncDisposable {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): void;
+    static register<T, A = any, D extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, D>>, options?: RegistrationOptions<T, A, D>): void;
     /**
      * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
      * @param token token to register

package/injector/injector.js

@@ -54,11 +54,13 @@ export class Injector {
      * @param options registration options
      */
     static register(token, providers, options = {}) {
+        const multi = isArray(providers);
         for (const provider of toArray(providers)) {
             const registration = {
                 token,
                 provider,
-                options: { multi: isArray(providers), ...options }
+                providers: options.providers ?? [],
+                options: { multi, ...options }
             };
             addRegistration(Injector.#globalRegistrations, registration);
         }
@@ -93,11 +95,13 @@ export class Injector {
      */
     register(token, providers, options = {}) {
         this.assertNotDisposed();
+        const multi = isArray(providers);
         for (const provider of toArray(providers)) {
             const registration = {
                 token,
                 provider,
-                options: { multi: isArray(providers), ...options },
+                providers: options.providers ?? [],
+                options: { multi, ...options },
                 resolutions: new Map()
             };
             addRegistration(this.#registrations, registration);
@@ -125,20 +129,22 @@ export class Injector {
      * @param token token to get registration for
      */
     tryGetRegistration(token, options) {
-        if (isNull(this.#parent) && !this.#registrations.has(token) && Injector.#globalRegistrations.has(token)) {
-            const globalRegistrations = toArray(Injector.#globalRegistrations.get(token));
+        if (isNull(this.#parent) && !this.#registrations.has(token)) {
+            const globalRegistrations = toArray(Injector.#globalRegistrations.get(token) ?? []);
             for (const globalRegistration of globalRegistrations) {
                 this.register(globalRegistration.token, globalRegistration.provider, globalRegistration.options);
             }
         }
-        const ownRegistration = (options?.skipSelf != true) ? this.#registrations.get(token) : undefined;
-        if (isDefined(ownRegistration)) {
-            return ownRegistration;
+        if (options?.skipSelf != true) {
+            const ownRegistration = this.#registrations.get(token);
+            if (isDefined(ownRegistration)) {
+                return ownRegistration;
+            }
         }
-        if (options?.onlySelf == true) {
-            return undefined;
+        if (options?.onlySelf != true) {
+            return this.#parent?.tryGetRegistration(token);
         }
-        return this.#parent?.tryGetRegistration(token);
+        return undefined;
     }
     /**
      * Get registration
@@ -212,17 +218,17 @@ export class Injector {
             throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
-        if (isUndefined(registration)) {
-            if (isNotNull(this.#parent) && (options.onlySelf != true)) {
-                return this.#parent._resolve(token, argument, { ...options, skipSelf: false }, context, chain);
-            }
-            if (options.optional == true) {
-                return undefined;
-            }
-            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        if (isDefined(registration)) {
+            const singleRegistration = isArray(registration) ? registration[0] : registration;
+            return this._resolveRegistration(singleRegistration, argument, options, context, chain);
+        }
+        if (isNotNull(this.#parent) && (options.onlySelf != true)) {
+            return this.#parent._resolve(token, argument, { ...options, skipSelf: false }, context, chain);
+        }
+        if (options.optional == true) {
+            return undefined;
         }
-        const singleRegistration = isArray(registration) ? registration[0] : registration;
-        return this._resolveRegistration(singleRegistration, argument, options, context, chain);
+        throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
     }
     _resolveAll(token, argument, options, context, chain) {
         this.assertNotDisposed();
@@ -237,29 +243,33 @@ export class Injector {
             throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
-        if (isUndefined(registration)) {
-            if (isNotNull(this.#parent) && (options.onlySelf != true)) {
-                return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
-            }
-            if (options.optional == true) {
-                return [];
-            }
-            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        if (isDefined(registration)) {
+            const registrations = isArray(registration) ? registration : [registration];
+            return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
         }
-        const registrations = isArray(registration) ? registration : [registration];
-        return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
+        if (isNotNull(this.#parent) && (options.onlySelf != true)) {
+            return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
+        }
+        if (options.optional == true) {
+            return [];
+        }
+        throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
     }
     _resolveRegistration(registration, argument, options, context, chain) {
         checkOverflow(chain, context);
-        const injectionContext = this.getInjectionContext(context, argument, chain);
+        const { token, providers } = registration;
+        const injector = (providers.length > 0) ? this.fork('LocalProvidersInjector') : this;
+        for (const nestedProvider of providers) {
+            injector.register(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
+        }
+        const injectionContext = injector.getInjectionContext(context, argument, chain);
         const previousInjectionContext = setCurrentInjectionContext(injectionContext);
         const resolutionTag = Symbol(); // eslint-disable-line symbol-description
         try {
-            const { token } = registration;
             const resolutionScoped = registration.options.lifecycle == 'resolution';
             const injectorScoped = registration.options.lifecycle == 'injector';
             const singletonScoped = registration.options.lifecycle == 'singleton';
-            const resolveArgument = argument ?? registration.options.defaultArgument ?? (registration.options.defaultArgumentProvider?.(this.getResolveContext(resolutionTag, context, chain)));
+            const resolveArgument = argument ?? registration.options.defaultArgument ?? (registration.options.defaultArgumentProvider?.(injector.getResolveContext(resolutionTag, context, chain)));
             const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument);
             if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
                 return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
@@ -270,13 +280,13 @@ export class Injector {
             else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
                 return registration.resolutions.get(argumentIdentity);
             }
-            const value = this._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
+            const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
             const resolution = {
                 tag: resolutionTag,
                 registration,
                 value,
                 argument: injectionContext.argument,
-                afterResolveContext: this.getAfterResolveContext(resolutionTag, context),
+                afterResolveContext: injector.getAfterResolveContext(resolutionTag, context),
                 chain
             };
             context.resolutions.push(resolution);

package/injector/types.d.ts

@@ -2,11 +2,11 @@ import type { CancellationSignal } from '../cancellation/index.js';
 import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
 import type { Record } from '../types.js';
 import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
-import type { Injector } from './injector.js';
+import type { Injector, ProvidersItem } from './injector.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 /**
- * transient: new resolution for every resolve
+ * Transient: new resolution for every resolve
  * resolution: one resolution per resolve tree
  * injector: one resolution per injector
  * singleton: one resolution at injector where token is registered
@@ -34,11 +34,13 @@ export type ResolveOptions<T, A> = {
     forwardRefTypeHint?: ForwardRefTypeHint;
 };
 /**
- * data to store between different stages like resolve and afterResolve
+ * Data to store between different stages like resolve and afterResolve
  */
 export type ResolveContextData<T extends Record> = T;
 export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
     lifecycle?: Lifecycle;
+    /** Local providers for inner resolutions */
+    providers?: ProvidersItem[];
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
     defaultArgument?: ResolveArgument<T, A>;
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
@@ -57,6 +59,6 @@ export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
     afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => any;
     /** Whether multiple values can be resolved or not (used with {@link Injector.resolveAll}). If false, previous registrations are removed */
     multi?: boolean;
-    /** custom metadata */
+    /** Custom metadata */
     metadata?: Record;
 };

package/object-storage/object-storage.d.ts

@@ -1,74 +1,75 @@
-import type { Resolvable } from '../injector/interfaces.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
+import { resolveArgumentType, type Resolvable } from '../injector/interfaces.js';
 import type { ObjectMetadata, ObjectStorageObject } from './object.js';
 export type UploadObjectOptions = {
     metadata?: ObjectMetadata;
 };
 export type ObjectStorageArgument = string;
 export declare abstract class ObjectStorage implements Resolvable<ObjectStorageArgument> {
-    /** object storage module */
+    /** Object storage module */
     readonly module: string;
     readonly [resolveArgumentType]: ObjectStorageArgument;
     constructor(module: string);
     /**
-     * checks if an object exists
+     * Checks if an object exists
      * @param key object key
      */
     abstract exists(key: string): Promise<boolean>;
     /**
-     * uploads an object
+     * Uploads an object
      * @param key object key
      * @param content content of object
      */
-    abstract uploadObject(key: string, content: Uint8Array, options?: UploadObjectOptions): Promise<void>;
+    abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
     /**
-     * uploads an object stream
+     * Uploads an object stream
      * @param key object key
      * @param stream stream of object
+     * @deprecated use {@link uploadObject} instead
      */
     abstract uploadObjectStream(key: string, stream: ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
     /**
-     * get an url which can be used to upload the object without further authorization
+     * Get an url which can be used to upload the object without further authorization
      * @param key object key
      * @param expirationTimestamp timestamp when the url expires and can no longer be used
      */
     abstract getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
     /**
-     * get all objects
+     * Get all objects
      */
     abstract getObjects(): Promise<ObjectStorageObject[]>;
     /**
-     * get all objects
+     * Get all objects
      */
     abstract getObjectsCursor(): AsyncIterable<ObjectStorageObject>;
     /**
-     * get object
+     * Get object
      * @param key object key
      */
     abstract getObject(key: string): Promise<ObjectStorageObject>;
     /**
-     * get object resource uri
+     * Get object resource uri
      * @param key object key
      */
     abstract getResourceUri(key: string): Promise<string>;
     /**
-     * get stream of object content
+     * Get stream of object content
      * @param key object key
      */
     abstract getContentStream(key: string): ReadableStream<Uint8Array>;
     /**
-     * get an url which can be used to download the object without further authorization
+     * Get an url which can be used to download the object without further authorization
      * @param key object key
      * @param expirationTimestamp timestamp when the url expires and can no longer be used
+     * @param responseHeaders headers used for download response
      */
-    abstract getDownloadUrl(key: string, expirationTimestamp: number): Promise<string>;
+    abstract getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
     /**
-     * deletes an object
+     * Deletes an object
      * @param key object key
      */
     abstract deleteObject(key: string): Promise<void>;
     /**
-     * deletes objects
+     * Deletes objects
      * @param keys object key
      */
     abstract deleteObjects(keys: string[]): Promise<void>;

package/object-storage/object-storage.js

@@ -1,6 +1,6 @@
 import { resolveArgumentType } from '../injector/interfaces.js';
 export class ObjectStorage {
-    /** object storage module */
+    /** Object storage module */
     module;
     constructor(module) {
         this.module = module;

package/object-storage/s3/s3.object-storage.d.ts

@@ -1,7 +1,5 @@
-import type { BucketItemStat } from 'minio';
-import { Client } from 'minio';
-import type { UploadObjectOptions } from '../../object-storage/index.js';
-import { ObjectStorage } from '../../object-storage/index.js';
+import type { BucketItemStat, Client } from 'minio';
+import { ObjectStorage, type UploadObjectOptions } from '../../object-storage/index.js';
 import { S3Object } from './s3.object.js';
 export declare class S3ObjectStorage extends ObjectStorage {
     private readonly client;
@@ -13,7 +11,7 @@ export declare class S3ObjectStorage extends ObjectStorage {
     }): Promise<void>;
     exists(key: string): Promise<boolean>;
     statObject(key: string): Promise<BucketItemStat>;
-    uploadObject(key: string, content: Uint8Array, options?: UploadObjectOptions): Promise<void>;
+    uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
     uploadObjectStream(key: string, stream: ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
     getContent(key: string): Promise<Uint8Array>;
     getContentStream(key: string): ReadableStream<Uint8Array>;
@@ -21,7 +19,7 @@ export declare class S3ObjectStorage extends ObjectStorage {
     getObjectsCursor(): AsyncIterable<S3Object>;
     getObject(key: string): Promise<S3Object>;
     getResourceUri(key: string): Promise<string>;
-    getDownloadUrl(key: string, expirationTimestamp: number): Promise<string>;
+    getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
     getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
     deleteObject(key: string): Promise<void>;
     deleteObjects(keys: string[]): Promise<void>;

package/object-storage/s3/s3.object-storage.js

@@ -8,7 +8,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Readable } from 'node:stream';
-import { Client } from 'minio';
 import { Singleton } from '../../injector/decorators.js';
 import { ObjectStorage } from '../../object-storage/index.js';
 import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
@@ -16,7 +15,7 @@ import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { now } from '../../utils/date-time.js';
 import { readableStreamFromPromise } from '../../utils/stream/index.js';
 import { readBinaryStream } from '../../utils/stream/stream-reader.js';
-import { assertStringPass, isObject } from '../../utils/type-guards.js';
+import { assertStringPass, isObject, isUint8Array } from '../../utils/type-guards.js';
 import { S3ObjectStorageProvider } from './s3.object-storage-provider.js';
 import { S3Object } from './s3.object.js';
 let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
@@ -55,16 +54,20 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
     }
     async uploadObject(key, content, options) {
         const bucketKey = this.getBucketKey(key);
-        await this.client.putObject(this.bucket, bucketKey, Buffer.from(content), options?.metadata);
+        if (isUint8Array(content)) {
+            await this.client.putObject(this.bucket, bucketKey, Buffer.from(content), options?.metadata);
+        }
+        else {
+            const readable = Readable.fromWeb(content);
+            const errorPromise = new Promise((_, reject) => readable.on('error', reject));
+            await Promise.race([
+                this.client.putObject(this.bucket, bucketKey, readable, options?.metadata),
+                errorPromise
+            ]);
+        }
     }
     async uploadObjectStream(key, stream, options) {
-        const bucketKey = this.getBucketKey(key);
-        const readable = Readable.fromWeb(stream);
-        const errorPromise = new Promise((_, reject) => readable.on('error', reject));
-        await Promise.race([
-            this.client.putObject(this.bucket, bucketKey, readable, options?.metadata),
-            errorPromise
-        ]);
+        return this.uploadObject(key, stream, options);
     }
     async getContent(key) {
         const bucketKey = this.getBucketKey(key);
@@ -93,10 +96,10 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
     async getResourceUri(key) {
         return this.getResourceUriSync(key);
     }
-    async getDownloadUrl(key, expirationTimestamp) {
+    async getDownloadUrl(key, expirationTimestamp, responseHeaders) {
         const bucketKey = this.getBucketKey(key);
         const { date, expiration } = getDateAndExpiration(expirationTimestamp);
-        return this.client.presignedGetObject(this.bucket, bucketKey, expiration, {}, date);
+        return this.client.presignedGetObject(this.bucket, bucketKey, expiration, responseHeaders, date);
     }
     async getUploadUrl(key, expirationTimestamp) {
         const bucketKey = this.getBucketKey(key);
@@ -131,7 +134,7 @@ S3ObjectStorage = __decorate([
             }
         }
     }),
-    __metadata("design:paramtypes", [Client, String, String, String])
+    __metadata("design:paramtypes", [Function, String, String, String])
 ], S3ObjectStorage);
 export { S3ObjectStorage };
 function getDateAndExpiration(expirationTimestamp) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.61",
+  "version": "0.90.63",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -105,11 +105,11 @@
     "./utils/string": "./utils/object/index.js"
   },
   "dependencies": {
-    "disposablestack": "^1.1",
+    "core-js": "3.36",
     "luxon": "^3.4",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.14"
+    "type-fest": "4.15"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -130,10 +130,10 @@
     "typedoc": "0.25",
     "typedoc-plugin-missing-exports": "2.2",
     "typescript": "5.4",
-    "typescript-eslint": "7.3"
+    "typescript-eslint": "7.7"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.12",
+    "@elastic/elasticsearch": "^8.13",
     "@koa/router": "^12.0",
     "@tstdl/angular": "^0.90",
     "@zxcvbn-ts/core": "^3.0",
@@ -147,10 +147,10 @@
     "mjml": "^4.15",
     "mongodb": "^6.5",
     "nodemailer": "^6.9",
-    "playwright": "^1.42",
+    "playwright": "^1.43",
     "preact": "^10.20",
     "preact-render-to-string": "^6.4",
-    "undici": "^6.10",
+    "undici": "^6.13",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/polyfills.d.ts

@@ -1,159 +1,2 @@
-import 'disposablestack/auto';
-declare global {
-    interface SymbolConstructor {
-        /**
-         * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
-         */
-        readonly dispose: unique symbol;
-        /**
-         * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
-         */
-        readonly asyncDispose: unique symbol;
-    }
-    interface Disposable {
-        [Symbol.dispose](): void;
-    }
-    interface AsyncDisposable {
-        [Symbol.asyncDispose](): PromiseLike<void>;
-    }
-    interface SuppressedError extends Error {
-        error: any;
-        suppressed: any;
-    }
-    interface SuppressedErrorConstructor extends ErrorConstructor {
-        new (error: any, suppressed: any, message?: string): SuppressedError;
-        (error: any, suppressed: any, message?: string): SuppressedError;
-        readonly prototype: SuppressedError;
-    }
-    var SuppressedError: SuppressedErrorConstructor;
-    interface DisposableStack {
-        /**
-         * Returns a value indicating whether this stack has been disposed.
-         */
-        readonly disposed: boolean;
-        /**
-         * Disposes each resource in the stack in the reverse order that they were added.
-         */
-        dispose(): void;
-        /**
-         * Adds a disposable resource to the stack, returning the resource.
-         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
-         * @returns The provided {@link value}.
-         */
-        use<T extends Disposable | null | undefined>(value: T): T;
-        /**
-         * Adds a value and associated disposal callback as a resource to the stack.
-         * @param value The value to add.
-         * @param onDispose The callback to use in place of a `[Symbol.dispose]()` method. Will be invoked with `value`
-         * as the first parameter.
-         * @returns The provided {@link value}.
-         */
-        adopt<T>(value: T, onDispose: (value: T) => void): T;
-        /**
-         * Adds a callback to be invoked when the stack is disposed.
-         */
-        defer(onDispose: () => void): void;
-        /**
-         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
-         * @example
-         * ```ts
-         * class C {
-         *   #res1: Disposable;
-         *   #res2: Disposable;
-         *   #disposables: DisposableStack;
-         *   constructor() {
-         *     // stack will be disposed when exiting constructor for any reason
-         *     using stack = new DisposableStack();
-         *
-         *     // get first resource
-         *     this.#res1 = stack.use(getResource1());
-         *
-         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
-         *     this.#res2 = stack.use(getResource2());
-         *
-         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
-         *     // when constructor exits
-         *     this.#disposables = stack.move();
-         *   }
-         *
-         *   [Symbol.dispose]() {
-         *     this.#disposables.dispose();
-         *   }
-         * }
-         * ```
-         */
-        move(): DisposableStack;
-        [Symbol.dispose](): void;
-        readonly [Symbol.toStringTag]: string;
-    }
-    interface DisposableStackConstructor {
-        new (): DisposableStack;
-        readonly prototype: DisposableStack;
-    }
-    var DisposableStack: DisposableStackConstructor;
-    interface AsyncDisposableStack {
-        /**
-         * Returns a value indicating whether this stack has been disposed.
-         */
-        readonly disposed: boolean;
-        /**
-         * Disposes each resource in the stack in the reverse order that they were added.
-         */
-        disposeAsync(): Promise<void>;
-        /**
-         * Adds a disposable resource to the stack, returning the resource.
-         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
-         * @returns The provided {@link value}.
-         */
-        use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
-        /**
-         * Adds a value and associated disposal callback as a resource to the stack.
-         * @param value The value to add.
-         * @param onDisposeAsync The callback to use in place of a `[Symbol.asyncDispose]()` method. Will be invoked with `value`
-         * as the first parameter.
-         * @returns The provided {@link value}.
-         */
-        adopt<T>(value: T, onDisposeAsync: (value: T) => PromiseLike<void> | void): T;
-        /**
-         * Adds a callback to be invoked when the stack is disposed.
-         */
-        defer(onDisposeAsync: () => PromiseLike<void> | void): void;
-        /**
-         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
-         * @example
-         * ```ts
-         * class C {
-         *   #res1: Disposable;
-         *   #res2: Disposable;
-         *   #disposables: DisposableStack;
-         *   constructor() {
-         *     // stack will be disposed when exiting constructor for any reason
-         *     using stack = new DisposableStack();
-         *
-         *     // get first resource
-         *     this.#res1 = stack.use(getResource1());
-         *
-         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
-         *     this.#res2 = stack.use(getResource2());
-         *
-         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
-         *     // when constructor exits
-         *     this.#disposables = stack.move();
-         *   }
-         *
-         *   [Symbol.dispose]() {
-         *     this.#disposables.dispose();
-         *   }
-         * }
-         * ```
-         */
-        move(): AsyncDisposableStack;
-        [Symbol.asyncDispose](): Promise<void>;
-        readonly [Symbol.toStringTag]: string;
-    }
-    interface AsyncDisposableStackConstructor {
-        new (): AsyncDisposableStack;
-        readonly prototype: AsyncDisposableStack;
-    }
-    var AsyncDisposableStack: AsyncDisposableStackConstructor;
-}
+import 'core-js/actual/async-disposable-stack/index.js';
+import 'core-js/actual/disposable-stack/index.js';

package/polyfills.js

@@ -1 +1,2 @@
-import 'disposablestack/auto';
+import 'core-js/actual/async-disposable-stack/index.js';
+import 'core-js/actual/disposable-stack/index.js';

package/reflection/decorators.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata/lite';
 import type { ConstructorParameterDecorator } from '../types.js';
 import type { Decorator, DecoratorHandler } from './types.js';
-import type { CreateDecoratorOptions, SpecificCreateDecoratorOptions } from './utils.js';
+import { type CreateDecoratorOptions, type SpecificCreateDecoratorOptions } from './utils.js';
 export declare function Decorate({ handler, ...options }?: CreateDecoratorOptions & {
     handler?: DecoratorHandler;
 }): Decorator;