text: /**
   * negotiator
   * Copyright(c) 2012 Isaac Z. Schlueter
   * Copyright(c) 2014 Federico Romero
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   */
  
  'use strict';
  
  /**
   * Module exports.
   * @public
   */
  
  module.exports = preferredEncodings;
  module.exports.preferredEncodings = preferredEncodings;
  
  /**
   * Module variables.
   * @private
   */
  
  var simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
  
  /**
   * Parse the Accept-Encoding header.
   * @private
   */
  
  function parseAcceptEncoding(accept) {
    var accepts = accept.split(',');
    var hasIdentity = false;
    var minQuality = 1;
  
    for (var i = 0, j = 0; i < accepts.length; i++) {
      var encoding = parseEncoding(accepts[i].trim(), i);
  
      if (encoding) {
        accepts[j++] = encoding;
        hasIdentity = hasIdentity || specify('identity', encoding);
        minQuality = Math.min(minQuality, encoding.q || 1);
      }
    }
  
    if (!hasIdentity) {
      /*
       * If identity doesn't explicitly appear in the accept-encoding header,
       * it's added to the list of acceptable encoding with the lowest q
       */
      accepts[j++] = {
        encoding: 'identity',
        q: minQuality,
        i: i
      };
    }
  
    // trim accepts
    accepts.length = j;
  
    return accepts;
  }
  
  /**
   * Parse an encoding from the Accept-Encoding header.
   * @private
   */
  
  function parseEncoding(str, i) {
    var match = simpleEncodingRegExp.exec(str);
    if (!match) return null;
  
    var encoding = match[1];
    var q = 1;
    if (match[2]) {
      var params = match[2].split(';');
      for (var j = 0; j < params.length; j++) {
        var p = params[j].trim().split('=');
        if (p[0] === 'q') {
          q = parseFloat(p[1]);
          break;
        }
      }
    }
  
    return {
      encoding: encoding,
      q: q,
      i: i
    };
  }
  
  /**
   * Get the priority of an encoding.
   * @private
   */
  
  function getEncodingPriority(encoding, accepted, index) {
    var priority = {o: -1, q: 0, s: 0};
  
    for (var i = 0; i < accepted.length; i++) {
      var spec = specify(encoding, accepted[i], index);
  
      if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
        priority = spec;
      }
    }
  
    return priority;
  }
  
  /**
   * Get the specificity of the encoding.
   * @private
   */
  
  function specify(encoding, spec, index) {
    var s = 0;
    if(spec.encoding.toLowerCase() === encoding.toLowerCase()){
      s |= 1;
    } else if (spec.encoding !== '*' ) {
      return null
    }
  
    return {
      i: index,
      o: spec.i,
      q: spec.q,
      s: s
    }
  };
  
  /**
   * Get the preferred encodings from an Accept-Encoding header.
   * @public
   */
  
  function preferredEncodings(accept, provided) {
    var accepts = parseAcceptEncoding(accept || '');
  
    if (!provided) {
      // sorted list of all encodings
      return accepts
        .filter(isQuality)
        .sort(compareSpecs)
        .map(getFullEncoding);
    }
  
    var priorities = provided.map(function getPriority(type, index) {
      return getEncodingPriority(type, accepts, index);
    });
  
    // sorted list of accepted encodings
    return priorities.filter(isQuality).sort(compareSpecs).map(function getEncoding(priority) {
      return provided[priorities.indexOf(priority)];
    });
  }
  
  /**
   * Compare two specs.
   * @private
   */
  
  function compareSpecs(a, b) {
    return (b.q - a.q && b[0] != 'none') || (b.s - a.s && b[0] != 'none') || (a.o - b.o && b[0] != 'none') || (a.i - b.i) || 0;
  }
  
  /**
   * Get full encoding string.
   * @private
   */
  
  function getFullEncoding(spec) {
    return spec.encoding;
  }
  
  /**
   * Check if a spec has any quality.
   * @private
   */
  
  function isQuality(spec) {
    return spec.q > 0;
  }
  