When import passport package:

1. We get a new instance of the Passport i.e. Authenticator class
  - What comes with that instance:
    Instance Properties: {
      _key: 'passport'
      _strategies: {}
      _deserializers: []
      _infoTransformers: []
      _framework: null
    }
    Class Methods: {
      init:               () => null
      use:                (name, strategy)=> Passport Instance that called it i.e. `this`
      unuse:              (name) => Passport Instance that called it i.e. `this`
      framework:          (framework) => Passport Instance that called it i.e. `this`
      initialize:         (options) => this._framework.initialize(this, options)
      authenticate:       (strategy, options, callback) => this._framework.authenticate(this, strategy, options, callback)
      authorize:          (strategy, options, callback) => {fn = this._framework.authorize || this._framework.authenticate;
                                                             return fn(this, st, op, cb) }
      session:            (options) => this.authenticate('session', options)
      serializeUser:      (fn, req, done) => this._serializers.push(fn) || done(error) || null
      deserializeUser:    (fn, req, done) => this._deserializers.push(fn) || done(error) || null
      transformAuthInfo:  (fn, req, done) => this._infoTransformers.push(fn) || done(error) || done(error, tinfo) || done(null, info)
      _strategy:          (name) => this._strategies[name]
    }

  - When it get's constructed it automatically calls it's init method, which:

    1. Calls the Passport `Instance.framework()` inherited method which sets the Passport Instance._framework property to
       an object with an `initialize` and `authenticate` property derived from the
       middleware/{initialize,authenticate}.js modules respectively.

    2. Calls the Passport `Instance.use()` inherited method to add a new strategy to the `Instance._strategies` object. A
       new instance of the `SessionStrategy` class is constructed with an options object and the `Instance.deserializeUser`
       method passed in as the parameters. The `deserializeUser` method's `this` is bound to the Passport Instance before
       being provided as a function for the new Instance of the `SessionStrategy` class constructor.

       A. The `SessionStrategy` class Instance is constructed to have:

         Instance Properties (SessionStrategy): {
           name: 'session'
           _key: options.key || 'passport'
           _deserializeUser: (fn, req, done) => this._deserializers.push(fn) || done(error) || null
	   error:            () => *FILL IN*                     // Set on all Passport Instance Strategies when
	                                                         // the `middleware/authenticate.js` module function is run.
	   pass:             () => *FILL IN*                     // Set on all Passport Instance Strategies when
	                                                         // the `middleware/authenticate.js` module function is run.
	   success:          () => *FILL IN*                     // Set on all Passport Instance Strategies when
	                                                         // the `middleware/authenticate.js` module function is run.
         }
         Class Methods: {
           authenticate:     (req, options) => new Error || self.error(err) //?? Not sure when it got an error method?
         }

	   - It is also constructed to be a child class of the `Strategy` class from the `passport-strategy` node
	     modules package. The `Strategy` class does not do anything besides having a class method called
	     `authenticate` that will throw an error if not overridden by a child class method with the same name.
	     the `authenticate` method is a bit weird it references things that have not been declared yet to my knowledge.

    3. Adds and sets the Passport `Instance._sm` property to a new instance of the `SessionManager` class.