/*!
           * The buffer module from node.js, for the browser.
           *
           * @author   Feross Aboukhadijeh <https://feross.org>
           * @license  MIT
           */

/*!
       * Check to see if the MemoizeMap has recorded a result of the two operands
       *
       * @param {Mixed} leftHandOperand
       * @param {Mixed} rightHandOperand
       * @param {MemoizeMap} memoizeMap
       * @returns {Boolean|null} result
      */

/*!
       * Compare two Regular Expressions for equality.
       *
       * @param {RegExp} leftHandOperand
       * @param {RegExp} rightHandOperand
       * @return {Boolean} result
       */

/*!
       * Compare two Sets/Maps for equality. Faster than other equality functions.
       *
       * @param {Set} leftHandOperand
       * @param {Set} rightHandOperand
       * @param {Object} [options] (Optional)
       * @return {Boolean} result
       */

/*!
       * Determine if the given object has an @@iterator function.
       *
       * @param {Object} target
       * @return {Boolean} `true` if the object has an @@iterator function.
       */

/*!
       * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of
       * each key. If any value of the given key is not equal, the function will return false (early).
       *
       * @param {Mixed} leftHandOperand
       * @param {Mixed} rightHandOperand
       * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against
       * @param {Object} [options] (Optional)
       * @return {Boolean} result
       */

/*!
       * Gets all entries from a Generator. This will consume the generator - which could have side effects.
       *
       * @param {Generator} target
       * @returns {Array} an array of entries from the Generator.
       */

/*!
       * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array.
       * This will consume the iterator - which could have side effects depending on the @@iterator implementation.
       *
       * @param {Object} target
       * @returns {Array} an array of entries from the @@iterator function
       */

/*!
       * Gets all own and inherited enumerable keys from a target.
       *
       * @param {Object} target
       * @returns {Array} an array of own and inherited enumerable keys from the target.
       */

/*!
       * Primary Export
       */

/*!
       * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual`
       * for each enumerable key in the object.
       *
       * @param {Mixed} leftHandOperand
       * @param {Mixed} rightHandOperand
       * @param {Object} [options] (Optional)
       * @return {Boolean} result
       */

/*!
       * Returns true if the argument is a primitive.
       *
       * This intentionally returns true for all objects that can be compared by reference,
       * including functions and symbols.
       *
       * @param {Mixed} value
       * @return {Boolean} result
       */

/*!
       * Set the result of the equality into the MemoizeMap
       *
       * @param {Mixed} leftHandOperand
       * @param {Mixed} rightHandOperand
       * @param {MemoizeMap} memoizeMap
       * @param {Boolean} result
      */

/*!
       * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers.
       *
       * @param {Iterable} leftHandOperand
       * @param {Iterable} rightHandOperand
       * @param {Object} [options] (Optional)
       * @return {Boolean} result
       */

/*!
       * Simple equality for generator objects such as those returned by generator functions.
       *
       * @param {Iterable} leftHandOperand
       * @param {Iterable} rightHandOperand
       * @param {Object} [options] (Optional)
       * @return {Boolean} result
       */

/*!
       * The main logic of the `deepEqual` function.
       *
       * @param {Mixed} leftHandOperand
       * @param {Mixed} rightHandOperand
       * @param {Object} [options] (optional) Additional options
       * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.
       * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of
          complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular
          references to blow the stack.
       * @return {Boolean} equal match
      */

/*!
       * URI.js - Mutating URLs
       *
       * Version: 1.19.6
       *
       * Author: Rodney Rehm
       * Web: http://medialize.github.io/URI.js/
       *
       * Licensed under
       *   MIT License http://www.opensource.org/licenses/mit-license
       *
       */

/*!
       * URI.js - Mutating URLs
       * IPv6 Support
       *
       * Version: 1.19.6
       *
       * Author: Rodney Rehm
       * Web: http://medialize.github.io/URI.js/
       *
       * Licensed under
       *   MIT License http://www.opensource.org/licenses/mit-license
       *
       */

/*!
       * URI.js - Mutating URLs
       * Second Level Domain (SLD) Support
       *
       * Version: 1.19.6
       *
       * Author: Rodney Rehm
       * Web: http://medialize.github.io/URI.js/
       *
       * Licensed under
       *   MIT License http://www.opensource.org/licenses/mit-license
       *
       */

/*!
       * deep-eql
       * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
       * MIT Licensed
       */

/*!
   * Check to see if the MemoizeMap has recorded a result of the two operands
   *
   * @param {Mixed} leftHandOperand
   * @param {Mixed} rightHandOperand
   * @param {MemoizeMap} memoizeMap
   * @returns {Boolean|null} result
  */

/*!
   * Compare two Regular Expressions for equality.
   *
   * @param {RegExp} leftHandOperand
   * @param {RegExp} rightHandOperand
   * @return {Boolean} result
   */

/*!
   * Compare two Sets/Maps for equality. Faster than other equality functions.
   *
   * @param {Set} leftHandOperand
   * @param {Set} rightHandOperand
   * @param {Object} [options] (Optional)
   * @return {Boolean} result
   */

/*!
   * Determine if the given object has an @@iterator function.
   *
   * @param {Object} target
   * @return {Boolean} `true` if the object has an @@iterator function.
   */

/*!
   * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of
   * each key. If any value of the given key is not equal, the function will return false (early).
   *
   * @param {Mixed} leftHandOperand
   * @param {Mixed} rightHandOperand
   * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against
   * @param {Object} [options] (Optional)
   * @return {Boolean} result
   */

/*!
   * Gets all entries from a Generator. This will consume the generator - which could have side effects.
   *
   * @param {Generator} target
   * @returns {Array} an array of entries from the Generator.
   */

/*!
   * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array.
   * This will consume the iterator - which could have side effects depending on the @@iterator implementation.
   *
   * @param {Object} target
   * @returns {Array} an array of entries from the @@iterator function
   */

/*!
   * Gets all own and inherited enumerable keys from a target.
   *
   * @param {Object} target
   * @returns {Array} an array of own and inherited enumerable keys from the target.
   */

/*!
   * Primary Export
   */

/*!
   * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual`
   * for each enumerable key in the object.
   *
   * @param {Mixed} leftHandOperand
   * @param {Mixed} rightHandOperand
   * @param {Object} [options] (Optional)
   * @return {Boolean} result
   */

/*!
   * Returns true if the argument is a primitive.
   *
   * This intentionally returns true for all objects that can be compared by reference,
   * including functions and symbols.
   *
   * @param {Mixed} value
   * @return {Boolean} result
   */

/*!
   * Set the result of the equality into the MemoizeMap
   *
   * @param {Mixed} leftHandOperand
   * @param {Mixed} rightHandOperand
   * @param {MemoizeMap} memoizeMap
   * @param {Boolean} result
  */

/*!
   * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers.
   *
   * @param {Iterable} leftHandOperand
   * @param {Iterable} rightHandOperand
   * @param {Object} [options] (Optional)
   * @return {Boolean} result
   */

/*!
   * Simple equality for generator objects such as those returned by generator functions.
   *
   * @param {Iterable} leftHandOperand
   * @param {Iterable} rightHandOperand
   * @param {Object} [options] (Optional)
   * @return {Boolean} result
   */

/*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <https://feross.org>
   * @license  MIT
   */

/*!
   * The main logic of the `deepEqual` function.
   *
   * @param {Mixed} leftHandOperand
   * @param {Mixed} rightHandOperand
   * @param {Object} [options] (optional) Additional options
   * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.
   * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of
      complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular
      references to blow the stack.
   * @return {Boolean} equal match
  */

/*!
   * URI.js - Mutating URLs
   *
   * Version: 1.19.6
   *
   * Author: Rodney Rehm
   * Web: http://medialize.github.io/URI.js/
   *
   * Licensed under
   *   MIT License http://www.opensource.org/licenses/mit-license
   *
   */

/*!
   * URI.js - Mutating URLs
   * IPv6 Support
   *
   * Version: 1.19.6
   *
   * Author: Rodney Rehm
   * Web: http://medialize.github.io/URI.js/
   *
   * Licensed under
   *   MIT License http://www.opensource.org/licenses/mit-license
   *
   */

/*!
   * URI.js - Mutating URLs
   * Second Level Domain (SLD) Support
   *
   * Version: 1.19.6
   *
   * Author: Rodney Rehm
   * Web: http://medialize.github.io/URI.js/
   *
   * Licensed under
   *   MIT License http://www.opensource.org/licenses/mit-license
   *
   */

/*!
   * deep-eql
   * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
   * MIT Licensed
   */

/*!
 * mime-db
 * Copyright(c) 2014 Jonathan Ong
 * MIT Licensed
 */

/*!
 * mime-types
 * Copyright(c) 2014 Jonathan Ong
 * Copyright(c) 2015 Douglas Christopher Wilson
 * MIT Licensed
 */

/*!
 * ws: a node.js websocket client
 * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
 * MIT Licensed
 */

/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */

/**
 * @license
 * Lodash <https://lodash.com/>
 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/**!
 * @license http://www.apache.org/licenses/LICENSE-2.0
 *
 * Copyright 2015 Postdot Technologies Pvt. Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and limitations under the License.
 */
