awilix 11.0.3 → 12.0.0

package/lib/awilix.browser.js

@@ -1,147 +1,56 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
+import * as glob from 'fast-glob';
+import * as path from 'path';
 
 /**
  * Newline.
  */
-var EOL = '\n';
+const EOL = '\n';
 /**
  * An extendable error class.
  * @author https://github.com/bjyoungblood/es6-error/
  */
-var ExtendableError = /** @class */ (function (_super) {
-    __extends(ExtendableError, _super);
+class ExtendableError extends Error {
     /**
      * Constructor for the error.
      *
      * @param  {String} message
      * The error message.
      */
-    function ExtendableError(message) {
-        var _this = _super.call(this, message) || this;
+    constructor(message) {
+        super(message);
         // extending Error is weird and does not propagate `message`
-        Object.defineProperty(_this, 'message', {
+        Object.defineProperty(this, 'message', {
             enumerable: false,
             value: message,
         });
-        Object.defineProperty(_this, 'name', {
+        Object.defineProperty(this, 'name', {
             enumerable: false,
-            value: _this.constructor.name,
+            value: this.constructor.name,
         });
         // Not all browsers have this function.
         /* istanbul ignore else */
         if ('captureStackTrace' in Error) {
-            Error.captureStackTrace(_this, _this.constructor);
+            Error.captureStackTrace(this, this.constructor);
         }
         else {
-            Object.defineProperty(_this, 'stack', {
+            Object.defineProperty(this, 'stack', {
                 enumerable: false,
                 value: Error(message).stack,
                 writable: true,
                 configurable: true,
             });
         }
-        return _this;
     }
-    return ExtendableError;
-}(Error));
+}
 /**
  * Base error for all Awilix-specific errors.
  */
-var AwilixError = /** @class */ (function (_super) {
-    __extends(AwilixError, _super);
-    function AwilixError() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return AwilixError;
-}(ExtendableError));
+class AwilixError extends ExtendableError {
+}
 /**
  * Error thrown to indicate a type mismatch.
  */
-var AwilixTypeError = /** @class */ (function (_super) {
-    __extends(AwilixTypeError, _super);
+class AwilixTypeError extends AwilixError {
     /**
      * Constructor, takes the function name, expected and given
      * type to produce an error.
@@ -158,8 +67,8 @@ var AwilixTypeError = /** @class */ (function (_super) {
      * @param {string} givenType
      * Name of the given type.
      */
-    function AwilixTypeError(funcDescription, paramName, expectedType, givenType) {
-        return _super.call(this, "".concat(funcDescription, ": expected ").concat(paramName, " to be ").concat(expectedType, ", but got ").concat(givenType, ".")) || this;
+    constructor(funcDescription, paramName, expectedType, givenType) {
+        super(`${funcDescription}: expected ${paramName} to be ${expectedType}, but got ${givenType}.`);
     }
     /**
      * Asserts the given condition, throws an error otherwise.
@@ -179,19 +88,17 @@ var AwilixTypeError = /** @class */ (function (_super) {
      * @param {string} givenType
      * Name of the given type.
      */
-    AwilixTypeError.assert = function (condition, funcDescription, paramName, expectedType, givenType) {
+    static assert(condition, funcDescription, paramName, expectedType, givenType) {
         if (!condition) {
             throw new AwilixTypeError(funcDescription, paramName, expectedType, givenType);
         }
         return condition;
-    };
-    return AwilixTypeError;
-}(AwilixError));
+    }
+}
 /**
  * A nice error class so we can do an instanceOf check.
  */
-var AwilixResolutionError = /** @class */ (function (_super) {
-    __extends(AwilixResolutionError, _super);
+class AwilixResolutionError extends AwilixError {
     /**
      * Constructor, takes the registered modules and unresolved tokens
      * to create a message.
@@ -202,29 +109,24 @@ var AwilixResolutionError = /** @class */ (function (_super) {
      * @param  {string[]} resolutionStack
      * The current resolution stack
      */
-    function AwilixResolutionError(name, resolutionStack, message) {
-        var stringName = name.toString();
-        var nameStack = resolutionStack.map(function (_a) {
-            var val = _a.name;
-            return val.toString();
-        });
+    constructor(name, resolutionStack, message) {
+        const stringName = name.toString();
+        const nameStack = resolutionStack.map(({ name: val }) => val.toString());
         nameStack.push(stringName);
-        var resolutionPathString = nameStack.join(' -> ');
-        var msg = "Could not resolve '".concat(stringName, "'.");
+        const resolutionPathString = nameStack.join(' -> ');
+        let msg = `Could not resolve '${stringName}'.`;
         if (message) {
-            msg += " ".concat(message);
+            msg += ` ${message}`;
         }
         msg += EOL + EOL;
-        msg += "Resolution path: ".concat(resolutionPathString);
-        return _super.call(this, msg) || this;
+        msg += `Resolution path: ${resolutionPathString}`;
+        super(msg);
     }
-    return AwilixResolutionError;
-}(AwilixError));
+}
 /**
  * A nice error class so we can do an instanceOf check.
  */
-var AwilixRegistrationError = /** @class */ (function (_super) {
-    __extends(AwilixRegistrationError, _super);
+class AwilixRegistrationError extends AwilixError {
     /**
      * Constructor, takes the registered modules and unresolved tokens
      * to create a message.
@@ -232,21 +134,20 @@ var AwilixRegistrationError = /** @class */ (function (_super) {
      * @param {string|symbol} name
      * The name of the module that could not be registered.
      */
-    function AwilixRegistrationError(name, message) {
-        var stringName = name.toString();
-        var msg = "Could not register '".concat(stringName, "'.");
+    constructor(name, message) {
+        const stringName = name.toString();
+        let msg = `Could not register '${stringName}'.`;
         if (message) {
-            msg += " ".concat(message);
+            msg += ` ${message}`;
         }
-        return _super.call(this, msg) || this;
+        super(msg);
     }
-    return AwilixRegistrationError;
-}(AwilixError));
+}
 
 /**
  * Resolution modes.
  */
-var InjectionMode = {
+const InjectionMode = {
     /**
      * The dependencies will be resolved by injecting the cradle proxy.
      *
@@ -264,7 +165,7 @@ var InjectionMode = {
 /**
  * Lifetime types.
  */
-var Lifetime = {
+const Lifetime = {
     /**
      * The registration will be resolved once and only once.
      * @type {String}
@@ -295,24 +196,23 @@ function isLifetimeLonger(a, b) {
  * @param source
  */
 function createTokenizer(source) {
-    var end = source.length;
-    var pos = 0;
-    var type = 'EOF';
-    var value = '';
-    var flags = 0 /* TokenizerFlags.None */;
+    const end = source.length;
+    let pos = 0;
+    let type = 'EOF';
+    let value = '';
+    let flags = 0 /* TokenizerFlags.None */;
     // These are used to greedily skip as much as possible.
     // Whenever we reach a paren, we increment these.
-    var parenLeft = 0;
-    var parenRight = 0;
+    let parenLeft = 0;
+    let parenRight = 0;
     return {
-        next: next,
-        done: done,
+        next,
+        done,
     };
     /**
      * Advances the tokenizer and returns the next token.
      */
-    function next(nextFlags) {
-        if (nextFlags === void 0) { nextFlags = 0 /* TokenizerFlags.None */; }
+    function next(nextFlags = 0 /* TokenizerFlags.None */) {
         flags = nextFlags;
         advance();
         return createToken();
@@ -327,7 +227,7 @@ function createTokenizer(source) {
             if (pos >= end) {
                 return (type = 'EOF');
             }
-            var ch = source.charAt(pos);
+            const ch = source.charAt(pos);
             // Whitespace is irrelevant
             if (isWhiteSpace(ch)) {
                 pos++;
@@ -359,14 +259,14 @@ function createTokenizer(source) {
                     return (type = ch);
                 case '/': {
                     pos++;
-                    var nextCh = source.charAt(pos);
+                    const nextCh = source.charAt(pos);
                     if (nextCh === '/') {
-                        skipUntil(function (c) { return c === '\n'; }, true);
+                        skipUntil((c) => c === '\n', true);
                         pos++;
                     }
                     if (nextCh === '*') {
-                        skipUntil(function (c) {
-                            var closing = source.charAt(pos + 1);
+                        skipUntil((c) => {
+                            const closing = source.charAt(pos + 1);
                             return c === '*' && closing === '/';
                         }, true);
                         pos++;
@@ -389,8 +289,8 @@ function createTokenizer(source) {
      * we are ready to do so.
      */
     function scanIdentifier() {
-        var identStart = source.charAt(pos);
-        var start = ++pos;
+        const identStart = source.charAt(pos);
+        const start = ++pos;
         while (isIdentifierPart(source.charAt(pos))) {
             pos++;
         }
@@ -406,8 +306,8 @@ function createTokenizer(source) {
      * Checks the parenthesis balance so we correctly skip function calls.
      */
     function skipExpression() {
-        skipUntil(function (ch) {
-            var isAtRoot = parenLeft === parenRight + 1;
+        skipUntil((ch) => {
+            const isAtRoot = parenLeft === parenRight + 1;
             if (ch === ',' && isAtRoot) {
                 return true;
             }
@@ -431,10 +331,9 @@ function createTokenizer(source) {
      * @param dumb if `true`, does not skip whitespace and strings;
      * it only stops once the callback returns `true`.
      */
-    function skipUntil(callback, dumb) {
-        if (dumb === void 0) { dumb = false; }
+    function skipUntil(callback, dumb = false) {
         while (pos < source.length) {
-            var ch = source.charAt(pos);
+            const ch = source.charAt(pos);
             if (callback(ch)) {
                 return;
             }
@@ -455,11 +354,11 @@ function createTokenizer(source) {
      * Given the current position is at a string quote, skips the entire string.
      */
     function skipString() {
-        var quote = source.charAt(pos);
+        const quote = source.charAt(pos);
         pos++;
         while (pos < source.length) {
-            var ch = source.charAt(pos);
-            var prev = source.charAt(pos - 1);
+            const ch = source.charAt(pos);
+            const prev = source.charAt(pos - 1);
             // Checks if the quote was escaped.
             if (ch === quote && prev !== '\\') {
                 pos++;
@@ -467,15 +366,15 @@ function createTokenizer(source) {
             }
             // Template strings are a bit tougher, we want to skip the interpolated values.
             if (quote === '`') {
-                var next_1 = source.charAt(pos + 1);
-                if (next_1 === '$') {
-                    var afterDollar = source.charAt(pos + 2);
+                const next = source.charAt(pos + 1);
+                if (next === '$') {
+                    const afterDollar = source.charAt(pos + 2);
                     if (afterDollar === '{') {
                         // This is the start of an interpolation; skip the ${
                         pos = pos + 2;
                         // Skip strings and whitespace until we reach the ending }.
                         // This includes skipping nested interpolated strings. :D
-                        skipUntil(function (ch) { return ch === '}'; });
+                        skipUntil((ch) => ch === '}');
                     }
                 }
             }
@@ -487,9 +386,9 @@ function createTokenizer(source) {
      */
     function createToken() {
         if (value) {
-            return { value: value, type: type };
+            return { value, type };
         }
-        return { type: type };
+        return { type };
     }
     /**
      * Determines if we are done parsing.
@@ -530,8 +429,8 @@ function isStringQuote(ch) {
 // NOTE: I've added the `.` character so that member expression paths
 // are seen as identifiers. This is so we don't get a constructor token for
 // stuff like `MyClass.prototype.constructor()`
-var IDENT_START_EXPR = /^[_$a-zA-Z\xA0-\uFFFF]$/;
-var IDENT_PART_EXPR = /^[._$a-zA-Z0-9\xA0-\uFFFF]$/;
+const IDENT_START_EXPR = /^[_$a-zA-Z\xA0-\uFFFF]$/;
+const IDENT_PART_EXPR = /^[._$a-zA-Z0-9\xA0-\uFFFF]$/;
 /**
  * Determines if the character is a valid JS identifier start character.
  */
@@ -545,6 +444,24 @@ function isIdentifierPart(ch) {
     return IDENT_PART_EXPR.test(ch);
 }
 
+/**
+ * Quick flatten utility to flatten a 2-dimensional array.
+ *
+ * @param  {Array<Array<Item>>} array
+ * The array to flatten.
+ *
+ * @return {Array<Item>}
+ * The flattened array.
+ */
+function flatten(array) {
+    const result = [];
+    array.forEach((arr) => {
+        arr.forEach((item) => {
+            result.push(item);
+        });
+    });
+    return result;
+}
 /**
  * Creates a { name: value } object if the input isn't already in that format.
  *
@@ -557,10 +474,9 @@ function isIdentifierPart(ch) {
  * @return {object}
  */
 function nameValueToObject(name, value) {
-    var _a;
-    var obj = name;
+    const obj = name;
     if (typeof obj === 'string' || typeof obj === 'symbol') {
-        return _a = {}, _a[name] = value, _a;
+        return { [name]: value };
     }
     return obj;
 }
@@ -589,12 +505,12 @@ fn) {
         return false;
     }
     // Should only need 2 tokens.
-    var tokenizer = createTokenizer(fn.toString());
-    var first = tokenizer.next();
+    const tokenizer = createTokenizer(fn.toString());
+    const first = tokenizer.next();
     if (first.type === 'class') {
         return true;
     }
-    var second = tokenizer.next();
+    const second = tokenizer.next();
     if (first.type === 'function' && second.value) {
         if (second.value[0] === second.value[0].toUpperCase()) {
             return true;
@@ -611,6 +527,7 @@ fn) {
  * @return {boolean}
  * true if the value is a function, false otherwise.
  */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function isFunction(val) {
     return typeof val === 'function';
 }
@@ -627,6 +544,62 @@ function uniq(arr) {
     return Array.from(new Set(arr));
 }
 
+// Regex to extract the module name.
+const nameExpr = /(.*)\..*/i;
+/**
+ * Internal method for globbing a single pattern.
+ *
+ * @param  {String} globPattern
+ * The glob pattern.
+ *
+ * @param  {String} opts.cwd
+ * Current working directory, used for resolving filepaths.
+ * Defaults to `process.cwd()`.
+ *
+ * @return {[{name, path, opts}]}
+ * The module names and paths.
+ *
+ * @api private
+ */
+function _listModules(globPattern, opts) {
+    opts = { cwd: process.cwd(), glob: glob.sync, ...opts };
+    let patternOpts = null;
+    if (Array.isArray(globPattern)) {
+        patternOpts = globPattern[1];
+        globPattern = globPattern[0];
+    }
+    // Replace Windows path separators with Posix path
+    globPattern = globPattern.replace(/\\/g, '/');
+    const result = opts.glob(globPattern, { cwd: opts.cwd });
+    const mapped = result.map((p) => ({
+        name: nameExpr.exec(path.basename(p))[1],
+        path: path.resolve(opts.cwd, p),
+        opts: patternOpts,
+    }));
+    return mapped;
+}
+/**
+ * Returns a list of {name, path} pairs,
+ * where the name is the module name, and path is the actual
+ * full path to the module.
+ *
+ * @param  {String|Array<String>} globPatterns
+ * The glob pattern as a string or an array of strings.
+ *
+ * @param  {String} opts.cwd
+ * Current working directory, used for resolving filepaths.
+ * Defaults to `process.cwd()`.
+ *
+ * @return {[{name, path}]}
+ * An array of objects with the module names and paths.
+ */
+function listModules(globPatterns, opts) {
+    if (Array.isArray(globPatterns)) {
+        return flatten(globPatterns.map((p) => _listModules(p, opts)));
+    }
+    return _listModules(globPatterns, opts);
+}
+
 /*
  * Parses the parameter list of a function string, including ES6 class constructors.
  *
@@ -638,9 +611,9 @@ function uniq(arr) {
  * constructor was found for a class.
  */
 function parseParameterList(source) {
-    var _a = createTokenizer(source), _next = _a.next, done = _a.done;
-    var params = [];
-    var t = null;
+    const { next: _next, done } = createTokenizer(source);
+    const params = [];
+    let t = null;
     nextToken();
     while (!done()) {
         switch (t.type) {
@@ -655,7 +628,7 @@ function parseParameterList(source) {
                 nextToken();
                 break;
             case 'function': {
-                var next = nextToken();
+                const next = nextToken();
                 if (next.type === 'ident' || next.type === '*') {
                     // This is the function name or a generator star. Skip it.
                     nextToken();
@@ -672,12 +645,12 @@ function parseParameterList(source) {
             case 'ident': {
                 // Likely a paren-less arrow function
                 // which can have no default args.
-                var param = { name: t.value, optional: false };
+                const param = { name: t.value, optional: false };
                 if (t.value === 'async') {
                     // Given it's the very first token, we can assume it's an async function,
                     // so skip the async keyword if the next token is not an equals sign, in which
                     // case it is a single-arg arrow func.
-                    var next = nextToken();
+                    const next = nextToken();
                     if (next && next.type !== '=') {
                         break;
                     }
@@ -697,7 +670,7 @@ function parseParameterList(source) {
      */
     function parseParams() {
         // Current token is a left-paren
-        var param = { name: '', optional: false };
+        let param = { name: '', optional: false };
         while (!done()) {
             nextToken();
             switch (t.type) {
@@ -740,8 +713,7 @@ function parseParameterList(source) {
     /**
      * Advances the tokenizer and stores the previous token in history
      */
-    function nextToken(flags) {
-        if (flags === void 0) { flags = 0 /* TokenizerFlags.None */; }
+    function nextToken(flags = 0 /* TokenizerFlags.None */) {
         t = _next(flags);
         return t;
     }
@@ -750,7 +722,7 @@ function parseParameterList(source) {
      */
     /* istanbul ignore next */
     function unexpected() {
-        return new SyntaxError("Parsing parameter list, did not expect ".concat(t.type, " token").concat(t.value ? " (".concat(t.value, ")") : ''));
+        return new SyntaxError(`Parsing parameter list, did not expect ${t.type} token${t.value ? ` (${t.value})` : ''}`);
     }
 }
 
@@ -760,7 +732,7 @@ function parseParameterList(source) {
  * RESOLVER symbol can be used by modules loaded by
  * `loadModules` to configure their lifetime, injection mode, etc.
  */
-var RESOLVER = Symbol('Awilix Resolver Config');
+const RESOLVER = Symbol('Awilix Resolver Config');
 /**
  * Creates a simple value resolver where the given value will always be resolved. The value is
  * marked as leak-safe since in strict mode, the value will only be resolved when it is not leaking
@@ -774,7 +746,7 @@ var RESOLVER = Symbol('Awilix Resolver Config');
  */
 function asValue(value) {
     return {
-        resolve: function () { return value; },
+        resolve: () => value,
         isLeakSafe: true,
     };
 }
@@ -798,12 +770,15 @@ function asFunction(fn, opts) {
     if (!isFunction(fn)) {
         throw new AwilixTypeError('asFunction', 'fn', 'function', fn);
     }
-    var defaults = {
+    const defaults = {
         lifetime: Lifetime.TRANSIENT,
     };
     opts = makeOptions(defaults, opts, fn[RESOLVER]);
-    var resolve = generateResolve(fn);
-    var result = __assign({ resolve: resolve }, opts);
+    const resolve = generateResolve(fn);
+    const result = {
+        resolve,
+        ...opts,
+    };
     return createDisposableResolver(createBuildResolver(result));
 }
 /**
@@ -825,20 +800,19 @@ function asClass(Type, opts) {
     if (!isFunction(Type)) {
         throw new AwilixTypeError('asClass', 'Type', 'class', Type);
     }
-    var defaults = {
+    const defaults = {
         lifetime: Lifetime.TRANSIENT,
     };
     opts = makeOptions(defaults, opts, Type[RESOLVER]);
     // A function to handle object construction for us, as to make the generateResolve more reusable
-    var newClass = function newClass() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
+    const newClass = function newClass(...args) {
         return Reflect.construct(Type, args);
     };
-    var resolve = generateResolve(newClass, Type);
-    return createDisposableResolver(createBuildResolver(__assign(__assign({}, opts), { resolve: resolve })));
+    const resolve = generateResolve(newClass, Type);
+    return createDisposableResolver(createBuildResolver({
+        ...opts,
+        resolve,
+    }));
 }
 /**
  * Resolves to the specified registration. Marked as leak-safe since the alias target is what should
@@ -846,7 +820,7 @@ function asClass(Type, opts) {
  */
 function aliasTo(name) {
     return {
-        resolve: function (container) {
+        resolve(container) {
             return container.resolve(name);
         },
         isLeakSafe: true,
@@ -864,21 +838,30 @@ function aliasTo(name) {
  */
 function createBuildResolver(obj) {
     function setLifetime(value) {
-        return createBuildResolver(__assign(__assign({}, this), { lifetime: value }));
+        return createBuildResolver({
+            ...this,
+            lifetime: value,
+        });
     }
     function setInjectionMode(value) {
-        return createBuildResolver(__assign(__assign({}, this), { injectionMode: value }));
+        return createBuildResolver({
+            ...this,
+            injectionMode: value,
+        });
     }
     function inject(injector) {
-        return createBuildResolver(__assign(__assign({}, this), { injector: injector }));
+        return createBuildResolver({
+            ...this,
+            injector,
+        });
     }
     return updateResolver(obj, {
-        setLifetime: setLifetime,
-        inject: inject,
+        setLifetime,
+        inject,
         transient: partial(setLifetime, Lifetime.TRANSIENT),
         scoped: partial(setLifetime, Lifetime.SCOPED),
         singleton: partial(setLifetime, Lifetime.SINGLETON),
-        setInjectionMode: setInjectionMode,
+        setInjectionMode,
         proxy: partial(setInjectionMode, InjectionMode.PROXY),
         classic: partial(setInjectionMode, InjectionMode.CLASSIC),
     });
@@ -890,10 +873,13 @@ function createBuildResolver(obj) {
  */
 function createDisposableResolver(obj) {
     function disposer(dispose) {
-        return createDisposableResolver(__assign(__assign({}, this), { dispose: dispose }));
+        return createDisposableResolver({
+            ...this,
+            dispose,
+        });
     }
     return updateResolver(obj, {
-        disposer: disposer,
+        disposer,
     });
 }
 /**
@@ -915,12 +901,8 @@ function partial(fn, arg1) {
  *
  * @return {object}
  */
-function makeOptions(defaults) {
-    var rest = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rest[_i - 1] = arguments[_i];
-    }
-    return Object.assign.apply(Object, __spreadArray([{}, defaults], rest, false));
+function makeOptions(defaults, ...rest) {
+    return Object.assign({}, defaults, ...rest);
 }
 /**
  * Creates a new resolver with props merged from both.
@@ -929,7 +911,10 @@ function makeOptions(defaults) {
  * @param target
  */
 function updateResolver(source, target) {
-    var result = __assign(__assign({}, source), target);
+    const result = {
+        ...source,
+        ...target,
+    };
     return result;
 }
 /**
@@ -957,61 +942,26 @@ function wrapWithLocals(container, locals) {
  * @return {Proxy}
  */
 function createInjectorProxy(container, injector) {
-    var locals = injector(container);
-    var allKeys = uniq(__spreadArray(__spreadArray([], Reflect.ownKeys(container.cradle), true), Reflect.ownKeys(locals), true));
+    const locals = injector(container);
+    const allKeys = uniq([
+        ...Reflect.ownKeys(container.cradle),
+        ...Reflect.ownKeys(locals),
+    ]);
     // TODO: Lots of duplication here from the container proxy.
     // Need to refactor.
-    var proxy = new Proxy({}, {
+    const proxy = new Proxy({}, {
         /**
          * Resolves the value by first checking the locals, then the container.
          */
-        get: function (target, name) {
+        get(target, name) {
             if (name === Symbol.iterator) {
-                return function iterateRegistrationsAndLocals() {
-                    var _a, _b, _c, _i, prop, _d, _e, _f, _g, prop;
-                    return __generator(this, function (_h) {
-                        switch (_h.label) {
-                            case 0:
-                                _a = container.cradle;
-                                _b = [];
-                                for (_c in _a)
-                                    _b.push(_c);
-                                _i = 0;
-                                _h.label = 1;
-                            case 1:
-                                if (!(_i < _b.length)) return [3 /*break*/, 4];
-                                _c = _b[_i];
-                                if (!(_c in _a)) return [3 /*break*/, 3];
-                                prop = _c;
-                                return [4 /*yield*/, prop];
-                            case 2:
-                                _h.sent();
-                                _h.label = 3;
-                            case 3:
-                                _i++;
-                                return [3 /*break*/, 1];
-                            case 4:
-                                _d = locals;
-                                _e = [];
-                                for (_f in _d)
-                                    _e.push(_f);
-                                _g = 0;
-                                _h.label = 5;
-                            case 5:
-                                if (!(_g < _e.length)) return [3 /*break*/, 8];
-                                _f = _e[_g];
-                                if (!(_f in _d)) return [3 /*break*/, 7];
-                                prop = _f;
-                                return [4 /*yield*/, prop];
-                            case 6:
-                                _h.sent();
-                                _h.label = 7;
-                            case 7:
-                                _g++;
-                                return [3 /*break*/, 5];
-                            case 8: return [2 /*return*/];
-                        }
-                    });
+                return function* iterateRegistrationsAndLocals() {
+                    for (const prop in container.cradle) {
+                        yield prop;
+                    }
+                    for (const prop in locals) {
+                        yield prop;
+                    }
                 };
             }
             if (name in locals) {
@@ -1022,13 +972,13 @@ function createInjectorProxy(container, injector) {
         /**
          * Used for `Object.keys`.
          */
-        ownKeys: function () {
+        ownKeys() {
             return allKeys;
         },
         /**
          * Used for `Object.keys`.
          */
-        getOwnPropertyDescriptor: function (target, key) {
+        getOwnPropertyDescriptor(target, key) {
             if (allKeys.indexOf(key) > -1) {
                 return {
                     enumerable: true,
@@ -1067,17 +1017,17 @@ function generateResolve(fn, dependencyParseTarget) {
     // NOTE: we do this regardless of whether PROXY is used or not,
     // because if this fails, we want it to fail early (at startup) rather
     // than at resolution time.
-    var dependencies = parseDependencies(dependencyParseTarget);
+    const dependencies = parseDependencies(dependencyParseTarget);
     // Use a regular function instead of an arrow function to facilitate binding to the resolver.
     return function resolve(container) {
         // Because the container holds a global reolutionMode we need to determine it in the proper order of precedence:
         // resolver -> container -> default value
-        var injectionMode = this.injectionMode ||
+        const injectionMode = this.injectionMode ||
             container.options.injectionMode ||
             InjectionMode.PROXY;
         if (injectionMode !== InjectionMode.CLASSIC) {
             // If we have a custom injector, we need to wrap the cradle.
-            var cradle = this.injector
+            const cradle = this.injector
                 ? createInjectorProxy(container, this.injector)
                 : container.cradle;
             // Return the target injected with the cradle
@@ -1085,13 +1035,11 @@ function generateResolve(fn, dependencyParseTarget) {
         }
         // We have dependencies so we need to resolve them manually
         if (dependencies.length > 0) {
-            var resolve_1 = this.injector
+            const resolve = this.injector
                 ? wrapWithLocals(container, this.injector(container))
                 : container.resolve;
-            var children = dependencies.map(function (p) {
-                return resolve_1(p.name, { allowUnregistered: p.optional });
-            });
-            return fn.apply(void 0, children);
+            const children = dependencies.map((p) => resolve(p.name, { allowUnregistered: p.optional }));
+            return fn(...children);
         }
         return fn();
     };
@@ -1102,11 +1050,11 @@ function generateResolve(fn, dependencyParseTarget) {
  * not have a defined constructor, attempt to parse it's super constructor.
  */
 function parseDependencies(fn) {
-    var result = parseParameterList(fn.toString());
+    const result = parseParameterList(fn.toString());
     if (!result) {
         // No defined constructor for a class, check if there is a parent
         // we can parse.
-        var parent = Object.getPrototypeOf(fn);
+        const parent = Object.getPrototypeOf(fn);
         if (typeof parent === 'function' && parent !== Function.prototype) {
             // Try to parse the parent
             return parseDependencies(parent);
@@ -1119,15 +1067,15 @@ function parseDependencies(fn) {
 /**
  * Family tree symbol.
  */
-var FAMILY_TREE = Symbol('familyTree');
+const FAMILY_TREE = Symbol('familyTree');
 /**
  * Roll Up Registrations symbol.
  */
-var ROLL_UP_REGISTRATIONS = Symbol('rollUpRegistrations');
+const ROLL_UP_REGISTRATIONS = Symbol('rollUpRegistrations');
 /**
  * The string representation when calling toString.
  */
-var CRADLE_STRING_TAG = 'AwilixContainerCradle';
+const CRADLE_STRING_TAG = 'AwilixContainerCradle';
 /**
  * Creates an Awilix container instance.
  *
@@ -1141,26 +1089,28 @@ var CRADLE_STRING_TAG = 'AwilixContainerCradle';
  *
  * @return {AwilixContainer<T>} The container.
  */
-function createContainer(options) {
-    if (options === void 0) { options = {}; }
+function createContainer(options = {}) {
     return createContainerInternal(options);
 }
 function createContainerInternal(options, parentContainer, parentResolutionStack) {
-    var _a;
-    options = __assign({ injectionMode: InjectionMode.PROXY, strict: false }, options);
+    options = {
+        injectionMode: InjectionMode.PROXY,
+        strict: false,
+        ...options,
+    };
     /**
      * Tracks the names and lifetimes of the modules being resolved. Used to detect circular
      * dependencies and, in strict mode, lifetime leakage issues.
      */
-    var resolutionStack = parentResolutionStack !== null && parentResolutionStack !== void 0 ? parentResolutionStack : [];
+    const resolutionStack = parentResolutionStack ?? [];
     // Internal registration store for this container.
-    var registrations = {};
+    const registrations = {};
     /**
      * The `Proxy` that is passed to functions so they can resolve their dependencies without
      * knowing where they come from. I call it the "cradle" because
      * it is where registered things come to life at resolution-time.
      */
-    var cradle = new Proxy({
+    const cradle = new Proxy({
     /* removed in browser build */
     }, {
         /**
@@ -1175,27 +1125,27 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
          * @return {*}
          * Whatever the resolve call returns.
          */
-        get: function (_target, name) { return resolve(name); },
+        get: (_target, name) => resolve(name),
         /**
          * Setting things on the cradle throws an error.
          *
          * @param  {object} target
          * @param  {string} name
          */
-        set: function (_target, name) {
-            throw new Error("Attempted setting property \"".concat(name, "\" on container cradle - this is not allowed."));
+        set: (_target, name) => {
+            throw new Error(`Attempted setting property "${name}" on container cradle - this is not allowed.`);
         },
         /**
          * Used for `Object.keys`.
          */
-        ownKeys: function () {
+        ownKeys() {
             return Array.from(cradle);
         },
         /**
          * Used for `Object.keys`.
          */
-        getOwnPropertyDescriptor: function (target, key) {
-            var regs = rollUpRegistrations();
+        getOwnPropertyDescriptor(target, key) {
+            const regs = rollUpRegistrations();
             if (Object.getOwnPropertyDescriptor(regs, key)) {
                 return {
                     enumerable: true,
@@ -1206,44 +1156,39 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
         },
     });
     // The container being exposed.
-    var container = (_a = {
-            options: options,
-            cradle: cradle,
-            inspect: inspect,
-            cache: new Map(),
-            loadModules: function () { throw new Error("loadModules is not supported in the browser."); },
-            createScope: createScope,
-            register: register,
-            build: build,
-            resolve: resolve,
-            hasRegistration: hasRegistration,
-            dispose: dispose,
-            getRegistration: getRegistration
-        },
+    const container = {
+        options,
+        cradle,
+        inspect,
+        cache: new Map(),
+        loadModules: () => { throw new Error("loadModules is not supported in the browser."); },
+        createScope,
+        register: register,
+        build,
+        resolve,
+        hasRegistration,
+        dispose,
+        getRegistration,
         /* removed in browser build */
-        _a[ROLL_UP_REGISTRATIONS] = rollUpRegistrations,
-        Object.defineProperty(_a, "registrations", {
-            get: function () {
-                return rollUpRegistrations();
-            },
-            enumerable: false,
-            configurable: true
-        }),
-        _a);
+        [ROLL_UP_REGISTRATIONS]: rollUpRegistrations,
+        get registrations() {
+            return rollUpRegistrations();
+        },
+    };
     // Track the family tree.
-    var familyTree = parentContainer
+    const familyTree = parentContainer
         ? [container].concat(parentContainer[FAMILY_TREE])
         : [container];
     container[FAMILY_TREE] = familyTree;
     // We need a reference to the root container,
     // so we can retrieve and store singletons.
-    var rootContainer = last(familyTree);
+    const rootContainer = last(familyTree);
     return container;
     /**
      * Used by util.inspect (which is used by console.log).
      */
     function inspect() {
-        return "[AwilixContainer (".concat(parentContainer ? 'scoped, ' : '', "registrations: ").concat(Object.keys(container.registrations).length, ")]");
+        return `[AwilixContainer (${parentContainer ? 'scoped, ' : ''}registrations: ${Object.keys(container.registrations).length})]`;
     }
     /**
      * Rolls up registrations from the family tree.
@@ -1259,38 +1204,19 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
      * The merged registrations object.
      */
     function rollUpRegistrations() {
-        return __assign(__assign({}, (parentContainer && parentContainer[ROLL_UP_REGISTRATIONS]())), registrations);
+        return {
+            ...(parentContainer && parentContainer[ROLL_UP_REGISTRATIONS]()),
+            ...registrations,
+        };
     }
     /**
      * Used for providing an iterator to the cradle.
      */
-    function cradleIterator() {
-        var registrations, _a, _b, _c, _i, registrationName;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    registrations = rollUpRegistrations();
-                    _a = registrations;
-                    _b = [];
-                    for (_c in _a)
-                        _b.push(_c);
-                    _i = 0;
-                    _d.label = 1;
-                case 1:
-                    if (!(_i < _b.length)) return [3 /*break*/, 4];
-                    _c = _b[_i];
-                    if (!(_c in _a)) return [3 /*break*/, 3];
-                    registrationName = _c;
-                    return [4 /*yield*/, registrationName];
-                case 2:
-                    _d.sent();
-                    _d.label = 3;
-                case 3:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 4: return [2 /*return*/];
-            }
-        });
+    function* cradleIterator() {
+        const registrations = rollUpRegistrations();
+        for (const registrationName in registrations) {
+            yield registrationName;
+        }
     }
     /**
      * Creates a scoped container.
@@ -1305,11 +1231,10 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
      * Adds a registration for a resolver.
      */
     function register(arg1, arg2) {
-        var obj = nameValueToObject(arg1, arg2);
-        var keys = __spreadArray(__spreadArray([], Object.keys(obj), true), Object.getOwnPropertySymbols(obj), true);
-        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-            var key = keys_1[_i];
-            var resolver = obj[key];
+        const obj = nameValueToObject(arg1, arg2);
+        const keys = [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj)];
+        for (const key of keys) {
+            const resolver = obj[key];
             // If strict mode is enabled, check to ensure we are not registering a singleton on a non-root
             // container.
             if (options.strict && resolver.lifetime === Lifetime.SINGLETON) {
@@ -1335,7 +1260,7 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
      * @param name {string | symbol} The registration name.
      */
     function getRegistration(name) {
-        var resolver = registrations[name];
+        const resolver = registrations[name];
         if (resolver) {
             return resolver;
         }
@@ -1360,11 +1285,8 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
         resolveOpts = resolveOpts || {};
         try {
             // Grab the registration by name.
-            var resolver = getRegistration(name);
-            if (resolutionStack.some(function (_a) {
-                var parentName = _a.name;
-                return parentName === name;
-            })) {
+            const resolver = getRegistration(name);
+            if (resolutionStack.some(({ name: parentName }) => parentName === name)) {
                 throw new AwilixResolutionError(name, resolutionStack, 'Cyclic dependencies detected.');
             }
             // Used in JSON.stringify.
@@ -1399,24 +1321,21 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
                 }
                 throw new AwilixResolutionError(name, resolutionStack);
             }
-            var lifetime_1 = resolver.lifetime || Lifetime.TRANSIENT;
+            const lifetime = resolver.lifetime || Lifetime.TRANSIENT;
             // if we are running in strict mode, this resolver is not explicitly marked leak-safe, and any
             // of the parents have a shorter lifetime than the one requested, throw an error.
             if (options.strict && !resolver.isLeakSafe) {
-                var maybeLongerLifetimeParentIndex = resolutionStack.findIndex(function (_a) {
-                    var parentLifetime = _a.lifetime;
-                    return isLifetimeLonger(parentLifetime, lifetime_1);
-                });
+                const maybeLongerLifetimeParentIndex = resolutionStack.findIndex(({ lifetime: parentLifetime }) => isLifetimeLonger(parentLifetime, lifetime));
                 if (maybeLongerLifetimeParentIndex > -1) {
-                    throw new AwilixResolutionError(name, resolutionStack, "Dependency '".concat(name.toString(), "' has a shorter lifetime than its ancestor: '").concat(resolutionStack[maybeLongerLifetimeParentIndex].name.toString(), "'"));
+                    throw new AwilixResolutionError(name, resolutionStack, `Dependency '${name.toString()}' has a shorter lifetime than its ancestor: '${resolutionStack[maybeLongerLifetimeParentIndex].name.toString()}'`);
                 }
             }
             // Pushes the currently-resolving module information onto the stack
-            resolutionStack.push({ name: name, lifetime: lifetime_1 });
+            resolutionStack.push({ name, lifetime });
             // Do the thing
-            var cached = void 0;
-            var resolved = void 0;
-            switch (lifetime_1) {
+            let cached;
+            let resolved;
+            switch (lifetime) {
                 case Lifetime.TRANSIENT:
                     // Transient lifetime means resolve every time.
                     resolved = resolver.resolve(container);
@@ -1428,7 +1347,7 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
                         // if we are running in strict mode, perform singleton resolution using the root
                         // container only.
                         resolved = resolver.resolve(options.strict ? rootContainer : container);
-                        rootContainer.cache.set(name, { resolver: resolver, value: resolved });
+                        rootContainer.cache.set(name, { resolver, value: resolved });
                     }
                     else {
                         resolved = cached.value;
@@ -1448,10 +1367,10 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
                     }
                     // If we still have not found one, we need to resolve and cache it.
                     resolved = resolver.resolve(container);
-                    container.cache.set(name, { resolver: resolver, value: resolved });
+                    container.cache.set(name, { resolver, value: resolved });
                     break;
                 default:
-                    throw new AwilixResolutionError(name, resolutionStack, "Unknown lifetime \"".concat(resolver.lifetime, "\""));
+                    throw new AwilixResolutionError(name, resolutionStack, `Unknown lifetime "${resolver.lifetime}"`);
             }
             // Pop it from the stack again, ready for the next resolution
             resolutionStack.pop();
@@ -1488,11 +1407,11 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
         if (targetOrResolver && targetOrResolver.resolve) {
             return targetOrResolver.resolve(container);
         }
-        var funcName = 'build';
-        var paramName = 'targetOrResolver';
+        const funcName = 'build';
+        const paramName = 'targetOrResolver';
         AwilixTypeError.assert(targetOrResolver, funcName, paramName, 'a registration, function or class', targetOrResolver);
         AwilixTypeError.assert(typeof targetOrResolver === 'function', funcName, paramName, 'a function or class', targetOrResolver);
-        var resolver = isClass(targetOrResolver)
+        const resolver = isClass(targetOrResolver)
             ? asClass(targetOrResolver, opts)
             : asFunction(targetOrResolver, opts);
         return resolver.resolve(container);
@@ -1502,18 +1421,17 @@ function createContainerInternal(options, parentContainer, parentResolutionStack
      * on all disposable registrations and clearing the cache.
      */
     function dispose() {
-        var entries = Array.from(container.cache.entries());
+        const entries = Array.from(container.cache.entries());
         container.cache.clear();
-        return Promise.all(entries.map(function (_a) {
-            var entry = _a[1];
-            var resolver = entry.resolver, value = entry.value;
-            var disposable = resolver;
+        return Promise.all(entries.map(([, entry]) => {
+            const { resolver, value } = entry;
+            const disposable = resolver;
             if (disposable.dispose) {
-                return Promise.resolve().then(function () { return disposable.dispose(value); });
+                return Promise.resolve().then(() => disposable.dispose(value));
             }
             return Promise.resolve();
-        })).then(function () { return undefined; });
+        })).then(() => undefined);
     }
 }
 
-export { AwilixError, AwilixRegistrationError, AwilixResolutionError, AwilixTypeError, InjectionMode, Lifetime, RESOLVER, aliasTo, asClass, asFunction, asValue, createBuildResolver, createContainer, createDisposableResolver };
+export { AwilixError, AwilixRegistrationError, AwilixResolutionError, AwilixTypeError, InjectionMode, Lifetime, RESOLVER, aliasTo, asClass, asFunction, asValue, createBuildResolver, createContainer, createDisposableResolver, isClass, isFunction, listModules };