vulcan 0.2.5 → 0.3.0

data/server/node_modules/express/node_modules/qs/support/should/package.json

@@ -0,0 +1,8 @@
+{   "name": "should"
+  , "description": "test framework agnostic BDD-style assertions"
+  , "version": "0.0.4"
+  , "author": "TJ Holowaychuk <tj@vision-media.ca>"
+  , "keywords": ["test", "bdd", "assert"]
+  , "main": "./lib/should.js"
+  , "engines": { "node": ">= 0.2.0" }
+}

data/server/node_modules/express/node_modules/qs/support/should/test/should.test.js

@@ -0,0 +1,358 @@
+
+/**
+ * Module dependencies.
+ */
+
+var should = require('should');
+
+function err(fn, msg) {
+  try {
+    fn();
+    should.fail('expected an error');
+  } catch (err) {
+    should.equal(msg, err.message);
+  }
+}
+
+module.exports = {
+  'test .version': function(){
+    should.version.should.match(/^\d+\.\d+\.\d+$/);
+  },
+
+  'test double require': function(){
+    require('should').should.equal(should);
+  },
+
+  'test assertion': function(){
+    'test'.should.be.a.string;
+    should.equal('foo', 'foo');
+  },
+  
+  'test true': function(){
+    true.should.be.true;
+    false.should.not.be.true;
+    (1).should.not.be.true;
+    
+    err(function(){
+      'test'.should.be.true;
+    }, "expected 'test' to be true")
+  },
+  
+  'test ok': function(){
+    true.should.be.ok;
+    false.should.not.be.ok;
+    (1).should.be.ok;
+    (0).should.not.be.ok;
+    
+    err(function(){
+      ''.should.be.ok;
+    }, "expected '' to be truthy");
+    
+    err(function(){
+      'test'.should.not.be.ok;
+    }, "expected 'test' to be falsey");
+  },
+  
+  'test false': function(){
+    false.should.be.false;
+    true.should.not.be.false;
+    (0).should.not.be.false;
+    
+    err(function(){
+      ''.should.be.false;
+    }, "expected '' to be false")
+  },
+  
+  'test arguments': function(){
+    var args = (function(){ return arguments; })(1,2,3);
+    args.should.be.arguments;
+    [].should.not.be.arguments;
+  },
+  
+  'test .equal()': function(){
+    var foo;
+    should.equal(undefined, foo);
+  },
+  
+  'test typeof': function(){
+    'test'.should.be.a('string');
+
+    err(function(){
+      'test'.should.not.be.a('string');
+    }, "expected 'test' not to be a string");
+    
+    (5).should.be.a('number');
+
+    err(function(){
+      (5).should.not.be.a('number');
+    }, "expected 5 not to be a number");
+  },
+  
+  'test instanceof': function(){
+    function Foo(){}
+    new Foo().should.be.an.instanceof(Foo);
+
+    err(function(){
+      (3).should.an.instanceof(Foo);
+    }, "expected 3 to be an instance of Foo");
+  },
+  
+  'test within(start, finish)': function(){
+    (5).should.be.within(5, 10);
+    (5).should.be.within(3,6);
+    (5).should.be.within(3,5);
+    (5).should.not.be.within(1,3);
+    
+    err(function(){
+      (5).should.not.be.within(4,6);
+    }, "expected 5 to not be within 4..6");
+    
+    err(function(){
+      (10).should.be.within(50,100);
+    }, "expected 10 to be within 50..100");
+  },
+  
+  'test above(n)': function(){
+    (5).should.be.above(2);
+    (5).should.be.greaterThan(2);
+    (5).should.not.be.above(5);
+    (5).should.not.be.above(6);
+
+    err(function(){
+      (5).should.be.above(6);
+    }, "expected 5 to be above 6");
+    
+    err(function(){
+      (10).should.not.be.above(6);
+    }, "expected 10 to be below 6");
+  },
+  
+  'test match(regexp)': function(){
+    'foobar'.should.match(/^foo/)
+    'foobar'.should.not.match(/^bar/)
+    
+    err(function(){
+      'foobar'.should.match(/^bar/i)
+    }, "expected 'foobar' to match /^bar/i");
+    
+    err(function(){
+      'foobar'.should.not.match(/^foo/i)
+    }, "expected 'foobar' not to match /^foo/i");
+  },
+  
+  'test length(n)': function(){
+    'test'.should.have.length(4);
+    'test'.should.not.have.length(3);
+    [1,2,3].should.have.length(3);
+    
+    err(function(){
+      (4).should.have.length(3);
+    }, 'expected 4 to have a property \'length\'');
+    
+    err(function(){
+      'asd'.should.not.have.length(3);
+    }, "expected 'asd' to not have a length of 3");
+  },
+  
+  'test eql(val)': function(){
+    'test'.should.eql('test');
+    ({ foo: 'bar' }).should.eql({ foo: 'bar' });
+    (1).should.eql(1);
+    '4'.should.eql(4);
+    
+    err(function(){
+      (4).should.eql(3);
+    }, 'expected 4 to equal 3');
+  },
+  
+  'test equal(val)': function(){
+    'test'.should.equal('test');
+    (1).should.equal(1);
+    
+    err(function(){
+      (4).should.equal(3);
+    }, 'expected 4 to equal 3');
+    
+    err(function(){
+      '4'.should.equal(4);
+    }, "expected '4' to equal 4");
+  },
+  
+  'test empty': function(){
+    ''.should.be.empty;
+    [].should.be.empty;
+    ({ length: 0 }).should.be.empty;
+    
+    err(function(){
+      ({}).should.be.empty;
+    }, 'expected {} to have a property \'length\'');
+    
+    err(function(){
+      'asd'.should.be.empty;
+    }, "expected 'asd' to be empty");
+    
+    err(function(){
+      ''.should.not.be.empty;
+    }, "expected '' not to be empty");
+  },
+  
+  'test property(name)': function(){
+    'test'.should.have.property('length');
+    (4).should.not.have.property('length');
+    
+    err(function(){
+      'asd'.should.have.property('foo');
+    }, "expected 'asd' to have a property 'foo'");
+  },
+  
+  'test property(name, val)': function(){
+    'test'.should.have.property('length', 4);
+    'asd'.should.have.property('constructor', String);
+    
+    err(function(){
+      'asd'.should.have.property('length', 4);
+    }, "expected 'asd' to have a property 'length' of 4, but got 3");
+    
+    err(function(){
+      'asd'.should.not.have.property('length', 3);
+    }, "expected 'asd' to not have a property 'length' of 3");
+    
+    err(function(){
+      'asd'.should.not.have.property('foo', 3);
+    }, "'asd' has no property 'foo'");
+    
+    err(function(){
+      'asd'.should.have.property('constructor', Number);
+    }, "expected 'asd' to have a property 'constructor' of [Function: Number], but got [Function: String]");
+  },
+  
+  'test ownProperty(name)': function(){
+    'test'.should.have.ownProperty('length');
+    'test'.should.haveOwnProperty('length');
+    ({ length: 12 }).should.have.ownProperty('length');
+    
+    err(function(){
+      ({ length: 12 }).should.not.have.ownProperty('length');
+    }, "expected { length: 12 } to not have own property 'length'");
+  },
+  
+  'test string()': function(){
+    'foobar'.should.include.string('bar');
+    'foobar'.should.include.string('foo');
+    'foobar'.should.not.include.string('baz');
+
+    err(function(){
+      (3).should.include.string('baz');
+    }, "expected 3 to be a string");
+    
+    err(function(){
+      'foobar'.should.include.string('baz');
+    }, "expected 'foobar' to include 'baz'");
+    
+    err(function(){
+      'foobar'.should.not.include.string('bar');
+    }, "expected 'foobar' to not include 'bar'");
+  },
+  
+  'test contain()': function(){
+    ['foo', 'bar'].should.contain('foo');
+    ['foo', 'bar'].should.contain('foo');
+    ['foo', 'bar'].should.contain('bar');
+    [1,2].should.contain(1);
+    ['foo', 'bar'].should.not.contain('baz');
+    ['foo', 'bar'].should.not.contain(1);
+
+    err(function(){
+      ['foo'].should.contain('bar');
+    }, "expected [ 'foo' ] to contain 'bar'");
+    
+    err(function(){
+      ['bar', 'foo'].should.not.contain('foo');
+    }, "expected [ 'bar', 'foo' ] to not contain 'foo'");
+  },
+  
+  'test keys(array)': function(){
+    ({ foo: 1 }).should.have.keys(['foo']);
+    ({ foo: 1, bar: 2 }).should.have.keys(['foo', 'bar']);
+    ({ foo: 1, bar: 2 }).should.have.keys('foo', 'bar');
+    ({ foo: 1, bar: 2, baz: 3 }).should.include.keys('foo', 'bar');
+    ({ foo: 1, bar: 2, baz: 3 }).should.include.keys('bar', 'foo');
+    ({ foo: 1, bar: 2, baz: 3 }).should.include.keys('baz');
+
+    ({ foo: 1, bar: 2 }).should.include.keys('foo');
+    ({ foo: 1, bar: 2 }).should.include.keys('bar', 'foo');
+    ({ foo: 1, bar: 2 }).should.include.keys(['foo']);
+    ({ foo: 1, bar: 2 }).should.include.keys(['bar']);
+    ({ foo: 1, bar: 2 }).should.include.keys(['bar', 'foo']);
+
+    ({ foo: 1, bar: 2 }).should.not.have.keys('baz');
+    ({ foo: 1, bar: 2 }).should.not.have.keys('foo', 'baz');
+    ({ foo: 1, bar: 2 }).should.not.include.keys('baz');
+    ({ foo: 1, bar: 2 }).should.not.include.keys('foo', 'baz');
+    ({ foo: 1, bar: 2 }).should.not.include.keys('baz', 'foo');
+
+    err(function(){
+      ({ foo: 1 }).should.have.keys();
+    }, "keys required");
+    
+    err(function(){
+      ({ foo: 1 }).should.have.keys([]);
+    }, "keys required");
+    
+    err(function(){
+      ({ foo: 1 }).should.not.have.keys([]);
+    }, "keys required");
+    
+    err(function(){
+      ({ foo: 1 }).should.include.keys([]);
+    }, "keys required");
+
+    err(function(){
+      ({ foo: 1 }).should.have.keys(['bar']);
+    }, "expected { foo: 1 } to have key 'bar'");
+    
+    err(function(){
+      ({ foo: 1 }).should.have.keys(['bar', 'baz']);
+    }, "expected { foo: 1 } to have keys 'bar', and 'baz'");
+    
+    err(function(){
+      ({ foo: 1 }).should.have.keys(['foo', 'bar', 'baz']);
+    }, "expected { foo: 1 } to have keys 'foo', 'bar', and 'baz'");
+
+    err(function(){
+      ({ foo: 1 }).should.not.have.keys(['foo']);
+    }, "expected { foo: 1 } to not have key 'foo'");
+    
+    err(function(){
+      ({ foo: 1 }).should.not.have.keys(['foo']);
+    }, "expected { foo: 1 } to not have key 'foo'");
+    
+    err(function(){
+      ({ foo: 1, bar: 2 }).should.not.have.keys(['foo', 'bar']);
+    }, "expected { foo: 1, bar: 2 } to not have keys 'foo', and 'bar'");
+    
+    err(function(){
+      ({ foo: 1 }).should.not.include.keys(['foo']);
+    }, "expected { foo: 1 } to not include key 'foo'");
+    
+    err(function(){
+      ({ foo: 1 }).should.include.keys('foo', 'bar');
+    }, "expected { foo: 1 } to include keys 'foo', and 'bar'");
+  },
+  
+  'test respondTo(method)': function(){
+    'test'.should.respondTo('toString');
+    'test'.should.not.respondTo('toBuffer');
+  },
+  
+  'test chaining': function(){
+    var user = { name: 'tj', pets: ['tobi', 'loki', 'jane', 'bandit'] };
+    user.should.have.property('pets').with.lengthOf(4);
+ 
+    err(function(){
+      user.should.have.property('pets').with.lengthOf(5);
+    }, "expected [ 'tobi', 'loki', 'jane', 'bandit' ] to have a length of 5 but got 4");
+ 
+    user.should.be.a('object').and.have.property('name', 'tj');
+  }
+};

data/server/node_modules/express/node_modules/qs/test/{parse.js → parse.test.js}

@@ -3,7 +3,8 @@
  * Module dependencies.
  */
 
-var qs = require('../');
+var qs = require('../')
+  , should = require('should');
 
 module.exports = {
   'test basics': function(){

data/server/node_modules/express/package.json

@@ -1,7 +1,7 @@
 {
   "name": "express",
   "description": "Sinatra inspired web development framework",
-  "version": "2.5.6",
+  "version": "2.4.6",
   "author": "TJ Holowaychuk <tj@vision-media.ca>",
   "contributors": [ 
     { "name": "TJ Holowaychuk", "email": "tj@vision-media.ca" }, 
@@ -10,19 +10,18 @@
     { "name": "Guillermo Rauch", "email": "rauchg@gmail.com" }
   ],
   "dependencies": {
-    "connect": "1.x",
+    "connect": ">= 1.5.2 < 2.0.0",
     "mime": ">= 0.0.1",
-    "qs": ">= 0.3.1",
-    "mkdirp": "0.0.7"
+    "qs": ">= 0.3.1"
   },
   "devDependencies": {
     "connect-form": "0.2.1",
     "ejs": "0.4.2",
-    "expresso": "0.9.2",
-    "hamljs": "0.6.x",
-    "jade": "0.16.2",
+    "expresso": "0.7.2",
+    "hamljs": "0.5.1",
+    "jade": "0.11.0",
     "stylus": "0.13.0",
-    "should": "0.3.2",
+    "should": "0.2.1",
     "express-messages": "0.0.2",
     "node-markdown": ">= 0.0.1",
     "connect-redis": ">= 0.0.1"
@@ -35,5 +34,5 @@
     "test": "make test",
     "prepublish" : "npm prune"
   },
-  "engines": { "node": ">= 0.4.1 < 0.7.0" }
+  "engines": { "node": ">= 0.4.1 < 0.5.0" }
 }

data/server/node_modules/node-uuid/README.md

@@ -1,199 +1,100 @@
 # node-uuid
 
-Simple, fast generation of [RFC4122](http://www.ietf.org/rfc/rfc4122.txt) UUIDS.
+Simple, fast generation of RFC4122[RFC4122(v4)](http://www.ietf.org/rfc/rfc4122.txt) UUIDS.  It runs in node.js and all major browsers.
 
-Features:
+## Installation
 
-* Generate RFC4122 version 1 or version 4 UUIDs
-* Runs in node.js and all browsers.
-* Cryptographically strong random # generation on supporting platforms
-* 1.1K minified and gzip'ed  (Want something smaller?  Check this [crazy shit](https://gist.github.com/982883) out! )
-* [Annotated source code](http://broofa.github.com/node-uuid/docs/uuid.html)
+    npm install node-uuid
 
-## Getting Started
+### In browser
 
-Install it in your browser:
+    <script src="uuid.js"></script>
 
-```html
-<script src="uuid.js"></script>
-```
+### In node.js
 
-Or in node.js:
+    var uuid = require('node-uuid');
 
-```
-npm install node-uuid
-```
+## Usage
 
-```javascript
-var uuid = require('node-uuid');
-```
+### Generate a String UUID
 
-Then create some ids ...
+    var id = uuid(); // -> '92329D39-6F5C-4520-ABFC-AAB64544E172'
 
-```javascript
-// Generate a v1 (time-based) id
-uuid.v1(); // -> '6c84fb90-12c4-11e1-840d-7b25c5ee775a'
+### Generate a Binary UUID
 
-// Generate a v4 (random) id
-uuid.v4(); // -> '110ec58a-a0f2-4ac4-8393-c866d813b8d1'
-```
+    // Simple form - allocates a Buffer/Array for you
+    var buf = uuid('binary');
+    // node.js -> <Buffer 08 50 05 c8 9c b2 4c 07 ac 07 d1 4f b9 f5 04 51>
+    // browser -> [8, 80, 5, 200, 156, 178, 76, 7, 172, 7, 209, 79, 185, 245, 4, 81]
 
-## API
+    // Provide your own Buffer or Array
+    var buf = new Array(16);
+    uuid('binary', buf); // -> [8, 80, 5, 200, 156, 178, 76, 7, 172, 7, 209, 79, 185, 245, 4, 81]
+    var buf = new Buffer(16);
+    uuid('binary', buf); // -> <Buffer 08 50 05 c8 9c b2 4c 07 ac 07 d1 4f b9 f5 04 51>
 
-### uuid.v1([`options` [, `buffer` [, `offset`]]])
+    // Provide your own Buffer/Array, plus specify offset
+    // (e.g. here we fill an array with 3 uuids)
+    var buf = new Buffer(16 \* 3);
+    uuid('binary', id, 0);
+    uuid('binary', id, 16);
+    uuid('binary', id, 32);
 
-Generate and return a RFC4122 v1 (timestamp-based) UUID.
-
-* `options` - (Object) Optional uuid state to apply. Properties may include:
-
-  * `node` - (Array) Node id as Array of 6 bytes (per 4.1.6). Default: Randomnly generated ID.  See note 1.
-  * `clockseq` - (Number between 0 - 0x3fff) RFC clock sequence.  Default: An internally maintained clockseq is used.
-  * `msecs` - (Number | Date) Time in milliseconds since unix Epoch.  Default: The current time is used.
-  * `nsecs` - (Number between 0-9999) additional time, in 100-nanosecond units. Ignored if `msecs` is unspecified. Default: internal uuid counter is used, as per 4.2.1.2.
-
-* `buffer` - (Array | Buffer) Array or buffer where UUID bytes are to be written.
-* `offset` - (Number) Starting index in `buffer` at which to begin writing.
-
-Returns `buffer`, if specified, otherwise the string form of the UUID
-
-Notes:
-
-1. The randomly generated node id is only guaranteed to stay constant for the lifetime of the current JS runtime. (Future versions of this module may use persistent storage mechanisms to extend this guarantee.)
-
-Example: Generate string UUID with fully-specified options
-
-```javascript
-uuid.v1({
-  node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
-  clockseq: 0x1234,
-  msecs: new Date('2011-11-01').getTime(),
-  nsecs: 5678
-});   // -> "710b962e-041c-11e1-9234-0123456789ab"
-```
-
-Example: In-place generation of two binary IDs
-
-```javascript
-// Generate two ids in an array
-var arr = new Array(32); // -> []
-uuid.v1(null, arr, 0);   // -> [02 a2 ce 90 14 32 11 e1 85 58 0b 48 8e 4f c1 15]
-uuid.v1(null, arr, 16);  // -> [02 a2 ce 90 14 32 11 e1 85 58 0b 48 8e 4f c1 15 02 a3 1c b0 14 32 11 e1 85 58 0b 48 8e 4f c1 15]
-
-// Optionally use uuid.unparse() to get stringify the ids
-uuid.unparse(buffer);    // -> '02a2ce90-1432-11e1-8558-0b488e4fc115'
-uuid.unparse(buffer, 16) // -> '02a31cb0-1432-11e1-8558-0b488e4fc115'
-```
-
-### uuid.v4([`options` [, `buffer` [, `offset`]]])
-
-Generate and return a RFC4122 v4 UUID.
-
-* `options` - (Object) Optional uuid state to apply. Properties may include:
-
-  * `random` - (Number[16]) Array of 16 numbers (0-255) to use in place of randomly generated values
-  * `rng` - (Function) Random # generator to use.  Set to one of the built-in generators - `uuid.mathRNG` (all platforms), `uuid.nodeRNG` (node.js only), `uuid.whatwgRNG` (WebKit only) - or a custom function that returns an array[16] of byte values.
-
-* `buffer` - (Array | Buffer) Array or buffer where UUID bytes are to be written.
-* `offset` - (Number) Starting index in `buffer` at which to begin writing.
-
-Returns `buffer`, if specified, otherwise the string form of the UUID
-
-Example: Generate string UUID with fully-specified options
-
-```javascript
-uuid.v4({
-  random: [
-    0x10, 0x91, 0x56, 0xbe, 0xc4, 0xfb, 0xc1, 0xea,
-    0x71, 0xb4, 0xef, 0xe1, 0x67, 0x1c, 0x58, 0x36
-  ]
-});
-// -> "109156be-c4fb-41ea-b1b4-efe1671c5836"
-```
-
-Example: Generate two IDs in a single buffer
-
-```javascript
-var buffer = new Array(32); // (or 'new Buffer' in node.js)
-uuid.v4(null, buffer, 0);
-uuid.v4(null, buffer, 16);
-```
-
-### uuid.parse(id[, buffer[, offset]])
-### uuid.unparse(buffer[, offset])
-
-Parse and unparse UUIDs
-
-  * `id` - (String) UUID(-like) string
-  * `buffer` - (Array | Buffer) Array or buffer where UUID bytes are to be written. Default: A new Array or Buffer is used
-  * `offset` - (Number) Starting index in `buffer` at which to begin writing. Default: 0
-
-Example parsing and unparsing a UUID string
-
-```javascript
-var bytes = uuid.parse('797ff043-11eb-11e1-80d6-510998755d10'); // -> <Buffer 79 7f f0 43 11 eb 11 e1 80 d6 51 09 98 75 5d 10>
-var string = uuid.unparse(bytes); // -> '797ff043-11eb-11e1-80d6-510998755d10'
-```
-
-### uuid.noConflict()
-
-(Browsers only) Set `uuid` property back to it's previous value.
-
-Returns the node-uuid object.
-
-Example:
-
-```javascript
-var myUuid = uuid.noConflict();
-myUuid.v1(); // -> '6c84fb90-12c4-11e1-840d-7b25c5ee775a'
-```
-
-## Deprecated APIs
-
-Support for the following v1.2 APIs is available in v1.3, but is deprecated and will be removed in the next major version.
+## Testing
 
-### uuid([format [, buffer [, offset]]])
+test/test.js generates performance data (similar to test/benchmark.js). It also verifies the syntax of 100K string UUIDs, and logs the distribution of hex digits found therein.  For example:
 
-uuid() has become uuid.v4(), and the `format` argument is now implicit in the `buffer` argument. (i.e. if you specify a buffer, the format is assumed to be binary).
+    - - - Performance Data - - -
+    uuid(): 1052631 uuids/second
+    uuid('binary'): 680272 uuids/second
+    uuid('binary', buffer): 2702702 uuids/second
 
-### uuid.BufferClass
+    - - - Distribution of Hex Digits (% deviation from ideal) - - -
+    0 |================================| 187705 (0.11%)
+    1 |================================| 187880 (0.2%)
+    2 |================================| 186875 (-0.33%)
+    3 |================================| 186847 (-0.35%)
+    4 |==================================================| 287433 (-0.02%)
+    5 |================================| 187910 (0.22%)
+    6 |================================| 188172 (0.36%)
+    7 |================================| 187350 (-0.08%)
+    8 |====================================| 211994 (-0.24%)
+    9 |====================================| 212664 (0.08%)
+    A |=====================================| 213185 (0.32%)
+    B |=====================================| 212877 (0.18%)
+    C |================================| 187445 (-0.03%)
+    D |================================| 186737 (-0.41%)
+    E |================================| 187155 (-0.18%)
+    F |================================| 187771 (0.14%)
 
-The class of container created when generating binary uuid data if no buffer argument is specified.  This is expected to go away, with no replacement API.
+Note that the increased values for 4 and 8-B are expected as part of the RFC4122 syntax (and are accounted for in the deviation calculation). BTW, if someone wants to do the calculation to determine what a statistically significant deviation would be, I'll gladly add that to the test.
 
-## Testing
+### In browser
 
-In node.js
+    Open test/test.html
 
-```
-> cd test
-> node uuid.js
-```
+### In node.js
 
-In Browser
+    > node test/test.js
 
-```
-open test/test.html
-```
+node.js users can also run the node-uuid .vs. uuid.js benchmark:
 
-### Benchmarking
+    > node test/benchmark.js
 
-Requires node.js
+## Performance
 
-```
-npm install uuid uuid-js
-node test/benchmark.js
-```
+### In node.js
 
-For a more complete discussion of node-uuid performance, please see the `benchmark/README.md` file, and the [benchmark wiki](https://github.com/broofa/node-uuid/wiki/Benchmark)
+node-uuid is designed to be fast.  That said, the target platform is node.js, where it is screaming fast.  Here's what I get on my 2.66GHz Macbook Pro for the test/benchmark.js script:
 
-For browser performance [checkout the JSPerf tests](http://jsperf.com/node-uuid-performance).
+    nodeuuid(): 1126126 uuids/second
+    nodeuuid('binary'): 782472 uuids/second
+    nodeuuid('binary', buffer): 2688172 uuids/second
+    uuidjs(): 620347 uuids/second
+    uuidjs('binary'): 1275510 uuids/second
 
-## Release notes
+The uuidjs() entries are for Nikhil Marathe's [uuidjs module](https://bitbucket.org/nikhilm/uuidjs), and are provided for comparison.  uuidjs is a wrapper around the native libuuid library.
 
-v1.3.2:
-* Improve tests and handling of v1() options (Issue #24)
-* Expose RNG option to allow for perf testing with different generators
+### In browser
 
-v1.3:
-* Support for version 1 ids, thanks to [@ctavan](https://github.com/ctavan)!
-* Support for node.js crypto API
-* De-emphasizing performance in favor of a) cryptographic quality PRNGs where available and b) more manageable code
+node-uuid performance varies dramatically across browsers.  For comprehensive test results, please [checkout the JSPerf tests](http://jsperf.com/node-uuid-performance).