first commit

build/node_modules/browserify/.travis.yml

@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+  - "7"
+  - "6"
+  - "4"
+  - "0.12"
+  - "0.10"
+  

build/node_modules/browserify/LICENSE

@@ -0,0 +1,63 @@
+Some pieces from builtins/ taken from node core under this license:
+
+----
+
+Copyright Joyent, Inc. and other Node contributors.
+
+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.
+
+----
+
+buffer_ieee754.js has this license in it:
+
+----
+
+Copyright (c) 2008-2015, Fair Oaks Labs, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+Modifications to writeIEEE754 to support negative zeroes made by Brian White
+
+----

build/node_modules/browserify/bin/advanced.txt

@@ -0,0 +1,113 @@
+Advanced Options:
+
+  --insert-globals, --ig, --fast    [default: false]
+
+    Skip detection and always insert definitions for process, global,
+    __filename, and __dirname.
+                  
+    benefit: faster builds
+    cost: extra bytes
+ 
+  --insert-global-vars, --igv
+
+    Comma-separated list of global variables to detect and define.
+    Default: __filename,__dirname,process,Buffer,global
+ 
+  --detect-globals, --dg            [default: true]
+
+    Detect the presence of process, global, __filename, and __dirname and define
+    these values when present.
+
+    benefit: npm modules more likely to work
+    cost: slower builds
+
+  --ignore-missing, --im            [default: false]
+
+    Ignore `require()` statements that don't resolve to anything.
+
+  --noparse=FILE
+
+    Don't parse FILE at all. This will make bundling much, much faster for giant
+    libs like jquery or threejs.
+
+  --no-builtins
+
+    Turn off builtins. This is handy when you want to run a bundle in node which
+    provides the core builtins.
+
+  --no-commondir
+ 
+    Turn off setting a commondir. This is useful if you want to preserve the
+    original paths that a bundle was generated with. 
+ 
+  --no-bundle-external
+
+    Turn off bundling of all external modules. This is useful if you only want
+    to bundle your local files.
+
+  --bare 
+
+    Alias for both --no-builtins, --no-commondir, and sets --insert-global-vars
+    to just "__filename,__dirname". This is handy if you want to run bundles in
+    node.
+
+  --no-browser-field, --no-bf
+
+    Turn off package.json browser field resolution. This is also handy if you
+    need to run a bundle in node.
+
+  --transform-key
+
+    Instead of the default package.json#browserify#transform field to list
+    all transforms to apply when running browserify, a custom field, like, e.g.
+    package.json#browserify#production or package.json#browserify#staging
+    can be used, by for example running:
+    * `browserify index.js --transform-key=production > bundle.js`
+    * `browserify index.js --transform-key=staging > bundle.js`
+
+  --node
+
+    Alias for --bare and --no-browser-field.
+
+  --full-paths
+
+    Turn off converting module ids into numerical indexes. This is useful for
+    preserving the original paths that a bundle was generated with.
+
+  --deps
+  
+    Instead of standard bundle output, print the dependency array generated by
+    module-deps.
+
+  --no-dedupe
+
+    Turn off deduping.
+
+  --list
+ 
+    Print each file in the dependency graph. Useful for makefiles.
+
+  --extension=EXTENSION
+
+    Consider files with specified EXTENSION as modules, this option can used
+    multiple times.
+
+  --global-transform=MODULE, -g MODULE
+
+    Use a transform module on all files after any ordinary transforms have run.
+
+  --plugin=MODULE, -p MODULE
+
+    Register MODULE as a plugin.
+
+Passing arguments to transforms and plugins:
+
+  For -t, -g, and -p, you may use subarg syntax to pass options to the
+  transforms or plugin function as the second parameter. For example:
+
+    -t [ foo -x 3 --beep ]
+
+  will call the `foo` transform for each applicable file by calling:
+
+    foo(file, { x: 3, beep: true })
+

build/node_modules/browserify/bin/args.js

@@ -0,0 +1,269 @@
+var browserify = require('../');
+var path = require('path');
+var spawn = require('child_process').spawn;
+var parseShell = require('shell-quote').parse;
+var insertGlobals = require('insert-module-globals');
+var duplexer = require('duplexer2');
+var subarg = require('subarg');
+var glob = require('glob');
+var Readable = require('readable-stream').Readable;
+var xtend = require('xtend');
+
+module.exports = function (args, opts) {
+    var argv = subarg(args, {
+        'boolean': [
+            'deps', 'pack', 'ig', 'dg', 'im', 'd', 'list', 'builtins',
+            'commondir', 'bare', 'full-paths', 'bundle-external', 'bf',
+            'node'
+        ],
+        string: [ 's', 'r', 'u', 'x', 't', 'i', 'o', 'e', 'c', 'it' ],
+        alias: {
+            ig: [ 'insert-globals', 'fast' ],
+            dg: [ 'detect-globals', 'detectGlobals', 'dg' ],
+            bf: [ 'browser-field', 'browserField' ],
+            im: 'ignore-missing',
+            it: 'ignore-transform',
+            igv: 'insert-global-vars',
+            d: 'debug',
+            s: 'standalone',
+            noParse: [ 'noparse' ],
+            'full-paths': [ 'fullpaths', 'fullPaths' ],
+            r: 'require',
+            u: 'exclude',
+            x: 'external',
+            t: 'transform',
+            i: 'ignore',
+            o: 'outfile',
+            e: 'entry',
+            c: 'command',
+            bare: 'bear'
+        },
+        'default': {
+            ig: false,
+            im: false,
+            dg: true,
+            d: false,
+            builtins: true,
+            commondir: true,
+            'bundle-external': true,
+            bf: true,
+            dedupe: true,
+            node: false
+        }
+    });
+    
+    var entries = argv._.concat(argv.entry)
+    .filter(Boolean).map(function (entry) {
+        if (entry === '-') {
+            var s = process.stdin;
+            if (typeof s.read === 'function') return s;
+            // only needed for 0.8, remove at some point later:
+            var rs = Readable().wrap(s);
+            s.resume();
+            return rs;
+        }
+        return entry;
+    });
+    
+    if (argv.node) {
+        argv.bare = true;
+        argv.browserField = false;
+    }
+    if (argv.bare) {
+        argv.builtins = false;
+        argv.commondir = false;
+        if (argv.igv === undefined) {
+            argv.igv = '__filename,__dirname';
+        }
+    }
+    
+    if (argv.igv) {
+        var insertGlobalVars = {};
+        var wantedGlobalVars = argv.igv.split(',');
+        Object.keys(insertGlobals.vars).forEach(function (x) {
+            if (wantedGlobalVars.indexOf(x) === -1) {
+                insertGlobalVars[x] = undefined;
+            }
+        });
+    }
+    
+    var ignoreTransform = argv['ignore-transform'] || argv.it;
+    var b = browserify(xtend({
+        noParse: Array.isArray(argv.noParse) ? argv.noParse : [argv.noParse],
+        extensions: [].concat(argv.extension).filter(Boolean).map(function (extension) {
+            if (extension.charAt(0) != '.') { 
+                return '.' + extension;
+            } else {
+                return extension
+            }
+        }),
+        ignoreTransform: [].concat(ignoreTransform).filter(Boolean),
+        entries: entries,
+        fullPaths: argv['full-paths'],
+        builtins: argv.builtins === false ? false : undefined,
+        commondir: argv.commondir === false ? false : undefined,
+        bundleExternal: argv['bundle-external'],
+        basedir: argv.basedir,
+        browserField: argv.browserField,
+        transformKey: argv['transform-key'] ? ['browserify', argv['transform-key']] : undefined,
+        dedupe: argv['dedupe'],
+
+        detectGlobals: argv.detectGlobals,
+        insertGlobals: argv['insert-globals'] || argv.ig,
+        insertGlobalVars: insertGlobalVars,
+        ignoreMissing: argv['ignore-missing'] || argv.im,
+        debug: argv['debug'] || argv.d,
+        standalone: argv['standalone'] || argv.s
+    }, opts));
+    function error (msg) {
+        var e = new Error(msg);
+        process.nextTick(function () { b.emit('error', e) });
+    }
+    b.argv = argv;
+    [].concat(argv.p).concat(argv.plugin).filter(Boolean)
+        .forEach(function (p) {
+            var pf = p, pOpts = {};
+            if (typeof p === 'object') {
+                pf = p._.shift(), pOpts = p;
+            }
+            b.plugin(pf, pOpts);
+        })
+    ;
+    
+    [].concat(argv.ignore).filter(Boolean)
+        .forEach(function (i) {
+            b._pending ++;
+            glob(i, function (err, files) {
+                if (err) return b.emit('error', err);
+                if (files.length === 0) {
+                  b.ignore(i);
+                }
+                else {
+                  files.forEach(function (file) { b.ignore(file) });
+                }
+                if (--b._pending === 0) b.emit('_ready');
+            });
+        })
+    ;
+    
+    [].concat(argv.exclude).filter(Boolean)
+        .forEach(function (u) {
+            b.exclude(u);
+            
+            b._pending ++;
+            glob(u, function (err, files) {
+                if (err) return b.emit('error', err);
+                files.forEach(function (file) { b.exclude(file) });
+                if (--b._pending === 0) b.emit('_ready');
+            });
+        })
+    ;
+
+    [].concat(argv.require).filter(Boolean)
+        .forEach(function (r) {
+            var xs = splitOnColon(r);
+            b.require(xs[0], { expose: xs.length === 1 ? xs[0] : xs[1] })
+        })
+    ;
+    
+    // resolve any external files and add them to the bundle as externals
+    [].concat(argv.external).filter(Boolean)
+        .forEach(function (x) {
+            var xs = splitOnColon(x);
+            if (xs.length === 2) {
+                add(xs[0], { expose: xs[1] });
+            }
+            else if (/\*/.test(x)) {
+                b.external(x);
+                glob(x, function (err, files) {
+                    files.forEach(function (file) {
+                        add(file, {});
+                    });
+                });
+            }
+            else add(x, {});
+            
+            function add (x, opts) {
+                if (/^[\/.]/.test(x)) b.external(path.resolve(x), opts)
+                else b.external(x, opts)
+            }
+        })
+    ;
+    
+    [].concat(argv.transform)
+        .filter(Boolean)
+        .forEach(function (t) { addTransform(t) })
+    ;
+    
+    [].concat(argv.g).concat(argv['global-transform'])
+        .filter(Boolean)
+        .forEach(function (t) {
+            addTransform(t, { global: true });
+        })
+    ;
+    
+    function addTransform (t, opts) {
+        if (typeof t === 'string' || typeof t === 'function') {
+            b.transform(opts, t);
+        }
+        else if (t && typeof t === 'object') {
+            if (!t._[0] || typeof t._[0] !== 'string') {
+                return error(
+                    'expected first parameter to be a transform string'
+                );
+            }
+            if (opts) Object.keys(opts).forEach(function (key) {
+                t[key] = opts[key];
+            });
+            b.transform(t, t._.shift());
+        }
+        else error('unexpected transform of type ' + typeof t);
+    }
+    
+    [].concat(argv.command).filter(Boolean)
+        .forEach(function (c) {
+            var cmd = parseShell(c);
+            b.transform(function (file) {
+                var env = Object.keys(process.env).reduce(function (acc, key) {
+                    acc[key] = process.env[key];
+                    return acc;
+                }, {});
+                env.FILENAME = file;
+                var ps = spawn(cmd[0], cmd.slice(1), { env: env });
+                var error = '';
+                ps.stderr.on('data', function (buf) { error += buf });
+                
+                ps.on('exit', function (code) {
+                    if (code === 0) return;
+                    console.error([
+                        'error running source transform command: ' + c,
+                        error.split('\n').join('\n  '),
+                        ''
+                    ].join('\n'));
+                    process.exit(1);
+                });
+                return duplexer(ps.stdin, ps.stdout);
+            });
+        })
+    ;
+    
+    if (argv.standalone === '') {
+        error('--standalone requires an export name argument');
+        return b;
+    }
+    
+    return b;
+};
+
+function splitOnColon (f) {
+    var pos = f.lastIndexOf(':');
+    if (pos == -1) {
+        return [f]; // No colon
+    } else {
+        if ((/[a-zA-Z]:[\\/]/.test(f)) && (pos == 1)){
+            return [f]; // Windows path and colon is part of drive name
+        } else {
+            return [f.substr(0, pos), f.substr(pos + 1)];
+        }
+    }
+}

build/node_modules/browserify/bin/cmd.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+var fs = require('fs');
+var JSONStream = require('JSONStream');
+var through = require('through2');
+
+var b = require('./args')(process.argv.slice(2));
+process.stdout.on('error', process.exit);
+
+if ((b.argv._[0] === 'help' && b.argv._[1]) === 'advanced'
+|| (b.argv.h || b.argv.help) === 'advanced') {
+    return fs.createReadStream(__dirname + '/advanced.txt')
+        .pipe(process.stdout)
+        .on('close', function () { process.exit(1) })
+    ;
+}
+if (b.argv._[0] === 'help' || b.argv.h || b.argv.help
+|| (process.argv.length <= 2 && process.stdin.isTTY)) {
+    return fs.createReadStream(__dirname + '/usage.txt')
+        .pipe(process.stdout)
+        .on('close', function () { process.exit(1) })
+    ;
+}
+if (b.argv.version) {
+    return console.log(require('../package.json').version);
+}
+
+b.on('error', errorExit);
+
+if (b.argv.pack) {
+    process.stdin.pipe(b.pack()).pipe(process.stdout);
+    process.stdin.resume();
+    return;
+}
+
+if (b.argv.deps) {
+    var stringify = JSONStream.stringify();
+    stringify.pipe(process.stdout);
+    b.pipeline.get('deps').push(through.obj(
+        function (row, enc, next) { stringify.write(row); next() },
+        function () { stringify.end() }
+    ));
+    return b.bundle();
+}
+
+if (b.argv.list) {
+    b.pipeline.get('deps').push(through.obj(
+        function (row, enc, next) {
+            console.log(row.file || row.id);
+            next()
+        }
+    ));
+    return b.bundle();
+}
+
+var bundle = b.bundle();
+bundle.on('error', errorExit);
+bundle.on('end', successExit);
+
+var tmpfile;
+var outfile = b.argv.o || b.argv.outfile;
+if (outfile) {
+    // we'll output to a temp file within same filesystem, then atomically overwrite outfile once successful
+    tmpfile = outfile + ".tmp-browserify-" + Math.random().toFixed(20).slice(2)
+    bundle.pipe(fs.createWriteStream(tmpfile));
+}
+else {
+    bundle.pipe(process.stdout);
+}
+
+function errorExit(err) {
+    if (tmpfile) fs.unlink(tmpfile, function (err) {
+      if (err) /* no-op, we're already exiting unhappily… */;
+    });
+    if (err.stack) {
+        console.error(err.stack);
+    }
+    else {
+        console.error(String(err));
+    }
+    process.exit(1);
+}
+
+function successExit() {
+  if (tmpfile && outfile) fs.rename(tmpfile, outfile, function (err) {
+    if (err) errorExit(err);
+  });
+}

build/node_modules/browserify/bin/usage.txt

@@ -0,0 +1,34 @@
+Usage: browserify [entry files] {OPTIONS}
+
+Standard Options:
+
+    --outfile, -o  Write the browserify bundle to this file.
+                   If unspecified, browserify prints to stdout.
+
+    --require, -r  A module name or file to bundle.require()
+                   Optionally use a colon separator to set the target.
+
+      --entry, -e  An entry point of your app
+  
+     --ignore, -i  Replace a file with an empty stub. Files can be globs.
+ 
+    --exclude, -u  Omit a file from the output bundle. Files can be globs.
+
+   --external, -x  Reference a file from another bundle. Files can be globs.
+  
+  --transform, -t  Use a transform module on top-level files.
+ 
+    --command, -c  Use a transform command on top-level files.
+   
+  --standalone -s  Generate a UMD bundle for the supplied export name.
+                   This bundle works with other module systems and sets the name
+                   given as a window global if no module system is found.
+  
+       --debug -d  Enable source maps that allow you to debug your files
+                   separately.
+
+       --help, -h  Show this message
+
+For advanced options, type `browserify --help advanced`.
+
+Specify a parameter.

build/node_modules/browserify/code-of-conduct.md

@@ -0,0 +1,78 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at (any one or all of these):
+
+* substack@gmail.com
+
+All complaints will be reviewed and investigated and will result in a response
+that is deemed necessary and appropriate to the circumstances. The project team
+is obligated to maintain confidentiality with regard to the reporter of an
+incident. Further details of specific enforcement policies may be posted
+separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

build/node_modules/browserify/example/api/browser/bar.js

@@ -0,0 +1 @@
+module.exports = function (n) { return n * 3 };

build/node_modules/browserify/example/api/browser/foo.js

@@ -0,0 +1,5 @@
+var bar = require('./bar');
+
+module.exports = function (n) {
+    return n * bar(n);
+};

build/node_modules/browserify/example/api/browser/main.js

@@ -0,0 +1,2 @@
+var foo = require('./foo');
+console.log(foo(5));

build/node_modules/browserify/example/api/build.js

@@ -0,0 +1,4 @@
+var browserify = require('browserify');
+var b = browserify();
+b.add('./browser/main.js');
+b.bundle().pipe(process.stdout);

build/node_modules/browserify/example/multiple_bundles/beep.js

@@ -0,0 +1,2 @@
+var robot = require('./robot');
+console.log(robot('beep'));

build/node_modules/browserify/example/multiple_bundles/boop.js

@@ -0,0 +1,2 @@
+var robot = require('./robot');
+console.log(robot('boop'));

build/node_modules/browserify/example/multiple_bundles/build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+browserify -r ./robot.js > static/common.js
+browserify -x ./robot.js beep.js > static/beep.js
+browserify -x ./robot.js boop.js > static/boop.js

build/node_modules/browserify/example/multiple_bundles/robot.js

@@ -0,0 +1 @@
+module.exports = function (s) { return s.toUpperCase() + '!' };

build/node_modules/browserify/example/multiple_bundles/static/beep.html

@@ -0,0 +1,2 @@
+<script src="common.js"></script>
+<script src="beep.js"></script>

build/node_modules/browserify/example/multiple_bundles/static/boop.html

@@ -0,0 +1,2 @@
+<script src="common.js"></script>
+<script src="boop.js"></script>

build/node_modules/browserify/example/source_maps/build.js

@@ -0,0 +1,13 @@
+var browserify = require('../..'),
+    path = require('path'),
+    fs = require('fs'),
+    bundlePath = path.join(__dirname, 'js', 'build', 'bundle.js');
+
+browserify()
+    .require(require.resolve('./js/main.js'), { 
+    	entry: true, 
+    	debug: true  
+    })
+    .bundle()
+    .on('error', function (err) { console.error(err); })
+    .pipe(fs.createWriteStream(bundlePath));

build/node_modules/browserify/example/source_maps/build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+../../bin/cmd.js --debug -e ./js/main.js > js/build/bundle.js
+
+echo bundle was generated with source maps, you can now open index.html

build/node_modules/browserify/example/source_maps/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset=utf-8 />
+  <title></title>
+  <script type="text/javascript" src="./js/build/bundle.js"></script>
+</head>
+<body>
+  <p>Open your dev tools ;)</p>  
+</body>
+</html>

build/node_modules/browserify/example/source_maps/js/build/.npmignore

@@ -0,0 +1 @@
+!.gitignore

build/node_modules/browserify/example/source_maps/js/build/bundle.js

@@ -0,0 +1,28 @@
+;(function(e,t,n,r){function i(r){if(!n[r]){if(!t[r]){if(e)return e(r);throw new Error("Cannot find module '"+r+"'")}var s=n[r]={exports:{}};t[r][0](function(e){var n=t[r][1][e];return i(n?n:e)},s,s.exports)}return n[r].exports}for(var s=0;s<r.length;s++)i(r[s]);return i})(typeof require!=="undefined"&&require,{1:[function(require,module,exports){
+console.log('main line 1');
+var foo = require('./foo.js');
+
+foo();
+
+},{"./foo.js":2}],2:[function(require,module,exports){
+console.log('foo line 1');
+var bar = require('./wunder/bar');
+
+module.exports = function foo() {
+  console.log('hello from foo line 5');
+  bar();
+};
+
+},{"./wunder/bar":3}],3:[function(require,module,exports){
+console.log('bar line 1');
+'use strict';
+
+// this is a meaningless comment to add some lines
+
+module.exports = function bar() {
+  console.log('hello from bar line 7');
+};
+
+},{}]},{},[1])
+//@ sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiIiwic291cmNlcyI6WyIvVXNlcnMvdGhsb3JlbnovZGV2L2pzL3Byb2plY3RzL2ZvcmtzL25vZGUtYnJvd3NlcmlmeS9leGFtcGxlL3NvdXJjZV9tYXBzL2pzL21haW4uanMiLCIvVXNlcnMvdGhsb3JlbnovZGV2L2pzL3Byb2plY3RzL2ZvcmtzL25vZGUtYnJvd3NlcmlmeS9leGFtcGxlL3NvdXJjZV9tYXBzL2pzL2Zvby5qcyIsIi9Vc2Vycy90aGxvcmVuei9kZXYvanMvcHJvamVjdHMvZm9ya3Mvbm9kZS1icm93c2VyaWZ5L2V4YW1wbGUvc291cmNlX21hcHMvanMvd3VuZGVyL2Jhci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTs7QUNKQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOztBQ1BBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQSIsInNvdXJjZVJvb3QiOiJmaWxlOi8vbG9jYWxob3N0Iiwic291cmNlQ29udGVudCI6WyJjb25zb2xlLmxvZygnbWFpbiBsaW5lIDEnKTtcbnZhciBmb28gPSByZXF1aXJlKCcuL2Zvby5qcycpO1xuXG5mb28oKTtcbiIsImNvbnNvbGUubG9nKCdmb28gbGluZSAxJyk7XG52YXIgYmFyID0gcmVxdWlyZSgnLi93dW5kZXIvYmFyJyk7XG5cbm1vZHVsZS5leHBvcnRzID0gZnVuY3Rpb24gZm9vKCkge1xuICBjb25zb2xlLmxvZygnaGVsbG8gZnJvbSBmb28gbGluZSA1Jyk7XG4gIGJhcigpO1xufTtcbiIsImNvbnNvbGUubG9nKCdiYXIgbGluZSAxJyk7XG4ndXNlIHN0cmljdCc7XG5cbi8vIHRoaXMgaXMgYSBtZWFuaW5nbGVzcyBjb21tZW50IHRvIGFkZCBzb21lIGxpbmVzXG5cbm1vZHVsZS5leHBvcnRzID0gZnVuY3Rpb24gYmFyKCkge1xuICBjb25zb2xlLmxvZygnaGVsbG8gZnJvbSBiYXIgbGluZSA3Jyk7XG59O1xuIl19
+;

build/node_modules/browserify/example/source_maps/js/foo.js

@@ -0,0 +1,7 @@
+console.log('foo line 1');
+var bar = require('./wunder/bar');
+
+module.exports = function foo() {
+  console.log('hello from foo line 5');
+  bar();
+};

build/node_modules/browserify/example/source_maps/js/main.js

@@ -0,0 +1,4 @@
+console.log('main line 1');
+var foo = require('./foo.js');
+
+foo();

build/node_modules/browserify/example/source_maps/js/wunder/bar.js

@@ -0,0 +1,8 @@
+console.log('bar line 1');
+'use strict';
+
+// this is a meaningless comment to add some lines
+
+module.exports = function bar() {
+  console.log('hello from bar line 7');
+};

build/node_modules/browserify/index.js

@@ -0,0 +1,807 @@
+var mdeps = require('module-deps');
+var depsSort = require('deps-sort');
+var bpack = require('browser-pack');
+var insertGlobals = require('insert-module-globals');
+var syntaxError = require('syntax-error');
+
+var builtins = require('./lib/builtins.js');
+
+var splicer = require('labeled-stream-splicer');
+var through = require('through2');
+var concat = require('concat-stream');
+
+var inherits = require('inherits');
+var EventEmitter = require('events').EventEmitter;
+var xtend = require('xtend');
+var isArray = Array.isArray;
+var defined = require('defined');
+var has = require('has');
+var sanitize = require('htmlescape').sanitize;
+var shasum = require('shasum');
+
+var bresolve = require('browser-resolve');
+var resolve = require('resolve');
+
+var readonly = require('read-only-stream');
+
+module.exports = Browserify;
+inherits(Browserify, EventEmitter);
+
+var fs = require('fs');
+var path = require('path');
+var relativePath = require('cached-path-relative')
+var paths = {
+    empty: path.join(__dirname, 'lib/_empty.js')
+};
+
+function Browserify (files, opts) {
+    var self = this;
+    if (!(this instanceof Browserify)) return new Browserify(files, opts);
+    if (!opts) opts = {};
+    
+    if (typeof files === 'string' || isArray(files) || isStream(files)) {
+        opts = xtend(opts, { entries: [].concat(opts.entries || [], files) });
+    }
+    else opts = xtend(files, opts);
+    
+    self._options = opts;
+    if (opts.noparse) opts.noParse = opts.noparse;
+    
+    if (opts.basedir !== undefined && typeof opts.basedir !== 'string') {
+        throw new Error('opts.basedir must be either undefined or a string.');
+    }
+
+    opts.dedupe = opts.dedupe === false ? false : true;
+
+    self._external = [];
+    self._exclude = [];
+    self._ignore = [];
+    self._expose = {};
+    self._hashes = {};
+    self._pending = 0;
+    self._transformOrder = 0;
+    self._transformPending = 0;
+    self._transforms = [];
+    self._entryOrder = 0;
+    self._ticked = false;
+    self._bresolve = opts.browserField === false
+        ? function (id, opts, cb) {
+            if (!opts.basedir) opts.basedir = path.dirname(opts.filename)
+            resolve(id, opts, cb)
+        }
+        : bresolve
+    ;
+    self._syntaxCache = {};
+
+    var ignoreTransform = [].concat(opts.ignoreTransform).filter(Boolean);
+    self._filterTransform = function (tr) {
+        if (isArray(tr)) {
+            return ignoreTransform.indexOf(tr[0]) === -1;
+        }
+        return ignoreTransform.indexOf(tr) === -1;
+    };
+
+    self.pipeline = self._createPipeline(opts);
+    
+    [].concat(opts.transform).filter(Boolean).filter(self._filterTransform)
+    .forEach(function (tr) {
+        self.transform(tr);
+    });
+    
+    [].concat(opts.entries).filter(Boolean).forEach(function (file) {
+        self.add(file, { basedir: opts.basedir });
+    });
+    
+    [].concat(opts.require).filter(Boolean).forEach(function (file) {
+        self.require(file, { basedir: opts.basedir });
+    });
+    
+    [].concat(opts.plugin).filter(Boolean).forEach(function (p) {
+        self.plugin(p, { basedir: opts.basedir });
+    });
+}
+
+Browserify.prototype.require = function (file, opts) {
+    var self = this;
+    if (isArray(file)) {
+        file.forEach(function (x) {
+            if (typeof x === 'object') {
+                self.require(x.file, xtend(opts, x));
+            }
+            else self.require(x, opts);
+        });
+        return this;
+    }
+    
+    if (!opts) opts = {};
+    var basedir = defined(opts.basedir, self._options.basedir, process.cwd());
+    var expose = opts.expose;
+    if (file === expose && /^[\.]/.test(expose)) {
+        expose = '/' + relativePath(basedir, expose);
+        expose = expose.replace(/\\/g, '/');
+    }
+    if (expose === undefined && this._options.exposeAll) {
+        expose = true;
+    }
+    if (expose === true) {
+        expose = '/' + relativePath(basedir, file);
+        expose = expose.replace(/\\/g, '/');
+    }
+    
+    if (isStream(file)) {
+        self._pending ++;
+        var order = self._entryOrder ++;
+        file.pipe(concat(function (buf) {
+            var filename = opts.file || file.file || path.join(
+                basedir,
+                '_stream_' + order + '.js'
+            );
+            var id = file.id || expose || filename;
+            if (expose || opts.entry === false) {
+                self._expose[id] = filename;
+            }
+            if (!opts.entry && self._options.exports === undefined) {
+                self._bpack.hasExports = true;
+            }
+            var rec = {
+                source: buf.toString('utf8'),
+                entry: defined(opts.entry, false),
+                file: filename,
+                id: id
+            };
+            if (rec.entry) rec.order = order;
+            if (rec.transform === false) rec.transform = false;
+            self.pipeline.write(rec);
+            
+            if (-- self._pending === 0) self.emit('_ready');
+        }));
+        return this;
+    }
+    
+    var row;
+    if (typeof file === 'object') {
+        row = xtend(file, opts);
+    }
+    else if (!opts.entry && isExternalModule(file)) {
+        // external module or builtin
+        row = xtend(opts, { id: expose || file, file: file });
+    }
+    else {
+        row = xtend(opts, { file: path.resolve(basedir, file) });
+    }
+    
+    if (!row.id) {
+        row.id = expose || row.file;
+    }
+    if (expose || !row.entry) {
+        // Make this available to mdeps so that it can assign the value when it
+        // resolves the pathname.
+        row.expose = row.id;
+    }
+    
+    if (opts.external) return self.external(file, opts);
+    if (row.entry === undefined) row.entry = false;
+    
+    if (!row.entry && self._options.exports === undefined) {
+        self._bpack.hasExports = true;
+    }
+    
+    if (row.entry) row.order = self._entryOrder ++;
+    
+    if (opts.transform === false) row.transform = false;
+    self.pipeline.write(row);
+    return self;
+};
+
+Browserify.prototype.add = function (file, opts) {
+    var self = this;
+    if (!opts) opts = {};
+    if (isArray(file)) {
+        file.forEach(function (x) { self.add(x, opts) });
+        return this;
+    }
+    return this.require(file, xtend({ entry: true, expose: false }, opts));
+};
+
+Browserify.prototype.external = function (file, opts) {
+    var self = this;
+    if (isArray(file)) {
+        file.forEach(function (f) {
+            if (typeof f === 'object') {
+                self.external(f, xtend(opts, f));
+            }
+            else self.external(f, opts)
+        });
+        return this;
+    }
+    if (file && typeof file === 'object' && typeof file.bundle === 'function') {
+        var b = file;
+        self._pending ++;
+
+        var bdeps = {};
+        var blabels = {};
+
+        b.on('label', function (prev, id) {
+            self._external.push(id);
+
+            if (prev !== id) {
+                blabels[prev] = id;
+                self._external.push(prev);
+            }
+        });
+
+        b.pipeline.get('deps').push(through.obj(function (row, enc, next) {
+            bdeps = xtend(bdeps, row.deps);
+            this.push(row);
+            next();
+        }));
+
+        self.on('dep', function (row) {
+            Object.keys(row.deps).forEach(function (key) {
+                var prev = bdeps[key];
+                if (prev) {
+                    var id = blabels[prev];
+                    if (id) {
+                        row.indexDeps[key] = id;
+                    }
+                }
+            });
+        });
+
+        b.pipeline.get('label').once('end', function () {
+            if (-- self._pending === 0) self.emit('_ready');
+        });
+        return this;
+    }
+    
+    if (!opts) opts = {};
+    var basedir = defined(opts.basedir, process.cwd());
+    this._external.push(file);
+    this._external.push('/' + relativePath(basedir, file));
+    return this;
+};
+
+Browserify.prototype.exclude = function (file, opts) {
+    if (!opts) opts = {};
+    var basedir = defined(opts.basedir, process.cwd());
+    this._exclude.push(file);
+    this._exclude.push('/' + relativePath(basedir, file));
+    return this;
+};
+
+Browserify.prototype.ignore = function (file, opts) {
+    if (!opts) opts = {};
+    var basedir = defined(opts.basedir, process.cwd());
+
+    // Handle relative paths
+    if (file[0] === '.') {
+        this._ignore.push(path.resolve(basedir, file));
+    }
+    else {
+        this._ignore.push(file);
+    }
+    return this;
+};
+
+Browserify.prototype.transform = function (tr, opts) {
+    var self = this;
+    if (typeof opts === 'function' || typeof opts === 'string') {
+        tr = [ opts, tr ];
+    }
+    if (isArray(tr)) {
+        opts = tr[1];
+        tr = tr[0];
+    }
+    
+    //if the bundler is ignoring this transform
+    if (typeof tr === 'string' && !self._filterTransform(tr)) {
+        return this;
+    }
+
+    function resolved () {
+      self._transforms[order] = rec;
+      -- self._pending;
+      if (-- self._transformPending === 0) {
+          self._transforms.forEach(function (transform) {
+            self.pipeline.write(transform);
+          });
+
+          if (self._pending === 0) {
+            self.emit('_ready');
+          }
+      }
+    }
+    
+    if (!opts) opts = {};
+    opts._flags = '_flags' in opts ? opts._flags : self._options;
+    
+    var basedir = defined(opts.basedir, this._options.basedir, process.cwd());
+    var order = self._transformOrder ++;
+    self._pending ++;
+    self._transformPending ++;
+
+    var rec = {
+        transform: tr,
+        options: opts,
+        global: opts.global
+    };
+
+    if (typeof tr === 'string') {
+        var topts = {
+            basedir: basedir,
+            paths: (self._options.paths || []).map(function (p) {
+                return path.resolve(basedir, p);
+            })
+        };
+        resolve(tr, topts, function (err, res) {
+            if (err) return self.emit('error', err);
+            rec.transform = res;
+            resolved();
+        });
+    }
+    else process.nextTick(resolved);
+    return this;
+};
+
+Browserify.prototype.plugin = function (p, opts) {
+    if (isArray(p)) {
+        opts = p[1];
+        p = p[0];
+    }
+    if (!opts) opts = {};
+    var basedir = defined(opts.basedir, this._options.basedir, process.cwd());
+    if (typeof p === 'function') {
+        p(this, opts);
+    }
+    else {
+        var pfile = resolve.sync(String(p), { basedir: basedir })
+        var f = require(pfile);
+        if (typeof f !== 'function') {
+            throw new Error('plugin ' + p + ' should export a function');
+        }
+        f(this, opts);
+    }
+    return this;
+};
+
+Browserify.prototype._createPipeline = function (opts) {
+    var self = this;
+    if (!opts) opts = {};
+    this._mdeps = this._createDeps(opts);
+    this._mdeps.on('file', function (file, id) {
+        pipeline.emit('file', file, id);
+        self.emit('file', file, id);
+    });
+    this._mdeps.on('package', function (pkg) {
+        pipeline.emit('package', pkg);
+        self.emit('package', pkg);
+    });
+    this._mdeps.on('transform', function (tr, file) {
+        pipeline.emit('transform', tr, file);
+        self.emit('transform', tr, file);
+    });
+    
+    var dopts = {
+        index: !opts.fullPaths && !opts.exposeAll,
+        dedupe: opts.dedupe,
+        expose: this._expose
+    };
+    this._bpack = bpack(xtend(opts, { raw: true }));
+    
+    var pipeline = splicer.obj([
+        'record', [ this._recorder() ],
+        'deps', [ this._mdeps ],
+        'json', [ this._json() ],
+        'unbom', [ this._unbom() ],
+        'unshebang', [ this._unshebang() ],
+        'syntax', [ this._syntax() ],
+        'sort', [ depsSort(dopts) ],
+        'dedupe', [ this._dedupe() ],
+        'label', [ this._label(opts) ],
+        'emit-deps', [ this._emitDeps() ],
+        'debug', [ this._debug(opts) ],
+        'pack', [ this._bpack ],
+        'wrap', []
+    ]);
+    if (opts.exposeAll) {
+        var basedir = defined(opts.basedir, process.cwd());
+        pipeline.get('deps').push(through.obj(function (row, enc, next) {
+            if (self._external.indexOf(row.id) >= 0) return next();
+            if (self._external.indexOf(row.file) >= 0) return next();
+            
+            if (isAbsolutePath(row.id)) {
+                row.id = '/' + relativePath(basedir, row.file);
+            }
+            Object.keys(row.deps || {}).forEach(function (key) {
+                row.deps[key] = '/' + relativePath(basedir, row.deps[key]);
+            });
+            this.push(row);
+            next();
+        }));
+    }
+    return pipeline;
+};
+
+Browserify.prototype._createDeps = function (opts) {
+    var self = this;
+    var mopts = xtend(opts);
+    var basedir = defined(opts.basedir, process.cwd());
+
+    // Let mdeps populate these values since it will be resolving file paths
+    // anyway.
+    mopts.expose = this._expose;
+    mopts.extensions = [ '.js', '.json' ].concat(mopts.extensions || []);
+    self._extensions = mopts.extensions;
+
+    mopts.transform = [];
+    mopts.transformKey = defined(opts.transformKey, [ 'browserify', 'transform' ]);
+    mopts.postFilter = function (id, file, pkg) {
+        if (opts.postFilter && !opts.postFilter(id, file, pkg)) return false;
+        if (self._external.indexOf(file) >= 0) return false;
+        if (self._exclude.indexOf(file) >= 0) return false;
+
+        //filter transforms on module dependencies
+        if (pkg && pkg.browserify && pkg.browserify.transform) {
+            //In edge cases it may be a string
+            pkg.browserify.transform = [].concat(pkg.browserify.transform)
+                    .filter(Boolean)
+                    .filter(self._filterTransform);
+        }
+        return true;
+    };
+    mopts.filter = function (id) {
+        if (opts.filter && !opts.filter(id)) return false;
+        if (self._external.indexOf(id) >= 0) return false;
+        if (self._exclude.indexOf(id) >= 0) return false;
+        if (opts.bundleExternal === false && isExternalModule(id)) {
+            return false;
+        }
+        return true;
+    };
+    mopts.resolve = function (id, parent, cb) {
+        if (self._ignore.indexOf(id) >= 0) return cb(null, paths.empty, {});
+        
+        self._bresolve(id, parent, function (err, file, pkg) {
+            if (file && self._ignore.indexOf(file) >= 0) {
+                return cb(null, paths.empty, {});
+            }
+            if (file && self._ignore.length) {
+                var nm = file.split('/node_modules/')[1];
+                if (nm) {
+                    nm = nm.split('/')[0];
+                    if (self._ignore.indexOf(nm) >= 0) {
+                        return cb(null, paths.empty, {});
+                    }
+                }
+            }
+            
+            if (file) {
+                var ex = '/' + relativePath(basedir, file);
+                if (self._external.indexOf(ex) >= 0) {
+                    return cb(null, ex);
+                }
+                if (self._exclude.indexOf(ex) >= 0) {
+                    return cb(null, ex);
+                }
+                if (self._ignore.indexOf(ex) >= 0) {
+                    return cb(null, paths.empty, {});
+                }
+            }
+            if (err) cb(err, file, pkg)
+            else if (file) fs.realpath(file, function (err, res) {
+                cb(err, res, pkg, file);
+            });
+            else cb(err, null, pkg)
+        });
+    };
+    
+    if (opts.builtins === false) {
+        mopts.modules = {};
+        self._exclude.push.apply(self._exclude, Object.keys(builtins));
+    }
+    else if (opts.builtins && isArray(opts.builtins)) {
+        mopts.modules = {};
+        opts.builtins.forEach(function (key) {
+            mopts.modules[key] = builtins[key];
+        });
+    }
+    else if (opts.builtins && typeof opts.builtins === 'object') {
+        mopts.modules = opts.builtins;
+    }
+    else mopts.modules = xtend(builtins);
+    
+    Object.keys(builtins).forEach(function (key) {
+        if (!has(mopts.modules, key)) self._exclude.push(key);
+    });
+    
+    mopts.globalTransform = [];
+    if (!this._bundled) {
+        this.once('bundle', function () {
+            self.pipeline.write({
+                transform: globalTr,
+                global: true,
+                options: {}
+            });
+        });
+    }
+    
+    var no = [].concat(opts.noParse).filter(Boolean);
+    var absno = no.filter(function(x) {
+        return typeof x === 'string';
+    }).map(function (x) {
+        return path.resolve(basedir, x);
+    });
+    
+    function globalTr (file) {
+        if (opts.detectGlobals === false) return through();
+        
+        if (opts.noParse === true) return through();
+        if (no.indexOf(file) >= 0) return through();
+        if (absno.indexOf(file) >= 0) return through();
+        
+        var parts = file.split('/node_modules/');
+        for (var i = 0; i < no.length; i++) {
+            if (typeof no[i] === 'function' && no[i](file)) {
+                return through();
+            }
+            else if (no[i] === parts[parts.length-1].split('/')[0]) {
+                return through();
+            }
+            else if (no[i] === parts[parts.length-1]) {
+                return through();
+            }
+        }
+        
+        var vars = xtend({
+            process: function () { return "require('_process')" },
+        }, opts.insertGlobalVars);
+        
+        if (opts.bundleExternal === false) {
+            vars.process = undefined;
+            vars.buffer = undefined;
+        }
+        
+        return insertGlobals(file, xtend(opts, {
+            debug: opts.debug,
+            always: opts.insertGlobals,
+            basedir: opts.commondir === false
+                ? '/'
+                : opts.basedir || process.cwd()
+            ,
+            vars: vars
+        }));
+    }
+    return mdeps(mopts);
+};
+
+Browserify.prototype._recorder = function (opts) {
+    var self = this;
+    var ended = false;
+    this._recorded = [];
+    
+    if (!this._ticked) {
+        process.nextTick(function () {
+            self._ticked = true;
+            self._recorded.forEach(function (row) {
+                stream.push(row);
+            });
+            if (ended) stream.push(null);
+        });
+    }
+    
+    var stream = through.obj(write, end);
+    return stream;
+    
+    function write (row, enc, next) {
+        self._recorded.push(row);
+        if (self._ticked) this.push(row);
+        next();
+    }
+    function end () {
+        ended = true;
+        if (self._ticked) this.push(null);
+    }
+};
+
+Browserify.prototype._json = function () {
+    return through.obj(function (row, enc, next) {
+        if (/\.json$/.test(row.file)) {
+            row.source = 'module.exports=' + sanitize(row.source);
+        }
+        this.push(row);
+        next();
+    });
+};
+
+Browserify.prototype._unbom = function () {
+    return through.obj(function (row, enc, next) {
+        if (/^\ufeff/.test(row.source)) {
+            row.source = row.source.replace(/^\ufeff/, '');
+        }
+        this.push(row);
+        next();
+    });
+};
+
+Browserify.prototype._unshebang = function () {
+    return through.obj(function (row, enc, next) {
+        if (/^#!/.test(row.source)) {
+            row.source = row.source.replace(/^#![^\n]*\n/, '');
+        }
+        this.push(row);
+        next();
+    });
+};
+
+Browserify.prototype._syntax = function () {
+    var self = this;
+    return through.obj(function (row, enc, next) {
+        var h = shasum(row.source);
+        if (typeof self._syntaxCache[h] === 'undefined') {
+            var err = syntaxError(row.source, row.file || row.id);
+            if (err) return this.emit('error', err);
+            self._syntaxCache[h] = true;
+        }
+        this.push(row);
+        next();
+    });
+};
+
+Browserify.prototype._dedupe = function () {
+    return through.obj(function (row, enc, next) {
+        if (!row.dedupeIndex && row.dedupe) {
+            row.source = 'arguments[4]['
+                + JSON.stringify(row.dedupe)
+                + '][0].apply(exports,arguments)'
+            ;
+            row.nomap = true;
+        }
+        else if (row.dedupeIndex) {
+            row.source = 'arguments[4]['
+                + JSON.stringify(row.dedupeIndex)
+                + '][0].apply(exports,arguments)'
+            ;
+            row.nomap = true;
+        }
+        if (row.dedupeIndex && row.indexDeps) {
+            row.indexDeps.dup = row.dedupeIndex;
+        }
+        this.push(row);
+        next();
+    });
+};
+
+Browserify.prototype._label = function (opts) {
+    var self = this;
+    var basedir = defined(opts.basedir, process.cwd());
+    
+    return through.obj(function (row, enc, next) {
+        var prev = row.id;
+
+        if (self._external.indexOf(row.id) >= 0) return next();
+        if (self._external.indexOf('/' + relativePath(basedir, row.id)) >= 0) {
+            return next();
+        }
+        if (self._external.indexOf(row.file) >= 0) return next();
+        
+        if (row.index) row.id = row.index;
+        
+        self.emit('label', prev, row.id);
+        if (row.indexDeps) row.deps = row.indexDeps || {};
+        
+        Object.keys(row.deps).forEach(function (key) {
+            if (self._expose[key]) {
+                row.deps[key] = key;
+                return;
+            }
+
+            var afile = path.resolve(path.dirname(row.file), key);
+            var rfile = '/' + relativePath(basedir, afile);
+            if (self._external.indexOf(rfile) >= 0) {
+                row.deps[key] = rfile;
+            }
+            if (self._external.indexOf(afile) >= 0) {
+                row.deps[key] = rfile;
+            }
+            if (self._external.indexOf(key) >= 0) {
+                row.deps[key] = key;
+                return;
+            }
+            
+            for (var i = 0; i < self._extensions.length; i++) {
+                var ex = self._extensions[i];
+                if (self._external.indexOf(rfile + ex) >= 0) {
+                    row.deps[key] = rfile + ex;
+                    break;
+                }
+            }
+        });
+        
+        if (row.entry || row.expose) {
+            self._bpack.standaloneModule = row.id;
+        }
+        this.push(row);
+        next();
+    });
+};
+
+Browserify.prototype._emitDeps = function () {
+    var self = this;
+    return through.obj(function (row, enc, next) {
+        self.emit('dep', row);
+        this.push(row);
+        next();
+    })
+};
+
+Browserify.prototype._debug = function (opts) {
+    var basedir = defined(opts.basedir, process.cwd());
+    return through.obj(function (row, enc, next) {
+        if (opts.debug) {
+            row.sourceRoot = 'file://localhost';
+            row.sourceFile = relativePath(basedir, row.file)
+                .replace(/\\/g, '/');
+        }
+        this.push(row);
+        next();
+    });
+};
+
+Browserify.prototype.reset = function (opts) {
+    if (!opts) opts = {};
+    var hadExports = this._bpack.hasExports;
+    this.pipeline = this._createPipeline(xtend(opts, this._options));
+    this._bpack.hasExports = hadExports;
+    this._entryOrder = 0;
+    this._bundled = false;
+    this.emit('reset');
+};
+
+Browserify.prototype.bundle = function (cb) {
+    var self = this;
+    if (cb && typeof cb === 'object') {
+        throw new Error(
+            'bundle() no longer accepts option arguments.\n'
+            + 'Move all option arguments to the browserify() constructor.'
+        );
+    }
+    if (this._bundled) {
+        var recorded = this._recorded;
+        this.reset();
+        recorded.forEach(function (x) {
+            self.pipeline.write(x);
+        });
+    }
+    var output = readonly(this.pipeline);
+    if (cb) {
+        output.on('error', cb);
+        output.pipe(concat(function (body) {
+            cb(null, body);
+        }));
+    }
+
+    function ready () {
+        self.emit('bundle', output);
+        self.pipeline.end();
+    }
+
+    if (this._pending === 0) ready();
+    else this.once('_ready', ready);
+
+    this._bundled = true;
+    return output;
+};
+
+function isStream (s) { return s && typeof s.pipe === 'function' }
+function isAbsolutePath (file) {
+    var regexp = process.platform === 'win32' ?
+        /^\w:/ :
+        /^\//;
+    return regexp.test(file);
+}
+function isExternalModule (file) {
+    var regexp = process.platform === 'win32' ?
+        /^(\.|\w:)/ :
+        /^[\/.]/;
+    return !regexp.test(file);
+}

build/node_modules/browserify/lib/builtins.js

@@ -0,0 +1,38 @@
+exports.assert = require.resolve('assert/');
+exports.buffer = require.resolve('buffer/');
+exports.child_process = require.resolve('./_empty.js');
+exports.cluster = require.resolve('./_empty.js');
+exports.console = require.resolve('console-browserify');
+exports.constants = require.resolve('constants-browserify');
+exports.crypto = require.resolve('crypto-browserify');
+exports.dgram = require.resolve('./_empty.js');
+exports.dns = require.resolve('./_empty.js');
+exports.domain = require.resolve('domain-browser');
+exports.events = require.resolve('events/');
+exports.fs = require.resolve('./_empty.js');
+exports.http = require.resolve('stream-http');
+exports.https = require.resolve('https-browserify');
+exports.module = require.resolve('./_empty.js');
+exports.net = require.resolve('./_empty.js');
+exports.os = require.resolve('os-browserify/browser.js');
+exports.path = require.resolve('path-browserify');
+exports.punycode = require.resolve('punycode/');
+exports.querystring = require.resolve('querystring-es3/');
+exports.readline = require.resolve('./_empty.js');
+exports.repl = require.resolve('./_empty.js');
+exports.stream = require.resolve('stream-browserify');
+exports._stream_duplex = require.resolve('readable-stream/duplex.js');
+exports._stream_passthrough = require.resolve('readable-stream/passthrough.js');
+exports._stream_readable = require.resolve('readable-stream/readable.js');
+exports._stream_transform = require.resolve('readable-stream/transform.js');
+exports._stream_writable = require.resolve('readable-stream/writable.js');
+exports.string_decoder = require.resolve('string_decoder/');
+exports.sys = require.resolve('util/util.js');
+exports.timers = require.resolve('timers-browserify');
+exports.tls = require.resolve('./_empty.js');
+exports.tty = require.resolve('tty-browserify');
+exports.url = require.resolve('url/');
+exports.util = require.resolve('util/util.js');
+exports.vm = require.resolve('vm-browserify');
+exports.zlib = require.resolve('browserify-zlib');
+exports._process = require.resolve('process/browser');

build/node_modules/browserify/node_modules/concat-stream/LICENSE

@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2013 Max Ogden
+
+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.

build/node_modules/browserify/node_modules/concat-stream/index.js

@@ -0,0 +1,143 @@
+var Writable = require('readable-stream').Writable
+var inherits = require('inherits')
+
+if (typeof Uint8Array === 'undefined') {
+  var U8 = require('typedarray').Uint8Array
+} else {
+  var U8 = Uint8Array
+}
+
+function ConcatStream(opts, cb) {
+  if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb)
+
+  if (typeof opts === 'function') {
+    cb = opts
+    opts = {}
+  }
+  if (!opts) opts = {}
+
+  var encoding = opts.encoding
+  var shouldInferEncoding = false
+
+  if (!encoding) {
+    shouldInferEncoding = true
+  } else {
+    encoding =  String(encoding).toLowerCase()
+    if (encoding === 'u8' || encoding === 'uint8') {
+      encoding = 'uint8array'
+    }
+  }
+
+  Writable.call(this, { objectMode: true })
+
+  this.encoding = encoding
+  this.shouldInferEncoding = shouldInferEncoding
+
+  if (cb) this.on('finish', function () { cb(this.getBody()) })
+  this.body = []
+}
+
+module.exports = ConcatStream
+inherits(ConcatStream, Writable)
+
+ConcatStream.prototype._write = function(chunk, enc, next) {
+  this.body.push(chunk)
+  next()
+}
+
+ConcatStream.prototype.inferEncoding = function (buff) {
+  var firstBuffer = buff === undefined ? this.body[0] : buff;
+  if (Buffer.isBuffer(firstBuffer)) return 'buffer'
+  if (typeof Uint8Array !== 'undefined' && firstBuffer instanceof Uint8Array) return 'uint8array'
+  if (Array.isArray(firstBuffer)) return 'array'
+  if (typeof firstBuffer === 'string') return 'string'
+  if (Object.prototype.toString.call(firstBuffer) === "[object Object]") return 'object'
+  return 'buffer'
+}
+
+ConcatStream.prototype.getBody = function () {
+  if (!this.encoding && this.body.length === 0) return []
+  if (this.shouldInferEncoding) this.encoding = this.inferEncoding()
+  if (this.encoding === 'array') return arrayConcat(this.body)
+  if (this.encoding === 'string') return stringConcat(this.body)
+  if (this.encoding === 'buffer') return bufferConcat(this.body)
+  if (this.encoding === 'uint8array') return u8Concat(this.body)
+  return this.body
+}
+
+var isArray = Array.isArray || function (arr) {
+  return Object.prototype.toString.call(arr) == '[object Array]'
+}
+
+function isArrayish (arr) {
+  return /Array\]$/.test(Object.prototype.toString.call(arr))
+}
+
+function isBufferish (p) {
+  return typeof p === 'string' || isArrayish(p) || (p && typeof p.subarray === 'function')
+}
+
+function stringConcat (parts) {
+  var strings = []
+  var needsToString = false
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i]
+    if (typeof p === 'string') {
+      strings.push(p)
+    } else if (Buffer.isBuffer(p)) {
+      strings.push(p)
+    } else if (isBufferish(p)) {
+      strings.push(new Buffer(p))
+    } else {
+      strings.push(new Buffer(String(p)))
+    }
+  }
+  if (Buffer.isBuffer(parts[0])) {
+    strings = Buffer.concat(strings)
+    strings = strings.toString('utf8')
+  } else {
+    strings = strings.join('')
+  }
+  return strings
+}
+
+function bufferConcat (parts) {
+  var bufs = []
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i]
+    if (Buffer.isBuffer(p)) {
+      bufs.push(p)
+    } else if (isBufferish(p)) {
+      bufs.push(new Buffer(p))
+    } else {
+      bufs.push(new Buffer(String(p)))
+    }
+  }
+  return Buffer.concat(bufs)
+}
+
+function arrayConcat (parts) {
+  var res = []
+  for (var i = 0; i < parts.length; i++) {
+    res.push.apply(res, parts[i])
+  }
+  return res
+}
+
+function u8Concat (parts) {
+  var len = 0
+  for (var i = 0; i < parts.length; i++) {
+    if (typeof parts[i] === 'string') {
+      parts[i] = new Buffer(parts[i])
+    }
+    len += parts[i].length
+  }
+  var u8 = new U8(len)
+  for (var i = 0, offset = 0; i < parts.length; i++) {
+    var part = parts[i]
+    for (var j = 0; j < part.length; j++) {
+      u8[offset++] = part[j]
+    }
+  }
+  return u8
+}

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/.npmignore

@@ -0,0 +1,5 @@
+build/
+test/
+examples/
+fs.js
+zlib.js

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/.travis.yml

@@ -0,0 +1,52 @@
+sudo: false
+language: node_js
+before_install:
+  - npm install -g npm@2
+  - npm install -g npm
+notifications:
+  email: false
+matrix:
+  fast_finish: true
+  allow_failures:
+    - env: TASK=browser BROWSER_NAME=ipad BROWSER_VERSION="6.0..latest"
+    - env: TASK=browser BROWSER_NAME=iphone BROWSER_VERSION="6.0..latest"
+  include:
+  - node_js: '0.8'
+    env: TASK=test
+  - node_js: '0.10'
+    env: TASK=test
+  - node_js: '0.11'
+    env: TASK=test
+  - node_js: '0.12'
+    env: TASK=test
+  - node_js: 1
+    env: TASK=test
+  - node_js: 2
+    env: TASK=test
+  - node_js: 3
+    env: TASK=test
+  - node_js: 4
+    env: TASK=test
+  - node_js: 5
+    env: TASK=test
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=android BROWSER_VERSION="4.0..latest"
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=ie BROWSER_VERSION="9..latest"
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=opera BROWSER_VERSION="11..latest"
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=chrome BROWSER_VERSION="-3..latest"
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=firefox BROWSER_VERSION="-3..latest"
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=ipad BROWSER_VERSION="6.0..latest"
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=iphone BROWSER_VERSION="6.0..latest"
+  - node_js: 5
+    env: TASK=browser BROWSER_NAME=safari BROWSER_VERSION="5..latest"
+script: "npm run $TASK"
+env:
+  global:
+  - secure: rE2Vvo7vnjabYNULNyLFxOyt98BoJexDqsiOnfiD6kLYYsiQGfr/sbZkPMOFm9qfQG7pjqx+zZWZjGSswhTt+626C0t/njXqug7Yps4c3dFblzGfreQHp7wNX5TFsvrxd6dAowVasMp61sJcRnB2w8cUzoe3RAYUDHyiHktwqMc=
+  - secure: g9YINaKAdMatsJ28G9jCGbSaguXCyxSTy+pBO6Ch0Cf57ZLOTka3HqDj8p3nV28LUIHZ3ut5WO43CeYKwt4AUtLpBS3a0dndHdY6D83uY6b2qh5hXlrcbeQTq2cvw2y95F7hm4D1kwrgZ7ViqaKggRcEupAL69YbJnxeUDKWEdI=

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/.zuul.yml

@@ -0,0 +1 @@
+ui: tape

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/LICENSE

@@ -0,0 +1,18 @@
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+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.

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/README.md

@@ -0,0 +1,36 @@
+# readable-stream
+
+***Node-core v5.8.0 streams for userland*** [![Build Status](https://travis-ci.org/nodejs/readable-stream.svg?branch=master)](https://travis-ci.org/nodejs/readable-stream)
+
+
+[![NPM](https://nodei.co/npm/readable-stream.png?downloads=true&downloadRank=true)](https://nodei.co/npm/readable-stream/)
+[![NPM](https://nodei.co/npm-dl/readable-stream.png?&months=6&height=3)](https://nodei.co/npm/readable-stream/)
+
+
+[![Sauce Test Status](https://saucelabs.com/browser-matrix/readable-stream.svg)](https://saucelabs.com/u/readable-stream)
+
+```bash
+npm install --save readable-stream
+```
+
+***Node-core streams for userland***
+
+This package is a mirror of the Streams2 and Streams3 implementations in
+Node-core, including [documentation](doc/stream.markdown).
+
+If you want to guarantee a stable streams base, regardless of what version of
+Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core, for background see [this blogpost](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html).
+
+As of version 2.0.0 **readable-stream** uses semantic versioning.  
+
+# Streams WG Team Members
+
+* **Chris Dickinson** ([@chrisdickinson](https://github.com/chrisdickinson)) <christopher.s.dickinson@gmail.com>
+  - Release GPG key: 9554F04D7259F04124DE6B476D5A82AC7E37093B
+* **Calvin Metcalf** ([@calvinmetcalf](https://github.com/calvinmetcalf)) <calvin.metcalf@gmail.com>
+  - Release GPG key: F3EF5F62A87FC27A22E643F714CE4FF5015AA242
+* **Rod Vagg** ([@rvagg](https://github.com/rvagg)) <rod@vagg.org>
+  - Release GPG key: DD8F2338BAE7501E3DD5AC78C273792F7D83545D
+* **Sam Newman** ([@sonewman](https://github.com/sonewman)) <newmansam@outlook.com>
+* **Mathias Buus** ([@mafintosh](https://github.com/mafintosh)) <mathiasbuus@gmail.com>
+* **Domenic Denicola** ([@domenic](https://github.com/domenic)) <d@domenic.me>

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/doc/wg-meetings/2015-01-30.md

@@ -0,0 +1,60 @@
+# streams WG Meeting 2015-01-30
+
+## Links
+
+* **Google Hangouts Video**: http://www.youtube.com/watch?v=I9nDOSGfwZg
+* **GitHub Issue**: https://github.com/iojs/readable-stream/issues/106
+* **Original Minutes Google Doc**: https://docs.google.com/document/d/17aTgLnjMXIrfjgNaTUnHQO7m3xgzHR2VXBTmi03Qii4/
+
+## Agenda
+
+Extracted from https://github.com/iojs/readable-stream/labels/wg-agenda prior to meeting.
+
+* adopt a charter [#105](https://github.com/iojs/readable-stream/issues/105)
+* release and versioning strategy [#101](https://github.com/iojs/readable-stream/issues/101)
+* simpler stream creation [#102](https://github.com/iojs/readable-stream/issues/102)
+* proposal: deprecate implicit flowing of streams [#99](https://github.com/iojs/readable-stream/issues/99)
+
+## Minutes
+
+### adopt a charter
+
+* group: +1's all around
+
+### What versioning scheme should be adopted?
+* group: +1’s 3.0.0
+* domenic+group: pulling in patches from other sources where appropriate
+* mikeal: version independently, suggesting versions for io.js
+* mikeal+domenic: work with TC to notify in advance of changes
+simpler stream creation
+
+### streamline creation of streams
+* sam: streamline creation of streams
+* domenic: nice simple solution posted
+  but, we lose the opportunity to change the model
+  may not be backwards incompatible (double check keys)
+
+  **action item:** domenic will check
+
+### remove implicit flowing of streams on(‘data’)
+* add isFlowing / isPaused
+* mikeal: worrying that we’re documenting polyfill methods – confuses users
+* domenic: more reflective API is probably good, with warning labels for users
+* new section for mad scientists (reflective stream access)
+* calvin: name the “third state”
+* mikeal: maybe borrow the name from whatwg?
+* domenic: we’re missing the “third state”
+* consensus: kind of difficult to name the third state
+* mikeal: figure out differences in states / compat
+* mathias: always flow on data – eliminates third state
+  * explore what it breaks
+
+**action items:**
+* ask isaac for ability to list packages by what public io.js APIs they use (esp. Stream)
+* ask rod/build for infrastructure
+* **chris**: explore the “flow on data” approach
+* add isPaused/isFlowing
+* add new docs section
+* move isPaused to that section
+
+

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/duplex.js

@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_duplex.js")

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/lib/_stream_duplex.js

@@ -0,0 +1,75 @@
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+'use strict';
+
+/*<replacement>*/
+
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    keys.push(key);
+  }return keys;
+};
+/*</replacement>*/
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+var keys = objectKeys(Writable.prototype);
+for (var v = 0; v < keys.length; v++) {
+  var method = keys[v];
+  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+}
+
+function Duplex(options) {
+  if (!(this instanceof Duplex)) return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+
+  if (options && options.readable === false) this.readable = false;
+
+  if (options && options.writable === false) this.writable = false;
+
+  this.allowHalfOpen = true;
+  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+
+  this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+  // if we allow half-open state, or if the writable side ended,
+  // then we're ok.
+  if (this.allowHalfOpen || this._writableState.ended) return;
+
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
+  processNextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+  self.end();
+}
+
+function forEach(xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/lib/_stream_passthrough.js

@@ -0,0 +1,26 @@
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+'use strict';
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough)) return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+  cb(null, chunk);
+};

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/lib/_stream_readable.js

@@ -0,0 +1,880 @@
+'use strict';
+
+module.exports = Readable;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+var EE = require('events');
+
+/*<replacement>*/
+var EElistenerCount = function (emitter, type) {
+  return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream;
+(function () {
+  try {
+    Stream = require('st' + 'ream');
+  } catch (_) {} finally {
+    if (!Stream) Stream = require('events').EventEmitter;
+  }
+})();
+/*</replacement>*/
+
+var Buffer = require('buffer').Buffer;
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var debugUtil = require('util');
+var debug = undefined;
+if (debugUtil && debugUtil.debuglog) {
+  debug = debugUtil.debuglog('stream');
+} else {
+  debug = function () {};
+}
+/*</replacement>*/
+
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+var Duplex;
+function ReadableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // object stream flag. Used to make read(n) ignore n and to
+  // make all the buffer merging and length checks go away
+  this.objectMode = !!options.objectMode;
+
+  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+  // the point at which it stops calling _read() to fill the buffer
+  // Note: 0 is a valid value, means "don't call _read preemptively ever"
+  var hwm = options.highWaterMark;
+  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = ~ ~this.highWaterMark;
+
+  this.buffer = [];
+  this.length = 0;
+  this.pipes = null;
+  this.pipesCount = 0;
+  this.flowing = null;
+  this.ended = false;
+  this.endEmitted = false;
+  this.reading = false;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, because any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // whenever we return null, then we set a flag to say
+  // that we're awaiting a 'readable' event emission.
+  this.needReadable = false;
+  this.emittedReadable = false;
+  this.readableListening = false;
+  this.resumeScheduled = false;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // when piping, we only care about 'readable' events that happen
+  // after read()ing all the bytes and not getting any pushback.
+  this.ranOut = false;
+
+  // the number of writers that are awaiting a drain event in .pipe()s
+  this.awaitDrain = 0;
+
+  // if true, a maybeReadMore has been scheduled
+  this.readingMore = false;
+
+  this.decoder = null;
+  this.encoding = null;
+  if (options.encoding) {
+    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+    this.decoder = new StringDecoder(options.encoding);
+    this.encoding = options.encoding;
+  }
+}
+
+var Duplex;
+function Readable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  if (!(this instanceof Readable)) return new Readable(options);
+
+  this._readableState = new ReadableState(options, this);
+
+  // legacy
+  this.readable = true;
+
+  if (options && typeof options.read === 'function') this._read = options.read;
+
+  Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function (chunk, encoding) {
+  var state = this._readableState;
+
+  if (!state.objectMode && typeof chunk === 'string') {
+    encoding = encoding || state.defaultEncoding;
+    if (encoding !== state.encoding) {
+      chunk = new Buffer(chunk, encoding);
+      encoding = '';
+    }
+  }
+
+  return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function (chunk) {
+  var state = this._readableState;
+  return readableAddChunk(this, state, chunk, '', true);
+};
+
+Readable.prototype.isPaused = function () {
+  return this._readableState.flowing === false;
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+  var er = chunkInvalid(state, chunk);
+  if (er) {
+    stream.emit('error', er);
+  } else if (chunk === null) {
+    state.reading = false;
+    onEofChunk(stream, state);
+  } else if (state.objectMode || chunk && chunk.length > 0) {
+    if (state.ended && !addToFront) {
+      var e = new Error('stream.push() after EOF');
+      stream.emit('error', e);
+    } else if (state.endEmitted && addToFront) {
+      var e = new Error('stream.unshift() after end event');
+      stream.emit('error', e);
+    } else {
+      var skipAdd;
+      if (state.decoder && !addToFront && !encoding) {
+        chunk = state.decoder.write(chunk);
+        skipAdd = !state.objectMode && chunk.length === 0;
+      }
+
+      if (!addToFront) state.reading = false;
+
+      // Don't add to the buffer if we've decoded to an empty string chunk and
+      // we're not in object mode
+      if (!skipAdd) {
+        // if we want the data now, just emit it.
+        if (state.flowing && state.length === 0 && !state.sync) {
+          stream.emit('data', chunk);
+          stream.read(0);
+        } else {
+          // update the buffer info.
+          state.length += state.objectMode ? 1 : chunk.length;
+          if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+
+          if (state.needReadable) emitReadable(stream);
+        }
+      }
+
+      maybeReadMore(stream, state);
+    }
+  } else if (!addToFront) {
+    state.reading = false;
+  }
+
+  return needMoreData(state);
+}
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes.  This is to work around cases where hwm=0,
+// such as the repl.  Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function (enc) {
+  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+  this._readableState.decoder = new StringDecoder(enc);
+  this._readableState.encoding = enc;
+  return this;
+};
+
+// Don't raise the hwm > 8MB
+var MAX_HWM = 0x800000;
+function computeNewHighWaterMark(n) {
+  if (n >= MAX_HWM) {
+    n = MAX_HWM;
+  } else {
+    // Get the next highest power of 2
+    n--;
+    n |= n >>> 1;
+    n |= n >>> 2;
+    n |= n >>> 4;
+    n |= n >>> 8;
+    n |= n >>> 16;
+    n++;
+  }
+  return n;
+}
+
+function howMuchToRead(n, state) {
+  if (state.length === 0 && state.ended) return 0;
+
+  if (state.objectMode) return n === 0 ? 0 : 1;
+
+  if (n === null || isNaN(n)) {
+    // only flow one buffer at a time
+    if (state.flowing && state.buffer.length) return state.buffer[0].length;else return state.length;
+  }
+
+  if (n <= 0) return 0;
+
+  // If we're asking for more than the target buffer level,
+  // then raise the water mark.  Bump up to the next highest
+  // power of 2, to prevent increasing it excessively in tiny
+  // amounts.
+  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+
+  // don't have that much.  return null, unless we've ended.
+  if (n > state.length) {
+    if (!state.ended) {
+      state.needReadable = true;
+      return 0;
+    } else {
+      return state.length;
+    }
+  }
+
+  return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function (n) {
+  debug('read', n);
+  var state = this._readableState;
+  var nOrig = n;
+
+  if (typeof n !== 'number' || n > 0) state.emittedReadable = false;
+
+  // if we're doing read(0) to trigger a readable event, but we
+  // already have a bunch of data in the buffer, then just trigger
+  // the 'readable' event and move on.
+  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+    debug('read: emitReadable', state.length, state.ended);
+    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
+    return null;
+  }
+
+  n = howMuchToRead(n, state);
+
+  // if we've ended, and we're now clear, then finish it up.
+  if (n === 0 && state.ended) {
+    if (state.length === 0) endReadable(this);
+    return null;
+  }
+
+  // All the actual chunk generation logic needs to be
+  // *below* the call to _read.  The reason is that in certain
+  // synthetic stream cases, such as passthrough streams, _read
+  // may be a completely synchronous operation which may change
+  // the state of the read buffer, providing enough data when
+  // before there was *not* enough.
+  //
+  // So, the steps are:
+  // 1. Figure out what the state of things will be after we do
+  // a read from the buffer.
+  //
+  // 2. If that resulting state will trigger a _read, then call _read.
+  // Note that this may be asynchronous, or synchronous.  Yes, it is
+  // deeply ugly to write APIs this way, but that still doesn't mean
+  // that the Readable class should behave improperly, as streams are
+  // designed to be sync/async agnostic.
+  // Take note if the _read call is sync or async (ie, if the read call
+  // has returned yet), so that we know whether or not it's safe to emit
+  // 'readable' etc.
+  //
+  // 3. Actually pull the requested chunks out of the buffer and return.
+
+  // if we need a readable event, then we need to do some reading.
+  var doRead = state.needReadable;
+  debug('need readable', doRead);
+
+  // if we currently have less than the highWaterMark, then also read some
+  if (state.length === 0 || state.length - n < state.highWaterMark) {
+    doRead = true;
+    debug('length less than watermark', doRead);
+  }
+
+  // however, if we've ended, then there's no point, and if we're already
+  // reading, then it's unnecessary.
+  if (state.ended || state.reading) {
+    doRead = false;
+    debug('reading or ended', doRead);
+  }
+
+  if (doRead) {
+    debug('do read');
+    state.reading = true;
+    state.sync = true;
+    // if the length is currently zero, then we *need* a readable event.
+    if (state.length === 0) state.needReadable = true;
+    // call internal read method
+    this._read(state.highWaterMark);
+    state.sync = false;
+  }
+
+  // If _read pushed data synchronously, then `reading` will be false,
+  // and we need to re-evaluate how much data we can return to the user.
+  if (doRead && !state.reading) n = howMuchToRead(nOrig, state);
+
+  var ret;
+  if (n > 0) ret = fromList(n, state);else ret = null;
+
+  if (ret === null) {
+    state.needReadable = true;
+    n = 0;
+  }
+
+  state.length -= n;
+
+  // If we have nothing in the buffer, then we want to know
+  // as soon as we *do* get something into the buffer.
+  if (state.length === 0 && !state.ended) state.needReadable = true;
+
+  // If we tried to read() past the EOF, then emit end on the next tick.
+  if (nOrig !== n && state.ended && state.length === 0) endReadable(this);
+
+  if (ret !== null) this.emit('data', ret);
+
+  return ret;
+};
+
+function chunkInvalid(state, chunk) {
+  var er = null;
+  if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  return er;
+}
+
+function onEofChunk(stream, state) {
+  if (state.ended) return;
+  if (state.decoder) {
+    var chunk = state.decoder.end();
+    if (chunk && chunk.length) {
+      state.buffer.push(chunk);
+      state.length += state.objectMode ? 1 : chunk.length;
+    }
+  }
+  state.ended = true;
+
+  // emit 'readable' now to make sure it gets picked up.
+  emitReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow.  This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+  var state = stream._readableState;
+  state.needReadable = false;
+  if (!state.emittedReadable) {
+    debug('emitReadable', state.flowing);
+    state.emittedReadable = true;
+    if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);
+  }
+}
+
+function emitReadable_(stream) {
+  debug('emit readable');
+  stream.emit('readable');
+  flow(stream);
+}
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data.  that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+  if (!state.readingMore) {
+    state.readingMore = true;
+    processNextTick(maybeReadMore_, stream, state);
+  }
+}
+
+function maybeReadMore_(stream, state) {
+  var len = state.length;
+  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+    debug('maybeReadMore read 0');
+    stream.read(0);
+    if (len === state.length)
+      // didn't get any data, stop spinning.
+      break;else len = state.length;
+  }
+  state.readingMore = false;
+}
+
+// abstract method.  to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function (n) {
+  this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function (dest, pipeOpts) {
+  var src = this;
+  var state = this._readableState;
+
+  switch (state.pipesCount) {
+    case 0:
+      state.pipes = dest;
+      break;
+    case 1:
+      state.pipes = [state.pipes, dest];
+      break;
+    default:
+      state.pipes.push(dest);
+      break;
+  }
+  state.pipesCount += 1;
+  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+
+  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+
+  var endFn = doEnd ? onend : cleanup;
+  if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);
+
+  dest.on('unpipe', onunpipe);
+  function onunpipe(readable) {
+    debug('onunpipe');
+    if (readable === src) {
+      cleanup();
+    }
+  }
+
+  function onend() {
+    debug('onend');
+    dest.end();
+  }
+
+  // when the dest drains, it reduces the awaitDrain counter
+  // on the source.  This would be more elegant with a .once()
+  // handler in flow(), but adding and removing repeatedly is
+  // too slow.
+  var ondrain = pipeOnDrain(src);
+  dest.on('drain', ondrain);
+
+  var cleanedUp = false;
+  function cleanup() {
+    debug('cleanup');
+    // cleanup event handlers once the pipe is broken
+    dest.removeListener('close', onclose);
+    dest.removeListener('finish', onfinish);
+    dest.removeListener('drain', ondrain);
+    dest.removeListener('error', onerror);
+    dest.removeListener('unpipe', onunpipe);
+    src.removeListener('end', onend);
+    src.removeListener('end', cleanup);
+    src.removeListener('data', ondata);
+
+    cleanedUp = true;
+
+    // if the reader is waiting for a drain event from this
+    // specific writer, then it would cause it to never start
+    // flowing again.
+    // So, if this is awaiting a drain, then we just call it now.
+    // If we don't know, then assume that we are waiting for one.
+    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+  }
+
+  src.on('data', ondata);
+  function ondata(chunk) {
+    debug('ondata');
+    var ret = dest.write(chunk);
+    if (false === ret) {
+      // If the user unpiped during `dest.write()`, it is possible
+      // to get stuck in a permanently paused state if that write
+      // also returned false.
+      if (state.pipesCount === 1 && state.pipes[0] === dest && src.listenerCount('data') === 1 && !cleanedUp) {
+        debug('false write response, pause', src._readableState.awaitDrain);
+        src._readableState.awaitDrain++;
+      }
+      src.pause();
+    }
+  }
+
+  // if the dest has an error, then stop piping into it.
+  // however, don't suppress the throwing behavior for this.
+  function onerror(er) {
+    debug('onerror', er);
+    unpipe();
+    dest.removeListener('error', onerror);
+    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+  }
+  // This is a brutally ugly hack to make sure that our error handler
+  // is attached before any userland ones.  NEVER DO THIS.
+  if (!dest._events || !dest._events.error) dest.on('error', onerror);else if (isArray(dest._events.error)) dest._events.error.unshift(onerror);else dest._events.error = [onerror, dest._events.error];
+
+  // Both close and finish should trigger unpipe, but only once.
+  function onclose() {
+    dest.removeListener('finish', onfinish);
+    unpipe();
+  }
+  dest.once('close', onclose);
+  function onfinish() {
+    debug('onfinish');
+    dest.removeListener('close', onclose);
+    unpipe();
+  }
+  dest.once('finish', onfinish);
+
+  function unpipe() {
+    debug('unpipe');
+    src.unpipe(dest);
+  }
+
+  // tell the dest that it's being piped to
+  dest.emit('pipe', src);
+
+  // start the flow if it hasn't been started already.
+  if (!state.flowing) {
+    debug('pipe resume');
+    src.resume();
+  }
+
+  return dest;
+};
+
+function pipeOnDrain(src) {
+  return function () {
+    var state = src._readableState;
+    debug('pipeOnDrain', state.awaitDrain);
+    if (state.awaitDrain) state.awaitDrain--;
+    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+      state.flowing = true;
+      flow(src);
+    }
+  };
+}
+
+Readable.prototype.unpipe = function (dest) {
+  var state = this._readableState;
+
+  // if we're not piping anywhere, then do nothing.
+  if (state.pipesCount === 0) return this;
+
+  // just one destination.  most common case.
+  if (state.pipesCount === 1) {
+    // passed in one, but it's not the right one.
+    if (dest && dest !== state.pipes) return this;
+
+    if (!dest) dest = state.pipes;
+
+    // got a match.
+    state.pipes = null;
+    state.pipesCount = 0;
+    state.flowing = false;
+    if (dest) dest.emit('unpipe', this);
+    return this;
+  }
+
+  // slow case. multiple pipe destinations.
+
+  if (!dest) {
+    // remove all.
+    var dests = state.pipes;
+    var len = state.pipesCount;
+    state.pipes = null;
+    state.pipesCount = 0;
+    state.flowing = false;
+
+    for (var _i = 0; _i < len; _i++) {
+      dests[_i].emit('unpipe', this);
+    }return this;
+  }
+
+  // try to find the right one.
+  var i = indexOf(state.pipes, dest);
+  if (i === -1) return this;
+
+  state.pipes.splice(i, 1);
+  state.pipesCount -= 1;
+  if (state.pipesCount === 1) state.pipes = state.pipes[0];
+
+  dest.emit('unpipe', this);
+
+  return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function (ev, fn) {
+  var res = Stream.prototype.on.call(this, ev, fn);
+
+  // If listening to data, and it has not explicitly been paused,
+  // then call resume to start the flow of data on the next tick.
+  if (ev === 'data' && false !== this._readableState.flowing) {
+    this.resume();
+  }
+
+  if (ev === 'readable' && !this._readableState.endEmitted) {
+    var state = this._readableState;
+    if (!state.readableListening) {
+      state.readableListening = true;
+      state.emittedReadable = false;
+      state.needReadable = true;
+      if (!state.reading) {
+        processNextTick(nReadingNextTick, this);
+      } else if (state.length) {
+        emitReadable(this, state);
+      }
+    }
+  }
+
+  return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+function nReadingNextTick(self) {
+  debug('readable nexttick read 0');
+  self.read(0);
+}
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function () {
+  var state = this._readableState;
+  if (!state.flowing) {
+    debug('resume');
+    state.flowing = true;
+    resume(this, state);
+  }
+  return this;
+};
+
+function resume(stream, state) {
+  if (!state.resumeScheduled) {
+    state.resumeScheduled = true;
+    processNextTick(resume_, stream, state);
+  }
+}
+
+function resume_(stream, state) {
+  if (!state.reading) {
+    debug('resume read 0');
+    stream.read(0);
+  }
+
+  state.resumeScheduled = false;
+  stream.emit('resume');
+  flow(stream);
+  if (state.flowing && !state.reading) stream.read(0);
+}
+
+Readable.prototype.pause = function () {
+  debug('call pause flowing=%j', this._readableState.flowing);
+  if (false !== this._readableState.flowing) {
+    debug('pause');
+    this._readableState.flowing = false;
+    this.emit('pause');
+  }
+  return this;
+};
+
+function flow(stream) {
+  var state = stream._readableState;
+  debug('flow', state.flowing);
+  if (state.flowing) {
+    do {
+      var chunk = stream.read();
+    } while (null !== chunk && state.flowing);
+  }
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function (stream) {
+  var state = this._readableState;
+  var paused = false;
+
+  var self = this;
+  stream.on('end', function () {
+    debug('wrapped end');
+    if (state.decoder && !state.ended) {
+      var chunk = state.decoder.end();
+      if (chunk && chunk.length) self.push(chunk);
+    }
+
+    self.push(null);
+  });
+
+  stream.on('data', function (chunk) {
+    debug('wrapped data');
+    if (state.decoder) chunk = state.decoder.write(chunk);
+
+    // don't skip over falsy values in objectMode
+    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
+
+    var ret = self.push(chunk);
+    if (!ret) {
+      paused = true;
+      stream.pause();
+    }
+  });
+
+  // proxy all the other methods.
+  // important when wrapping filters and duplexes.
+  for (var i in stream) {
+    if (this[i] === undefined && typeof stream[i] === 'function') {
+      this[i] = function (method) {
+        return function () {
+          return stream[method].apply(stream, arguments);
+        };
+      }(i);
+    }
+  }
+
+  // proxy certain important events.
+  var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+  forEach(events, function (ev) {
+    stream.on(ev, self.emit.bind(self, ev));
+  });
+
+  // when we try to consume some more bytes, simply unpause the
+  // underlying stream.
+  self._read = function (n) {
+    debug('wrapped _read', n);
+    if (paused) {
+      paused = false;
+      stream.resume();
+    }
+  };
+
+  return self;
+};
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+  var list = state.buffer;
+  var length = state.length;
+  var stringMode = !!state.decoder;
+  var objectMode = !!state.objectMode;
+  var ret;
+
+  // nothing in the list, definitely empty.
+  if (list.length === 0) return null;
+
+  if (length === 0) ret = null;else if (objectMode) ret = list.shift();else if (!n || n >= length) {
+    // read it all, truncate the array.
+    if (stringMode) ret = list.join('');else if (list.length === 1) ret = list[0];else ret = Buffer.concat(list, length);
+    list.length = 0;
+  } else {
+    // read just some of it.
+    if (n < list[0].length) {
+      // just take a part of the first list item.
+      // slice is the same for buffers and strings.
+      var buf = list[0];
+      ret = buf.slice(0, n);
+      list[0] = buf.slice(n);
+    } else if (n === list[0].length) {
+      // first list is a perfect match
+      ret = list.shift();
+    } else {
+      // complex case.
+      // we have enough to cover it, but it spans past the first buffer.
+      if (stringMode) ret = '';else ret = new Buffer(n);
+
+      var c = 0;
+      for (var i = 0, l = list.length; i < l && c < n; i++) {
+        var buf = list[0];
+        var cpy = Math.min(n - c, buf.length);
+
+        if (stringMode) ret += buf.slice(0, cpy);else buf.copy(ret, c, 0, cpy);
+
+        if (cpy < buf.length) list[0] = buf.slice(cpy);else list.shift();
+
+        c += cpy;
+      }
+    }
+  }
+
+  return ret;
+}
+
+function endReadable(stream) {
+  var state = stream._readableState;
+
+  // If we get here before consuming all the bytes, then that is a
+  // bug in node.  Should never happen.
+  if (state.length > 0) throw new Error('endReadable called on non-empty stream');
+
+  if (!state.endEmitted) {
+    state.ended = true;
+    processNextTick(endReadableNT, state, stream);
+  }
+}
+
+function endReadableNT(state, stream) {
+  // Check that we didn't get one last unshift.
+  if (!state.endEmitted && state.length === 0) {
+    state.endEmitted = true;
+    stream.readable = false;
+    stream.emit('end');
+  }
+}
+
+function forEach(xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
+
+function indexOf(xs, x) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    if (xs[i] === x) return i;
+  }
+  return -1;
+}

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/lib/_stream_transform.js

@@ -0,0 +1,180 @@
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+'use strict';
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+function TransformState(stream) {
+  this.afterTransform = function (er, data) {
+    return afterTransform(stream, er, data);
+  };
+
+  this.needTransform = false;
+  this.transforming = false;
+  this.writecb = null;
+  this.writechunk = null;
+  this.writeencoding = null;
+}
+
+function afterTransform(stream, er, data) {
+  var ts = stream._transformState;
+  ts.transforming = false;
+
+  var cb = ts.writecb;
+
+  if (!cb) return stream.emit('error', new Error('no writecb in Transform class'));
+
+  ts.writechunk = null;
+  ts.writecb = null;
+
+  if (data !== null && data !== undefined) stream.push(data);
+
+  cb(er);
+
+  var rs = stream._readableState;
+  rs.reading = false;
+  if (rs.needReadable || rs.length < rs.highWaterMark) {
+    stream._read(rs.highWaterMark);
+  }
+}
+
+function Transform(options) {
+  if (!(this instanceof Transform)) return new Transform(options);
+
+  Duplex.call(this, options);
+
+  this._transformState = new TransformState(this);
+
+  // when the writable side finishes, then flush out anything remaining.
+  var stream = this;
+
+  // start out asking for a readable event once data is transformed.
+  this._readableState.needReadable = true;
+
+  // we have implemented the _read method, and done the other things
+  // that Readable wants before the first _read call, so unset the
+  // sync guard flag.
+  this._readableState.sync = false;
+
+  if (options) {
+    if (typeof options.transform === 'function') this._transform = options.transform;
+
+    if (typeof options.flush === 'function') this._flush = options.flush;
+  }
+
+  this.once('prefinish', function () {
+    if (typeof this._flush === 'function') this._flush(function (er) {
+      done(stream, er);
+    });else done(stream);
+  });
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+  this._transformState.needTransform = false;
+  return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side.  You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk.  If you pass
+// an error, then that'll put the hurt on the whole operation.  If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+  throw new Error('not implemented');
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+  var ts = this._transformState;
+  ts.writecb = cb;
+  ts.writechunk = chunk;
+  ts.writeencoding = encoding;
+  if (!ts.transforming) {
+    var rs = this._readableState;
+    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+  }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+  var ts = this._transformState;
+
+  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+    ts.transforming = true;
+    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+  } else {
+    // mark that we need a transform, so that any data that comes in
+    // will get processed, now that we've asked for it.
+    ts.needTransform = true;
+  }
+};
+
+function done(stream, er) {
+  if (er) return stream.emit('error', er);
+
+  // if there's nothing in the write buffer, then that means
+  // that nothing more will ever be provided
+  var ws = stream._writableState;
+  var ts = stream._transformState;
+
+  if (ws.length) throw new Error('calling transform done when ws.length != 0');
+
+  if (ts.transforming) throw new Error('calling transform done when still transforming');
+
+  return stream.push(null);
+}

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/lib/_stream_writable.js

@@ -0,0 +1,516 @@
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+'use strict';
+
+module.exports = Writable;
+
+/*<replacement>*/
+var processNextTick = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;
+/*</replacement>*/
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+/*<replacement>*/
+var internalUtil = {
+  deprecate: require('util-deprecate')
+};
+/*</replacement>*/
+
+/*<replacement>*/
+var Stream;
+(function () {
+  try {
+    Stream = require('st' + 'ream');
+  } catch (_) {} finally {
+    if (!Stream) Stream = require('events').EventEmitter;
+  }
+})();
+/*</replacement>*/
+
+var Buffer = require('buffer').Buffer;
+
+util.inherits(Writable, Stream);
+
+function nop() {}
+
+function WriteReq(chunk, encoding, cb) {
+  this.chunk = chunk;
+  this.encoding = encoding;
+  this.callback = cb;
+  this.next = null;
+}
+
+var Duplex;
+function WritableState(options, stream) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  options = options || {};
+
+  // object stream flag to indicate whether or not this stream
+  // contains buffers or objects.
+  this.objectMode = !!options.objectMode;
+
+  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+
+  // the point at which write() starts returning false
+  // Note: 0 is a valid value, means that we always return false if
+  // the entire buffer is not flushed immediately on write()
+  var hwm = options.highWaterMark;
+  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+
+  // cast to ints.
+  this.highWaterMark = ~ ~this.highWaterMark;
+
+  this.needDrain = false;
+  // at the start of calling end()
+  this.ending = false;
+  // when end() has been called, and returned
+  this.ended = false;
+  // when 'finish' is emitted
+  this.finished = false;
+
+  // should we decode strings into buffers before passing to _write?
+  // this is here so that some node-core streams can optimize string
+  // handling at a lower level.
+  var noDecode = options.decodeStrings === false;
+  this.decodeStrings = !noDecode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // not an actual buffer we keep track of, but a measurement
+  // of how much we're waiting to get pushed to some underlying
+  // socket or file.
+  this.length = 0;
+
+  // a flag to see when we're in the middle of a write.
+  this.writing = false;
+
+  // when true all writes will be buffered until .uncork() call
+  this.corked = 0;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, because any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // a flag to know if we're processing previously buffered items, which
+  // may call the _write() callback in the same tick, so that we don't
+  // end up in an overlapped onwrite situation.
+  this.bufferProcessing = false;
+
+  // the callback that's passed to _write(chunk,cb)
+  this.onwrite = function (er) {
+    onwrite(stream, er);
+  };
+
+  // the callback that the user supplies to write(chunk,encoding,cb)
+  this.writecb = null;
+
+  // the amount that is being written when _write is called.
+  this.writelen = 0;
+
+  this.bufferedRequest = null;
+  this.lastBufferedRequest = null;
+
+  // number of pending user-supplied write callbacks
+  // this must be 0 before 'finish' can be emitted
+  this.pendingcb = 0;
+
+  // emit prefinish if the only thing we're waiting for is _write cbs
+  // This is relevant for synchronous Transform streams
+  this.prefinished = false;
+
+  // True if the error was already emitted and should not be thrown again
+  this.errorEmitted = false;
+
+  // count buffered requests
+  this.bufferedRequestCount = 0;
+
+  // create the two objects needed to store the corked requests
+  // they are not a linked list, as no new elements are inserted in there
+  this.corkedRequestsFree = new CorkedRequest(this);
+  this.corkedRequestsFree.next = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function writableStateGetBuffer() {
+  var current = this.bufferedRequest;
+  var out = [];
+  while (current) {
+    out.push(current);
+    current = current.next;
+  }
+  return out;
+};
+
+(function () {
+  try {
+    Object.defineProperty(WritableState.prototype, 'buffer', {
+      get: internalUtil.deprecate(function () {
+        return this.getBuffer();
+      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
+    });
+  } catch (_) {}
+})();
+
+var Duplex;
+function Writable(options) {
+  Duplex = Duplex || require('./_stream_duplex');
+
+  // Writable ctor is applied to Duplexes, though they're not
+  // instanceof Writable, they're instanceof Readable.
+  if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options);
+
+  this._writableState = new WritableState(options, this);
+
+  // legacy.
+  this.writable = true;
+
+  if (options) {
+    if (typeof options.write === 'function') this._write = options.write;
+
+    if (typeof options.writev === 'function') this._writev = options.writev;
+  }
+
+  Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function () {
+  this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+function writeAfterEnd(stream, cb) {
+  var er = new Error('write after end');
+  // TODO: defer error events consistently everywhere, not just the cb
+  stream.emit('error', er);
+  processNextTick(cb, er);
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+  var valid = true;
+
+  if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
+    var er = new TypeError('Invalid non-string/buffer chunk');
+    stream.emit('error', er);
+    processNextTick(cb, er);
+    valid = false;
+  }
+  return valid;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+  var state = this._writableState;
+  var ret = false;
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+
+  if (typeof cb !== 'function') cb = nop;
+
+  if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) {
+    state.pendingcb++;
+    ret = writeOrBuffer(this, state, chunk, encoding, cb);
+  }
+
+  return ret;
+};
+
+Writable.prototype.cork = function () {
+  var state = this._writableState;
+
+  state.corked++;
+};
+
+Writable.prototype.uncork = function () {
+  var state = this._writableState;
+
+  if (state.corked) {
+    state.corked--;
+
+    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+  }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+  // node::ParseEncoding() requires lower case.
+  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
+  this._writableState.defaultEncoding = encoding;
+};
+
+function decodeChunk(state, chunk, encoding) {
+  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+    chunk = new Buffer(chunk, encoding);
+  }
+  return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn.  Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+  chunk = decodeChunk(state, chunk, encoding);
+
+  if (Buffer.isBuffer(chunk)) encoding = 'buffer';
+  var len = state.objectMode ? 1 : chunk.length;
+
+  state.length += len;
+
+  var ret = state.length < state.highWaterMark;
+  // we must ensure that previous needDrain will not be reset to false.
+  if (!ret) state.needDrain = true;
+
+  if (state.writing || state.corked) {
+    var last = state.lastBufferedRequest;
+    state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);
+    if (last) {
+      last.next = state.lastBufferedRequest;
+    } else {
+      state.bufferedRequest = state.lastBufferedRequest;
+    }
+    state.bufferedRequestCount += 1;
+  } else {
+    doWrite(stream, state, false, len, chunk, encoding, cb);
+  }
+
+  return ret;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+  state.writelen = len;
+  state.writecb = cb;
+  state.writing = true;
+  state.sync = true;
+  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+  state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+  --state.pendingcb;
+  if (sync) processNextTick(cb, er);else cb(er);
+
+  stream._writableState.errorEmitted = true;
+  stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+  state.writing = false;
+  state.writecb = null;
+  state.length -= state.writelen;
+  state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+  var state = stream._writableState;
+  var sync = state.sync;
+  var cb = state.writecb;
+
+  onwriteStateUpdate(state);
+
+  if (er) onwriteError(stream, state, sync, er, cb);else {
+    // Check if we're actually ready to finish, but don't emit yet
+    var finished = needFinish(state);
+
+    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+      clearBuffer(stream, state);
+    }
+
+    if (sync) {
+      /*<replacement>*/
+      asyncWrite(afterWrite, stream, state, finished, cb);
+      /*</replacement>*/
+    } else {
+        afterWrite(stream, state, finished, cb);
+      }
+  }
+}
+
+function afterWrite(stream, state, finished, cb) {
+  if (!finished) onwriteDrain(stream, state);
+  state.pendingcb--;
+  cb();
+  finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+  if (state.length === 0 && state.needDrain) {
+    state.needDrain = false;
+    stream.emit('drain');
+  }
+}
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+  state.bufferProcessing = true;
+  var entry = state.bufferedRequest;
+
+  if (stream._writev && entry && entry.next) {
+    // Fast case, write everything using _writev()
+    var l = state.bufferedRequestCount;
+    var buffer = new Array(l);
+    var holder = state.corkedRequestsFree;
+    holder.entry = entry;
+
+    var count = 0;
+    while (entry) {
+      buffer[count] = entry;
+      entry = entry.next;
+      count += 1;
+    }
+
+    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+    // doWrite is always async, defer these to save a bit of time
+    // as the hot path ends with doWrite
+    state.pendingcb++;
+    state.lastBufferedRequest = null;
+    state.corkedRequestsFree = holder.next;
+    holder.next = null;
+  } else {
+    // Slow case, write chunks one-by-one
+    while (entry) {
+      var chunk = entry.chunk;
+      var encoding = entry.encoding;
+      var cb = entry.callback;
+      var len = state.objectMode ? 1 : chunk.length;
+
+      doWrite(stream, state, false, len, chunk, encoding, cb);
+      entry = entry.next;
+      // if we didn't call the onwrite immediately, then
+      // it means that we need to wait until it does.
+      // also, that means that the chunk and cb are currently
+      // being processed, so move the buffer counter past them.
+      if (state.writing) {
+        break;
+      }
+    }
+
+    if (entry === null) state.lastBufferedRequest = null;
+  }
+
+  state.bufferedRequestCount = 0;
+  state.bufferedRequest = entry;
+  state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+  cb(new Error('not implemented'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+  var state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+
+  // .end() fully uncorks
+  if (state.corked) {
+    state.corked = 1;
+    this.uncork();
+  }
+
+  // ignore unnecessary end() calls.
+  if (!state.ending && !state.finished) endWritable(this, state, cb);
+};
+
+function needFinish(state) {
+  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+
+function prefinish(stream, state) {
+  if (!state.prefinished) {
+    state.prefinished = true;
+    stream.emit('prefinish');
+  }
+}
+
+function finishMaybe(stream, state) {
+  var need = needFinish(state);
+  if (need) {
+    if (state.pendingcb === 0) {
+      prefinish(stream, state);
+      state.finished = true;
+      stream.emit('finish');
+    } else {
+      prefinish(stream, state);
+    }
+  }
+  return need;
+}
+
+function endWritable(stream, state, cb) {
+  state.ending = true;
+  finishMaybe(stream, state);
+  if (cb) {
+    if (state.finished) processNextTick(cb);else stream.once('finish', cb);
+  }
+  state.ended = true;
+  stream.writable = false;
+}
+
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+  var _this = this;
+
+  this.next = null;
+  this.entry = null;
+
+  this.finish = function (err) {
+    var entry = _this.entry;
+    _this.entry = null;
+    while (entry) {
+      var cb = entry.callback;
+      state.pendingcb--;
+      cb(err);
+      entry = entry.next;
+    }
+    if (state.corkedRequestsFree) {
+      state.corkedRequestsFree.next = _this;
+    } else {
+      state.corkedRequestsFree = _this;
+    }
+  };
+}

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/package.json

@@ -0,0 +1,66 @@
+{
+  "_from": "readable-stream@~2.0.0",
+  "_id": "readable-stream@2.0.6",
+  "_inBundle": false,
+  "_integrity": "sha1-j5A0HmilPMySh4jaz80Rs265t44=",
+  "_location": "/browserify/concat-stream/readable-stream",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "readable-stream@~2.0.0",
+    "name": "readable-stream",
+    "escapedName": "readable-stream",
+    "rawSpec": "~2.0.0",
+    "saveSpec": null,
+    "fetchSpec": "~2.0.0"
+  },
+  "_requiredBy": [
+    "/browserify/concat-stream"
+  ],
+  "_resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz",
+  "_shasum": "8f90341e68a53ccc928788dacfcd11b36eb9b78e",
+  "_spec": "readable-stream@~2.0.0",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build/node_modules/browserify/node_modules/concat-stream",
+  "browser": {
+    "util": false
+  },
+  "bugs": {
+    "url": "https://github.com/nodejs/readable-stream/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "core-util-is": "~1.0.0",
+    "inherits": "~2.0.1",
+    "isarray": "~1.0.0",
+    "process-nextick-args": "~1.0.6",
+    "string_decoder": "~0.10.x",
+    "util-deprecate": "~1.0.1"
+  },
+  "deprecated": false,
+  "description": "Streams3, a user-land copy of the stream library from Node.js",
+  "devDependencies": {
+    "tap": "~0.2.6",
+    "tape": "~4.5.1",
+    "zuul": "~3.9.0"
+  },
+  "homepage": "https://github.com/nodejs/readable-stream#readme",
+  "keywords": [
+    "readable",
+    "stream",
+    "pipe"
+  ],
+  "license": "MIT",
+  "main": "readable.js",
+  "name": "readable-stream",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/readable-stream.git"
+  },
+  "scripts": {
+    "browser": "npm run write-zuul && zuul -- test/browser.js",
+    "test": "tap test/parallel/*.js test/ours/*.js",
+    "write-zuul": "printf \"ui: tape\nbrowsers:\n  - name: $BROWSER_NAME\n    version: $BROWSER_VERSION\n\">.zuul.yml"
+  },
+  "version": "2.0.6"
+}

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/passthrough.js

@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_passthrough.js")

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/readable.js

@@ -0,0 +1,12 @@
+var Stream = (function (){
+  try {
+    return require('st' + 'ream'); // hack to fix a circular dependency issue when used with browserify
+  } catch(_){}
+}());
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = Stream || exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/transform.js

@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_transform.js")

build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream/writable.js

@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_writable.js")

build/node_modules/browserify/node_modules/concat-stream/node_modules/string_decoder/.npmignore

@@ -0,0 +1,2 @@
+build
+test

build/node_modules/browserify/node_modules/concat-stream/node_modules/string_decoder/LICENSE

@@ -0,0 +1,20 @@
+Copyright Joyent, Inc. and other Node contributors.
+
+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.

build/node_modules/browserify/node_modules/concat-stream/node_modules/string_decoder/README.md

@@ -0,0 +1,7 @@
+**string_decoder.js** (`require('string_decoder')`) from Node.js core
+
+Copyright Joyent, Inc. and other Node contributors. See LICENCE file for details.
+
+Version numbers match the versions found in Node core, e.g. 0.10.24 matches Node 0.10.24, likewise 0.11.10 matches Node 0.11.10. **Prefer the stable version over the unstable.**
+
+The *build/* directory contains a build script that will scrape the source from the [joyent/node](https://github.com/joyent/node) repo given a specific Node version.

build/node_modules/browserify/node_modules/concat-stream/node_modules/string_decoder/index.js

@@ -0,0 +1,221 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+  || function(encoding) {
+       switch (encoding && encoding.toLowerCase()) {
+         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+         default: return false;
+       }
+     }
+
+
+function assertEncoding(encoding) {
+  if (encoding && !isBufferEncoding(encoding)) {
+    throw new Error('Unknown encoding: ' + encoding);
+  }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+var StringDecoder = exports.StringDecoder = function(encoding) {
+  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+  assertEncoding(encoding);
+  switch (this.encoding) {
+    case 'utf8':
+      // CESU-8 represents each of Surrogate Pair by 3-bytes
+      this.surrogateSize = 3;
+      break;
+    case 'ucs2':
+    case 'utf16le':
+      // UTF-16 represents each of Surrogate Pair by 2-bytes
+      this.surrogateSize = 2;
+      this.detectIncompleteChar = utf16DetectIncompleteChar;
+      break;
+    case 'base64':
+      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+      this.surrogateSize = 3;
+      this.detectIncompleteChar = base64DetectIncompleteChar;
+      break;
+    default:
+      this.write = passThroughWrite;
+      return;
+  }
+
+  // Enough space to store all bytes of a single character. UTF-8 needs 4
+  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+  this.charBuffer = new Buffer(6);
+  // Number of bytes received for the current incomplete multi-byte character.
+  this.charReceived = 0;
+  // Number of bytes expected for the current incomplete multi-byte character.
+  this.charLength = 0;
+};
+
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+  var charStr = '';
+  // if our last write ended with an incomplete multibyte character
+  while (this.charLength) {
+    // determine how many remaining bytes this buffer has to offer for this char
+    var available = (buffer.length >= this.charLength - this.charReceived) ?
+        this.charLength - this.charReceived :
+        buffer.length;
+
+    // add the new bytes to the char buffer
+    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+    this.charReceived += available;
+
+    if (this.charReceived < this.charLength) {
+      // still not enough chars in this buffer? wait for more ...
+      return '';
+    }
+
+    // remove bytes belonging to the current character from the buffer
+    buffer = buffer.slice(available, buffer.length);
+
+    // get the character that was split
+    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+    var charCode = charStr.charCodeAt(charStr.length - 1);
+    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+      this.charLength += this.surrogateSize;
+      charStr = '';
+      continue;
+    }
+    this.charReceived = this.charLength = 0;
+
+    // if there are no more bytes in this buffer, just emit our char
+    if (buffer.length === 0) {
+      return charStr;
+    }
+    break;
+  }
+
+  // determine and set charLength / charReceived
+  this.detectIncompleteChar(buffer);
+
+  var end = buffer.length;
+  if (this.charLength) {
+    // buffer the incomplete character bytes we got
+    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+    end -= this.charReceived;
+  }
+
+  charStr += buffer.toString(this.encoding, 0, end);
+
+  var end = charStr.length - 1;
+  var charCode = charStr.charCodeAt(end);
+  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+    var size = this.surrogateSize;
+    this.charLength += size;
+    this.charReceived += size;
+    this.charBuffer.copy(this.charBuffer, size, 0, size);
+    buffer.copy(this.charBuffer, 0, 0, size);
+    return charStr.substring(0, end);
+  }
+
+  // or just emit the charStr
+  return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+  // determine how many bytes we have to check at the end of this buffer
+  var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+  // Figure out if one of the last i bytes of our buffer announces an
+  // incomplete char.
+  for (; i > 0; i--) {
+    var c = buffer[buffer.length - i];
+
+    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+    // 110XXXXX
+    if (i == 1 && c >> 5 == 0x06) {
+      this.charLength = 2;
+      break;
+    }
+
+    // 1110XXXX
+    if (i <= 2 && c >> 4 == 0x0E) {
+      this.charLength = 3;
+      break;
+    }
+
+    // 11110XXX
+    if (i <= 3 && c >> 3 == 0x1E) {
+      this.charLength = 4;
+      break;
+    }
+  }
+  this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+  var res = '';
+  if (buffer && buffer.length)
+    res = this.write(buffer);
+
+  if (this.charReceived) {
+    var cr = this.charReceived;
+    var buf = this.charBuffer;
+    var enc = this.encoding;
+    res += buf.slice(0, cr).toString(enc);
+  }
+
+  return res;
+};
+
+function passThroughWrite(buffer) {
+  return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 2;
+  this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 3;
+  this.charLength = this.charReceived ? 3 : 0;
+}

build/node_modules/browserify/node_modules/concat-stream/node_modules/string_decoder/package.json

@@ -0,0 +1,53 @@
+{
+  "_from": "string_decoder@~0.10.x",
+  "_id": "string_decoder@0.10.31",
+  "_inBundle": false,
+  "_integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
+  "_location": "/browserify/concat-stream/string_decoder",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "string_decoder@~0.10.x",
+    "name": "string_decoder",
+    "escapedName": "string_decoder",
+    "rawSpec": "~0.10.x",
+    "saveSpec": null,
+    "fetchSpec": "~0.10.x"
+  },
+  "_requiredBy": [
+    "/browserify/concat-stream/readable-stream"
+  ],
+  "_resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+  "_shasum": "62e203bc41766c6c28c9fc84301dab1c5310fa94",
+  "_spec": "string_decoder@~0.10.x",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build/node_modules/browserify/node_modules/concat-stream/node_modules/readable-stream",
+  "bugs": {
+    "url": "https://github.com/rvagg/string_decoder/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {},
+  "deprecated": false,
+  "description": "The string_decoder module from Node core",
+  "devDependencies": {
+    "tap": "~0.4.8"
+  },
+  "homepage": "https://github.com/rvagg/string_decoder",
+  "keywords": [
+    "string",
+    "decoder",
+    "browser",
+    "browserify"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "string_decoder",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/rvagg/string_decoder.git"
+  },
+  "scripts": {
+    "test": "tap test/simple/*.js"
+  },
+  "version": "0.10.31"
+}

build/node_modules/browserify/node_modules/concat-stream/package.json

@@ -0,0 +1,89 @@
+{
+  "_from": "concat-stream@~1.5.1",
+  "_id": "concat-stream@1.5.2",
+  "_inBundle": false,
+  "_integrity": "sha1-cIl4Yk2FavQaWnQd790mHadSwmY=",
+  "_location": "/browserify/concat-stream",
+  "_phantomChildren": {
+    "core-util-is": "1.0.2",
+    "inherits": "2.0.3",
+    "isarray": "1.0.0",
+    "process-nextick-args": "1.0.7",
+    "util-deprecate": "1.0.2"
+  },
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "concat-stream@~1.5.1",
+    "name": "concat-stream",
+    "escapedName": "concat-stream",
+    "rawSpec": "~1.5.1",
+    "saveSpec": null,
+    "fetchSpec": "~1.5.1"
+  },
+  "_requiredBy": [
+    "/browserify"
+  ],
+  "_resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.5.2.tgz",
+  "_shasum": "708978624d856af41a5a741defdd261da752c266",
+  "_spec": "concat-stream@~1.5.1",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build/node_modules/browserify",
+  "author": {
+    "name": "Max Ogden",
+    "email": "max@maxogden.com"
+  },
+  "bugs": {
+    "url": "http://github.com/maxogden/concat-stream/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "inherits": "~2.0.1",
+    "readable-stream": "~2.0.0",
+    "typedarray": "~0.0.5"
+  },
+  "deprecated": false,
+  "description": "writable stream that concatenates strings or binary data and calls a callback with the result",
+  "devDependencies": {
+    "tape": "~2.3.2"
+  },
+  "engines": [
+    "node >= 0.8"
+  ],
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/maxogden/concat-stream#readme",
+  "license": "MIT",
+  "main": "index.js",
+  "name": "concat-stream",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/maxogden/concat-stream.git"
+  },
+  "scripts": {
+    "test": "tape test/*.js test/server/*.js"
+  },
+  "tags": [
+    "stream",
+    "simple",
+    "util",
+    "utility"
+  ],
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/17..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "version": "1.5.2"
+}

build/node_modules/browserify/node_modules/concat-stream/readme.md

@@ -0,0 +1,102 @@
+# concat-stream
+
+Writable stream that concatenates all the data from a stream and calls a callback with the result. Use this when you want to collect all the data from a stream into a single buffer.
+
+[![Build Status](https://travis-ci.org/maxogden/concat-stream.svg?branch=master)](https://travis-ci.org/maxogden/concat-stream)
+
+[![NPM](https://nodei.co/npm/concat-stream.png)](https://nodei.co/npm/concat-stream/)
+
+### description
+
+Streams emit many buffers. If you want to collect all of the buffers, and when the stream ends concatenate all of the buffers together and receive a single buffer then this is the module for you.
+
+Only use this if you know you can fit all of the output of your stream into a single Buffer (e.g. in RAM).
+
+There are also `objectMode` streams that emit things other than Buffers, and you can concatenate these too. See below for details.
+
+## Related
+
+`stream-each` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.
+
+### examples
+
+#### Buffers
+
+```js
+var fs = require('fs')
+var concat = require('concat-stream')
+
+var readStream = fs.createReadStream('cat.png')
+var concatStream = concat(gotPicture)
+
+readStream.on('error', handleError)
+readStream.pipe(concatStream)
+
+function gotPicture(imageBuffer) {
+  // imageBuffer is all of `cat.png` as a node.js Buffer
+}
+
+function handleError(err) {
+  // handle your error appropriately here, e.g.:
+  console.error(err) // print the error to STDERR
+  process.exit(1) // exit program with non-zero exit code
+}
+
+```
+
+#### Arrays
+
+```js
+var write = concat(function(data) {})
+write.write([1,2,3])
+write.write([4,5,6])
+write.end()
+// data will be [1,2,3,4,5,6] in the above callback
+```
+
+#### Uint8Arrays
+
+```js
+var write = concat(function(data) {})
+var a = new Uint8Array(3)
+a[0] = 97; a[1] = 98; a[2] = 99
+write.write(a)
+write.write('!')
+write.end(Buffer('!!1'))
+```
+
+See `test/` for more examples
+
+# methods
+
+```js
+var concat = require('concat-stream')
+```
+
+## var writable = concat(opts={}, cb)
+
+Return a `writable` stream that will fire `cb(data)` with all of the data that
+was written to the stream. Data can be written to `writable` as strings,
+Buffers, arrays of byte integers, and Uint8Arrays. 
+
+By default `concat-stream` will give you back the same data type as the type of the first buffer written to the stream. Use `opts.encoding` to set what format `data` should be returned as, e.g. if you if you don't want to rely on the built-in type checking or for some other reason.
+
+* `string` - get a string
+* `buffer` - get back a Buffer
+* `array` - get an array of byte integers
+* `uint8array`, `u8`, `uint8` - get back a Uint8Array
+* `object`, get back an array of Objects
+
+If you don't specify an encoding, and the types can't be inferred (e.g. you write things that aren't in the list above), it will try to convert concat them into a `Buffer`.
+
+If nothing is written to `writable` then `data` will be an empty array `[]`.
+
+# error handling
+
+`concat-stream` does not handle errors for you, so you must handle errors on whatever streams you pipe into `concat-stream`. This is a general rule when programming with node.js streams: always handle errors on each and every stream. Since `concat-stream` is not itself a stream it does not emit errors.
+
+We recommend using [`end-of-stream`](https://npmjs.org/end-of-stream) or [`pump`](https://npmjs.org/pump) for writing error tolerant stream code.
+
+# license
+
+MIT LICENSE

build/node_modules/browserify/node_modules/process/.eslintrc

@@ -0,0 +1,21 @@
+{
+extends: "eslint:recommended",
+  "env": {
+    "node": true,
+    "browser": true,
+    "es6" : true,
+    "mocha": true
+  },
+  "rules": {
+    "indent": [2, 4],
+    "brace-style": [2, "1tbs"],
+    "quotes": [2, "single"],
+    "no-console": 0,
+    "no-shadow": 0,
+    "no-use-before-define": [2, "nofunc"],
+    "no-underscore-dangle": 0,
+    "no-constant-condition": 0,
+    "space-after-function-name": 0,
+   "consistent-return": 0
+  }
+}

build/node_modules/browserify/node_modules/process/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2013 Roman Shtylman <shtylman@gmail.com>
+
+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.

build/node_modules/browserify/node_modules/process/README.md

@@ -0,0 +1,26 @@
+# process
+
+```require('process');``` just like any other module.
+
+Works in node.js and browsers via the browser.js shim provided with the module.
+
+## browser implementation
+
+The goal of this module is not to be a full-fledged alternative to the builtin process module. This module mostly exists to provide the nextTick functionality and little more. We keep this module lean because it will often be included by default by tools like browserify when it detects a module has used the `process` global.
+
+It also exposes a "browser" member (i.e. `process.browser`) which is `true` in this implementation but `undefined` in node. This can be used in isomorphic code that adjusts it's behavior depending on which environment it's running in. 
+
+If you are looking to provide other process methods, I suggest you monkey patch them onto the process global in your app. A list of user created patches is below.
+
+* [hrtime](https://github.com/kumavis/browser-process-hrtime)
+* [stdout](https://github.com/kumavis/browser-stdout)
+
+## package manager notes
+
+If you are writing a bundler to package modules for client side use, make sure you use the ```browser``` field hint in package.json.
+
+See https://gist.github.com/4339901 for details.
+
+The [browserify](https://github.com/substack/node-browserify) module will properly handle this field when bundling your files.
+
+

build/node_modules/browserify/node_modules/process/browser.js

@@ -0,0 +1,184 @@
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };

build/node_modules/browserify/node_modules/process/index.js

@@ -0,0 +1,2 @@
+// for now just expose the builtin process global from node.js
+module.exports = global.process;

build/node_modules/browserify/node_modules/process/package.json

@@ -0,0 +1,59 @@
+{
+  "_from": "process@~0.11.0",
+  "_id": "process@0.11.10",
+  "_inBundle": false,
+  "_integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=",
+  "_location": "/browserify/process",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "process@~0.11.0",
+    "name": "process",
+    "escapedName": "process",
+    "rawSpec": "~0.11.0",
+    "saveSpec": null,
+    "fetchSpec": "~0.11.0"
+  },
+  "_requiredBy": [
+    "/browserify"
+  ],
+  "_resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
+  "_shasum": "7332300e840161bda3e69a1d1d91a7d4bc16f182",
+  "_spec": "process@~0.11.0",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build/node_modules/browserify",
+  "author": {
+    "name": "Roman Shtylman",
+    "email": "shtylman@gmail.com"
+  },
+  "browser": "./browser.js",
+  "bugs": {
+    "url": "https://github.com/shtylman/node-process/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "process information for node.js and browsers",
+  "devDependencies": {
+    "mocha": "2.2.1",
+    "zuul": "^3.10.3"
+  },
+  "engines": {
+    "node": ">= 0.6.0"
+  },
+  "homepage": "https://github.com/shtylman/node-process#readme",
+  "keywords": [
+    "process"
+  ],
+  "license": "MIT",
+  "main": "./index.js",
+  "name": "process",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/shtylman/node-process.git"
+  },
+  "scripts": {
+    "browser": "zuul --no-coverage --ui mocha-bdd --local 8080 -- test.js",
+    "test": "mocha test.js"
+  },
+  "version": "0.11.10"
+}

build/node_modules/browserify/node_modules/process/test.js

@@ -0,0 +1,199 @@
+var assert = require('assert');
+var ourProcess = require('./browser');
+describe('test against our process', function () {
+    test(ourProcess);
+});
+if (!process.browser) {
+  describe('test against node', function () {
+    test(process);
+  });
+  vmtest();
+}
+function test (ourProcess) {
+    describe('test arguments', function () {
+        it ('works', function (done) {
+          var order = 0;
+
+
+          ourProcess.nextTick(function (num) {
+              assert.equal(num, order++, 'first one works');
+              ourProcess.nextTick(function (num) {
+                assert.equal(num, order++, 'recursive one is 4th');
+              }, 3);
+          }, 0);
+          ourProcess.nextTick(function (num) {
+              assert.equal(num, order++, 'second one starts');
+              ourProcess.nextTick(function (num) {
+                assert.equal(num, order++, 'this is third');
+                ourProcess.nextTick(function (num) {
+                    assert.equal(num, order++, 'this is last');
+                    done();
+                }, 5);
+            }, 4);
+          }, 1);
+          ourProcess.nextTick(function (num) {
+
+              assert.equal(num, order++, '3rd schedualed happens after the error');
+          }, 2);
+        });
+    });
+if (!process.browser) {
+    describe('test errors', function (t) {
+        it ('works', function (done) {
+        var order = 0;
+        process.removeAllListeners('uncaughtException');
+        process.once('uncaughtException', function(err) {
+            assert.equal(2, order++, 'error is third');
+            ourProcess.nextTick(function () {
+                assert.equal(5, order++, 'schedualed in error is last');
+                done();
+            });
+        });
+        ourProcess.nextTick(function () {
+            assert.equal(0, order++, 'first one works');
+            ourProcess.nextTick(function () {
+            assert.equal(4, order++, 'recursive one is 4th');
+            });
+        });
+        ourProcess.nextTick(function () {
+            assert.equal(1, order++, 'second one starts');
+            throw(new Error('an error is thrown'));
+        });
+        ourProcess.nextTick(function () {
+            assert.equal(3, order++, '3rd schedualed happens after the error');
+        });
+        });
+    });
+}
+    describe('rename globals', function (t) {
+      var oldTimeout = setTimeout;
+      var oldClear = clearTimeout;
+
+      it('clearTimeout', function (done){
+
+        var ok = true;
+        clearTimeout = function () {
+          ok = false;
+        }
+        var ran = false;
+        function cleanup() {
+          clearTimeout = oldClear;
+          var err;
+          try {
+            assert.ok(ok, 'fake clearTimeout ran');
+            assert.ok(ran, 'should have run');
+          } catch (e) {
+            err = e;
+          }
+          done(err);
+        }
+        setTimeout(cleanup, 1000);
+        ourProcess.nextTick(function () {
+          ran = true;
+        });
+      });
+      it('just setTimeout', function (done){
+
+
+        setTimeout = function () {
+          setTimeout = oldTimeout;
+          try {
+            assert.ok(false, 'fake setTimeout called')
+          } catch (e) {
+            done(e);
+          }
+
+        }
+
+        ourProcess.nextTick(function () {
+          setTimeout = oldTimeout;
+          done();
+        });
+      });
+    });
+}
+function vmtest() {
+  var vm = require('vm');
+  var fs = require('fs');
+  var process =  fs.readFileSync('./browser.js', {encoding: 'utf8'});
+
+
+  describe('should work in vm in strict mode with no globals', function () {
+    it('should parse', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'this.works = process.browser;';
+      var script = new vm.Script(str);
+      var context = {
+        works: false
+      };
+      script.runInNewContext(context);
+      assert.ok(context.works);
+      done();
+    });
+    it('setTimeout throws error', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'try {process.nextTick(function () {})} catch (e){this.works = e;}';
+      var script = new vm.Script(str);
+      var context = {
+        works: false
+      };
+      script.runInNewContext(context);
+      assert.ok(context.works);
+      done();
+    });
+    it('should generally work', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'process.nextTick(function () {assert.ok(true);done();})';
+      var script = new vm.Script(str);
+      var context = {
+        clearTimeout: clearTimeout,
+        setTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+    it('late defs setTimeout', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'var setTimeout = hiddenSetTimeout;process.nextTick(function () {assert.ok(true);done();})';
+      var script = new vm.Script(str);
+      var context = {
+        clearTimeout: clearTimeout,
+        hiddenSetTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+    it('late defs clearTimeout', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'var clearTimeout = hiddenClearTimeout;process.nextTick(function () {assert.ok(true);done();})';
+      var script = new vm.Script(str);
+      var context = {
+        hiddenClearTimeout: clearTimeout,
+        setTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+    it('late defs setTimeout and then redefine', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'var setTimeout = hiddenSetTimeout;process.nextTick(function () {setTimeout = function (){throw new Error("foo")};hiddenSetTimeout(function(){process.nextTick(function (){assert.ok(true);done();});});});';
+      var script = new vm.Script(str);
+      var context = {
+        clearTimeout: clearTimeout,
+        hiddenSetTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+  });
+}

build/node_modules/browserify/node_modules/through2/.npmignore

@@ -0,0 +1,3 @@
+test
+.jshintrc
+.travis.yml

build/node_modules/browserify/node_modules/through2/LICENSE.html

@@ -0,0 +1,336 @@
+<!doctype html>
+<!-- Created with GFM2HTML: https://github.com/rvagg/gfm2html -->
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <title></title>
+    <meta name="description" content="">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="created-with" content="https://github.com/rvagg/gfm2html">
+
+    <style type="text/css">
+/* most of normalize.css */
+article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block;}[hidden],template{display:none;}html{font-family:sans-serif;/*1*/-ms-text-size-adjust:100%;/*2*/-webkit-text-size-adjust:100%;/*2*/}body{margin:0;}a{background:transparent;}a:focus{outline:thindotted;}a:active,a:hover{outline:0;}h1{font-size:2em;margin:0.67em0;}abbr[title]{border-bottom:1pxdotted;}b,strong{font-weight:bold;}dfn{font-style:italic;}hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0;}mark{background:#ff0;color:#000;}code,kbd,pre,samp{font-family:monospace,serif;font-size:1em;}pre{white-space:pre-wrap;}q{quotes:"\201C""\201D""\2018""\2019";}small{font-size:80%;}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline;}sup{top:-0.5em;}sub{bottom:-0.25em;}img{border:0;}svg:not(:root){overflow:hidden;}table{border-collapse:collapse;border-spacing:0;}
+
+html {
+  font: 14px 'Helvetica Neue', Helvetica, arial, freesans, clean, sans-serif;
+}
+
+.container {
+  line-height: 1.6;
+  color: #333;
+  background: #eee;
+  border-radius: 3px;
+  padding: 3px;
+  width: 790px;
+  margin: 10px auto;
+}
+
+.body-content {
+  background-color: #fff;
+  border: 1px solid #CACACA;
+  padding: 30px;
+}
+
+.body-content > *:first-child {
+  margin-top: 0 !important;
+}
+
+a, a:visited {
+  color: #4183c4;
+  text-decoration: none;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+p, blockquote, ul, ol, dl, table, pre {
+  margin: 15px 0;
+}
+
+  .markdown-body h1
+, .markdown-body h2
+, .markdown-body h3
+, .markdown-body h4
+, .markdown-body h5
+, .markdown-body h6 {
+  margin: 20px 0 10px;
+  padding: 0;
+  font-weight: bold;
+}
+
+h1 {
+  font-size: 2.5em;
+  color: #000;
+  border-bottom: 1px solid #ddd;
+}
+
+h2 {
+  font-size: 2em;
+  border-bottom: 1px solid #eee;
+  color: #000;
+}
+
+img {
+  max-width: 100%;
+}
+
+hr {
+  background: transparent url("/img/hr.png") repeat-x 0 0;
+  border: 0 none;
+  color: #ccc;
+  height: 4px;
+  padding: 0;
+}
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+tr:nth-child(2n) {
+  background-color: #f8f8f8;
+}
+
+.markdown-body tr {
+  border-top: 1px solid #ccc;
+  background-color: #fff;
+}
+
+td, th {
+  border: 1px solid #ccc;
+  padding: 6px 13px;
+}
+
+th {
+  font-weight: bold;
+}
+
+blockquote {
+  border-left: 4px solid #ddd;
+  padding: 0 15px;
+  color: #777;
+}
+
+blockquote > :last-child, blockquote > :first-child {
+  margin-bottom: 0px;
+}
+
+pre, code {
+  font-size: 13px;
+  font-family: 'UbuntuMono', monospace;
+  white-space: nowrap;
+  margin: 0 2px;
+  padding: 0px 5px;
+  border: 1px solid #eaeaea;
+  background-color: #f8f8f8;
+  border-radius: 3px;
+}
+
+pre > code {
+  white-space: pre;
+}
+
+pre {
+  overflow-x: auto;
+  white-space: pre;
+  padding: 10px;
+  line-height: 150%;
+  background-color: #f8f8f8;
+  border-color: #ccc;
+}
+
+pre code, pre tt {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  background-color: transparent;
+  border: none;
+}
+
+  .highlight .c
+, .highlight .cm
+, .highlight .cp
+, .highlight .c1 {
+    color:#999988;
+    font-style:italic;
+}
+
+.highlight .err {
+  color:#a61717;
+  background-color:#e3d2d2
+}
+
+  .highlight .o
+, .highlight .gs
+, .highlight .kc
+, .highlight .kd
+, .highlight .kn
+, .highlight .kp
+, .highlight .kr {
+    font-weight:bold
+}
+
+.highlight .cs {
+  color:#999999;
+  font-weight:bold;
+  font-style:italic
+}
+
+.highlight .gd {
+  color:#000000;
+  background-color:#ffdddd
+}
+
+.highlight .gd .x {
+  color:#000000;
+  background-color:#ffaaaa
+}
+
+.highlight .ge {
+  font-style:italic
+}
+
+  .highlight .gr
+, .highlight .gt {
+    color:#aa0000
+}
+
+  .highlight .gh
+, .highlight .bp {
+    color:#999999
+}
+
+.highlight .gi {
+  color:#000000;
+  background-color:#ddffdd
+}
+
+.highlight .gi .x {
+  color:#000000;
+  background-color:#aaffaa
+}
+
+.highlight .go {
+  color:#888888
+}
+
+  .highlight .gp
+, .highlight .nn {
+    color:#555555
+}
+
+
+.highlight .gu {
+  color:#800080;
+  font-weight:bold
+}
+
+
+.highlight .kt {
+  color:#445588;
+  font-weight:bold
+}
+
+  .highlight .m
+, .highlight .mf
+, .highlight .mh
+, .highlight .mi
+, .highlight .mo
+, .highlight .il {
+    color:#009999
+}
+
+  .highlight .s
+, .highlight .sb
+, .highlight .sc
+, .highlight .sd
+, .highlight .s2
+, .highlight .se
+, .highlight .sh
+, .highlight .si
+, .highlight .sx
+, .highlight .s1 {
+    color:#d14
+}
+
+.highlight .n {
+  color:#333333
+}
+
+  .highlight .na
+, .highlight .no
+, .highlight .nv
+, .highlight .vc
+, .highlight .vg
+, .highlight .vi
+, .highlight .nb {
+    color:#0086B3
+}
+
+.highlight .nc {
+  color:#445588;
+  font-weight:bold
+}
+
+.highlight .ni {
+  color:#800080
+}
+
+  .highlight .ne
+, .highlight .nf {
+    color:#990000;
+    font-weight:bold
+}
+
+.highlight .nt {
+  color:#000080
+}
+
+.highlight .ow {
+  font-weight:bold
+}
+
+.highlight .w {
+  color:#bbbbbb
+}
+
+.highlight .sr {
+  color:#009926
+}
+
+.highlight .ss {
+  color:#990073
+}
+
+.highlight .gc {
+  color:#999;
+  background-color:#EAF2F5
+}
+
+@media print {
+  .container {
+    background: transparent;
+    border-radius: 0;
+    padding: 0;
+  }
+
+  .body-content {
+    border: none;
+  }
+}
+</style>
+  </head>
+  <body>
+    <div class="container">
+      <div class="body-content"><h1 id="the-mit-license-mit-">The MIT License (MIT)</h1>
+<p><strong>Copyright (c) 2016 Rod Vagg (the &quot;Original Author&quot;) and additional contributors</strong></p>
+<p>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the &quot;Software&quot;), 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:</p>
+<p>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.</p>
+<p>THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, 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.</p>
+</div>
+    </div>
+  </body>
+</html>

build/node_modules/browserify/node_modules/through2/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+**Copyright (c) 2016 Rod Vagg (the "Original Author") and additional contributors**
+
+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.

build/node_modules/browserify/node_modules/through2/README.md

@@ -0,0 +1,136 @@
+# through2
+
+[![NPM](https://nodei.co/npm/through2.png?downloads&downloadRank)](https://nodei.co/npm/through2/)
+
+**A tiny wrapper around Node streams.Transform (Streams2) to avoid explicit subclassing noise**
+
+Inspired by [Dominic Tarr](https://github.com/dominictarr)'s [through](https://github.com/dominictarr/through) in that it's so much easier to make a stream out of a function than it is to set up the prototype chain properly: `through(function (chunk) { ... })`.
+
+Note: As 2.x.x this module starts using **Streams3** instead of Stream2. To continue using a Streams2 version use `npm install through2@0` to fetch the latest version of 0.x.x. More information about Streams2 vs Streams3 and recommendations see the article **[Why I don't use Node's core 'stream' module](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html)**.
+
+```js
+fs.createReadStream('ex.txt')
+  .pipe(through2(function (chunk, enc, callback) {
+    for (var i = 0; i < chunk.length; i++)
+      if (chunk[i] == 97)
+        chunk[i] = 122 // swap 'a' for 'z'
+
+    this.push(chunk)
+
+    callback()
+   }))
+  .pipe(fs.createWriteStream('out.txt'))
+  .on('finish', function () {
+    doSomethingSpecial()
+  })
+```
+
+Or object streams:
+
+```js
+var all = []
+
+fs.createReadStream('data.csv')
+  .pipe(csv2())
+  .pipe(through2.obj(function (chunk, enc, callback) {
+    var data = {
+        name    : chunk[0]
+      , address : chunk[3]
+      , phone   : chunk[10]
+    }
+    this.push(data)
+
+    callback()
+  }))
+  .on('data', function (data) {
+    all.push(data)
+  })
+  .on('end', function () {
+    doSomethingSpecial(all)
+  })
+```
+
+Note that `through2.obj(fn)` is a convenience wrapper around `through2({ objectMode: true }, fn)`.
+
+## API
+
+<b><code>through2([ options, ] [ transformFunction ] [, flushFunction ])</code></b>
+
+Consult the **[stream.Transform](http://nodejs.org/docs/latest/api/stream.html#stream_class_stream_transform)** documentation for the exact rules of the `transformFunction` (i.e. `this._transform`) and the optional `flushFunction` (i.e. `this._flush`).
+
+### options
+
+The options argument is optional and is passed straight through to `stream.Transform`. So you can use `objectMode:true` if you are processing non-binary streams (or just use `through2.obj()`).
+
+The `options` argument is first, unlike standard convention, because if I'm passing in an anonymous function then I'd prefer for the options argument to not get lost at the end of the call:
+
+```js
+fs.createReadStream('/tmp/important.dat')
+  .pipe(through2({ objectMode: true, allowHalfOpen: false },
+    function (chunk, enc, cb) {
+      cb(null, 'wut?') // note we can use the second argument on the callback
+                       // to provide data as an alternative to this.push('wut?')
+    }
+  )
+  .pipe(fs.createWriteStream('/tmp/wut.txt'))
+```
+
+### transformFunction
+
+The `transformFunction` must have the following signature: `function (chunk, encoding, callback) {}`. A minimal implementation should call the `callback` function to indicate that the transformation is done, even if that transformation means discarding the chunk.
+
+To queue a new chunk, call `this.push(chunk)`&mdash;this can be called as many times as required before the `callback()` if you have multiple pieces to send on.
+
+Alternatively, you may use `callback(err, chunk)` as shorthand for emitting a single chunk or an error.
+
+If you **do not provide a `transformFunction`** then you will get a simple pass-through stream.
+
+### flushFunction
+
+The optional `flushFunction` is provided as the last argument (2nd or 3rd, depending on whether you've supplied options) is called just prior to the stream ending. Can be used to finish up any processing that may be in progress.
+
+```js
+fs.createReadStream('/tmp/important.dat')
+  .pipe(through2(
+    function (chunk, enc, cb) { cb(null, chunk) }, // transform is a noop
+    function (cb) { // flush function
+      this.push('tacking on an extra buffer to the end');
+      cb();
+    }
+  ))
+  .pipe(fs.createWriteStream('/tmp/wut.txt'));
+```
+
+<b><code>through2.ctor([ options, ] transformFunction[, flushFunction ])</code></b>
+
+Instead of returning a `stream.Transform` instance, `through2.ctor()` returns a **constructor** for a custom Transform. This is useful when you want to use the same transform logic in multiple instances.
+
+```js
+var FToC = through2.ctor({objectMode: true}, function (record, encoding, callback) {
+  if (record.temp != null && record.unit == "F") {
+    record.temp = ( ( record.temp - 32 ) * 5 ) / 9
+    record.unit = "C"
+  }
+  this.push(record)
+  callback()
+})
+
+// Create instances of FToC like so:
+var converter = new FToC()
+// Or:
+var converter = FToC()
+// Or specify/override options when you instantiate, if you prefer:
+var converter = FToC({objectMode: true})
+```
+
+## See Also
+
+  - [through2-map](https://github.com/brycebaril/through2-map) - Array.prototype.map analog for streams.
+  - [through2-filter](https://github.com/brycebaril/through2-filter) - Array.prototype.filter analog for streams.
+  - [through2-reduce](https://github.com/brycebaril/through2-reduce) - Array.prototype.reduce analog for streams.
+  - [through2-spy](https://github.com/brycebaril/through2-spy) - Wrapper for simple stream.PassThrough spies.
+  - the [mississippi stream utility collection](https://github.com/maxogden/mississippi) includes `through2` as well as many more useful stream modules similar to this one
+
+## License
+
+**through2** is Copyright (c) 2013 Rod Vagg [@rvagg](https://twitter.com/rvagg) and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.

build/node_modules/browserify/node_modules/through2/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "through2@^2.0.0",
+  "_id": "through2@2.0.3",
+  "_inBundle": false,
+  "_integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=",
+  "_location": "/browserify/through2",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "through2@^2.0.0",
+    "name": "through2",
+    "escapedName": "through2",
+    "rawSpec": "^2.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.0.0"
+  },
+  "_requiredBy": [
+    "/browserify"
+  ],
+  "_resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz",
+  "_shasum": "0004569b37c7c74ba39c43f3ced78d1ad94140be",
+  "_spec": "through2@^2.0.0",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build/node_modules/browserify",
+  "author": {
+    "name": "Rod Vagg",
+    "email": "r@va.gg",
+    "url": "https://github.com/rvagg"
+  },
+  "bugs": {
+    "url": "https://github.com/rvagg/through2/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "readable-stream": "^2.1.5",
+    "xtend": "~4.0.1"
+  },
+  "deprecated": false,
+  "description": "A tiny wrapper around Node streams2 Transform to avoid explicit subclassing noise",
+  "devDependencies": {
+    "bl": "~1.1.2",
+    "faucet": "0.0.1",
+    "stream-spigot": "~3.0.5",
+    "tape": "~4.6.2"
+  },
+  "homepage": "https://github.com/rvagg/through2#readme",
+  "keywords": [
+    "stream",
+    "streams2",
+    "through",
+    "transform"
+  ],
+  "license": "MIT",
+  "main": "through2.js",
+  "name": "through2",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rvagg/through2.git"
+  },
+  "scripts": {
+    "test": "node test/test.js | faucet",
+    "test-local": "brtapsauce-local test/basic-test.js"
+  },
+  "version": "2.0.3"
+}

build/node_modules/browserify/node_modules/through2/through2.js

@@ -0,0 +1,96 @@
+var Transform = require('readable-stream/transform')
+  , inherits  = require('util').inherits
+  , xtend     = require('xtend')
+
+function DestroyableTransform(opts) {
+  Transform.call(this, opts)
+  this._destroyed = false
+}
+
+inherits(DestroyableTransform, Transform)
+
+DestroyableTransform.prototype.destroy = function(err) {
+  if (this._destroyed) return
+  this._destroyed = true
+  
+  var self = this
+  process.nextTick(function() {
+    if (err)
+      self.emit('error', err)
+    self.emit('close')
+  })
+}
+
+// a noop _transform function
+function noop (chunk, enc, callback) {
+  callback(null, chunk)
+}
+
+
+// create a new export function, used by both the main export and
+// the .ctor export, contains common logic for dealing with arguments
+function through2 (construct) {
+  return function (options, transform, flush) {
+    if (typeof options == 'function') {
+      flush     = transform
+      transform = options
+      options   = {}
+    }
+
+    if (typeof transform != 'function')
+      transform = noop
+
+    if (typeof flush != 'function')
+      flush = null
+
+    return construct(options, transform, flush)
+  }
+}
+
+
+// main export, just make me a transform stream!
+module.exports = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(options)
+
+  t2._transform = transform
+
+  if (flush)
+    t2._flush = flush
+
+  return t2
+})
+
+
+// make me a reusable prototype that I can `new`, or implicitly `new`
+// with a constructor call
+module.exports.ctor = through2(function (options, transform, flush) {
+  function Through2 (override) {
+    if (!(this instanceof Through2))
+      return new Through2(override)
+
+    this.options = xtend(options, override)
+
+    DestroyableTransform.call(this, this.options)
+  }
+
+  inherits(Through2, DestroyableTransform)
+
+  Through2.prototype._transform = transform
+
+  if (flush)
+    Through2.prototype._flush = flush
+
+  return Through2
+})
+
+
+module.exports.obj = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(xtend({ objectMode: true, highWaterMark: 16 }, options))
+
+  t2._transform = transform
+
+  if (flush)
+    t2._flush = flush
+
+  return t2
+})

build/node_modules/browserify/package.json

@@ -0,0 +1,131 @@
+{
+  "_from": "browserify",
+  "_id": "browserify@14.5.0",
+  "_inBundle": false,
+  "_integrity": "sha512-gKfOsNQv/toWz+60nSPfYzuwSEdzvV2WdxrVPUbPD/qui44rAkB3t3muNtmmGYHqrG56FGwX9SUEQmzNLAeS7g==",
+  "_location": "/browserify",
+  "_phantomChildren": {
+    "core-util-is": "1.0.2",
+    "inherits": "2.0.3",
+    "isarray": "1.0.0",
+    "process-nextick-args": "1.0.7",
+    "readable-stream": "2.3.3",
+    "typedarray": "0.0.6",
+    "util-deprecate": "1.0.2",
+    "xtend": "4.0.1"
+  },
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "browserify",
+    "name": "browserify",
+    "escapedName": "browserify",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/browserify/-/browserify-14.5.0.tgz",
+  "_shasum": "0bbbce521acd6e4d1d54d8e9365008efb85a9cc5",
+  "_spec": "browserify",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "bin": {
+    "browserify": "bin/cmd.js"
+  },
+  "bugs": {
+    "url": "https://github.com/substack/node-browserify/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "JSONStream": "^1.0.3",
+    "assert": "^1.4.0",
+    "browser-pack": "^6.0.1",
+    "browser-resolve": "^1.11.0",
+    "browserify-zlib": "~0.2.0",
+    "buffer": "^5.0.2",
+    "cached-path-relative": "^1.0.0",
+    "concat-stream": "~1.5.1",
+    "console-browserify": "^1.1.0",
+    "constants-browserify": "~1.0.0",
+    "crypto-browserify": "^3.0.0",
+    "defined": "^1.0.0",
+    "deps-sort": "^2.0.0",
+    "domain-browser": "~1.1.0",
+    "duplexer2": "~0.1.2",
+    "events": "~1.1.0",
+    "glob": "^7.1.0",
+    "has": "^1.0.0",
+    "htmlescape": "^1.1.0",
+    "https-browserify": "^1.0.0",
+    "inherits": "~2.0.1",
+    "insert-module-globals": "^7.0.0",
+    "labeled-stream-splicer": "^2.0.0",
+    "module-deps": "^4.0.8",
+    "os-browserify": "~0.3.0",
+    "parents": "^1.0.1",
+    "path-browserify": "~0.0.0",
+    "process": "~0.11.0",
+    "punycode": "^1.3.2",
+    "querystring-es3": "~0.2.0",
+    "read-only-stream": "^2.0.0",
+    "readable-stream": "^2.0.2",
+    "resolve": "^1.1.4",
+    "shasum": "^1.0.0",
+    "shell-quote": "^1.6.1",
+    "stream-browserify": "^2.0.0",
+    "stream-http": "^2.0.0",
+    "string_decoder": "~1.0.0",
+    "subarg": "^1.0.0",
+    "syntax-error": "^1.1.1",
+    "through2": "^2.0.0",
+    "timers-browserify": "^1.0.1",
+    "tty-browserify": "~0.0.0",
+    "url": "~0.11.0",
+    "util": "~0.10.1",
+    "vm-browserify": "~0.0.1",
+    "xtend": "^4.0.0"
+  },
+  "deprecated": false,
+  "description": "browser-side require() the node way",
+  "devDependencies": {
+    "backbone": "~0.9.2",
+    "browser-unpack": "^1.1.1",
+    "coffee-script": "~1.10.0",
+    "coffeeify": "~1.1.0",
+    "es6ify": "~0.4.8",
+    "isstream": "^0.1.2",
+    "seq": "0.3.5",
+    "tap": "^2.2.0",
+    "temp": "^0.8.1",
+    "through": "^2.3.4"
+  },
+  "homepage": "https://github.com/substack/node-browserify#readme",
+  "keywords": [
+    "browser",
+    "require",
+    "commonjs",
+    "commonj-esque",
+    "bundle",
+    "npm",
+    "javascript"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "browserify",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/substack/node-browserify.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "version": "14.5.0"
+}

build/node_modules/browserify/readme.markdown

@@ -0,0 +1,820 @@
+# browserify
+
+`require('modules')` in the browser
+
+Use a [node](http://nodejs.org)-style `require()` to organize your browser code
+and load modules installed by [npm](https://www.npmjs.com).
+
+browserify will recursively analyze all the `require()` calls in your app in
+order to build a bundle you can serve up to the browser in a single `<script>`
+tag.
+
+[![build status](https://img.shields.io/travis/browserify/browserify/master.svg)](https://travis-ci.org/browserify/browserify)
+
+![browserify!](http://substack.net/images/browserify_logo.png)
+
+# getting started
+
+If you're new to browserify, check out the
+[browserify handbook](https://github.com/browserify/browserify-handbook)
+and the resources on [browserify.org](http://browserify.org/).
+
+Check out [browserify search](http://browserifysearch.org/) to find
+browserify-compatible packages on npm.
+
+# example
+
+Whip up a file, `main.js` with some `require()`s in it. You can use relative
+paths like `'./foo.js'` and `'../lib/bar.js'` or module paths like `'gamma'`
+that will search `node_modules/` using
+[node's module lookup algorithm](https://github.com/browserify/resolve).
+
+``` js
+var foo = require('./foo.js');
+var bar = require('../lib/bar.js');
+var gamma = require('gamma');
+
+var elem = document.getElementById('result');
+var x = foo(100) + bar('baz');
+elem.textContent = gamma(x);
+```
+
+Export functionality by assigning onto `module.exports` or `exports`:
+
+``` js
+module.exports = function (n) { return n * 111 }
+```
+
+Now just use the `browserify` command to build a bundle starting at `main.js`:
+
+```
+$ browserify main.js > bundle.js
+```
+
+All of the modules that `main.js` needs are included in the `bundle.js` from a
+recursive walk of the `require()` graph using
+[required](https://github.com/defunctzombie/node-required).
+
+To use this bundle, just toss a `<script src="bundle.js"></script>` into your
+html!
+
+# install
+
+With [npm](https://www.npmjs.com/) do:
+
+```
+npm install -g browserify
+```
+
+# usage
+
+```
+Usage: browserify [entry files] {OPTIONS}
+
+Standard Options:
+
+    --outfile, -o  Write the browserify bundle to this file.
+                   If unspecified, browserify prints to stdout.
+
+    --require, -r  A module name or file to bundle.require()
+                   Optionally use a colon separator to set the target.
+
+      --entry, -e  An entry point of your app
+
+     --ignore, -i  Replace a file with an empty stub. Files can be globs.
+
+    --exclude, -u  Omit a file from the output bundle. Files can be globs.
+
+   --external, -x  Reference a file from another bundle. Files can be globs.
+
+  --transform, -t  Use a transform module on top-level files.
+
+    --command, -c  Use a transform command on top-level files.
+
+  --standalone -s  Generate a UMD bundle for the supplied export name.
+                   This bundle works with other module systems and sets the name
+                   given as a window global if no module system is found.
+
+       --debug -d  Enable source maps that allow you to debug your files
+                   separately.
+
+       --help, -h  Show this message
+
+For advanced options, type `browserify --help advanced`.
+
+Specify a parameter.
+```
+
+```
+Advanced Options:
+
+  --insert-globals, --ig, --fast    [default: false]
+
+    Skip detection and always insert definitions for process, global,
+    __filename, and __dirname.
+
+    benefit: faster builds
+    cost: extra bytes
+
+  --insert-global-vars, --igv
+
+    Comma-separated list of global variables to detect and define.
+    Default: __filename,__dirname,process,Buffer,global
+
+  --detect-globals, --dg            [default: true]
+
+    Detect the presence of process, global, __filename, and __dirname and define
+    these values when present.
+
+    benefit: npm modules more likely to work
+    cost: slower builds
+
+  --ignore-missing, --im            [default: false]
+
+    Ignore `require()` statements that don't resolve to anything.
+
+  --noparse=FILE
+
+    Don't parse FILE at all. This will make bundling much, much faster for giant
+    libs like jquery or threejs.
+
+  --no-builtins
+
+    Turn off builtins. This is handy when you want to run a bundle in node which
+    provides the core builtins.
+
+  --no-commondir
+
+    Turn off setting a commondir. This is useful if you want to preserve the
+    original paths that a bundle was generated with.
+
+  --no-bundle-external
+
+    Turn off bundling of all external modules. This is useful if you only want
+    to bundle your local files.
+
+  --bare
+
+    Alias for both --no-builtins, --no-commondir, and sets --insert-global-vars
+    to just "__filename,__dirname". This is handy if you want to run bundles in
+    node.
+
+  --no-browser-field, --no-bf
+
+    Turn off package.json browser field resolution. This is also handy if you
+    need to run a bundle in node.
+
+  --transform-key
+
+    Instead of the default package.json#browserify#transform field to list
+    all transforms to apply when running browserify, a custom field, like, e.g.
+    package.json#browserify#production or package.json#browserify#staging
+    can be used, by for example running:
+    * `browserify index.js --transform-key=production > bundle.js`
+    * `browserify index.js --transform-key=staging > bundle.js`
+
+  --node
+
+    Alias for --bare and --no-browser-field.
+
+  --full-paths
+
+    Turn off converting module ids into numerical indexes. This is useful for
+    preserving the original paths that a bundle was generated with.
+
+  --deps
+
+    Instead of standard bundle output, print the dependency array generated by
+    module-deps.
+
+  --no-dedupe
+
+    Turn off deduping.
+
+  --list
+
+    Print each file in the dependency graph. Useful for makefiles.
+
+  --extension=EXTENSION
+
+    Consider files with specified EXTENSION as modules, this option can used
+    multiple times.
+
+  --global-transform=MODULE, -g MODULE
+
+    Use a transform module on all files after any ordinary transforms have run.
+
+  --ignore-transform=MODULE, -it MODULE
+
+    Do not run certain transformations, even if specified elsewhere.
+
+  --plugin=MODULE, -p MODULE
+
+    Register MODULE as a plugin.
+
+Passing arguments to transforms and plugins:
+
+  For -t, -g, and -p, you may use subarg syntax to pass options to the
+  transforms or plugin function as the second parameter. For example:
+
+    -t [ foo -x 3 --beep ]
+
+  will call the `foo` transform for each applicable file by calling:
+
+    foo(file, { x: 3, beep: true })
+
+```
+
+# compatibility
+
+Many [npm](https://www.npmjs.com/) modules that don't do IO will just work after being
+browserified. Others take more work.
+
+Many node built-in modules have been wrapped to work in the browser, but only
+when you explicitly `require()` or use their functionality.
+
+When you `require()` any of these modules, you will get a browser-specific shim:
+
+* [assert](https://www.npmjs.com/package/assert)
+* [buffer](https://www.npmjs.com/package/buffer)
+* [console](https://www.npmjs.com/package/console-browserify)
+* [constants](https://www.npmjs.com/package/constants-browserify)
+* [crypto](https://www.npmjs.com/package/crypto-browserify)
+* [domain](https://www.npmjs.com/package/domain-browser)
+* [events](https://www.npmjs.com/package/events)
+* [http](https://www.npmjs.com/package/stream-http)
+* [https](https://www.npmjs.com/package/https-browserify)
+* [os](https://www.npmjs.com/package/os-browserify)
+* [path](https://www.npmjs.com/package/path-browserify)
+* [punycode](https://www.npmjs.com/package/punycode)
+* [querystring](https://www.npmjs.com/package/querystring-es3)
+* [stream](https://www.npmjs.com/package/stream-browserify)
+* [string_decoder](https://www.npmjs.com/package/string_decoder)
+* [timers](https://www.npmjs.com/package/timers-browserify)
+* [tty](https://www.npmjs.com/package/tty-browserify)
+* [url](https://www.npmjs.com/package/url)
+* [util](https://www.npmjs.com/package/util)
+* [vm](https://www.npmjs.com/package/vm-browserify)
+* [zlib](https://www.npmjs.com/package/browserify-zlib)
+
+Additionally, if you use any of these variables, they
+[will be defined](https://github.com/browserify/insert-module-globals)
+in the bundled output in a browser-appropriate way:
+
+* [process](https://www.npmjs.com/package/process)
+* [Buffer](https://www.npmjs.com/package/buffer)
+* global - top-level scope object (window)
+* __filename - file path of the currently executing file
+* __dirname - directory path of the currently executing file
+
+# more examples
+
+## external requires
+
+You can just as easily create a bundle that will export a `require()` function so
+you can `require()` modules from another script tag. Here we'll create a
+`bundle.js` with the [through](https://www.npmjs.com/package/through)
+and [duplexer](https://www.npmjs.com/package/duplexer) modules.
+
+```
+$ browserify -r through -r duplexer -r ./my-file.js:my-module > bundle.js
+```
+
+Then in your page you can do:
+
+``` html
+<script src="bundle.js"></script>
+<script>
+  var through = require('through');
+  var duplexer = require('duplexer');
+  var myModule = require('my-module');
+  /* ... */
+</script>
+```
+
+## external source maps
+
+If you prefer the source maps be saved to a separate `.js.map` source map file, you may use
+[exorcist](https://github.com/thlorenz/exorcist) in order to achieve that. It's as simple as:
+
+```
+$ browserify main.js --debug | exorcist bundle.js.map > bundle.js
+```
+
+Learn about additional options [here](https://github.com/thlorenz/exorcist#usage).
+
+## multiple bundles
+
+If browserify finds a `require`d function already defined in the page scope, it
+will fall back to that function if it didn't find any matches in its own set of
+bundled modules.
+
+In this way, you can use browserify to split up bundles among multiple pages to
+get the benefit of caching for shared, infrequently-changing modules, while
+still being able to use `require()`. Just use a combination of `--external` and
+`--require` to factor out common dependencies.
+
+For example, if a website with 2 pages, `beep.js`:
+
+``` js
+var robot = require('./robot.js');
+console.log(robot('beep'));
+```
+
+and `boop.js`:
+
+``` js
+var robot = require('./robot.js');
+console.log(robot('boop'));
+```
+
+both depend on `robot.js`:
+
+``` js
+module.exports = function (s) { return s.toUpperCase() + '!' };
+```
+
+```
+$ browserify -r ./robot.js > static/common.js
+$ browserify -x ./robot.js beep.js > static/beep.js
+$ browserify -x ./robot.js boop.js > static/boop.js
+```
+
+Then on the beep page you can have:
+
+``` html
+<script src="common.js"></script>
+<script src="beep.js"></script>
+```
+
+while the boop page can have:
+
+``` html
+<script src="common.js"></script>
+<script src="boop.js"></script>
+```
+
+This approach using `-r` and `-x` works fine for a small number of split assets,
+but there are plugins for automatically factoring out components which are
+described in the
+[partitioning section of the browserify handbook](https://github.com/browserify/browserify-handbook#partitioning).
+
+## api example
+
+You can use the API directly too:
+
+``` js
+var browserify = require('browserify');
+var b = browserify();
+b.add('./browser/main.js');
+b.bundle().pipe(process.stdout);
+```
+
+# methods
+
+``` js
+var browserify = require('browserify')
+```
+
+## `browserify([files] [, opts])`
+
+Returns a new browserify instance.
+
+<dl>
+<dt>
+files
+</dt>
+
+<dd>
+String, file object, or array of those types (they may be mixed) specifying entry file(s).
+</dd>
+
+<dt>
+opts
+</dt>
+
+<dd>
+Object.
+</dd>
+</dl>
+
+`files` and `opts` are both optional, but must be in the order shown if both are
+passed.
+
+Entry files may be passed in `files` and / or `opts.entries`.
+
+External requires may be specified in `opts.require`, accepting the same formats
+that the `files` argument does.
+
+If an entry file is a stream, its contents will be used. You should pass
+`opts.basedir` when using streaming files so that relative requires can be
+resolved.
+
+`opts.entries` has the same definition as `files`.
+
+`opts.noParse` is an array which will skip all require() and global parsing for
+each file in the array. Use this for giant libs like jquery or threejs that
+don't have any requires or node-style globals but take forever to parse.
+
+`opts.transform` is an array of transform functions or modules names which will
+transform the source code before the parsing.
+
+`opts.ignoreTransform` is an array of transformations that will not be run,
+even if specified elsewhere.
+
+`opts.plugin` is an array of plugin functions or module names to use. See the
+plugins section below for details.
+
+`opts.extensions` is an array of optional extra extensions for the module lookup
+machinery to use when the extension has not been specified.
+By default browserify considers only `.js` and `.json` files in such cases.
+
+`opts.basedir` is the directory that browserify starts bundling from for
+filenames that start with `.`.
+
+`opts.paths` is an array of directories that browserify searches when looking
+for modules which are not referenced using relative path. Can be absolute or
+relative to `basedir`. Equivalent of setting `NODE_PATH` environmental variable
+when calling `browserify` command.
+
+`opts.commondir` sets the algorithm used to parse out the common paths. Use
+`false` to turn this off, otherwise it uses the
+[commondir](https://www.npmjs.com/package/commondir) module.
+
+`opts.fullPaths` disables converting module ids into numerical indexes. This is
+useful for preserving the original paths that a bundle was generated with.
+
+`opts.builtins` sets the list of built-ins to use, which by default is set in
+`lib/builtins.js` in this distribution.
+
+`opts.bundleExternal` boolean option to set if external modules should be
+bundled. Defaults to true.
+
+When `opts.browserField` is false, the package.json browser field will be ignored.
+
+When `opts.insertGlobals` is true, always insert `process`, `global`,
+`__filename`, and `__dirname` without analyzing the AST for faster builds but
+larger output bundles. Default false.
+
+When `opts.detectGlobals` is true, scan all files for `process`, `global`,
+`__filename`, and `__dirname`, defining as necessary. With this option npm
+modules are more likely to work but bundling takes longer. Default true.
+
+When `opts.ignoreMissing` is true, ignore `require()` statements that don't
+resolve to anything.
+
+When `opts.debug` is true, add a source map inline to the end of the bundle.
+This makes debugging easier because you can see all the original files if
+you are in a modern enough browser.
+
+When `opts.standalone` is a non-empty string, a standalone module is created
+with that name and a [umd](https://github.com/forbeslindesay/umd) wrapper.
+You can use namespaces in the standalone global export using a `.` in the string
+name as a separator, for example `'A.B.C'`. The global export will be [sanitized
+and camel cased](https://github.com/ForbesLindesay/umd#name-casing-and-characters).
+
+Note that in standalone mode the `require()` calls from the original source will
+still be around, which may trip up AMD loaders scanning for `require()` calls.
+You can remove these calls with
+[derequire](https://www.npmjs.com/package/derequire):
+
+```
+$ npm install -g derequire
+$ browserify main.js --standalone Foo | derequire > bundle.js
+```
+
+`opts.insertGlobalVars` will be passed to
+[insert-module-globals](https://www.npmjs.com/package/insert-module-globals)
+as the `opts.vars` parameter.
+
+`opts.externalRequireName` defaults to `'require'` in `expose` mode but you can
+use another name.
+
+Note that if files do not contain javascript source code then you also need to
+specify a corresponding transform for them.
+
+All other options are forwarded along to
+[module-deps](https://www.npmjs.com/package/module-deps)
+and [browser-pack](https://www.npmjs.com/package/browser-pack) directly.
+
+## b.add(file, opts)
+
+Add an entry file from `file` that will be executed when the bundle loads.
+
+If `file` is an array, each item in `file` will be added as an entry file.
+
+## b.require(file, opts)
+
+Make `file` available from outside the bundle with `require(file)`.
+
+The `file` param is anything that can be resolved by `require.resolve()`.
+
+`file` can also be a stream, but you should also use `opts.basedir` so that
+relative requires will be resolvable.
+
+If `file` is an array, each item in `file` will be required.
+In `file` array form, you can use a string or object for each item. Object items
+should have a `file` property and the rest of the parameters will be used for
+the `opts`.
+
+Use the `expose` property of opts to specify a custom dependency name.
+`require('./vendor/angular/angular.js', {expose: 'angular'})` enables `require('angular')`
+
+## b.bundle(cb)
+
+Bundle the files and their dependencies into a single javascript file.
+
+Return a readable stream with the javascript file contents or
+optionally specify a `cb(err, buf)` to get the buffered results.
+
+## b.external(file)
+
+Prevent `file` from being loaded into the current bundle, instead referencing
+from another bundle.
+
+If `file` is an array, each item in `file` will be externalized.
+
+If `file` is another bundle, that bundle's contents will be read and excluded
+from the current bundle as the bundle in `file` gets bundled.
+
+## b.ignore(file)
+
+Prevent the module name or file at `file` from showing up in the output bundle.
+
+Instead you will get a file with `module.exports = {}`.
+
+## b.exclude(file)
+
+Prevent the module name or file at `file` from showing up in the output bundle.
+
+If your code tries to `require()` that file it will throw unless you've provided
+another mechanism for loading it.
+
+## b.transform(tr, opts={})
+
+Transform source code before parsing it for `require()` calls with the transform
+function or module name `tr`.
+
+If `tr` is a function, it will be called with `tr(file)` and it should return a
+[through-stream](https://github.com/substack/stream-handbook#through)
+that takes the raw file contents and produces the transformed source.
+
+If `tr` is a string, it should be a module name or file path of a
+[transform module](https://github.com/browserify/module-deps#transforms)
+with a signature of:
+
+``` js
+var through = require('through');
+module.exports = function (file) { return through() };
+```
+
+You don't need to necessarily use the
+[through](https://www.npmjs.com/package/through) module.
+Browserify is compatible with the newer, more verbose
+[Transform streams](http://nodejs.org/api/stream.html#stream_class_stream_transform_1)
+built into Node v0.10.
+
+Here's how you might compile coffee script on the fly using `.transform()`:
+
+``` js
+var coffee = require('coffee-script');
+var through = require('through');
+
+b.transform(function (file) {
+    var data = '';
+    return through(write, end);
+
+    function write (buf) { data += buf }
+    function end () {
+        this.queue(coffee.compile(data));
+        this.queue(null);
+    }
+});
+```
+
+Note that on the command-line with the `-c` flag you can just do:
+
+```
+$ browserify -c 'coffee -sc' main.coffee > bundle.js
+```
+
+Or better still, use the [coffeeify](https://github.com/jnordberg/coffeeify)
+module:
+
+```
+$ npm install coffeeify
+$ browserify -t coffeeify main.coffee > bundle.js
+```
+
+If `opts.global` is `true`, the transform will operate on ALL files, despite
+whether they exist up a level in a `node_modules/` directory. Use global
+transforms cautiously and sparingly, since most of the time an ordinary
+transform will suffice. You can also not configure global transforms in a
+`package.json` like you can with ordinary transforms.
+
+Global transforms always run after any ordinary transforms have run.
+
+Transforms may obtain options from the command-line with
+[subarg](https://www.npmjs.com/package/subarg) syntax:
+
+```
+$ browserify -t [ foo --bar=555 ] main.js
+```
+
+or from the api:
+
+```
+b.transform('foo', { bar: 555 })
+```
+
+In both cases, these options are provided as the second argument to the
+transform function:
+
+```
+module.exports = function (file, opts) { /* opts.bar === 555 */ }
+```
+
+Options sent to the browserify constructor are also provided under
+`opts._flags`. These browserify options are sometimes required if your transform
+needs to do something different when browserify is run in debug mode, for
+example.
+
+## b.plugin(plugin, opts)
+
+Register a `plugin` with `opts`. Plugins can be a string module name or a
+function the same as transforms.
+
+`plugin(b, opts)` is called with the browserify instance `b`.
+
+For more information, consult the plugins section below.
+
+## b.pipeline
+
+There is an internal
+[labeled-stream-splicer](https://www.npmjs.com/package/labeled-stream-splicer)
+pipeline with these labels:
+
+* `'record'` - save inputs to play back later on subsequent `bundle()` calls
+* `'deps'` - [module-deps](https://www.npmjs.com/package/module-deps)
+* `'json'` - adds `module.exports=` to the beginning of json files
+* `'unbom'` - remove byte-order markers
+* `'unshebang'` - remove #! labels on the first line
+* `'syntax'` - check for syntax errors
+* `'sort'` - sort the dependencies for deterministic bundles
+* `'dedupe'` - remove duplicate source contents
+* `'label'` - apply integer labels to files
+* `'emit-deps'` - emit `'dep'` event
+* `'debug'` - apply source maps
+* `'pack'` - [browser-pack](https://www.npmjs.com/package/browser-pack)
+* `'wrap'` - apply final wrapping, `require=` and a newline and semicolon
+
+You can call `b.pipeline.get()` with a label name to get a handle on a stream pipeline
+that you can `push()`, `unshift()`, or `splice()` to insert your own transform
+streams.
+
+## b.reset(opts)
+
+Reset the pipeline back to a normal state. This function is called automatically
+when `bundle()` is called multiple times.
+
+This function triggers a 'reset' event.
+
+# package.json
+
+browserify uses the `package.json` in its module resolution algorithm, just like
+node. If there is a `"main"` field, browserify will start resolving the package
+at that point. If there is no `"main"` field, browserify will look for an
+`"index.js"` file in the module root directory. Here are some more
+sophisticated things you can do in the package.json:
+
+## browser field
+
+There is a special "[browser](https://gist.github.com/4339901)" field you can
+set in your package.json on a per-module basis to override file resolution for
+browser-specific versions of files.
+
+For example, if you want to have a browser-specific module entry point for your
+`"main"` field you can just set the `"browser"` field to a string:
+
+``` json
+"browser": "./browser.js"
+```
+
+or you can have overrides on a per-file basis:
+
+``` json
+"browser": {
+  "fs": "level-fs",
+  "./lib/ops.js": "./browser/opts.js"
+}
+```
+
+Note that the browser field only applies to files in the local module, and like
+transforms, it doesn't apply into `node_modules` directories.
+
+## browserify.transform
+
+You can specify source transforms in the package.json in the
+`browserify.transform` field. There is more information about how source
+transforms work in package.json on the
+[module-deps readme](https://github.com/browserify/module-deps#transforms).
+
+For example, if your module requires [brfs](https://www.npmjs.com/package/brfs), you
+can add
+
+``` json
+"browserify": { "transform": [ "brfs" ] }
+```
+
+to your package.json. Now when somebody `require()`s your module, brfs will
+automatically be applied to the files in your module without explicit
+intervention by the person using your module. Make sure to add transforms to
+your package.json dependencies field.
+
+# events
+
+## b.on('file', function (file, id, parent) {})
+## b.pipeline.on('file', function (file, id, parent) {})
+
+When a file is resolved for the bundle, the bundle emits a `'file'` event with
+the full `file` path, the `id` string passed to `require()`, and the `parent`
+object used by
+[browser-resolve](https://github.com/defunctzombie/node-browser-resolve).
+
+You could use the `file` event to implement a file watcher to regenerate bundles
+when files change.
+
+## b.on('package', function (pkg) {})
+## b.pipeline.on('package', function (pkg) {})
+
+When a package file is read, this event fires with the contents. The package
+directory is available at `pkg.__dirname`.
+
+## b.on('bundle', function (bundle) {})
+
+When `.bundle()` is called, this event fires with the `bundle` output stream.
+
+## b.on('reset', function () {})
+
+When the `.reset()` method is called or implicitly called by another call to
+`.bundle()`, this event fires.
+
+## b.on('transform', function (tr, file) {})
+## b.pipeline.on('transform', function (tr, file) {})
+
+When a transform is applied to a file, the `'transform'` event fires on the
+bundle stream with the transform stream `tr` and the `file` that the transform
+is being applied to.
+
+# plugins
+
+For some more advanced use-cases, a transform is not sufficiently extensible.
+Plugins are modules that take the bundle instance as their first parameter and
+an option hash as their second.
+
+Plugins can be used to do perform some fancy features that transforms can't do.
+For example, [factor-bundle](https://www.npmjs.com/package/factor-bundle) is a
+plugin that can factor out common dependencies from multiple entry-points into a
+common bundle. Use plugins with `-p` and pass options to plugins with
+[subarg](https://www.npmjs.com/package/subarg) syntax:
+
+```
+browserify x.js y.js -p [ factor-bundle -o bundle/x.js -o bundle/y.js ] \
+  > bundle/common.js
+```
+
+For a list of plugins, consult the
+[browserify-plugin tag](https://www.npmjs.com/browse/keyword/browserify-plugin)
+on npm.
+
+# list of source transforms
+
+There is a [wiki page that lists the known browserify
+transforms](https://github.com/browserify/browserify/wiki/list-of-transforms).
+
+If you write a transform, make sure to add your transform to that wiki page and
+add a package.json keyword of `browserify-transform` so that
+[people can browse for all the browserify
+transforms](https://www.npmjs.com/browse/keyword/browserify-transform) on npmjs.org.
+
+# third-party tools
+
+There is a [wiki page that lists the known browserify
+tools](https://github.com/browserify/browserify/wiki/browserify-tools).
+
+If you write a tool, make sure to add it to that wiki page and
+add a package.json keyword of `browserify-tool` so that
+[people can browse for all the browserify
+tools](https://www.npmjs.com/browse/keyword/browserify-tool) on npmjs.org.
+
+# changelog
+
+Releases are documented in
+[changelog.markdown](changelog.markdown) and on the
+[browserify twitter feed](https://twitter.com/browserify).
+
+# license
+
+MIT
+
+![browserify!](http://substack.net/images/browserify/browserify.png)

build/node_modules/browserify/test/args.js

@@ -0,0 +1,72 @@
+var test = require('tap').test;
+var fromArgs = require('../bin/args.js');
+var path = require('path');
+var vm = require('vm');
+
+test('bundle from an arguments array', function (t) {
+    t.plan(2);
+    
+    var b = fromArgs([ __dirname + '/entry/two.js', '-s', 'XYZ' ]);
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        var c = { window: {} };
+        vm.runInNewContext(src, c);
+        t.equal(c.window.XYZ, 2);
+    });
+});
+
+test('external flag for node modules', function(t) {
+    t.plan(2);
+    
+    var b = fromArgs([ __dirname + '/external_args/main.js', '-x', 'backbone' ]);
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, {t: t});
+    });
+});
+
+test('bundle from an arguments with --insert-global-vars', function (t) {
+    t.plan(4);
+
+    var b = fromArgs([
+        __dirname + '/global/filename.js',
+        '--insert-global-vars=__filename,__dirname',
+        '--basedir', __dirname
+    ]);
+    b.require(__dirname + '/global/filename.js', { expose: 'x' });
+    b.bundle(function (err, src) {
+        t.ifError(err, 'b.bundle()');
+        var c = {}, x;
+        vm.runInNewContext(src, c);
+        t.doesNotThrow(function() {
+            x = c.require('x');
+        }, 'x = c.require(\'x\')');
+        t.equal(x && x.filename, '/global/filename.js', 'x.filename');
+        t.equal(x && x.dirname, '/global', 'x.dirname');
+    })
+});
+
+test('numeric module names', function(t) {
+    t.plan(1);
+
+    var b = fromArgs([ '-x', '1337' ]);
+    b.bundle(function (err, src) {
+        t.ifError(err);
+    });
+});
+
+test('entry expose', function (t) {
+    t.plan(3)
+    
+    var b = fromArgs([
+        path.join(__dirname, '/entry_expose/main.js'),
+        '--require', path.join(__dirname, '/entry_expose/main.js') + ':x',
+    ]);
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        var c = { console: { log: log } };
+        function log (msg) { t.equal(msg, 'wow') }
+        vm.runInNewContext(src, c);
+        t.equal(c.require('x'), 555);
+    })
+});

build/node_modules/browserify/test/array.js

@@ -0,0 +1,74 @@
+var browserify = require('../');
+var vm = require('vm');
+var test = require('tap').test;
+
+test('array add', function (t) {
+    var expected = [ 'ONE', 'TWO', 'THREE' ];
+    t.plan(expected.length);
+    
+    var b = browserify();
+    var files = [
+        __dirname + '/array/one.js',
+        __dirname + '/array/two.js',
+        __dirname + '/array/three.js'
+    ];
+    b.add(files);
+    b.bundle(function (err, src) {
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (msg) {
+            t.equal(msg, expected.shift());
+        }
+    });
+});
+
+test('array require', function (t) {
+    t.plan(3);
+    
+    var b = browserify();
+    var files = [ 'defined', 'subarg' ];
+    b.require(files);
+    b.bundle(function (err, src) {
+        var c = {};
+        vm.runInNewContext(src, c);
+
+        t.equal(c.require('defined')(undefined, true), true);
+        t.equal(c.require('defined')(undefined, false), false);
+        t.deepEqual(c.require('subarg')(['-x', '3']), { x: 3, _: [] });
+    });
+});
+
+test('array require opts', function (t) {
+    t.plan(3);
+    
+    var b = browserify();
+    var files = [
+        { file: require.resolve('defined'), expose: 'abc' },
+        { file: require.resolve('subarg'), expose: 'def' }
+    ];
+    b.require(files);
+    b.bundle(function (err, src) {
+        var c = {};
+        vm.runInNewContext(src, c);
+
+        t.equal(c.require('abc')(undefined, true), true);
+        t.equal(c.require('abc')(undefined, false), false);
+        t.deepEqual(c.require('def')(['-x', '3']), { x: 3, _: [] });
+    });
+});
+
+test('array external', function (t) {
+    t.plan(2);
+    
+    var b = browserify(__dirname + '/external/main.js');
+    b.external(['util','freelist']);
+    b.bundle(function (err, src) {
+        if (err) return t.fail(err);
+        vm.runInNewContext(
+            'function require (x) {'
+            + 'if (x==="freelist") return function (n) { return n + 1000 }'
+            + '}'
+            + src,
+            { t: t }
+        );
+    });
+});

build/node_modules/browserify/test/array/one.js

@@ -0,0 +1 @@
+console.log('ONE');

build/node_modules/browserify/test/array/three.js

@@ -0,0 +1 @@
+console.log('THREE');

build/node_modules/browserify/test/array/two.js

@@ -0,0 +1 @@
+console.log('TWO');

build/node_modules/browserify/test/async.js

@@ -0,0 +1,24 @@
+var browserify = require('../');
+var fs = require('fs');
+var vm = require('vm');
+var test = require('tap').test;
+
+var src = fs.readFileSync(__dirname + '/async/src.js','utf8');
+var canAsync = true;
+try { Function(src) } catch (err) { canAsync = false }
+
+if (!canAsync) console.error('# async/await unsupported in this environment')
+else test('async/await', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/async/src.js');
+    b.bundle(function (err, src) {
+        t.error(err)
+        var c = {
+            console: { log: log },
+            setTimeout: setTimeout,
+            clearTimeout: clearTimeout
+        }
+        vm.runInNewContext(src, c);
+        function log (msg) { t.equal(msg, 60) }
+    });
+});

build/node_modules/browserify/test/async/src.js

@@ -0,0 +1,8 @@
+function f (x) { return new Promise(resolve => {
+  process.nextTick(() => { resolve(x) }) }) }
+
+async function add (x) {
+  return x + await f(20) + await f(30)
+}
+
+add(10).then(v => { console.log(v) })

build/node_modules/browserify/test/backbone.js

@@ -0,0 +1,23 @@
+var browserify = require('../');
+var vm = require('vm');
+var backbone = require('backbone');
+var test = require('tap').test;
+
+test('backbone', function (t) {
+    t.plan(3);
+    var b = browserify();
+    b.require('backbone');
+    b.bundle(function (err, buf) {
+        t.ok(Buffer.isBuffer(buf));
+        var src = buf.toString('utf8');
+        t.ok(src.length > 0);
+        
+        var c = { console: console };
+        vm.runInNewContext(src, c);
+        t.deepEqual(
+            Object.keys(backbone).sort(),
+            Object.keys(c.require('backbone')).sort()
+        );
+        t.end();
+    });
+});

build/node_modules/browserify/test/bare.js

@@ -0,0 +1,70 @@
+var test = require('tap').test;
+var spawn = require('child_process').spawn;
+var path = require('path');
+var concat = require('concat-stream');
+var vm = require('vm');
+
+test('bare', function (t) {
+    t.plan(4);
+    
+    var cwd = process.cwd();
+    process.chdir(__dirname);
+    
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        '-', '--bare'
+    ]);
+    ps.stdout.pipe(concat(function (body) {
+        vm.runInNewContext(body, {
+            Buffer: function (s) { return s.toLowerCase() },
+            console: {
+                log: function (msg) { t.equal(msg, 'abc') }
+            }
+        });
+        vm.runInNewContext(body, {
+            Buffer: Buffer,
+            console: {
+                log: function (msg) {
+                    t.ok(Buffer.isBuffer(msg));
+                    t.equal(msg.toString('utf8'), 'ABC')
+                }
+            }
+        });
+    }));
+    ps.stdin.end('console.log(Buffer("ABC"))');
+    
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+    });
+});
+
+test('bare inserts __filename,__dirname but not process,global,Buffer', function (t) {
+    t.plan(2);
+    
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        path.resolve(__dirname, 'bare/main.js'),
+        '--bare'
+    ]);
+    
+    ps.stdout.pipe(concat(function (body) {
+        vm.runInNewContext(body, {
+            console: {
+                log: function (msg) {
+                    t.same(msg, [
+                        path.join(__dirname, 'bare'),
+                        path.join(__dirname, 'bare/main.js'),
+                        'undefined',
+                        'undefined',
+                        'undefined'
+                    ]);
+                }
+            }
+        });
+    }));
+    ps.stdin.end();
+    
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+    });
+});

build/node_modules/browserify/test/bare/main.js

@@ -0,0 +1,7 @@
+console.log([
+  __dirname,
+  __filename,
+  typeof process,
+  typeof global,
+  typeof Buffer
+]);

build/node_modules/browserify/test/bare_shebang.js

@@ -0,0 +1,37 @@
+var test = require('tap').test;
+var spawn = require('child_process').spawn;
+var path = require('path');
+var concat = require('concat-stream');
+var vm = require('vm');
+
+test('bare shebang', function (t) {
+    t.plan(4);
+    
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        '-', '--bare'
+    ]);
+    ps.stderr.pipe(process.stderr);
+    ps.stdout.pipe(concat(function (body) {
+        vm.runInNewContext(body, {
+            Buffer: function (s) { return s.toLowerCase() },
+            console: {
+                log: function (msg) { t.equal(msg, 'woo') }
+            }
+        });
+        vm.runInNewContext(body, {
+            Buffer: Buffer,
+            console: {
+                log: function (msg) {
+                    t.ok(Buffer.isBuffer(msg));
+                    t.equal(msg.toString('utf8'), 'WOO')
+                }
+            }
+        });
+    }));
+    ps.stdin.end('#!/usr/bin/env node\nconsole.log(Buffer("WOO"))');
+    
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+    });
+});

build/node_modules/browserify/test/bin.js

@@ -0,0 +1,31 @@
+var test = require('tap').test;
+var spawn = require('child_process').spawn;
+var path = require('path');
+var vm = require('vm');
+
+test('bin', function (t) {
+    t.plan(3);
+    
+    var cwd = process.cwd();
+    process.chdir(__dirname);
+    
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        'entry/main.js'
+    ]);
+    var src = '';
+    var err = '';
+    ps.stdout.on('data', function (buf) { src += buf });
+    ps.stderr.on('data', function (buf) { err += buf });
+    
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+        t.equal(err, '');
+        
+        var allDone = false;
+        var c = { done : function () { allDone = true } };
+        
+        vm.runInNewContext(src, c);
+        t.ok(allDone);
+    });
+});

build/node_modules/browserify/test/bin_entry.js

@@ -0,0 +1,31 @@
+var test = require('tap').test;
+var spawn = require('child_process').spawn;
+var path = require('path');
+var vm = require('vm');
+
+test('bin --entry', function (t) {
+    t.plan(3);
+    
+    var cwd = process.cwd();
+    process.chdir(__dirname);
+    
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        '--entry', 'entry/main.js'
+    ]);
+    var src = '';
+    var err = '';
+    ps.stdout.on('data', function (buf) { src += buf });
+    ps.stderr.on('data', function (buf) { err += buf });
+    
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+        t.equal(err, '');
+        
+        var allDone = false;
+        var c = { done : function () { allDone = true } };
+        
+        vm.runInNewContext(src, c);
+        t.ok(allDone);
+    });
+});

build/node_modules/browserify/test/bin_tr_error.js

@@ -0,0 +1,23 @@
+var browserify = require('../');
+var spawn = require('child_process').spawn;
+var test = require('tap').test;
+var path = require('path')
+
+test('function transform', function (t) {
+    t.plan(3);
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        '-t', './tr.js', './main.js'
+    ], {cwd: path.resolve(__dirname, 'bin_tr_error')});
+    var src = '';
+    var err = '';
+    ps.stdout.on('data', function (buf) { src += buf });
+    ps.stderr.on('data', function (buf) { err += buf });
+    
+    ps.on('exit', function (code) {
+        t.notEqual(code, 0);
+        var errorFile = path.resolve(__dirname, 'bin_tr_error', 'tr.js');
+        t.notEqual(err.indexOf('there was error'), -1, 'Error should contain error message')
+        t.notEqual(err.indexOf(errorFile), -1, 'Error should contain stack trace')
+    });
+});

build/node_modules/browserify/test/bin_tr_error/main.js

@@ -0,0 +1 @@
+t.equal(XXX * 5, 555);

build/node_modules/browserify/test/bin_tr_error/tr.js

@@ -0,0 +1,12 @@
+var through = require('through2');
+
+module.exports = function (file, opts) {
+    var data = '';
+    return through(write, end);
+    
+    function write (buf, enc, next) { data += buf; next() }
+    function end () {
+        this.emit('error', new Error('there was error'))
+        this.push(null);
+    }
+};

build/node_modules/browserify/test/bom.js

@@ -0,0 +1,19 @@
+var browserify = require('../');
+var vm = require('vm');
+var test = require('tap').test;
+
+test('byte order marker', function (t) {
+    t.plan(2);
+    
+    var b = browserify(__dirname + '/bom/hello.js');
+    b.bundle(function (err, src) {
+        if (err) t.fail(err);
+        var c = {
+            console: { log: function (msg) {
+                t.equal(msg, 'hello');
+            } }
+        };
+        vm.runInNewContext(src, c);
+        t.notOk(/\ufeff/.test(src.toString('utf8')));
+    });
+});

build/node_modules/browserify/test/bom/hello.js

@@ -0,0 +1 @@
+console.log('hello')

build/node_modules/browserify/test/browser_field_file.js

@@ -0,0 +1,13 @@
+var test = require('tap').test;
+var vm = require('vm');
+var browserify = require('../');
+
+test('browser field file no ext', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_file/xyz');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (msg) { t.equal(msg, 'cool beans') }
+    });
+});

build/node_modules/browserify/test/browser_field_file/package.json

@@ -0,0 +1,5 @@
+{
+  "browser": {
+    "./xyz": "wow.js"
+  }
+}

build/node_modules/browserify/test/browser_field_file/wow.js

@@ -0,0 +1 @@
+console.log('cool beans');

build/node_modules/browserify/test/browser_field_resolve.js

@@ -0,0 +1,124 @@
+var browserify = require('../');
+var vm = require('vm');
+var test = require('tap').test;
+
+test('browser field resolve (a)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/a/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.equal(x, 555) }
+    });
+});
+
+test('browser field resolve (b)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/b/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.equal(x, 444) }
+    });
+});
+
+test('browser field resolve (c)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/c/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.equal(x, 333) }
+    });
+    
+});
+
+test('browser field resolve (d)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/d/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.equal(x, 222) }
+    });
+});
+
+test('browser field resolve (e)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/e/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.equal(x, 111) }
+    });
+});
+
+test('browser field resolve (f)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/f/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.equal(x, 999) }
+    });
+});
+
+test('browser field resolve (g)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/g/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.deepEqual(x, {}) }
+    });
+});
+
+test('browser field resolve (h)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/h/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.deepEqual(x, {}) }
+    });
+});
+
+test('browser field resolve (i)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/i/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.deepEqual(x, 5000) }
+    });
+});
+
+test('browser field resolve (j)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/j/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.deepEqual(x, 5000) }
+    });
+});
+
+test('browser field resolve (k)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/k/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.deepEqual(x, 3000) }
+    });
+});
+
+test('browser field resolve (l)', function (t) {
+    t.plan(2);
+    var b = browserify(__dirname + '/browser_field_resolve/l/main.js');
+    b.bundle(function (err, src) {
+        t.ifError(err);
+        vm.runInNewContext(src, { console: { log: log } });
+        function log (x) { t.deepEqual(x, 3000) }
+    });
+});

build/node_modules/browserify/test/browser_field_resolve/a/main.js

@@ -0,0 +1 @@
+console.log(require('zzz'))

build/node_modules/browserify/test/browser_field_resolve/a/package.json

@@ -0,0 +1,5 @@
+{
+  "browser": {
+    "zzz": "aaa"
+  }
+}

build/node_modules/browserify/test/browser_field_resolve/b/main.js

@@ -0,0 +1 @@
+console.log(require('zzz'))

build/node_modules/browserify/test/browser_field_resolve/b/package.json

@@ -0,0 +1,5 @@
+{
+  "browser": {
+    "zzz": "./x"
+  }
+}

build/node_modules/browserify/test/browser_field_resolve/b/x.js

@@ -0,0 +1 @@
+module.exports = 444

build/node_modules/browserify/test/browser_field_resolve/c/main.js

@@ -0,0 +1 @@
+console.log(require('./z.js'))

build/node_modules/browserify/test/browser_field_resolve/c/package.json

@@ -0,0 +1,5 @@
+{
+  "browser": {
+    "./z": "./x"
+  }
+}