@tstdl/base 0.85.15 → 0.85.17

package/data-structures/array-list.d.ts

@@ -21,7 +21,7 @@ export declare class ArrayList<T> extends List<T, ArrayList<T>> {
     protected _set(index: number, item: T): void;
     remove(item: T): boolean;
     protected _removeAt(index: number): T;
-    protected _removeManyAt(index: number, count?: number): T[];
+    protected _removeManyAt(index: number, count: number): T[];
     clone(): ArrayList<T>;
     items(): IterableIterator<T>;
     itemsReverse(): IterableIterator<T>;

package/data-structures/array-list.js

@@ -40,7 +40,6 @@ class ArrayList extends import_list.List {
     return arrayList;
   }
   _at(index) {
-    this.ensureBounds(index);
     return this.backingArray[index];
   }
   _indexOf(item, fromIndex) {
@@ -88,7 +87,6 @@ class ArrayList extends import_list.List {
     this.updateSize();
   }
   _set(index, item) {
-    this.ensureBounds(index);
     this.backingArray[index] = item;
     this.emitChange();
   }
@@ -101,10 +99,12 @@ class ArrayList extends import_list.List {
     return true;
   }
   _removeAt(index) {
+    if (index == 0) {
+      return this.backingArray.shift();
+    }
     return this.removeManyAt(index, 1)[0];
   }
-  _removeManyAt(index, count = this.size - index) {
-    this.ensureBounds(index, count);
+  _removeManyAt(index, count) {
     const removed = this.backingArray.splice(index, count);
     this.updateSize();
     return removed;

package/data-structures/circular-buffer.js

@@ -182,7 +182,8 @@ class CircularBuffer extends import_collection.Collection {
     }
   }
   _clear() {
-    this.backingArray = new Array(2);
+    this.backingArray = [];
+    this.backingArray.length = 2;
     this.writeIndex = 0;
     this.readIndex = 0;
   }
@@ -199,7 +200,7 @@ class CircularBuffer extends import_collection.Collection {
     if (size < this.size) {
       throw new Error("buffer has more items than it would have capacity after resize");
     }
-    let newBackingArray = [];
+    let newBackingArray;
     if (this.size > 0) {
       if (this.readIndex < this.writeIndex) {
         newBackingArray = this.backingArray.slice(this.readIndex, this.writeIndex);
@@ -208,6 +209,8 @@ class CircularBuffer extends import_collection.Collection {
         const end = this.backingArray.slice(0, this.writeIndex);
         newBackingArray = start.concat(end);
       }
+    } else {
+      newBackingArray = [];
     }
     newBackingArray.length = size;
     this.backingArray = newBackingArray;

package/data-structures/distinct-collection.d.ts

@@ -0,0 +1,24 @@
+import { Collection } from './collection.js';
+export declare abstract class DistinctCollection<T, TThis extends DistinctCollection<T, TThis> = DistinctCollection<T, any>> extends Collection<T, TThis> {
+    /** Creates a new map and copies the items */
+    toSet(): Set<T>;
+    /** Returns an adapter that has the same interface as {@link Set}. No copying of data involved. */
+    asSet(): Set<T>;
+    abstract has(value: T): boolean;
+    abstract delete(value: T): boolean;
+}
+export declare class SetAdapter<T> implements Set<T> {
+    private readonly collection;
+    readonly [Symbol.toStringTag] = "SetAdapter";
+    get size(): number;
+    constructor(set: DistinctCollection<T, any>);
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    entries(): IterableIterator<[T, T]>;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/data-structures/distinct-collection.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var distinct_collection_exports = {};
+__export(distinct_collection_exports, {
+  DistinctCollection: () => DistinctCollection,
+  SetAdapter: () => SetAdapter
+});
+module.exports = __toCommonJS(distinct_collection_exports);
+var import_collection = require("./collection.js");
+class DistinctCollection extends import_collection.Collection {
+  /** Creates a new map and copies the items */
+  toSet() {
+    return new Set(this);
+  }
+  /** Returns an adapter that has the same interface as {@link Set}. No copying of data involved. */
+  asSet() {
+    return new SetAdapter(this);
+  }
+}
+class SetAdapter {
+  collection;
+  [Symbol.toStringTag] = "SetAdapter";
+  get size() {
+    return this.collection.size;
+  }
+  constructor(set) {
+    this.collection = set;
+  }
+  add(value) {
+    this.collection.add(value);
+    return this;
+  }
+  clear() {
+    this.collection.clear();
+  }
+  delete(value) {
+    return this.collection.delete(value);
+  }
+  forEach(callbackfn, thisArg) {
+    for (const value of this.collection) {
+      callbackfn.call(thisArg, value, value, this);
+    }
+  }
+  has(value) {
+    return this.collection.has(value);
+  }
+  *entries() {
+    for (const item of this.collection) {
+      yield [item, item];
+    }
+  }
+  keys() {
+    return this.collection.items();
+  }
+  values() {
+    return this.collection.items();
+  }
+  [Symbol.iterator]() {
+    return this.collection[Symbol.iterator]();
+  }
+}

package/data-structures/index.d.ts

@@ -10,6 +10,7 @@ export * from './linked-list.js';
 export * from './list.js';
 export * from './map-dictionary.js';
 export * from './multi-key-map.js';
-export * from './set.js';
+export * from './multi-key-set.js';
+export * from './set-collection.js';
 export * from './sorted-array-list.js';
 export * from './weak-ref-map.js';

package/data-structures/index.js

@@ -27,6 +27,7 @@ __reExport(data_structures_exports, require("./linked-list.js"), module.exports)
 __reExport(data_structures_exports, require("./list.js"), module.exports);
 __reExport(data_structures_exports, require("./map-dictionary.js"), module.exports);
 __reExport(data_structures_exports, require("./multi-key-map.js"), module.exports);
-__reExport(data_structures_exports, require("./set.js"), module.exports);
+__reExport(data_structures_exports, require("./multi-key-set.js"), module.exports);
+__reExport(data_structures_exports, require("./set-collection.js"), module.exports);
 __reExport(data_structures_exports, require("./sorted-array-list.js"), module.exports);
 __reExport(data_structures_exports, require("./weak-ref-map.js"), module.exports);

package/data-structures/list.js

@@ -27,7 +27,9 @@ var import_index_out_of_bounds_error = require("./index-out-of-bounds.error.js")
 class List extends import_collection.Collection {
   /** get item at index */
   at(index) {
-    return this._at(this.normalizeIndex(index));
+    const normalizedIndex = this.normalizeIndex(index);
+    this.ensureBounds(normalizedIndex);
+    return this._at(normalizedIndex);
   }
   /**
    * find index of first occurrence of item
@@ -48,11 +50,15 @@ class List extends import_collection.Collection {
   }
   /** set item at index */
   set(index, item) {
-    this._set(this.normalizeIndex(index), item);
+    const normalizedIndex = this.normalizeIndex(index);
+    this.ensureBounds(normalizedIndex);
+    this._set(normalizedIndex, item);
   }
   /** remove item at index */
   removeAt(index) {
-    return this._removeAt(this.normalizeIndex(index));
+    const normalizedIndex = this.normalizeIndex(index);
+    this.ensureBounds(normalizedIndex);
+    return this._removeAt(normalizedIndex);
   }
   /** remove first item */
   removeFirst() {
@@ -67,8 +73,10 @@ class List extends import_collection.Collection {
    * @param index index to start removing at
    * @param count how many items to remove. If not defined, all items starting at `index` are removed
    */
-  removeManyAt(index, count) {
-    return this._removeManyAt(this.normalizeIndex(index), count);
+  removeManyAt(index, count = this.size - index) {
+    const normalizedIndex = this.normalizeIndex(index);
+    this.ensureBounds(normalizedIndex, count);
+    return this._removeManyAt(normalizedIndex, count);
   }
   /**
    * remove range of items at `fromIndex` to `toIndex`

package/data-structures/multi-key-map.d.ts

@@ -6,7 +6,7 @@ type Node = {
     hasValue: boolean;
     value: any;
 };
-type NewMapProvider = () => Map<any, Node>;
+export type NewMapProvider = () => Map<any, Node>;
 export declare class MultiKeyMap<K extends any[], V> extends Dictionary<K, V, MultiKeyMap<K, V>> {
     private readonly newMapProvider;
     private rootNode;

package/data-structures/multi-key-map.js

@@ -57,6 +57,8 @@ class MultiKeyMap extends import_dictionary.Dictionary {
     if (!node.hasValue) {
       node.hasValue = true;
       this.incrementSize();
+    } else {
+      this.emitChange();
     }
   }
   hasFlat(...key) {

package/data-structures/multi-key-set.d.ts

@@ -0,0 +1,19 @@
+import { DistinctCollection } from './distinct-collection.js';
+import { NewMapProvider } from './multi-key-map.js';
+export declare class MultiKeySet<T extends any[]> extends DistinctCollection<T> {
+    #private;
+    readonly [Symbol.toStringTag]: string;
+    constructor(newMapProvider?: NewMapProvider);
+    includes(value: T): boolean;
+    addFlat(...value: T): void;
+    add(value: T): void;
+    addMany(values: Iterable<T>): void;
+    hasFlat(...value: T): boolean;
+    has(value: T): boolean;
+    deleteFlat(...value: T): boolean;
+    delete(value: T): boolean;
+    clone(): MultiKeySet<T>;
+    items(): IterableIterator<T>;
+    protected _clear(): void;
+    private updateSize;
+}

package/data-structures/multi-key-set.js

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var multi_key_set_exports = {};
+__export(multi_key_set_exports, {
+  MultiKeySet: () => MultiKeySet
+});
+module.exports = __toCommonJS(multi_key_set_exports);
+var import_distinct_collection = require("./distinct-collection.js");
+var import_multi_key_map = require("./multi-key-map.js");
+class MultiKeySet extends import_distinct_collection.DistinctCollection {
+  #map;
+  [Symbol.toStringTag] = "MultiKeySet";
+  constructor(newMapProvider) {
+    super();
+    this.#map = new import_multi_key_map.MultiKeyMap(newMapProvider);
+  }
+  includes(value) {
+    return this.#map.has(value);
+  }
+  addFlat(...value) {
+    this.#map.set(value, true);
+    this.updateSize();
+  }
+  add(value) {
+    this.#map.set(value, true);
+    this.updateSize();
+  }
+  addMany(values) {
+    for (const value of values) {
+      this.#map.set(value, true);
+    }
+    this.updateSize();
+  }
+  hasFlat(...value) {
+    return this.#map.has(value);
+  }
+  has(value) {
+    return this.#map.has(value);
+  }
+  deleteFlat(...value) {
+    const deleted = this.#map.delete(value);
+    this.updateSize();
+    return deleted;
+  }
+  delete(value) {
+    const deleted = this.#map.delete(value);
+    this.updateSize();
+    return deleted;
+  }
+  clone() {
+    const clone = new MultiKeySet();
+    clone.addMany(this);
+    return clone;
+  }
+  items() {
+    return this.#map.keys();
+  }
+  _clear() {
+    this.#map.clear();
+    this.updateSize();
+  }
+  updateSize() {
+    this.setSize(this.#map.size);
+  }
+}

package/data-structures/{set.d.ts → set-collection.d.ts}

@@ -1,12 +1,12 @@
-import { Collection } from './collection.js';
-export declare class Set<T> extends Collection<T, Set<T>> implements globalThis.Set<T> {
+import { DistinctCollection } from './distinct-collection.js';
+export declare class SetCollection<T> extends DistinctCollection<T, SetCollection<T>> implements globalThis.Set<T> {
     private readonly backingSet;
     readonly [Symbol.toStringTag]: string;
     constructor(items?: Iterable<T>);
     includes(item: T): boolean;
     add(item: T): this;
     addMany(items: Iterable<T>): void;
-    clone(): Set<T>;
+    clone(): SetCollection<T>;
     items(): IterableIterator<T>;
     delete(item: T): boolean;
     forEach(callbackfn: (value: T, value2: T, set: globalThis.Set<T>) => void, thisArg?: any): void;

package/data-structures/{set.js → set-collection.js}

@@ -16,13 +16,13 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var set_exports = {};
-__export(set_exports, {
-  Set: () => Set
+var set_collection_exports = {};
+__export(set_collection_exports, {
+  SetCollection: () => SetCollection
 });
-module.exports = __toCommonJS(set_exports);
-var import_collection = require("./collection.js");
-class Set extends import_collection.Collection {
+module.exports = __toCommonJS(set_collection_exports);
+var import_distinct_collection = require("./distinct-collection.js");
+class SetCollection extends import_distinct_collection.DistinctCollection {
   backingSet;
   [Symbol.toStringTag] = "Set";
   constructor(items) {
@@ -45,7 +45,7 @@ class Set extends import_collection.Collection {
     this.updateSize();
   }
   clone() {
-    return new Set(this);
+    return new SetCollection(this);
   }
   items() {
     return this.backingSet.values();

package/data-structures/sorted-array-list.d.ts

@@ -34,7 +34,7 @@ export declare class SortedArrayList<T extends TComparator, TComparator = T> ext
     protected _set(index: number, item: T): void;
     remove(item: T): boolean;
     protected _removeAt(index: number): T;
-    protected _removeManyAt(index: number, count?: number): T[];
+    protected _removeManyAt(index: number, count: number): T[];
     /**
      * remove items
      * @param from

package/data-structures/sorted-array-list.js

@@ -72,7 +72,6 @@ let SortedArrayList = SortedArrayList_1 = class SortedArrayList2 extends import_
     return SortedArrayList_1.fromSortedArray(data);
   }
   _at(index) {
-    this.ensureBounds(index);
     return this.backingArray[index];
   }
   /** find index of item, can be any occurrence of it */
@@ -122,7 +121,6 @@ let SortedArrayList = SortedArrayList_1 = class SortedArrayList2 extends import_
   }
   /** same as `removeAt(index); add(item);` as it is sorted */
   _set(index, item) {
-    this.ensureBounds(index);
     this.backingArray.splice(index, 1);
     this.add(item);
   }
@@ -137,8 +135,7 @@ let SortedArrayList = SortedArrayList_1 = class SortedArrayList2 extends import_
   _removeAt(index) {
     return this.removeManyAt(index, 1)[0];
   }
-  _removeManyAt(index, count = this.size - index) {
-    this.ensureBounds(index, count);
+  _removeManyAt(index, count) {
     const removed = this.backingArray.splice(index, count);
     this.updateSize();
     return removed;

package/data-structures/weak-ref-map.js

@@ -75,8 +75,11 @@ class WeakRefMap extends import_collection.Collection {
   }
   set(key, value) {
     const has = this.has(key);
+    if (this.has(key)) {
+      this.finalizationRegistry.unregister(this.get(key));
+    }
     this.backingMap.set(key, new WeakRef(value));
-    this.finalizationRegistry.register(value, key);
+    this.finalizationRegistry.register(value, key, value);
     if (!has) {
       this.incrementSize();
     }

package/injector/decorators.d.ts

@@ -0,0 +1,75 @@
+import type { Decorator } from '../reflection/index.js';
+import type { Constructor, OneOrMany, Simplify, TypedOmit } from '../types.js';
+import type { Provider } from './provider.js';
+import type { InjectionToken } from './token.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
+type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
+export type InjectableOptions<T, A> = RegistrationOptions<T, A> & {
+    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
+    alias?: OneOrMany<InjectionToken>;
+    /** custom provider. Useful for example if initialization is required */
+    provider?: Provider<T, A>;
+};
+export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
+/**
+ * Helper decorator to replace a class definition with an other
+ * can be used for example to type external classes with the {@link Resolvable} interface
+ * @param constructor class to replace with
+ */
+export declare function ReplaceClass<T>(constructor: Constructor<T>): ClassDecorator;
+/**
+ * Globally registers the class for injection
+ * @param options registration options
+ */
+export declare function Injectable<T = any, A = any>(options?: InjectableOptions<T, A>): ClassDecorator;
+/**
+ * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Scoped<T = any, A = any>(lifecycle: 'resolution' | 'injector', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * sets the token used to resolve the parameter
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function Inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * sets the argument used for resolving the parameter
+ * @param argument
+ */
+export declare function ResolveArg<T>(argument: T): InjectDecorator;
+/**
+ * sets the argument provider used for resolving the parameter
+ * @param argumentProvider
+ */
+export declare function ResolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
+/**
+ * injects the argument used for resolving the class instead of resolving the parameter
+ * @param argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function InjectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
+ * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
+ */
+export declare function ForwardArg(): InjectDecorator;
+export declare function ForwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
+/**
+ * marks the argument as optional
+ * @param argument
+ */
+export declare function Optional(): InjectDecorator;
+/**
+ * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
+ * @param token token to resolve
+ * @param argument resolve argument
+ */
+export declare function ForwardRef<T extends object, A>(token: ForwardRefInjectionToken<T>, argument?: A): InjectDecorator;
+export {};

package/injector/decorators.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decorators_exports = {};
+__export(decorators_exports, {
+  ForwardArg: () => ForwardArg,
+  ForwardRef: () => ForwardRef,
+  Inject: () => Inject,
+  InjectArg: () => InjectArg,
+  Injectable: () => Injectable,
+  Optional: () => Optional,
+  ReplaceClass: () => ReplaceClass,
+  ResolveArg: () => ResolveArg,
+  ResolveArgProvider: () => ResolveArgProvider,
+  Scoped: () => Scoped,
+  Singleton: () => Singleton
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_reflection = require("../reflection/index.js");
+var import_array = require("../utils/array/array.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_injector = require("./injector.js");
+var import_symbols = require("./symbols.js");
+function ReplaceClass(constructor) {
+  return (0, import_reflection.createClassDecorator)({ handler: () => constructor });
+}
+function Injectable(options = {}) {
+  return (0, import_reflection.createClassDecorator)({
+    data: { [import_symbols.injectableMetadataSymbol]: {} },
+    mergeData: true,
+    handler: (data) => {
+      const { alias: aliases, provider, ...registrationOptions } = options;
+      const token = data.constructor;
+      const targetProvider = provider ?? { useClass: token };
+      import_injector.Injector.register(token, targetProvider, registrationOptions);
+      if ((0, import_type_guards.isDefined)(aliases)) {
+        for (const alias of (0, import_array.toArray)(aliases)) {
+          import_injector.Injector.register(alias, { useToken: token }, registrationOptions);
+        }
+      }
+    }
+  });
+}
+function Singleton(options = {}) {
+  return Injectable({ ...options, lifecycle: "singleton" });
+}
+function Scoped(lifecycle, options = {}) {
+  return Injectable({ ...options, lifecycle });
+}
+function Inject(token, argument, mapperOrKey) {
+  const injectMetadata = {};
+  if ((0, import_type_guards.isDefined)(token)) {
+    injectMetadata.injectToken = token;
+  }
+  if ((0, import_type_guards.isDefined)(argument)) {
+    injectMetadata.resolveArgumentProvider = () => argument;
+  }
+  if ((0, import_type_guards.isDefined)(mapperOrKey)) {
+    injectMetadata.mapper = (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (value) => value[mapperOrKey];
+  }
+  return createInjectDecorator(injectMetadata);
+}
+function ResolveArg(argument) {
+  return ResolveArgProvider(() => argument);
+}
+function ResolveArgProvider(argumentProvider) {
+  return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
+}
+function InjectArg(mapperOrKey) {
+  return createInjectDecorator({
+    injectArgumentMapper: (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (0, import_type_guards.isDefined)(mapperOrKey) ? (value) => value[mapperOrKey] : (value) => value
+  });
+}
+function ForwardArg(mapper = (value) => value) {
+  return createInjectDecorator({ forwardArgumentMapper: mapper });
+}
+function Optional() {
+  return createInjectDecorator({ optional: true });
+}
+function ForwardRef(token, argument) {
+  const injectMetadata = {
+    forwardRefToken: token
+  };
+  if ((0, import_type_guards.isDefined)(argument)) {
+    injectMetadata.resolveArgumentProvider = () => argument;
+  }
+  return createInjectDecorator(injectMetadata);
+}
+function createInjectDecorator(metadata) {
+  return (0, import_reflection.createDecorator)({
+    property: true,
+    accessor: true,
+    constructorParameter: true,
+    data: { [import_symbols.injectMetadataSymbol]: metadata },
+    mergeData: true
+  });
+}