docs: function Esquire(timeout) {
  
      /* Proper construction */
      if (!(this instanceof Esquire)) return new Esquire(timeout);
  
      /* Timeout */
      if (timeout === undefined) {
        timeout = globalTimeout;
      } else {
        timeout = Number(timeout);
        if (timeout === NaN) {
          throw new EsquireError("Timeout is not a number");
        } else if (timeout < 100) {
          throw new EsquireError("Timeout must be greater or equal than 100ms");
        }
      }
  
      /* Our cache */
      var cache = {
        "$global":   global,
        "$esquire":  this,
        "$promise":  Promise,
        "$deferred": Deferred
      };
  
      /* Create a new instance from a defined module */
      function create(module, timeout, dependencyStack) {
        dependencyStack = dependencyStack.slice(0);
        if (module.name != null) dependencyStack.push(module.name);
  
        /* Already in cache? Why even bother? */
        if (cache[module.name]) return cache[module.name];
  
        /* Create an expiring Deferred, shortening the timeout */
        if (timeout < 50) timeout = 50;
        var deferred = new Deferred(timeout, "Timeout waiting for module '" + module.name + "'");
  
        /* ... and *IMMEDIATELY* cache the promise */
        if (module.name && (! module.$$dynamic)) {
          cache[module.name] = deferred.promise;
        }
  
        /* Calculate the module's direct dependencies */
        resolveDependencies(module).then(function(dependencies) {
          var parameters = [];
  
          /* Prepare parameters, either from cache or new creations */
          for (var i in dependencies) {
            var dependency = dependencies[i];
  
            /* Check for circular dependencies */
            var circularIndex = dependencyStack.indexOf(dependency.name);
            if (circularIndex >= 0) {
              var circularDependencies = dependencyStack.slice(circularIndex);
              throw new CircularDependencyError(circularDependencies);
            }
  
            if (cache[dependency.name]) {
              parameters.push(cache[dependency.name]);
            } else {
              parameters.push(create(dependency, timeout - 5, dependencyStack));
            }
          }
  
          /* When all parameters have been resolved... */
          return Promise.all(parameters).then(function(parameters) {
            return module.constructor.apply(module, parameters);
          });
        })
  
        /* Cache and resolve, or reject */
        .then(function(created) {
          if (module.name && (! module.$$dynamic)) cache[module.name] = created;
          deferred.resolve(created);
        }, function(failure) {
          deferred.reject(new InjectionError(module.name, failure));
        });
  
        /* Return the deferred promise */
        return deferred.promise;
  
      }
  
      /**
       * Require instances for the specified module(s).
       *
       * @instance
       * @function
       * @memberof Esquire
       * @example -
       * var esq = new Esquire();
       *
       * esq.require(['fooModule', 'barModule'])
       *   .then(function(fromArray) {
       *     // fromArray[0] will be an instance of 'fooModule'
       *     // fromArray[1] will be an instance of 'barModule'
       *   });
       *
       * @example Injection with a single `string` argument
       * esq.require('bazModule')
       *   .then(function(fromString) {
       *     // 'fromString' will be an instance of 'bazModule'
       *   });
       *
       * @example Injection with a number of different arguments
       * esq.require('abcModule', 'xyzModule')
       *   .then(function(fromArgs) {
       *     // fromArgs[0] will be an instance of 'abcModule'
       *     // fromArgs[1] will be an instance of 'xyzModule'
       *   });
       *
       * @param {string[]|string} dependencies - An array of required module names
       *                                         (or a single module name) whose
       *                                         instance are to be returned.
       * @return {Promise[]|Promise} An array of {@link Promise}s eventually
       *                             resolving to the required module instances,
       *                             or a single {@link Promise} (if this method
       *                             was called with a single `string` parameter).
       */
      function require() {
  
        /* Edge case, one only parameter, we don't return an array */
        if ((arguments.length == 1) && (typeof(arguments[0]) == 'string')) {
          return inject([arguments[0]], function(instance) {
            return instance;
          });
        }
  
        /* Inject a fake callback function returning an array */
        return inject(arguments, function() {
          var result = [];
          for (var i = 0; i < arguments.length; i ++) {
            result.push(arguments[i]);
          }
          return result;
        });
        return result;
      }
  
      /**
       * Request injection for the specified modules.
       *
       * @instance
       * @function inject
       * @memberof Esquire
       * @example -
       * var esq = new Esquire();
       *
       * esq.inject(['modA', 'depB'], function(a, b) {
       *   // 'a' will be an instance of 'modA'
       *   // 'b' will be an instance of 'depB'
       *   return "something";
       *
       * }).then(function(result) {
       *   // The function will be (eventually) injected with its required
       *   // modules, and its return value will resolve the promis returned
       *   // by the "inject(...) method!
       * });
       *
       * @example Injection also works without arrays (only arguments)
       * esq.inject('modA', 'depB', function(a, b) {
       *   // 'a' will be an instance of 'modA'
       *   // 'b' will be an instance of 'depB'
       * });
       *
       * @example Angular-JS style injection (one big array) is supported, too
       * esq.inject(['modA', 'depB', function(a, b) {
       *   // 'a' will be an instance of 'modA'
       *   // 'b' will be an instance of 'depB'
       * }]);
       *
       * @param {string[]|string} [dependencies] - An array of required module
       *                                           names whose instances will be
       *                                           passed to the `callback(...)`
       *                                           method.
       * @param {function} callback - A function that will be called once all
       *                              module dependencies have been instantiated,
       *                              with each instance as a parameter.
       * @return {@link Promise} Whatever value was returned by the `callback` function.
       */
      function inject() {
        var args = normalize(arguments);
  
        /* Sanity check, need a callback */
        if (!args.function) {
          throw new EsquireError("Callback for injection unspecified");
        }
  
        /* Create a fake "null" module and return its value */
        var module = new Module(null, args.arguments, args.function);
        try {
          return create(module, timeout, []);
        } catch (error) {
          return Promise.reject(error);
        }
  
      };
  
      /* Define our members */
      Object.defineProperties(this, {
        "inject":  { enumerable: true, configurable: false, value: inject },
        "require": { enumerable: true, configurable: false, value: require }
      });
  
    }