init

server/node_modules/negotiator/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2012 Federico Romero
+Copyright (c) 2012-2014 Isaac Z. Schlueter
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

server/node_modules/negotiator/README.md

@@ -0,0 +1,161 @@
+# negotiator
+
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+An HTTP content negotiator for Node.js
+
+## Installation
+
+```sh
+$ npm install negotiator
+```
+
+## API
+
+```js
+var Negotiator = require('negotiator')
+```
+
+### Accept Negotiation
+
+```js
+availableMediaTypes = ['text/html', 'text/plain', 'application/json']
+
+// The negotiator constructor receives a request object
+negotiator = new Negotiator(request)
+
+// Let's say Accept header is 'text/html, application/*;q=0.2, image/jpeg;q=0.8'
+
+negotiator.mediaTypes()
+// -> ['text/html', 'image/jpeg', 'application/*']
+
+negotiator.mediaTypes(availableMediaTypes)
+// -> ['text/html', 'application/json']
+
+negotiator.mediaType(availableMediaTypes)
+// -> 'text/html'
+```
+
+You can check a working example at `examples/accept.js`.
+
+#### Methods
+
+##### mediaTypes(availableMediaTypes):
+
+Returns an array of preferred media types ordered by priority from a list of available media types.
+
+##### mediaType(availableMediaType):
+
+Returns the top preferred media type from a list of available media types.
+
+### Accept-Language Negotiation
+
+```js
+negotiator = new Negotiator(request)
+
+availableLanguages = 'en', 'es', 'fr'
+
+// Let's say Accept-Language header is 'en;q=0.8, es, pt'
+
+negotiator.languages()
+// -> ['es', 'pt', 'en']
+
+negotiator.languages(availableLanguages)
+// -> ['es', 'en']
+
+language = negotiator.language(availableLanguages)
+// -> 'es'
+```
+
+You can check a working example at `examples/language.js`.
+
+#### Methods
+
+##### languages(availableLanguages):
+
+Returns an array of preferred languages ordered by priority from a list of available languages.
+
+##### language(availableLanguages):
+
+Returns the top preferred language from a list of available languages.
+
+### Accept-Charset Negotiation
+
+```js
+availableCharsets = ['utf-8', 'iso-8859-1', 'iso-8859-5']
+
+negotiator = new Negotiator(request)
+
+// Let's say Accept-Charset header is 'utf-8, iso-8859-1;q=0.8, utf-7;q=0.2'
+
+negotiator.charsets()
+// -> ['utf-8', 'iso-8859-1', 'utf-7']
+
+negotiator.charsets(availableCharsets)
+// -> ['utf-8', 'iso-8859-1']
+
+negotiator.charset(availableCharsets)
+// -> 'utf-8'
+```
+
+You can check a working example at `examples/charset.js`.
+
+#### Methods
+
+##### charsets(availableCharsets):
+
+Returns an array of preferred charsets ordered by priority from a list of available charsets.
+
+##### charset(availableCharsets):
+
+Returns the top preferred charset from a list of available charsets.
+
+### Accept-Encoding Negotiation
+
+```js
+availableEncodings = ['identity', 'gzip']
+
+negotiator = new Negotiator(request)
+
+// Let's say Accept-Encoding header is 'gzip, compress;q=0.2, identity;q=0.5'
+
+negotiator.encodings()
+// -> ['gzip', 'identity', 'compress']
+
+negotiator.encodings(availableEncodings)
+// -> ['gzip', 'identity']
+
+negotiator.encoding(availableEncodings)
+// -> 'gzip'
+```
+
+You can check a working example at `examples/encoding.js`.
+
+#### Methods
+
+##### encodings(availableEncodings):
+
+Returns an array of preferred encodings ordered by priority from a list of available encodings.
+
+##### encoding(availableEncodings):
+
+Returns the top preferred encoding from a list of available encodings.
+
+## License
+
+[MIT](LICENSE)
+
+[npm-image]: https://img.shields.io/npm/v/negotiator.svg?style=flat
+[npm-url]: https://npmjs.org/package/negotiator
+[node-version-image]: https://img.shields.io/node/v/negotiator.svg?style=flat
+[node-version-url]: http://nodejs.org/download/
+[travis-image]: https://img.shields.io/travis/jshttp/negotiator.svg?style=flat
+[travis-url]: https://travis-ci.org/jshttp/negotiator
+[coveralls-image]: https://img.shields.io/coveralls/jshttp/negotiator.svg?style=flat
+[coveralls-url]: https://coveralls.io/r/jshttp/negotiator?branch=master
+[downloads-image]: https://img.shields.io/npm/dm/negotiator.svg?style=flat
+[downloads-url]: https://npmjs.org/package/negotiator

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];
+})

server/node_modules/negotiator/package.json

@@ -0,0 +1,113 @@
+{
+  "_args": [
+    [
+      {
+        "raw": "negotiator@0.4.9",
+        "scope": null,
+        "escapedName": "negotiator",
+        "name": "negotiator",
+        "rawSpec": "0.4.9",
+        "spec": "0.4.9",
+        "type": "version"
+      },
+      "/home/nau/MEGA/CODI/githubRepos/colspace/node_modules/accepts"
+    ]
+  ],
+  "_from": "negotiator@0.4.9",
+  "_id": "negotiator@0.4.9",
+  "_inCache": true,
+  "_location": "/negotiator",
+  "_npmUser": {
+    "name": "dougwilson",
+    "email": "doug@somethingdoug.com"
+  },
+  "_npmVersion": "1.4.21",
+  "_phantomChildren": {},
+  "_requested": {
+    "raw": "negotiator@0.4.9",
+    "scope": null,
+    "escapedName": "negotiator",
+    "name": "negotiator",
+    "rawSpec": "0.4.9",
+    "spec": "0.4.9",
+    "type": "version"
+  },
+  "_requiredBy": [
+    "/accepts"
+  ],
+  "_resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.4.9.tgz",
+  "_shasum": "92e46b6db53c7e421ed64a2bc94f08be7630df3f",
+  "_shrinkwrap": null,
+  "_spec": "negotiator@0.4.9",
+  "_where": "/home/nau/MEGA/CODI/githubRepos/colspace/node_modules/accepts",
+  "author": {
+    "name": "Federico Romero",
+    "email": "federico.romero@outboxlabs.com"
+  },
+  "bugs": {
+    "url": "https://github.com/jshttp/negotiator/issues"
+  },
+  "contributors": [
+    {
+      "name": "Isaac Z. Schlueter",
+      "email": "i@izs.me",
+      "url": "http://blog.izs.me/"
+    }
+  ],
+  "dependencies": {},
+  "description": "HTTP content negotiation",
+  "devDependencies": {
+    "istanbul": "~0.3.2",
+    "nodeunit": "0.8.x"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "92e46b6db53c7e421ed64a2bc94f08be7630df3f",
+    "tarball": "https://registry.npmjs.org/negotiator/-/negotiator-0.4.9.tgz"
+  },
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "files": [
+    "lib",
+    "LICENSE"
+  ],
+  "gitHead": "1e90abd710b662db80f1ea244e647cce3bd74504",
+  "homepage": "https://github.com/jshttp/negotiator",
+  "keywords": [
+    "http",
+    "content negotiation",
+    "accept",
+    "accept-language",
+    "accept-encoding",
+    "accept-charset"
+  ],
+  "license": "MIT",
+  "main": "lib/negotiator.js",
+  "maintainers": [
+    {
+      "name": "federomero",
+      "email": "federomero@gmail.com"
+    },
+    {
+      "name": "dougwilson",
+      "email": "doug@somethingdoug.com"
+    },
+    {
+      "name": "jongleberry",
+      "email": "jonathanrichardong@gmail.com"
+    }
+  ],
+  "name": "negotiator",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jshttp/negotiator.git"
+  },
+  "scripts": {
+    "test": "nodeunit test",
+    "test-cov": "istanbul cover ./node_modules/nodeunit/bin/nodeunit test"
+  },
+  "version": "0.4.9"
+}