init

server/node_modules/negotiator/lib/charset.js

@@ -0,0 +1,87 @@
+module.exports = preferredCharsets;
+preferredCharsets.preferredCharsets = preferredCharsets;
+
+function parseAcceptCharset(accept) {
+  return accept.split(',').map(function(e, i) {
+    return parseCharset(e.trim(), i);
+  }).filter(function(e) {
+    return e;
+  });
+}
+
+function parseCharset(s, i) {
+  var match = s.match(/^\s*(\S+?)\s*(?:;(.*))?$/);
+  if (!match) return null;
+
+  var charset = match[1];
+  var q = 1;
+  if (match[2]) {
+    var params = match[2].split(';')
+    for (var i = 0; i < params.length; i ++) {
+      var p = params[i].trim().split('=');
+      if (p[0] === 'q') {
+        q = parseFloat(p[1]);
+        break;
+      }
+    }
+  }
+
+  return {
+    charset: charset,
+    q: q,
+    i: i
+  };
+}
+
+function getCharsetPriority(charset, accepted) {
+  return (accepted.map(function(a) {
+    return specify(charset, a);
+  }).filter(Boolean).sort(function (a, b) {
+    if(a.s == b.s) {
+      return a.q > b.q ? -1 : 1;
+    } else {
+      return a.s > b.s ? -1 : 1;
+    }
+  })[0] || {s: 0, q:0});
+}
+
+function specify(charset, spec) {
+  var s = 0;
+  if(spec.charset.toLowerCase() === charset.toLowerCase()){
+    s |= 1;
+  } else if (spec.charset !== '*' ) {
+    return null
+  }
+
+  return {
+    s: s,
+    q: spec.q,
+  }
+}
+
+function preferredCharsets(accept, provided) {
+  // RFC 2616 sec 14.2: no header = *
+  accept = parseAcceptCharset(accept === undefined ? '*' : accept || '');
+  if (provided) {
+    return provided.map(function(type) {
+      return [type, getCharsetPriority(type, accept)];
+    }).filter(function(pair) {
+      return pair[1].q > 0;
+    }).sort(function(a, b) {
+      var pa = a[1];
+      var pb = b[1];
+      return (pb.q - pa.q) || (pb.s - pa.s) || (pa.i - pb.i);
+    }).map(function(pair) {
+      return pair[0];
+    });
+  } else {
+    return accept.sort(function (a, b) {
+      // revsort
+      return (b.q - a.q) || (a.i - b.i);
+    }).filter(function(type) {
+      return type.q > 0;
+    }).map(function(type) {
+      return type.charset;
+    });
+  }
+}

server/node_modules/negotiator/lib/encoding.js

@@ -0,0 +1,117 @@
+module.exports = preferredEncodings;
+preferredEncodings.preferredEncodings = preferredEncodings;
+
+function parseAcceptEncoding(accept) {
+  var acceptableEncodings;
+
+  if (accept) {
+    acceptableEncodings = accept.split(',').map(function(e, i) {
+      return parseEncoding(e.trim(), i);
+    });
+  } else {
+    acceptableEncodings = [];
+  }
+
+  if (!acceptableEncodings.some(function(e) {
+    return e && specify('identity', e);
+  })) {
+    /*
+     * If identity doesn't explicitly appear in the accept-encoding header,
+     * it's added to the list of acceptable encoding with the lowest q
+     *
+     */
+    var lowestQ = 1;
+
+    for(var i = 0; i < acceptableEncodings.length; i++){
+      var e = acceptableEncodings[i];
+      if(e && e.q < lowestQ){
+        lowestQ = e.q;
+      }
+    }
+    acceptableEncodings.push({
+      encoding: 'identity',
+      q: lowestQ / 2,
+    });
+  }
+
+  return acceptableEncodings.filter(function(e) {
+    return e;
+  });
+}
+
+function parseEncoding(s, i) {
+  var match = s.match(/^\s*(\S+?)\s*(?:;(.*))?$/);
+
+  if (!match) return null;
+
+  var encoding = match[1];
+  var q = 1;
+  if (match[2]) {
+    var params = match[2].split(';');
+    for (var i = 0; i < params.length; i ++) {
+      var p = params[i].trim().split('=');
+      if (p[0] === 'q') {
+        q = parseFloat(p[1]);
+        break;
+      }
+    }
+  }
+
+  return {
+    encoding: encoding,
+    q: q,
+    i: i
+  };
+}
+
+function getEncodingPriority(encoding, accepted) {
+  return (accepted.map(function(a) {
+    return specify(encoding, a);
+  }).filter(Boolean).sort(function (a, b) {
+    if(a.s == b.s) {
+      return a.q > b.q ? -1 : 1;
+    } else {
+      return a.s > b.s ? -1 : 1;
+    }
+  })[0] || {s: 0, q: 0});
+}
+
+function specify(encoding, spec) {
+  var s = 0;
+  if(spec.encoding.toLowerCase() === encoding.toLowerCase()){
+    s |= 1;
+  } else if (spec.encoding !== '*' ) {
+    return null
+  }
+
+  return {
+    s: s,
+    q: spec.q,
+  }
+};
+
+function preferredEncodings(accept, provided) {
+  accept = parseAcceptEncoding(accept || '');
+  if (provided) {
+    return provided.map(function(type) {
+      return [type, getEncodingPriority(type, accept)];
+    }).filter(function(pair) {
+      return pair[1].q > 0;
+    }).sort(function(a, b) {
+      var pa = a[1];
+      var pb = b[1];
+      return (pb.q - pa.q) || (pb.s - pa.s) || (pa.i - pb.i);
+    }).map(function(pair) {
+      return pair[0];
+    });
+  } else {
+    return accept.sort(function (a, b) {
+      // revsort
+      return (b.q - a.q) || (a.i - b.i);
+    }).filter(function(type){
+      return type.q > 0;
+    }).map(function(type) {
+      return type.encoding;
+    });
+  }
+}

server/node_modules/negotiator/lib/language.js

@@ -0,0 +1,100 @@
+module.exports = preferredLanguages;
+preferredLanguages.preferredLanguages = preferredLanguages;
+
+function parseAcceptLanguage(accept) {
+  return accept.split(',').map(function(e, i) {
+    return parseLanguage(e.trim(), i);
+  }).filter(function(e) {
+    return e;
+  });
+}
+
+function parseLanguage(s, i) {
+  var match = s.match(/^\s*(\S+?)(?:-(\S+?))?\s*(?:;(.*))?$/);
+  if (!match) return null;
+
+  var prefix = match[1],
+      suffix = match[2],
+      full = prefix;
+
+  if (suffix) full += "-" + suffix;
+
+  var q = 1;
+  if (match[3]) {
+    var params = match[3].split(';')
+    for (var i = 0; i < params.length; i ++) {
+      var p = params[i].split('=');
+      if (p[0] === 'q') q = parseFloat(p[1]);
+    }
+  }
+
+  return {
+    prefix: prefix,
+    suffix: suffix,
+    q: q,
+    i: i,
+    full: full
+  };
+}
+
+function getLanguagePriority(language, accepted) {
+  return (accepted.map(function(a){
+    return specify(language, a);
+  }).filter(Boolean).sort(function (a, b) {
+    if(a.s == b.s) {
+      return a.q > b.q ? -1 : 1;
+    } else {
+      return a.s > b.s ? -1 : 1;
+    }
+  })[0] || {s: 0, q: 0});
+}
+
+function specify(language, spec) {
+  var p = parseLanguage(language)
+  if (!p) return null;
+  var s = 0;
+  if(spec.full.toLowerCase() === p.full.toLowerCase()){
+    s |= 4;
+  } else if (spec.prefix.toLowerCase() === p.full.toLowerCase()) {
+    s |= 2;
+  } else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) {
+    s |= 1;
+  } else if (spec.full !== '*' ) {
+    return null
+  }
+
+  return {
+    s: s,
+    q: spec.q,
+  }
+};
+
+function preferredLanguages(accept, provided) {
+  // RFC 2616 sec 14.4: no header = *
+  accept = parseAcceptLanguage(accept === undefined ? '*' : accept || '');
+  if (provided) {
+
+    var ret = provided.map(function(type) {
+      return [type, getLanguagePriority(type, accept)];
+    }).filter(function(pair) {
+      return pair[1].q > 0;
+    }).sort(function(a, b) {
+      var pa = a[1];
+      var pb = b[1];
+      return (pb.q - pa.q) || (pb.s - pa.s) || (pa.i - pb.i);
+    }).map(function(pair) {
+      return pair[0];
+    });
+    return ret;
+
+  } else {
+    return accept.sort(function (a, b) {
+      // revsort
+      return (b.q - a.q) || (a.i - b.i);
+    }).filter(function(type) {
+      return type.q > 0;
+    }).map(function(type) {
+      return type.full;
+    });
+  }
+}

server/node_modules/negotiator/lib/mediaType.js

@@ -0,0 +1,122 @@
+module.exports = preferredMediaTypes;
+preferredMediaTypes.preferredMediaTypes = preferredMediaTypes;
+
+function parseAccept(accept) {
+  return accept.split(',').map(function(e, i) {
+    return parseMediaType(e.trim(), i);
+  }).filter(function(e) {
+    return e;
+  });
+};
+
+function parseMediaType(s, i) {
+  var match = s.match(/\s*(\S+?)\/([^;\s]+)\s*(?:;(.*))?/);
+  if (!match) return null;
+
+  var type = match[1],
+      subtype = match[2],
+      full = "" + type + "/" + subtype,
+      params = {},
+      q = 1;
+
+  if (match[3]) {
+    params = match[3].split(';').map(function(s) {
+      return s.trim().split('=');
+    }).reduce(function (set, p) {
+      set[p[0]] = p[1];
+      return set
+    }, params);
+
+    if (params.q != null) {
+      q = parseFloat(params.q);
+      delete params.q;
+    }
+  }
+
+  return {
+    type: type,
+    subtype: subtype,
+    params: params,
+    q: q,
+    i: i,
+    full: full
+  };
+}
+
+function getMediaTypePriority(type, accepted) {
+  return (accepted.map(function(a) {
+    return specify(type, a);
+  }).filter(Boolean).sort(function (a, b) {
+    if(a.s == b.s) {
+      return a.q > b.q ? -1 : 1;
+    } else {
+      return a.s > b.s ? -1 : 1;
+    }
+  })[0] || {s: 0, q: 0});
+}
+
+function specify(type, spec) {
+  var p = parseMediaType(type);
+  var s = 0;
+
+  if (!p) {
+    return null;
+  }
+
+  if(spec.type.toLowerCase() == p.type.toLowerCase()) {
+    s |= 4
+  } else if(spec.type != '*') {
+    return null;
+  }
+
+  if(spec.subtype.toLowerCase() == p.subtype.toLowerCase()) {
+    s |= 2
+  } else if(spec.subtype != '*') {
+    return null;
+  }
+
+  var keys = Object.keys(spec.params);
+  if (keys.length > 0) {
+    if (keys.every(function (k) {
+      return spec.params[k] == '*' || (spec.params[k] || '').toLowerCase() == (p.params[k] || '').toLowerCase();
+    })) {
+      s |= 1
+    } else {
+      return null
+    }
+  }
+
+  return {
+    q: spec.q,
+    s: s,
+  }
+
+}
+
+function preferredMediaTypes(accept, provided) {
+  // RFC 2616 sec 14.2: no header = */*
+  accept = parseAccept(accept === undefined ? '*/*' : accept || '');
+  if (provided) {
+    return provided.map(function(type) {
+      return [type, getMediaTypePriority(type, accept)];
+    }).filter(function(pair) {
+      return pair[1].q > 0;
+    }).sort(function(a, b) {
+      var pa = a[1];
+      var pb = b[1];
+      return (pb.q - pa.q) || (pb.s - pa.s) || (pa.i - pb.i);
+    }).map(function(pair) {
+      return pair[0];
+    });
+
+  } else {
+    return accept.sort(function (a, b) {
+      // revsort
+      return (b.q - a.q) || (a.i - b.i);
+    }).filter(function(type) {
+      return type.q > 0;
+    }).map(function(type) {
+      return type.full;
+    });
+  }
+}

server/node_modules/negotiator/lib/negotiator.js

@@ -0,0 +1,37 @@
+module.exports = Negotiator;
+Negotiator.Negotiator = Negotiator;
+
+function Negotiator(request) {
+  if (!(this instanceof Negotiator)) return new Negotiator(request);
+  this.request = request;
+}
+
+var set = { charset: 'accept-charset',
+            encoding: 'accept-encoding',
+            language: 'accept-language',
+            mediaType: 'accept' };
+
+
+function capitalize(string){
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+Object.keys(set).forEach(function (k) {
+  var header = set[k],
+      method = require('./'+k+'.js'),
+      singular = k,
+      plural = k + 's';
+
+  Negotiator.prototype[plural] = function (available) {
+    return method(this.request.headers[header], available);
+  };
+
+  Negotiator.prototype[singular] = function(available) {
+    var set = this[plural](available);
+    if (set) return set[0];
+  };
+
+  // Keep preferred* methods for legacy compatibility
+  Negotiator.prototype['preferred'+capitalize(plural)] = Negotiator.prototype[plural];
+  Negotiator.prototype['preferred'+capitalize(singular)] = Negotiator.prototype[singular];
+})