sequenceserver 1.1.0.beta → 1.1.0.beta2

data/public/vendor/npm/qs@2.4.1/lib/parse.js

@@ -1,100 +0,0 @@
-/* */ 
-var Utils = require("./utils");
-var internals = {
-  delimiter: '&',
-  depth: 5,
-  arrayLimit: 20,
-  parameterLimit: 1000
-};
-internals.parseValues = function(str, options) {
-  var obj = {};
-  var parts = str.split(options.delimiter, options.parameterLimit === Infinity ? undefined : options.parameterLimit);
-  for (var i = 0,
-      il = parts.length; i < il; ++i) {
-    var part = parts[i];
-    var pos = part.indexOf(']=') === -1 ? part.indexOf('=') : part.indexOf(']=') + 1;
-    if (pos === -1) {
-      obj[Utils.decode(part)] = '';
-    } else {
-      var key = Utils.decode(part.slice(0, pos));
-      var val = Utils.decode(part.slice(pos + 1));
-      if (Object.prototype.hasOwnProperty(key)) {
-        continue;
-      }
-      if (!obj.hasOwnProperty(key)) {
-        obj[key] = val;
-      } else {
-        obj[key] = [].concat(obj[key]).concat(val);
-      }
-    }
-  }
-  return obj;
-};
-internals.parseObject = function(chain, val, options) {
-  if (!chain.length) {
-    return val;
-  }
-  var root = chain.shift();
-  var obj = {};
-  if (root === '[]') {
-    obj = [];
-    obj = obj.concat(internals.parseObject(chain, val, options));
-  } else {
-    var cleanRoot = root[0] === '[' && root[root.length - 1] === ']' ? root.slice(1, root.length - 1) : root;
-    var index = parseInt(cleanRoot, 10);
-    var indexString = '' + index;
-    if (!isNaN(index) && root !== cleanRoot && indexString === cleanRoot && index >= 0 && index <= options.arrayLimit) {
-      obj = [];
-      obj[index] = internals.parseObject(chain, val, options);
-    } else {
-      obj[cleanRoot] = internals.parseObject(chain, val, options);
-    }
-  }
-  return obj;
-};
-internals.parseKeys = function(key, val, options) {
-  if (!key) {
-    return;
-  }
-  var parent = /^([^\[\]]*)/;
-  var child = /(\[[^\[\]]*\])/g;
-  var segment = parent.exec(key);
-  if (Object.prototype.hasOwnProperty(segment[1])) {
-    return;
-  }
-  var keys = [];
-  if (segment[1]) {
-    keys.push(segment[1]);
-  }
-  var i = 0;
-  while ((segment = child.exec(key)) !== null && i < options.depth) {
-    ++i;
-    if (!Object.prototype.hasOwnProperty(segment[1].replace(/\[|\]/g, ''))) {
-      keys.push(segment[1]);
-    }
-  }
-  if (segment) {
-    keys.push('[' + key.slice(segment.index) + ']');
-  }
-  return internals.parseObject(keys, val, options);
-};
-module.exports = function(str, options) {
-  if (str === '' || str === null || typeof str === 'undefined') {
-    return {};
-  }
-  options = options || {};
-  options.delimiter = typeof options.delimiter === 'string' || Utils.isRegExp(options.delimiter) ? options.delimiter : internals.delimiter;
-  options.depth = typeof options.depth === 'number' ? options.depth : internals.depth;
-  options.arrayLimit = typeof options.arrayLimit === 'number' ? options.arrayLimit : internals.arrayLimit;
-  options.parameterLimit = typeof options.parameterLimit === 'number' ? options.parameterLimit : internals.parameterLimit;
-  var tempObj = typeof str === 'string' ? internals.parseValues(str, options) : str;
-  var obj = {};
-  var keys = Object.keys(tempObj);
-  for (var i = 0,
-      il = keys.length; i < il; ++i) {
-    var key = keys[i];
-    var newObj = internals.parseKeys(key, tempObj[key], options);
-    obj = Utils.merge(obj, newObj);
-  }
-  return Utils.compact(obj);
-};

data/public/vendor/npm/qs@2.4.1/lib/stringify.js

@@ -1,67 +0,0 @@
-/* */ 
-var Utils = require("./utils");
-var internals = {
-  delimiter: '&',
-  arrayPrefixGenerators: {
-    brackets: function(prefix, key) {
-      return prefix + '[]';
-    },
-    indices: function(prefix, key) {
-      return prefix + '[' + key + ']';
-    },
-    repeat: function(prefix, key) {
-      return prefix;
-    }
-  }
-};
-internals.stringify = function(obj, prefix, generateArrayPrefix) {
-  if (Utils.isBuffer(obj)) {
-    obj = obj.toString();
-  } else if (obj instanceof Date) {
-    obj = obj.toISOString();
-  } else if (obj === null) {
-    obj = '';
-  }
-  if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
-    return [encodeURIComponent(prefix) + '=' + encodeURIComponent(obj)];
-  }
-  var values = [];
-  if (typeof obj === 'undefined') {
-    return values;
-  }
-  var objKeys = Object.keys(obj);
-  for (var i = 0,
-      il = objKeys.length; i < il; ++i) {
-    var key = objKeys[i];
-    if (Array.isArray(obj)) {
-      values = values.concat(internals.stringify(obj[key], generateArrayPrefix(prefix, key), generateArrayPrefix));
-    } else {
-      values = values.concat(internals.stringify(obj[key], prefix + '[' + key + ']', generateArrayPrefix));
-    }
-  }
-  return values;
-};
-module.exports = function(obj, options) {
-  options = options || {};
-  var delimiter = typeof options.delimiter === 'undefined' ? internals.delimiter : options.delimiter;
-  var keys = [];
-  if (typeof obj !== 'object' || obj === null) {
-    return '';
-  }
-  var arrayFormat;
-  if (options.arrayFormat in internals.arrayPrefixGenerators) {
-    arrayFormat = options.arrayFormat;
-  } else if ('indices' in options) {
-    arrayFormat = options.indices ? 'indices' : 'repeat';
-  } else {
-    arrayFormat = 'indices';
-  }
-  var generateArrayPrefix = internals.arrayPrefixGenerators[arrayFormat];
-  var objKeys = Object.keys(obj);
-  for (var i = 0,
-      il = objKeys.length; i < il; ++i) {
-    var key = objKeys[i];
-    keys = keys.concat(internals.stringify(obj[key], key, generateArrayPrefix));
-  }
-  return keys.join(delimiter);
-};

data/public/vendor/npm/qs@2.4.1/lib/utils.js

@@ -1,132 +0,0 @@
-// Load modules
-
-
-// Declare internals
-
-var internals = {};
-
-
-exports.arrayToObject = function (source) {
-
-    var obj = {};
-    for (var i = 0, il = source.length; i < il; ++i) {
-        if (typeof source[i] !== 'undefined') {
-
-            obj[i] = source[i];
-        }
-    }
-
-    return obj;
-};
-
-
-exports.merge = function (target, source) {
-
-    if (!source) {
-        return target;
-    }
-
-    if (typeof source !== 'object') {
-        if (Array.isArray(target)) {
-            target.push(source);
-        }
-        else {
-            target[source] = true;
-        }
-
-        return target;
-    }
-
-    if (typeof target !== 'object') {
-        target = [target].concat(source);
-        return target;
-    }
-
-    if (Array.isArray(target) &&
-        !Array.isArray(source)) {
-
-        target = exports.arrayToObject(target);
-    }
-
-    var keys = Object.keys(source);
-    for (var k = 0, kl = keys.length; k < kl; ++k) {
-        var key = keys[k];
-        var value = source[key];
-
-        if (!target[key]) {
-            target[key] = value;
-        }
-        else {
-            target[key] = exports.merge(target[key], value);
-        }
-    }
-
-    return target;
-};
-
-
-exports.decode = function (str) {
-
-    try {
-        return decodeURIComponent(str.replace(/\+/g, ' '));
-    } catch (e) {
-        return str;
-    }
-};
-
-
-exports.compact = function (obj, refs) {
-
-    if (typeof obj !== 'object' ||
-        obj === null) {
-
-        return obj;
-    }
-
-    refs = refs || [];
-    var lookup = refs.indexOf(obj);
-    if (lookup !== -1) {
-        return refs[lookup];
-    }
-
-    refs.push(obj);
-
-    if (Array.isArray(obj)) {
-        var compacted = [];
-
-        for (var i = 0, il = obj.length; i < il; ++i) {
-            if (typeof obj[i] !== 'undefined') {
-                compacted.push(obj[i]);
-            }
-        }
-
-        return compacted;
-    }
-
-    var keys = Object.keys(obj);
-    for (i = 0, il = keys.length; i < il; ++i) {
-        var key = keys[i];
-        obj[key] = exports.compact(obj[key], refs);
-    }
-
-    return obj;
-};
-
-
-exports.isRegExp = function (obj) {
-    return Object.prototype.toString.call(obj) === '[object RegExp]';
-};
-
-
-exports.isBuffer = function (obj) {
-
-    if (obj === null ||
-        typeof obj === 'undefined') {
-
-        return false;
-    }
-
-    return !!(obj.constructor &&
-        obj.constructor.isBuffer &&
-        obj.constructor.isBuffer(obj));
-};

data/public/vendor/npm/qs@2.4.1/lib.js

@@ -1,2 +0,0 @@
-/* */ 
-module.exports = require('./lib/index');

data/public/vendor/npm/qs@2.4.1/package.json

@@ -1,29 +0,0 @@
-{
-  "name": "qs",
-  "version": "2.4.1",
-  "description": "A querystring parser that supports nesting and arrays, with a depth limit",
-  "homepage": "https://github.com/hapijs/qs",
-  "main": "index.js",
-  "dependencies": {},
-  "devDependencies": {
-    "code": "1.x.x",
-    "lab": "5.x.x"
-  },
-  "scripts": {
-    "test": "make test-cov"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hapijs/qs.git"
-  },
-  "keywords": [
-    "querystring",
-    "qs"
-  ],
-  "licenses": [
-    {
-      "type": "BSD",
-      "url": "http://github.com/hapijs/qs/raw/master/LICENSE"
-    }
-  ]
-}

data/public/vendor/npm/qs@2.4.1/test/parse.js

@@ -1,359 +0,0 @@
-/* */ 
-(function(Buffer) {
-  var Code = require("code");
-  var Lab = require("lab");
-  var Qs = require("../index");
-  var internals = {};
-  var lab = exports.lab = Lab.script();
-  var expect = Code.expect;
-  var describe = lab.experiment;
-  var it = lab.test;
-  describe('parse()', function() {
-    it('parses a simple string', function(done) {
-      expect(Qs.parse('0=foo')).to.deep.equal({'0': 'foo'});
-      expect(Qs.parse('foo=c++')).to.deep.equal({foo: 'c  '});
-      expect(Qs.parse('a[>=]=23')).to.deep.equal({a: {'>=': '23'}});
-      expect(Qs.parse('a[<=>]==23')).to.deep.equal({a: {'<=>': '=23'}});
-      expect(Qs.parse('a[==]=23')).to.deep.equal({a: {'==': '23'}});
-      expect(Qs.parse('foo')).to.deep.equal({foo: ''});
-      expect(Qs.parse('foo=bar')).to.deep.equal({foo: 'bar'});
-      expect(Qs.parse(' foo = bar = baz ')).to.deep.equal({' foo ': ' bar = baz '});
-      expect(Qs.parse('foo=bar=baz')).to.deep.equal({foo: 'bar=baz'});
-      expect(Qs.parse('foo=bar&bar=baz')).to.deep.equal({
-        foo: 'bar',
-        bar: 'baz'
-      });
-      expect(Qs.parse('foo=bar&baz')).to.deep.equal({
-        foo: 'bar',
-        baz: ''
-      });
-      expect(Qs.parse('cht=p3&chd=t:60,40&chs=250x100&chl=Hello|World')).to.deep.equal({
-        cht: 'p3',
-        chd: 't:60,40',
-        chs: '250x100',
-        chl: 'Hello|World'
-      });
-      done();
-    });
-    it('parses a single nested string', function(done) {
-      expect(Qs.parse('a[b]=c')).to.deep.equal({a: {b: 'c'}});
-      done();
-    });
-    it('parses a double nested string', function(done) {
-      expect(Qs.parse('a[b][c]=d')).to.deep.equal({a: {b: {c: 'd'}}});
-      done();
-    });
-    it('defaults to a depth of 5', function(done) {
-      expect(Qs.parse('a[b][c][d][e][f][g][h]=i')).to.deep.equal({a: {b: {c: {d: {e: {f: {'[g][h]': 'i'}}}}}}});
-      done();
-    });
-    it('only parses one level when depth = 1', function(done) {
-      expect(Qs.parse('a[b][c]=d', {depth: 1})).to.deep.equal({a: {b: {'[c]': 'd'}}});
-      expect(Qs.parse('a[b][c][d]=e', {depth: 1})).to.deep.equal({a: {b: {'[c][d]': 'e'}}});
-      done();
-    });
-    it('parses a simple array', function(done) {
-      expect(Qs.parse('a=b&a=c')).to.deep.equal({a: ['b', 'c']});
-      done();
-    });
-    it('parses an explicit array', function(done) {
-      expect(Qs.parse('a[]=b')).to.deep.equal({a: ['b']});
-      expect(Qs.parse('a[]=b&a[]=c')).to.deep.equal({a: ['b', 'c']});
-      expect(Qs.parse('a[]=b&a[]=c&a[]=d')).to.deep.equal({a: ['b', 'c', 'd']});
-      done();
-    });
-    it('parses a mix of simple and explicit arrays', function(done) {
-      expect(Qs.parse('a=b&a[]=c')).to.deep.equal({a: ['b', 'c']});
-      expect(Qs.parse('a[]=b&a=c')).to.deep.equal({a: ['b', 'c']});
-      expect(Qs.parse('a[0]=b&a=c')).to.deep.equal({a: ['b', 'c']});
-      expect(Qs.parse('a=b&a[0]=c')).to.deep.equal({a: ['b', 'c']});
-      expect(Qs.parse('a[1]=b&a=c')).to.deep.equal({a: ['b', 'c']});
-      expect(Qs.parse('a=b&a[1]=c')).to.deep.equal({a: ['b', 'c']});
-      done();
-    });
-    it('parses a nested array', function(done) {
-      expect(Qs.parse('a[b][]=c&a[b][]=d')).to.deep.equal({a: {b: ['c', 'd']}});
-      expect(Qs.parse('a[>=]=25')).to.deep.equal({a: {'>=': '25'}});
-      done();
-    });
-    it('allows to specify array indices', function(done) {
-      expect(Qs.parse('a[1]=c&a[0]=b&a[2]=d')).to.deep.equal({a: ['b', 'c', 'd']});
-      expect(Qs.parse('a[1]=c&a[0]=b')).to.deep.equal({a: ['b', 'c']});
-      expect(Qs.parse('a[1]=c')).to.deep.equal({a: ['c']});
-      done();
-    });
-    it('limits specific array indices to 20', function(done) {
-      expect(Qs.parse('a[20]=a')).to.deep.equal({a: ['a']});
-      expect(Qs.parse('a[21]=a')).to.deep.equal({a: {'21': 'a'}});
-      done();
-    });
-    it('supports keys that begin with a number', function(done) {
-      expect(Qs.parse('a[12b]=c')).to.deep.equal({a: {'12b': 'c'}});
-      done();
-    });
-    it('supports encoded = signs', function(done) {
-      expect(Qs.parse('he%3Dllo=th%3Dere')).to.deep.equal({'he=llo': 'th=ere'});
-      done();
-    });
-    it('is ok with url encoded strings', function(done) {
-      expect(Qs.parse('a[b%20c]=d')).to.deep.equal({a: {'b c': 'd'}});
-      expect(Qs.parse('a[b]=c%20d')).to.deep.equal({a: {b: 'c d'}});
-      done();
-    });
-    it('allows brackets in the value', function(done) {
-      expect(Qs.parse('pets=["tobi"]')).to.deep.equal({pets: '["tobi"]'});
-      expect(Qs.parse('operators=[">=", "<="]')).to.deep.equal({operators: '[">=", "<="]'});
-      done();
-    });
-    it('allows empty values', function(done) {
-      expect(Qs.parse('')).to.deep.equal({});
-      expect(Qs.parse(null)).to.deep.equal({});
-      expect(Qs.parse(undefined)).to.deep.equal({});
-      done();
-    });
-    it('transforms arrays to objects', function(done) {
-      expect(Qs.parse('foo[0]=bar&foo[bad]=baz')).to.deep.equal({foo: {
-          '0': 'bar',
-          bad: 'baz'
-        }});
-      expect(Qs.parse('foo[bad]=baz&foo[0]=bar')).to.deep.equal({foo: {
-          bad: 'baz',
-          '0': 'bar'
-        }});
-      expect(Qs.parse('foo[bad]=baz&foo[]=bar')).to.deep.equal({foo: {
-          bad: 'baz',
-          '0': 'bar'
-        }});
-      expect(Qs.parse('foo[]=bar&foo[bad]=baz')).to.deep.equal({foo: {
-          '0': 'bar',
-          bad: 'baz'
-        }});
-      expect(Qs.parse('foo[bad]=baz&foo[]=bar&foo[]=foo')).to.deep.equal({foo: {
-          bad: 'baz',
-          '0': 'bar',
-          '1': 'foo'
-        }});
-      expect(Qs.parse('foo[0][a]=a&foo[0][b]=b&foo[1][a]=aa&foo[1][b]=bb')).to.deep.equal({foo: [{
-          a: 'a',
-          b: 'b'
-        }, {
-          a: 'aa',
-          b: 'bb'
-        }]});
-      done();
-    });
-    it('can add keys to objects', function(done) {
-      expect(Qs.parse('a[b]=c&a=d')).to.deep.equal({a: {
-          b: 'c',
-          d: true
-        }});
-      done();
-    });
-    it('correctly prunes undefined values when converting an array to an object', function(done) {
-      expect(Qs.parse('a[2]=b&a[99999999]=c')).to.deep.equal({a: {
-          '2': 'b',
-          '99999999': 'c'
-        }});
-      done();
-    });
-    it('supports malformed uri characters', function(done) {
-      expect(Qs.parse('{%:%}')).to.deep.equal({'{%:%}': ''});
-      expect(Qs.parse('foo=%:%}')).to.deep.equal({foo: '%:%}'});
-      done();
-    });
-    it('doesn\'t produce empty keys', function(done) {
-      expect(Qs.parse('_r=1&')).to.deep.equal({'_r': '1'});
-      done();
-    });
-    it('cannot override prototypes', function(done) {
-      var obj = Qs.parse('hasOwnProperty=bad&toString=bad&bad[toString]=bad&constructor=bad');
-      expect(typeof obj.toString).to.equal('function');
-      expect(typeof obj.bad.toString).to.equal('function');
-      expect(typeof obj.constructor).to.equal('function');
-      done();
-    });
-    it('cannot access Object prototype', function(done) {
-      Qs.parse('constructor[prototype][bad]=bad');
-      Qs.parse('bad[constructor][prototype][bad]=bad');
-      expect(typeof Object.prototype.bad).to.equal('undefined');
-      done();
-    });
-    it('parses arrays of objects', function(done) {
-      expect(Qs.parse('a[][b]=c')).to.deep.equal({a: [{b: 'c'}]});
-      expect(Qs.parse('a[0][b]=c')).to.deep.equal({a: [{b: 'c'}]});
-      done();
-    });
-    it('allows for empty strings in arrays', function(done) {
-      expect(Qs.parse('a[]=b&a[]=&a[]=c')).to.deep.equal({a: ['b', '', 'c']});
-      expect(Qs.parse('a[0]=b&a[1]=&a[2]=c&a[19]=')).to.deep.equal({a: ['b', '', 'c', '']});
-      expect(Qs.parse('a[]=&a[]=b&a[]=c')).to.deep.equal({a: ['', 'b', 'c']});
-      done();
-    });
-    it('compacts sparse arrays', function(done) {
-      expect(Qs.parse('a[10]=1&a[2]=2')).to.deep.equal({a: ['2', '1']});
-      done();
-    });
-    it('parses semi-parsed strings', function(done) {
-      expect(Qs.parse({'a[b]': 'c'})).to.deep.equal({a: {b: 'c'}});
-      expect(Qs.parse({
-        'a[b]': 'c',
-        'a[d]': 'e'
-      })).to.deep.equal({a: {
-          b: 'c',
-          d: 'e'
-        }});
-      done();
-    });
-    it('parses buffers correctly', function(done) {
-      var b = new Buffer('test');
-      expect(Qs.parse({a: b})).to.deep.equal({a: b});
-      done();
-    });
-    it('continues parsing when no parent is found', function(done) {
-      expect(Qs.parse('[]&a=b')).to.deep.equal({
-        '0': '',
-        a: 'b'
-      });
-      expect(Qs.parse('[foo]=bar')).to.deep.equal({foo: 'bar'});
-      done();
-    });
-    it('does not error when parsing a very long array', function(done) {
-      var str = 'a[]=a';
-      while (Buffer.byteLength(str) < 128 * 1024) {
-        str += '&' + str;
-      }
-      expect(function() {
-        Qs.parse(str);
-      }).to.not.throw();
-      done();
-    });
-    it('should not throw when a native prototype has an enumerable property', {parallel: false}, function(done) {
-      Object.prototype.crash = '';
-      Array.prototype.crash = '';
-      expect(Qs.parse.bind(null, 'a=b')).to.not.throw();
-      expect(Qs.parse('a=b')).to.deep.equal({a: 'b'});
-      expect(Qs.parse.bind(null, 'a[][b]=c')).to.not.throw();
-      expect(Qs.parse('a[][b]=c')).to.deep.equal({a: [{b: 'c'}]});
-      delete Object.prototype.crash;
-      delete Array.prototype.crash;
-      done();
-    });
-    it('parses a string with an alternative string delimiter', function(done) {
-      expect(Qs.parse('a=b;c=d', {delimiter: ';'})).to.deep.equal({
-        a: 'b',
-        c: 'd'
-      });
-      done();
-    });
-    it('parses a string with an alternative RegExp delimiter', function(done) {
-      expect(Qs.parse('a=b; c=d', {delimiter: /[;,] */})).to.deep.equal({
-        a: 'b',
-        c: 'd'
-      });
-      done();
-    });
-    it('does not use non-splittable objects as delimiters', function(done) {
-      expect(Qs.parse('a=b&c=d', {delimiter: true})).to.deep.equal({
-        a: 'b',
-        c: 'd'
-      });
-      done();
-    });
-    it('allows overriding parameter limit', function(done) {
-      expect(Qs.parse('a=b&c=d', {parameterLimit: 1})).to.deep.equal({a: 'b'});
-      done();
-    });
-    it('allows setting the parameter limit to Infinity', function(done) {
-      expect(Qs.parse('a=b&c=d', {parameterLimit: Infinity})).to.deep.equal({
-        a: 'b',
-        c: 'd'
-      });
-      done();
-    });
-    it('allows overriding array limit', function(done) {
-      expect(Qs.parse('a[0]=b', {arrayLimit: -1})).to.deep.equal({a: {'0': 'b'}});
-      expect(Qs.parse('a[-1]=b', {arrayLimit: -1})).to.deep.equal({a: {'-1': 'b'}});
-      expect(Qs.parse('a[0]=b&a[1]=c', {arrayLimit: 0})).to.deep.equal({a: {
-          '0': 'b',
-          '1': 'c'
-        }});
-      done();
-    });
-    it('parses an object', function(done) {
-      var input = {
-        'user[name]': {'pop[bob]': 3},
-        'user[email]': null
-      };
-      var expected = {'user': {
-          'name': {'pop[bob]': 3},
-          'email': null
-        }};
-      var result = Qs.parse(input);
-      expect(result).to.deep.equal(expected);
-      done();
-    });
-    it('parses an object and not child values', function(done) {
-      var input = {
-        'user[name]': {'pop[bob]': {'test': 3}},
-        'user[email]': null
-      };
-      var expected = {'user': {
-          'name': {'pop[bob]': {'test': 3}},
-          'email': null
-        }};
-      var result = Qs.parse(input);
-      expect(result).to.deep.equal(expected);
-      done();
-    });
-    it('does not blow up when Buffer global is missing', function(done) {
-      var tempBuffer = global.Buffer;
-      delete global.Buffer;
-      var result = Qs.parse('a=b&c=d');
-      global.Buffer = tempBuffer;
-      expect(result).to.deep.equal({
-        a: 'b',
-        c: 'd'
-      });
-      done();
-    });
-    it('does not crash when using invalid dot notation', function(done) {
-      expect(Qs.parse('roomInfoList[0].childrenAges[0]=15&roomInfoList[0].numberOfAdults=2')).to.deep.equal({roomInfoList: [['15', '2']]});
-      done();
-    });
-    it('does not crash when parsing circular references', function(done) {
-      var a = {};
-      a.b = a;
-      var parsed;
-      expect(function() {
-        parsed = Qs.parse({
-          'foo[bar]': 'baz',
-          'foo[baz]': a
-        });
-      }).to.not.throw();
-      expect(parsed).to.contain('foo');
-      expect(parsed.foo).to.contain('bar', 'baz');
-      expect(parsed.foo.bar).to.equal('baz');
-      expect(parsed.foo.baz).to.deep.equal(a);
-      done();
-    });
-    it('parses plain objects correctly', function(done) {
-      var a = Object.create(null);
-      a.b = 'c';
-      expect(Qs.parse(a)).to.deep.equal({b: 'c'});
-      var result = Qs.parse({a: a});
-      expect(result).to.contain('a');
-      expect(result.a).to.deep.equal(a);
-      done();
-    });
-    it('parses dates correctly', function(done) {
-      var now = new Date();
-      expect(Qs.parse({a: now})).to.deep.equal({a: now});
-      done();
-    });
-    it('parses regular expressions correctly', function(done) {
-      var re = /^test$/;
-      expect(Qs.parse({a: re})).to.deep.equal({a: re});
-      done();
-    });
-  });
-})(require("buffer").Buffer);

data/public/vendor/npm/qs@2.4.1.js

@@ -1 +0,0 @@
-module.exports = require("npm:qs@2.4.1/index");

data/public/vendor/npm/react-router@0.13.3/.jspm-hash

@@ -1 +0,0 @@
-95455dd19d2c04c7b2957ff7fccda76031ac29b199914b932bd37a50b983c5e7c90ae93bjspm-npm@0.240.16