@tstdl/base 0.83.0-beta2 → 0.83.0-beta3

package/container/decorators.js

@@ -1,127 +1,110 @@
-import { createClassDecorator, createDecorator } from '../reflection/index.js';
-import { toArray } from '../utils/array/array.js';
-import { isDefined, isFunction } from '../utils/type-guards.js';
-import { container, injectMetadataSymbol } from './container.js';
-/**
- * Helper decorator to replace a class definition with an other
- * can be used for example to type external classes with the {@link Injectable} interface
- * @param constructor class to replace with
- */
-export function replaceClass(constructor) {
-    return createClassDecorator({ handler: () => constructor });
+"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_container = require("./container.js");
+function replaceClass(constructor) {
+  return (0, import_reflection.createClassDecorator)({ handler: () => constructor });
 }
-/**
- * registers the class in the global container. Decorated class is not modified in any way
- * @param options registration options
- */
-export function injectable(options = {}) {
-    return createClassDecorator({
-        data: { [injectMetadataSymbol]: {} },
-        mergeData: true,
-        handler: (data) => {
-            const { alias: aliases, provider, ...registrationOptions } = options;
-            const targetProvider = provider ?? { useClass: data.constructor };
-            container.register(data.constructor, targetProvider, registrationOptions);
-            if (isDefined(aliases)) {
-                for (const alias of toArray(aliases)) {
-                    container.register(alias, { useToken: data.constructor }, registrationOptions);
-                }
-            }
+function injectable(options = {}) {
+  return (0, import_reflection.createClassDecorator)({
+    data: { [import_container.injectMetadataSymbol]: {} },
+    mergeData: true,
+    handler: (data) => {
+      const { alias: aliases, provider, ...registrationOptions } = options;
+      const targetProvider = provider ?? { useClass: data.constructor };
+      import_container.container.register(data.constructor, targetProvider, registrationOptions);
+      if ((0, import_type_guards.isDefined)(aliases)) {
+        for (const alias of (0, import_array.toArray)(aliases)) {
+          import_container.container.register(alias, { useToken: data.constructor }, registrationOptions);
         }
-    });
+      }
+    }
+  });
 }
-/**
- * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export function singleton(options = {}) {
-    return injectable({ ...options, lifecycle: 'singleton' });
+function singleton(options = {}) {
+  return injectable({ ...options, lifecycle: "singleton" });
 }
-/**
- * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export function scoped(lifecycle, options = {}) {
-    return injectable({ ...options, lifecycle });
+function scoped(lifecycle, options = {}) {
+  return injectable({ ...options, lifecycle });
 }
-/**
- * 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 function inject(token, argument, mapperOrKey) {
-    const injectMetadata = {};
-    if (isDefined(token)) {
-        injectMetadata.injectToken = token;
-    }
-    if (isDefined(argument)) {
-        injectMetadata.resolveArgumentProvider = () => argument;
-    }
-    if (isDefined(mapperOrKey)) {
-        injectMetadata.mapper = isFunction(mapperOrKey) ? mapperOrKey : ((value) => value[mapperOrKey]);
-    }
-    return createInjectDecorator(injectMetadata);
+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);
 }
-/**
- * sets the argument used for resolving the parameter
- * @param argument
- */
-export function resolveArg(argument) {
-    return resolveArgProvider(() => argument);
+function resolveArg(argument) {
+  return resolveArgProvider(() => argument);
 }
-/**
- * sets the argument provider used for resolving the parameter
- * @param argumentProvider
- */
-export function resolveArgProvider(argumentProvider) {
-    return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
+function resolveArgProvider(argumentProvider) {
+  return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
 }
-/**
- * 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 function injectArg(mapperOrKey) {
-    return createInjectDecorator({
-        injectArgumentMapper: isFunction(mapperOrKey)
-            ? mapperOrKey
-            : isDefined(mapperOrKey)
-                ? ((value) => value[mapperOrKey])
-                : ((value) => value)
-    });
+function injectArg(mapperOrKey) {
+  return createInjectDecorator({
+    injectArgumentMapper: (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (0, import_type_guards.isDefined)(mapperOrKey) ? (value) => value[mapperOrKey] : (value) => value
+  });
 }
-export function forwardArg(mapper = (value) => value) {
-    return createInjectDecorator({ forwardArgumentMapper: mapper });
+function forwardArg(mapper = (value) => value) {
+  return createInjectDecorator({ forwardArgumentMapper: mapper });
 }
-/**
- * marks the argument as optional
- * @param argument
- */
-export function optional() {
-    return createInjectDecorator({ optional: true });
+function optional() {
+  return createInjectDecorator({ optional: true });
 }
-/**
- * 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 function forwardRef(token, argument) {
-    const injectMetadata = {
-        forwardRefToken: token
-    };
-    if (isDefined(argument)) {
-        injectMetadata.resolveArgumentProvider = () => argument;
-    }
-    return createInjectDecorator(injectMetadata);
+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 createDecorator({
-        property: true,
-        accessor: true,
-        constructorParameter: true,
-        data: { [injectMetadataSymbol]: metadata },
-        mergeData: true
-    });
+  return (0, import_reflection.createDecorator)({
+    property: true,
+    accessor: true,
+    constructorParameter: true,
+    data: { [import_container.injectMetadataSymbol]: metadata },
+    mergeData: true
+  });
 }
-//# sourceMappingURL=decorators.js.map

package/container/index.js

@@ -1,11 +1,27 @@
-export * from './container.js';
-export * from './decorators.js';
-export * from './interfaces.js';
-export * from './provider.js';
-export * from './resolve-chain.js';
-export * from './resolve.error.js';
-export * from './token.js';
-export * from './type-info.js';
-export * from './types.js';
-export * from './utils.js';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var container_exports = {};
+module.exports = __toCommonJS(container_exports);
+__reExport(container_exports, require("./container.js"), module.exports);
+__reExport(container_exports, require("./decorators.js"), module.exports);
+__reExport(container_exports, require("./interfaces.js"), module.exports);
+__reExport(container_exports, require("./provider.js"), module.exports);
+__reExport(container_exports, require("./resolve-chain.js"), module.exports);
+__reExport(container_exports, require("./resolve.error.js"), module.exports);
+__reExport(container_exports, require("./token.js"), module.exports);
+__reExport(container_exports, require("./type-info.js"), module.exports);
+__reExport(container_exports, require("./types.js"), module.exports);
+__reExport(container_exports, require("./utils.js"), module.exports);

package/container/interfaces.js

@@ -1,3 +1,26 @@
-export const resolveArgumentType = Symbol('resolveArgumentType');
-export const afterResolve = Symbol('after resolve');
-//# sourceMappingURL=interfaces.js.map
+"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 interfaces_exports = {};
+__export(interfaces_exports, {
+  afterResolve: () => afterResolve,
+  resolveArgumentType: () => resolveArgumentType
+});
+module.exports = __toCommonJS(interfaces_exports);
+const resolveArgumentType = Symbol("resolveArgumentType");
+const afterResolve = Symbol("after resolve");

package/container/provider.js

@@ -1,26 +1,55 @@
-import { hasOwnProperty } from '../utils/object/object.js';
-export function classProvider(constructor) {
-    return { useClass: constructor };
+"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 provider_exports = {};
+__export(provider_exports, {
+  classProvider: () => classProvider,
+  factoryProvider: () => factoryProvider,
+  isClassProvider: () => isClassProvider,
+  isFactoryProvider: () => isFactoryProvider,
+  isTokenProvider: () => isTokenProvider,
+  isValueProvider: () => isValueProvider,
+  tokenProvider: () => tokenProvider,
+  valueProvider: () => valueProvider
+});
+module.exports = __toCommonJS(provider_exports);
+var import_object = require("../utils/object/object.js");
+function classProvider(constructor) {
+  return { useClass: constructor };
+}
+function valueProvider(value) {
+  return { useValue: value };
+}
+function tokenProvider(token, argument) {
+  return { useToken: token, argument };
+}
+function factoryProvider(factory) {
+  return { useFactory: factory };
+}
+function isClassProvider(provider) {
+  return (0, import_object.hasOwnProperty)(provider, "useClass");
+}
+function isValueProvider(provider) {
+  return (0, import_object.hasOwnProperty)(provider, "useValue");
+}
+function isTokenProvider(provider) {
+  return (0, import_object.hasOwnProperty)(provider, "useToken") || (0, import_object.hasOwnProperty)(provider, "useTokenProvider");
+}
+function isFactoryProvider(provider) {
+  return (0, import_object.hasOwnProperty)(provider, "useFactory");
 }
-export function valueProvider(value) {
-    return { useValue: value };
-}
-export function tokenProvider(token, argument) {
-    return { useToken: token, argument };
-}
-export function factoryProvider(factory) {
-    return { useFactory: factory };
-}
-export function isClassProvider(provider) {
-    return hasOwnProperty(provider, 'useClass');
-}
-export function isValueProvider(provider) {
-    return hasOwnProperty(provider, 'useValue');
-}
-export function isTokenProvider(provider) {
-    return hasOwnProperty(provider, 'useToken') || hasOwnProperty(provider, 'useTokenProvider');
-}
-export function isFactoryProvider(provider) {
-    return hasOwnProperty(provider, 'useFactory');
-}
-//# sourceMappingURL=provider.js.map

package/container/resolve-chain.js

@@ -1,81 +1,105 @@
-import { reflectionRegistry } from '../reflection/index.js';
-import { assertDefinedPass, isDefined } from '../utils/type-guards.js';
-import { getTokenName } from './token.js';
-export class ResolveChain {
-    nodes;
-    get length() {
-        return this.nodes.length;
+"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 resolve_chain_exports = {};
+__export(resolve_chain_exports, {
+  ResolveChain: () => ResolveChain
+});
+module.exports = __toCommonJS(resolve_chain_exports);
+var import_reflection = require("../reflection/index.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_token = require("./token.js");
+class ResolveChain {
+  nodes;
+  get length() {
+    return this.nodes.length;
+  }
+  constructor(nodes) {
+    this.nodes = nodes ?? [];
+  }
+  static startWith(token) {
+    const chain = new ResolveChain();
+    return chain.addToken(token);
+  }
+  addToken(token) {
+    const node = { type: "token", token };
+    return new ResolveChain([...this.nodes, node]);
+  }
+  addParameter(constructor, index, token) {
+    const node = { type: "parameter", constructor, index, token };
+    return new ResolveChain([...this.nodes, node]);
+  }
+  addProperty(constructor, property, token) {
+    const node = { type: "property", constructor, property, token };
+    return new ResolveChain([...this.nodes, node]);
+  }
+  format(truncate) {
+    let chainString = "";
+    const chain = (0, import_type_guards.isDefined)(truncate) ? this.truncate(truncate) : this;
+    if (chain.length < this.length) {
+      chainString += "\n       [...]";
     }
-    constructor(nodes) {
-        this.nodes = nodes ?? [];
-    }
-    static startWith(token) {
-        const chain = new ResolveChain();
-        return chain.addToken(token);
-    }
-    addToken(token) {
-        const node = { type: 'token', token };
-        return new ResolveChain([...this.nodes, node]);
-    }
-    addParameter(constructor, index, token) {
-        const node = { type: 'parameter', constructor, index, token };
-        return new ResolveChain([...this.nodes, node]);
-    }
-    addProperty(constructor, property, token) {
-        const node = { type: 'property', constructor, property, token };
-        return new ResolveChain([...this.nodes, node]);
-    }
-    format(truncate) {
-        let chainString = '';
-        const chain = isDefined(truncate) ? this.truncate(truncate) : this;
-        if (chain.length < this.length) {
-            chainString += '\n       [...]';
-        }
-        for (const node of chain.nodes) {
-            const tokenName = getTokenName(node.token);
-            switch (node.type) {
-                case 'token':
-                    chainString += `\n    -> ${tokenName}`;
-                    break;
-                case 'parameter':
-                    const metadata = reflectionRegistry.getMetadata(node.constructor);
-                    const prefix = '_, '.repeat(node.index);
-                    const suffix = ', _'.repeat(assertDefinedPass(metadata?.parameters, 'missing parameters metadata').length - node.index - 1);
-                    chainString += `(${prefix}${tokenName}${suffix})`;
-                    break;
-                case 'property':
-                    const constructorName = getTokenName(node.constructor);
-                    const key = getPropertyKeyString(node.property);
-                    chainString += `\n    -> ${constructorName}[${key}]: ${tokenName}`;
-                    break;
-                default:
-                    throw new Error(`unknown chain node type ${node.type}`);
-            }
-        }
-        return chainString;
+    for (const node of chain.nodes) {
+      const tokenName = (0, import_token.getTokenName)(node.token);
+      switch (node.type) {
+        case "token":
+          chainString += `
+    -> ${tokenName}`;
+          break;
+        case "parameter":
+          const metadata = import_reflection.reflectionRegistry.getMetadata(node.constructor);
+          const prefix = "_, ".repeat(node.index);
+          const suffix = ", _".repeat((0, import_type_guards.assertDefinedPass)(metadata?.parameters, "missing parameters metadata").length - node.index - 1);
+          chainString += `(${prefix}${tokenName}${suffix})`;
+          break;
+        case "property":
+          const constructorName = (0, import_token.getTokenName)(node.constructor);
+          const key = getPropertyKeyString(node.property);
+          chainString += `
+    -> ${constructorName}[${key}]: ${tokenName}`;
+          break;
+        default:
+          throw new Error(`unknown chain node type ${node.type}`);
+      }
     }
-    truncate(tokenCount) {
-        const truncatedChain = [];
-        let counter = 0;
-        for (let i = this.nodes.length - 1; (i >= 0) && (counter < tokenCount); i--) {
-            const node = this.nodes[i];
-            truncatedChain.unshift(node);
-            if (node.type == 'token') {
-                counter++;
-            }
-        }
-        return new ResolveChain(truncatedChain);
+    return chainString;
+  }
+  truncate(tokenCount) {
+    const truncatedChain = [];
+    let counter = 0;
+    for (let i = this.nodes.length - 1; i >= 0 && counter < tokenCount; i--) {
+      const node = this.nodes[i];
+      truncatedChain.unshift(node);
+      if (node.type == "token") {
+        counter++;
+      }
     }
+    return new ResolveChain(truncatedChain);
+  }
 }
 function getPropertyKeyString(key) {
-    switch (typeof key) {
-        case 'number':
-        case 'symbol':
-            return key.toString();
-        case 'string':
-            return `'${key}'`;
-        default:
-            throw new Error(`unsupported key type ${typeof key}`);
-    }
+  switch (typeof key) {
+    case "number":
+    case "symbol":
+      return key.toString();
+    case "string":
+      return `'${key}'`;
+    default:
+      throw new Error(`unsupported key type ${typeof key}`);
+  }
 }
-//# sourceMappingURL=resolve-chain.js.map

package/container/resolve.error.js

@@ -1,12 +1,36 @@
-import { CustomError } from '../error/custom.error.js';
-import { isDefined } from '../utils/type-guards.js';
-export class ResolveError extends CustomError {
-    constructor(message, chain, cause) {
-        const causeMessage = isDefined(cause) ? `\n  cause: ${cause.message}` : '';
-        super({
-            message: `${message}${causeMessage}\n  chain: ${chain.format(15)}`,
-            cause
-        });
-    }
+"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 resolve_error_exports = {};
+__export(resolve_error_exports, {
+  ResolveError: () => ResolveError
+});
+module.exports = __toCommonJS(resolve_error_exports);
+var import_custom_error = require("../error/custom.error.js");
+var import_type_guards = require("../utils/type-guards.js");
+class ResolveError extends import_custom_error.CustomError {
+  constructor(message, chain, cause) {
+    const causeMessage = (0, import_type_guards.isDefined)(cause) ? `
+  cause: ${cause.message}` : "";
+    super({
+      message: `${message}${causeMessage}
+  chain: ${chain.format(15)}`,
+      cause
+    });
+  }
 }
-//# sourceMappingURL=resolve.error.js.map

package/container/token.js

@@ -1,12 +1,31 @@
-import { isFunction, isString } from '../utils/type-guards.js';
-export function injectionToken(token) {
-    return token;
+"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 token_exports = {};
+__export(token_exports, {
+  getTokenName: () => getTokenName,
+  injectionToken: () => injectionToken
+});
+module.exports = __toCommonJS(token_exports);
+var import_type_guards = require("../utils/type-guards.js");
+function injectionToken(token) {
+  return token;
 }
-export function getTokenName(token) {
-    return isFunction(token)
-        ? token.name
-        : isString(token)
-            ? `"${token}"`
-            : String(token);
+function getTokenName(token) {
+  return (0, import_type_guards.isFunction)(token) ? token.name : (0, import_type_guards.isString)(token) ? `"${token}"` : String(token);
 }
-//# sourceMappingURL=token.js.map