refactor: init cypress-cucumber-preprocessor install.

node_modules/browserify/.travis.yml

@@ -0,0 +1,23 @@
+language: node_js
+node_js:
+  - "10"
+  - "9"
+  - "8"
+  - "6"
+  - "4"
+  - "iojs"
+  - "0.12"
+  - "0.10"
+  - "0.8"
+  - "0.6"
+before_install:
+  # Old npm certs are untrusted https://github.com/npm/npm/issues/20191
+  - 'if [ "${TRAVIS_NODE_VERSION}" = "0.6" ] || [ "${TRAVIS_NODE_VERSION}" = "0.8" ]; then export NPM_CONFIG_STRICT_SSL=false; fi'
+  - 'nvm install-latest-npm'
+install:
+  - 'if [ "${TRAVIS_NODE_VERSION}" = "0.6" ] || [ "${TRAVIS_NODE_VERSION}" = "0.9" ]; then nvm install --latest-npm 0.8 && npm install && nvm use "${TRAVIS_NODE_VERSION}"; else npm install; fi;'
+sudo: false
+matrix:
+  fast_finish: true
+  allow_failures:
+    - node_js: "0.6"

node_modules/browserify/LICENSE

@@ -0,0 +1,84 @@
+This software is released under the MIT license:
+
+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.
+
+---
+
+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
+
+----

node_modules/browserify/appveyor.yml

@@ -0,0 +1,27 @@
+environment:
+  matrix:
+    - nodejs_version: "10"
+    - nodejs_version: "9"
+    - nodejs_version: "8"
+    - nodejs_version: "6"
+    - nodejs_version: "4"
+    - nodejs_version: "0.12"
+    - nodejs_version: "0.10"
+
+# Install scripts. (runs after repo cloning)
+install:
+  # Get the latest stable version of Node.js or io.js
+  - ps: Install-Product node $env:nodejs_version
+  # install modules
+  - npm install
+
+# Post-install test scripts.
+test_script:
+  # Output useful info for debugging.
+  - node --version
+  - npm --version
+  # run tests
+  - npm test
+
+# Don't actually build.
+build: off

node_modules/browserify/bin/advanced.txt

@@ -0,0 +1,117 @@
+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.
+
+  --preserve-symlinks
+
+    Preserves symlinks when resolving modules.
+
+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 })
+

node_modules/browserify/bin/args.js

@@ -0,0 +1,260 @@
+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', 'preserve-symlinks'
+        ],
+        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.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({
+        node: argv.node,
+        bare: argv.bare,
+        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'],
+        preserveSymlinks: argv['preserve-symlinks'],
+
+        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)];
+        }
+    }
+}

node_modules/browserify/bin/cmd.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+var fs = require('fs');
+var JSONStream = require('JSONStream');
+var through = require('through2');
+var mkdirp = require('mkdirp');
+var path = require('path');
+
+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) {
+    mkdirp.sync(path.dirname(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);
+  });
+}

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.

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/

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

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

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

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

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

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

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);

node_modules/browserify/example/multiple_bundles/beep.js

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

node_modules/browserify/example/multiple_bundles/boop.js

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

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

node_modules/browserify/example/multiple_bundles/robot.js

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

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

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

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

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

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));

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

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>

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

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

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
+;

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

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

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

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

node_modules/browserify/index.js

@@ -0,0 +1,859 @@
+var path = require('path');
+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 cachedPathRelative = 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);
+
+    if (opts.node) {
+        opts.bare = true;
+        opts.browserField = false;
+    }
+    if (opts.bare) {
+        opts.builtins = false;
+        opts.commondir = false;
+        if (opts.insertGlobalVars === undefined) {
+            opts.insertGlobalVars = {}
+            Object.keys(insertGlobals.vars).forEach(function (name) {
+                if (name !== '__dirname' && name !== '__filename') {
+                    opts.insertGlobalVars[name] = undefined;
+                }
+            })
+        }
+    }
+    
+    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);
+    }
+    if (expose === undefined && this._options.exposeAll) {
+        expose = true;
+    }
+    if (expose === true) {
+        expose = '/' + relativePath(basedir, file);
+    }
+    
+    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 = {};
+    if (isArray(file)) {
+        var self = this;
+        file.forEach(function(file) {
+            self.exclude(file, opts);
+        });
+        return this;
+    }
+    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 = {};
+    if (isArray(file)) {
+        var self = this;
+        file.forEach(function(file) {
+            self.ignore(file, opts);
+        });
+        return this;
+    }
+    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.replace(/\\/g, '/').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) {
+                if (opts.preserveSymlinks && parent.id !== self._mdeps.top.id) {
+                    return cb(err, path.resolve(file), pkg, 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.replace(/\\/g, '/').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();
+            }
+        }
+
+        if (opts.commondir === false && opts.builtins === false) {
+          opts.insertGlobalVars = xtend({
+            __dirname: function(file, basedir) {
+              var dir = path.dirname(path.relative(basedir, file));
+              return 'require("path").join(__dirname,' + dir.split(path.sep).map(JSON.stringify).join(',') + ')';
+            },
+            __filename: function(file, basedir) {
+              var filename = path.relative(basedir, file);
+              return 'require("path").join(__dirname,' + filename.split(path.sep).map(JSON.stringify).join(',') + ')';
+            }
+          }, opts.insertGlobalVars);
+        }
+        
+        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 && isArray(opts.builtins)
+                ? '/'
+                : 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);
+        }
+        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);
+}
+function relativePath (from, to) {
+    // Replace \ with / for OS-independent behavior
+    return cachedPathRelative(from, to).replace(/\\/g, '/');
+}

node_modules/browserify/lib/builtins.js

@@ -0,0 +1,40 @@
+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.inspector = require.resolve('./_empty.js');
+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.perf_hooks = require.resolve('./_empty.js')
+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');

node_modules/browserify/node_modules/punycode/LICENSE-MIT.txt

@@ -0,0 +1,20 @@
+Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+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.

node_modules/browserify/node_modules/punycode/README.md

@@ -0,0 +1,176 @@
+# Punycode.js [![Build status](https://travis-ci.org/bestiejs/punycode.js.svg?branch=master)](https://travis-ci.org/bestiejs/punycode.js) [![Code coverage status](http://img.shields.io/coveralls/bestiejs/punycode.js/master.svg)](https://coveralls.io/r/bestiejs/punycode.js) [![Dependency status](https://gemnasium.com/bestiejs/punycode.js.svg)](https://gemnasium.com/bestiejs/punycode.js)
+
+A robust Punycode converter that fully complies to [RFC 3492](https://tools.ietf.org/html/rfc3492) and [RFC 5891](https://tools.ietf.org/html/rfc5891), and works on nearly all JavaScript platforms.
+
+This JavaScript library is the result of comparing, optimizing and documenting different open-source implementations of the Punycode algorithm:
+
+* [The C example code from RFC 3492](https://tools.ietf.org/html/rfc3492#appendix-C)
+* [`punycode.c` by _Markus W. Scherer_ (IBM)](http://opensource.apple.com/source/ICU/ICU-400.42/icuSources/common/punycode.c)
+* [`punycode.c` by _Ben Noordhuis_](https://github.com/bnoordhuis/punycode/blob/master/punycode.c)
+* [JavaScript implementation by _some_](http://stackoverflow.com/questions/183485/can-anyone-recommend-a-good-free-javascript-for-punycode-to-unicode-conversion/301287#301287)
+* [`punycode.js` by _Ben Noordhuis_](https://github.com/joyent/node/blob/426298c8c1c0d5b5224ac3658c41e7c2a3fe9377/lib/punycode.js) (note: [not fully compliant](https://github.com/joyent/node/issues/2072))
+
+This project is [bundled](https://github.com/joyent/node/blob/master/lib/punycode.js) with [Node.js v0.6.2+](https://github.com/joyent/node/compare/975f1930b1...61e796decc) and [io.js v1.0.0+](https://github.com/iojs/io.js/blob/v1.x/lib/punycode.js).
+
+## Installation
+
+Via [npm](https://www.npmjs.com/) (only required for Node.js releases older than v0.6.2):
+
+```bash
+npm install punycode
+```
+
+Via [Bower](http://bower.io/):
+
+```bash
+bower install punycode
+```
+
+Via [Component](https://github.com/component/component):
+
+```bash
+component install bestiejs/punycode.js
+```
+
+In a browser:
+
+```html
+<script src="punycode.js"></script>
+```
+
+In [Node.js](https://nodejs.org/), [io.js](https://iojs.org/), [Narwhal](http://narwhaljs.org/), and [RingoJS](http://ringojs.org/):
+
+```js
+var punycode = require('punycode');
+```
+
+In [Rhino](http://www.mozilla.org/rhino/):
+
+```js
+load('punycode.js');
+```
+
+Using an AMD loader like [RequireJS](http://requirejs.org/):
+
+```js
+require(
+  {
+    'paths': {
+      'punycode': 'path/to/punycode'
+    }
+  },
+  ['punycode'],
+  function(punycode) {
+    console.log(punycode);
+  }
+);
+```
+
+## API
+
+### `punycode.decode(string)`
+
+Converts a Punycode string of ASCII symbols to a string of Unicode symbols.
+
+```js
+// decode domain name parts
+punycode.decode('maana-pta'); // 'mañana'
+punycode.decode('--dqo34k'); // '☃-⌘'
+```
+
+### `punycode.encode(string)`
+
+Converts a string of Unicode symbols to a Punycode string of ASCII symbols.
+
+```js
+// encode domain name parts
+punycode.encode('mañana'); // 'maana-pta'
+punycode.encode('☃-⌘'); // '--dqo34k'
+```
+
+### `punycode.toUnicode(input)`
+
+Converts a Punycode string representing a domain name or an email address to Unicode. Only the Punycoded parts of the input will be converted, i.e. it doesn’t matter if you call it on a string that has already been converted to Unicode.
+
+```js
+// decode domain names
+punycode.toUnicode('xn--maana-pta.com');
+// → 'mañana.com'
+punycode.toUnicode('xn----dqo34k.com');
+// → '☃-⌘.com'
+
+// decode email addresses
+punycode.toUnicode('джумла@xn--p-8sbkgc5ag7bhce.xn--ba-lmcq');
+// → 'джумла@джpумлатест.bрфa'
+```
+
+### `punycode.toASCII(input)`
+
+Converts a lowercased Unicode string representing a domain name or an email address to Punycode. Only the non-ASCII parts of the input will be converted, i.e. it doesn’t matter if you call it with a domain that’s already in ASCII.
+
+```js
+// encode domain names
+punycode.toASCII('mañana.com');
+// → 'xn--maana-pta.com'
+punycode.toASCII('☃-⌘.com');
+// → 'xn----dqo34k.com'
+
+// encode email addresses
+punycode.toASCII('джумла@джpумлатест.bрфa');
+// → 'джумла@xn--p-8sbkgc5ag7bhce.xn--ba-lmcq'
+```
+
+### `punycode.ucs2`
+
+#### `punycode.ucs2.decode(string)`
+
+Creates an array containing the numeric code point values of each Unicode symbol in the string. While [JavaScript uses UCS-2 internally](https://mathiasbynens.be/notes/javascript-encoding), this function will convert a pair of surrogate halves (each of which UCS-2 exposes as separate characters) into a single code point, matching UTF-16.
+
+```js
+punycode.ucs2.decode('abc');
+// → [0x61, 0x62, 0x63]
+// surrogate pair for U+1D306 TETRAGRAM FOR CENTRE:
+punycode.ucs2.decode('\uD834\uDF06');
+// → [0x1D306]
+```
+
+#### `punycode.ucs2.encode(codePoints)`
+
+Creates a string based on an array of numeric code point values.
+
+```js
+punycode.ucs2.encode([0x61, 0x62, 0x63]);
+// → 'abc'
+punycode.ucs2.encode([0x1D306]);
+// → '\uD834\uDF06'
+```
+
+### `punycode.version`
+
+A string representing the current Punycode.js version number.
+
+## Unit tests & code coverage
+
+After cloning this repository, run `npm install --dev` to install the dependencies needed for Punycode.js development and testing. You may want to install Istanbul _globally_ using `npm install istanbul -g`.
+
+Once that’s done, you can run the unit tests in Node using `npm test` or `node tests/tests.js`. To run the tests in Rhino, Ringo, Narwhal, PhantomJS, and web browsers as well, use `grunt test`.
+
+To generate the code coverage report, use `grunt cover`.
+
+Feel free to fork if you see possible improvements!
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
+
+## Contributors
+
+| [![twitter/jdalton](https://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## License
+
+Punycode.js is available under the [MIT](https://mths.be/mit) license.

node_modules/browserify/node_modules/punycode/package.json

@@ -0,0 +1,87 @@
+{
+  "_from": "punycode@^1.3.2",
+  "_id": "punycode@1.4.1",
+  "_inBundle": false,
+  "_integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=",
+  "_location": "/browserify/punycode",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "punycode@^1.3.2",
+    "name": "punycode",
+    "escapedName": "punycode",
+    "rawSpec": "^1.3.2",
+    "saveSpec": null,
+    "fetchSpec": "^1.3.2"
+  },
+  "_requiredBy": [
+    "/browserify"
+  ],
+  "_resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
+  "_shasum": "c0d5a63b2718800ad8e1eb0fa5269c84dd41845e",
+  "_spec": "punycode@^1.3.2",
+  "_where": "/home/simon/Documents/lifen-autotest/node_modules/browserify",
+  "author": {
+    "name": "Mathias Bynens",
+    "url": "https://mathiasbynens.be/"
+  },
+  "bugs": {
+    "url": "https://github.com/bestiejs/punycode.js/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Mathias Bynens",
+      "url": "https://mathiasbynens.be/"
+    },
+    {
+      "name": "John-David Dalton",
+      "url": "http://allyoucanleet.com/"
+    }
+  ],
+  "deprecated": false,
+  "description": "A robust Punycode converter that fully complies to RFC 3492 and RFC 5891, and works on nearly all JavaScript platforms.",
+  "devDependencies": {
+    "coveralls": "^2.11.4",
+    "grunt": "^0.4.5",
+    "grunt-contrib-uglify": "^0.11.0",
+    "grunt-shell": "^1.1.2",
+    "istanbul": "^0.4.1",
+    "qunit-extras": "^1.4.4",
+    "qunitjs": "~1.11.0",
+    "requirejs": "^2.1.22"
+  },
+  "files": [
+    "LICENSE-MIT.txt",
+    "punycode.js"
+  ],
+  "homepage": "https://mths.be/punycode",
+  "jspm": {
+    "map": {
+      "./punycode.js": {
+        "node": "@node/punycode"
+      }
+    }
+  },
+  "keywords": [
+    "punycode",
+    "unicode",
+    "idn",
+    "idna",
+    "dns",
+    "url",
+    "domain"
+  ],
+  "license": "MIT",
+  "main": "punycode.js",
+  "name": "punycode",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bestiejs/punycode.js.git"
+  },
+  "scripts": {
+    "test": "node tests/tests.js"
+  },
+  "version": "1.4.1"
+}

node_modules/browserify/node_modules/punycode/punycode.js

@@ -0,0 +1,533 @@
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+;(function(root) {
+
+	/** Detect free variables */
+	var freeExports = typeof exports == 'object' && exports &&
+		!exports.nodeType && exports;
+	var freeModule = typeof module == 'object' && module &&
+		!module.nodeType && module;
+	var freeGlobal = typeof global == 'object' && global;
+	if (
+		freeGlobal.global === freeGlobal ||
+		freeGlobal.window === freeGlobal ||
+		freeGlobal.self === freeGlobal
+	) {
+		root = freeGlobal;
+	}
+
+	/**
+	 * The `punycode` object.
+	 * @name punycode
+	 * @type Object
+	 */
+	var punycode,
+
+	/** Highest positive signed 32-bit float value */
+	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
+
+	/** Bootstring parameters */
+	base = 36,
+	tMin = 1,
+	tMax = 26,
+	skew = 38,
+	damp = 700,
+	initialBias = 72,
+	initialN = 128, // 0x80
+	delimiter = '-', // '\x2D'
+
+	/** Regular expressions */
+	regexPunycode = /^xn--/,
+	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
+	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
+
+	/** Error messages */
+	errors = {
+		'overflow': 'Overflow: input needs wider integers to process',
+		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+		'invalid-input': 'Invalid input'
+	},
+
+	/** Convenience shortcuts */
+	baseMinusTMin = base - tMin,
+	floor = Math.floor,
+	stringFromCharCode = String.fromCharCode,
+
+	/** Temporary variable */
+	key;
+
+	/*--------------------------------------------------------------------------*/
+
+	/**
+	 * A generic error utility function.
+	 * @private
+	 * @param {String} type The error type.
+	 * @returns {Error} Throws a `RangeError` with the applicable error message.
+	 */
+	function error(type) {
+		throw new RangeError(errors[type]);
+	}
+
+	/**
+	 * A generic `Array#map` utility function.
+	 * @private
+	 * @param {Array} array The array to iterate over.
+	 * @param {Function} callback The function that gets called for every array
+	 * item.
+	 * @returns {Array} A new array of values returned by the callback function.
+	 */
+	function map(array, fn) {
+		var length = array.length;
+		var result = [];
+		while (length--) {
+			result[length] = fn(array[length]);
+		}
+		return result;
+	}
+
+	/**
+	 * A simple `Array#map`-like wrapper to work with domain name strings or email
+	 * addresses.
+	 * @private
+	 * @param {String} domain The domain name or email address.
+	 * @param {Function} callback The function that gets called for every
+	 * character.
+	 * @returns {Array} A new string of characters returned by the callback
+	 * function.
+	 */
+	function mapDomain(string, fn) {
+		var parts = string.split('@');
+		var result = '';
+		if (parts.length > 1) {
+			// In email addresses, only the domain name should be punycoded. Leave
+			// the local part (i.e. everything up to `@`) intact.
+			result = parts[0] + '@';
+			string = parts[1];
+		}
+		// Avoid `split(regex)` for IE8 compatibility. See #17.
+		string = string.replace(regexSeparators, '\x2E');
+		var labels = string.split('.');
+		var encoded = map(labels, fn).join('.');
+		return result + encoded;
+	}
+
+	/**
+	 * Creates an array containing the numeric code points of each Unicode
+	 * character in the string. While JavaScript uses UCS-2 internally,
+	 * this function will convert a pair of surrogate halves (each of which
+	 * UCS-2 exposes as separate characters) into a single code point,
+	 * matching UTF-16.
+	 * @see `punycode.ucs2.encode`
+	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+	 * @memberOf punycode.ucs2
+	 * @name decode
+	 * @param {String} string The Unicode input string (UCS-2).
+	 * @returns {Array} The new array of code points.
+	 */
+	function ucs2decode(string) {
+		var output = [],
+		    counter = 0,
+		    length = string.length,
+		    value,
+		    extra;
+		while (counter < length) {
+			value = string.charCodeAt(counter++);
+			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+				// high surrogate, and there is a next character
+				extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+				} else {
+					// unmatched surrogate; only append this code unit, in case the next
+					// code unit is the high surrogate of a surrogate pair
+					output.push(value);
+					counter--;
+				}
+			} else {
+				output.push(value);
+			}
+		}
+		return output;
+	}
+
+	/**
+	 * Creates a string based on an array of numeric code points.
+	 * @see `punycode.ucs2.decode`
+	 * @memberOf punycode.ucs2
+	 * @name encode
+	 * @param {Array} codePoints The array of numeric code points.
+	 * @returns {String} The new Unicode string (UCS-2).
+	 */
+	function ucs2encode(array) {
+		return map(array, function(value) {
+			var output = '';
+			if (value > 0xFFFF) {
+				value -= 0x10000;
+				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+				value = 0xDC00 | value & 0x3FF;
+			}
+			output += stringFromCharCode(value);
+			return output;
+		}).join('');
+	}
+
+	/**
+	 * Converts a basic code point into a digit/integer.
+	 * @see `digitToBasic()`
+	 * @private
+	 * @param {Number} codePoint The basic numeric code point value.
+	 * @returns {Number} The numeric value of a basic code point (for use in
+	 * representing integers) in the range `0` to `base - 1`, or `base` if
+	 * the code point does not represent a value.
+	 */
+	function basicToDigit(codePoint) {
+		if (codePoint - 48 < 10) {
+			return codePoint - 22;
+		}
+		if (codePoint - 65 < 26) {
+			return codePoint - 65;
+		}
+		if (codePoint - 97 < 26) {
+			return codePoint - 97;
+		}
+		return base;
+	}
+
+	/**
+	 * Converts a digit/integer into a basic code point.
+	 * @see `basicToDigit()`
+	 * @private
+	 * @param {Number} digit The numeric value of a basic code point.
+	 * @returns {Number} The basic code point whose value (when used for
+	 * representing integers) is `digit`, which needs to be in the range
+	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+	 * used; else, the lowercase form is used. The behavior is undefined
+	 * if `flag` is non-zero and `digit` has no uppercase form.
+	 */
+	function digitToBasic(digit, flag) {
+		//  0..25 map to ASCII a..z or A..Z
+		// 26..35 map to ASCII 0..9
+		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+	}
+
+	/**
+	 * Bias adaptation function as per section 3.4 of RFC 3492.
+	 * https://tools.ietf.org/html/rfc3492#section-3.4
+	 * @private
+	 */
+	function adapt(delta, numPoints, firstTime) {
+		var k = 0;
+		delta = firstTime ? floor(delta / damp) : delta >> 1;
+		delta += floor(delta / numPoints);
+		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+			delta = floor(delta / baseMinusTMin);
+		}
+		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+	}
+
+	/**
+	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+	 * symbols.
+	 * @memberOf punycode
+	 * @param {String} input The Punycode string of ASCII-only symbols.
+	 * @returns {String} The resulting string of Unicode symbols.
+	 */
+	function decode(input) {
+		// Don't use UCS-2
+		var output = [],
+		    inputLength = input.length,
+		    out,
+		    i = 0,
+		    n = initialN,
+		    bias = initialBias,
+		    basic,
+		    j,
+		    index,
+		    oldi,
+		    w,
+		    k,
+		    digit,
+		    t,
+		    /** Cached calculation results */
+		    baseMinusT;
+
+		// Handle the basic code points: let `basic` be the number of input code
+		// points before the last delimiter, or `0` if there is none, then copy
+		// the first basic code points to the output.
+
+		basic = input.lastIndexOf(delimiter);
+		if (basic < 0) {
+			basic = 0;
+		}
+
+		for (j = 0; j < basic; ++j) {
+			// if it's not a basic code point
+			if (input.charCodeAt(j) >= 0x80) {
+				error('not-basic');
+			}
+			output.push(input.charCodeAt(j));
+		}
+
+		// Main decoding loop: start just after the last delimiter if any basic code
+		// points were copied; start at the beginning otherwise.
+
+		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+			// `index` is the index of the next character to be consumed.
+			// Decode a generalized variable-length integer into `delta`,
+			// which gets added to `i`. The overflow checking is easier
+			// if we increase `i` as we go, then subtract off its starting
+			// value at the end to obtain `delta`.
+			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
+
+				if (index >= inputLength) {
+					error('invalid-input');
+				}
+
+				digit = basicToDigit(input.charCodeAt(index++));
+
+				if (digit >= base || digit > floor((maxInt - i) / w)) {
+					error('overflow');
+				}
+
+				i += digit * w;
+				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+				if (digit < t) {
+					break;
+				}
+
+				baseMinusT = base - t;
+				if (w > floor(maxInt / baseMinusT)) {
+					error('overflow');
+				}
+
+				w *= baseMinusT;
+
+			}
+
+			out = output.length + 1;
+			bias = adapt(i - oldi, out, oldi == 0);
+
+			// `i` was supposed to wrap around from `out` to `0`,
+			// incrementing `n` each time, so we'll fix that now:
+			if (floor(i / out) > maxInt - n) {
+				error('overflow');
+			}
+
+			n += floor(i / out);
+			i %= out;
+
+			// Insert `n` at position `i` of the output
+			output.splice(i++, 0, n);
+
+		}
+
+		return ucs2encode(output);
+	}
+
+	/**
+	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
+	 * Punycode string of ASCII-only symbols.
+	 * @memberOf punycode
+	 * @param {String} input The string of Unicode symbols.
+	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
+	 */
+	function encode(input) {
+		var n,
+		    delta,
+		    handledCPCount,
+		    basicLength,
+		    bias,
+		    j,
+		    m,
+		    q,
+		    k,
+		    t,
+		    currentValue,
+		    output = [],
+		    /** `inputLength` will hold the number of code points in `input`. */
+		    inputLength,
+		    /** Cached calculation results */
+		    handledCPCountPlusOne,
+		    baseMinusT,
+		    qMinusT;
+
+		// Convert the input in UCS-2 to Unicode
+		input = ucs2decode(input);
+
+		// Cache the length
+		inputLength = input.length;
+
+		// Initialize the state
+		n = initialN;
+		delta = 0;
+		bias = initialBias;
+
+		// Handle the basic code points
+		for (j = 0; j < inputLength; ++j) {
+			currentValue = input[j];
+			if (currentValue < 0x80) {
+				output.push(stringFromCharCode(currentValue));
+			}
+		}
+
+		handledCPCount = basicLength = output.length;
+
+		// `handledCPCount` is the number of code points that have been handled;
+		// `basicLength` is the number of basic code points.
+
+		// Finish the basic string - if it is not empty - with a delimiter
+		if (basicLength) {
+			output.push(delimiter);
+		}
+
+		// Main encoding loop:
+		while (handledCPCount < inputLength) {
+
+			// All non-basic code points < n have been handled already. Find the next
+			// larger one:
+			for (m = maxInt, j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+				if (currentValue >= n && currentValue < m) {
+					m = currentValue;
+				}
+			}
+
+			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+			// but guard against overflow
+			handledCPCountPlusOne = handledCPCount + 1;
+			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+				error('overflow');
+			}
+
+			delta += (m - n) * handledCPCountPlusOne;
+			n = m;
+
+			for (j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+
+				if (currentValue < n && ++delta > maxInt) {
+					error('overflow');
+				}
+
+				if (currentValue == n) {
+					// Represent delta as a generalized variable-length integer
+					for (q = delta, k = base; /* no condition */; k += base) {
+						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+						if (q < t) {
+							break;
+						}
+						qMinusT = q - t;
+						baseMinusT = base - t;
+						output.push(
+							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+						);
+						q = floor(qMinusT / baseMinusT);
+					}
+
+					output.push(stringFromCharCode(digitToBasic(q, 0)));
+					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+					delta = 0;
+					++handledCPCount;
+				}
+			}
+
+			++delta;
+			++n;
+
+		}
+		return output.join('');
+	}
+
+	/**
+	 * Converts a Punycode string representing a domain name or an email address
+	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+	 * it doesn't matter if you call it on a string that has already been
+	 * converted to Unicode.
+	 * @memberOf punycode
+	 * @param {String} input The Punycoded domain name or email address to
+	 * convert to Unicode.
+	 * @returns {String} The Unicode representation of the given Punycode
+	 * string.
+	 */
+	function toUnicode(input) {
+		return mapDomain(input, function(string) {
+			return regexPunycode.test(string)
+				? decode(string.slice(4).toLowerCase())
+				: string;
+		});
+	}
+
+	/**
+	 * Converts a Unicode string representing a domain name or an email address to
+	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
+	 * i.e. it doesn't matter if you call it with a domain that's already in
+	 * ASCII.
+	 * @memberOf punycode
+	 * @param {String} input The domain name or email address to convert, as a
+	 * Unicode string.
+	 * @returns {String} The Punycode representation of the given domain name or
+	 * email address.
+	 */
+	function toASCII(input) {
+		return mapDomain(input, function(string) {
+			return regexNonASCII.test(string)
+				? 'xn--' + encode(string)
+				: string;
+		});
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	/** Define the public API */
+	punycode = {
+		/**
+		 * A string representing the current Punycode.js version number.
+		 * @memberOf punycode
+		 * @type String
+		 */
+		'version': '1.4.1',
+		/**
+		 * An object of methods to convert from JavaScript's internal character
+		 * representation (UCS-2) to Unicode code points, and back.
+		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+		 * @memberOf punycode
+		 * @type Object
+		 */
+		'ucs2': {
+			'decode': ucs2decode,
+			'encode': ucs2encode
+		},
+		'decode': decode,
+		'encode': encode,
+		'toASCII': toASCII,
+		'toUnicode': toUnicode
+	};
+
+	/** Expose `punycode` */
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define('punycode', function() {
+			return punycode;
+		});
+	} else if (freeExports && freeModule) {
+		if (module.exports == freeExports) {
+			// in Node.js, io.js, or RingoJS v0.8.0+
+			freeModule.exports = punycode;
+		} else {
+			// in Narwhal or RingoJS v0.7.0-
+			for (key in punycode) {
+				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+			}
+		}
+	} else {
+		// in Rhino or a web browser
+		root.punycode = punycode;
+	}
+
+}(this));

node_modules/browserify/package.json

@@ -0,0 +1,129 @@
+{
+  "_from": "browserify@16.2.3",
+  "_id": "browserify@16.2.3",
+  "_inBundle": false,
+  "_integrity": "sha512-zQt/Gd1+W+IY+h/xX2NYMW4orQWhqSwyV+xsblycTtpOuB27h1fZhhNQuipJ4t79ohw4P4mMem0jp/ZkISQtjQ==",
+  "_location": "/browserify",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "browserify@16.2.3",
+    "name": "browserify",
+    "escapedName": "browserify",
+    "rawSpec": "16.2.3",
+    "saveSpec": null,
+    "fetchSpec": "16.2.3"
+  },
+  "_requiredBy": [
+    "/@cypress/browserify-preprocessor",
+    "/watchify"
+  ],
+  "_resolved": "https://registry.npmjs.org/browserify/-/browserify-16.2.3.tgz",
+  "_shasum": "7ee6e654ba4f92bce6ab3599c3485b1cc7a0ad0b",
+  "_spec": "browserify@16.2.3",
+  "_where": "/home/simon/Documents/lifen-autotest/node_modules/@cypress/browserify-preprocessor",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "bin": {
+    "browserify": "bin/cmd.js"
+  },
+  "bugs": {
+    "url": "https://github.com/browserify/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.6.0",
+    "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.2.0",
+    "duplexer2": "~0.1.2",
+    "events": "^2.0.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",
+    "mkdirp": "^0.5.0",
+    "module-deps": "^6.0.0",
+    "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.1.1",
+    "subarg": "^1.0.0",
+    "syntax-error": "^1.1.1",
+    "through2": "^2.0.0",
+    "timers-browserify": "^1.0.1",
+    "tty-browserify": "0.0.1",
+    "url": "~0.11.0",
+    "util": "~0.10.1",
+    "vm-browserify": "^1.0.0",
+    "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",
+    "has-object-spread": "^1.0.0",
+    "has-template-literals": "^1.0.0",
+    "isstream": "^0.1.2",
+    "make-generator-function": "^1.1.0",
+    "semver": "^5.5.0",
+    "seq": "0.3.5",
+    "tap": "^10.7.2",
+    "temp": "^0.8.1",
+    "through": "^2.3.4"
+  },
+  "engines": {
+    "node": ">= 0.8"
+  },
+  "homepage": "https://github.com/browserify/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/browserify/browserify.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "version": "16.2.3"
+}

node_modules/browserify/readme.markdown

@@ -0,0 +1,829 @@
+# 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!](./assets/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/).
+
+# 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.
+
+`opts.bare` creates a bundle that does not include Node builtins, and does not
+replace global Node variables except for `__dirname` and `__filename`.
+
+`opts.node` creates a bundle that runs in Node and does not use the browser
+versions of dependencies. Same as passing `{ bare: true, browserField: false }`.
+
+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()`,
+including files from `node_modules`. Like with `require.resolve()`, you must
+prefix `file` with `./` to require a local file (not in `node_modules`).
+
+`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.
+
+If `file` is an array, each item in `file` will be ignored.
+
+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 `file` is an array, each item in `file` will be excluded.
+
+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://github.com/defunctzombie/package-browser-field-spec)" 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](./LICENSE)
+
+![browserify!](./assets/browserify.png)

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

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

node_modules/browserify/test/array/one.js

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

node_modules/browserify/test/array/three.js

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

node_modules/browserify/test/array/two.js

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

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

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) })

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

node_modules/browserify/test/bare.js

@@ -0,0 +1,173 @@
+var test = require('tap').test;
+var spawn = require('child_process').spawn;
+var browserify = require('../');
+var path = require('path');
+var concat = require('concat-stream');
+var vm = require('vm');
+var fs = require('fs');
+var through = require('through2');
+var temp = require('temp');
+temp.track();
+var tmpdir = temp.mkdirSync({prefix: 'browserify-test'});
+
+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 api', function (t) {
+    t.plan(3);
+    
+    var input = through();
+    var b = browserify(input, { bare: true });
+    b.bundle().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')
+                }
+            }
+        });
+    }));
+    input.end('console.log(Buffer("ABC"))');
+});
+
+test('bare inserts __filename,__dirname but not process,global,Buffer', function (t) {
+    t.plan(2);
+    
+    var file = path.resolve(__dirname, 'bare/main.js');
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        file,
+        '--bare'
+    ]);
+    
+    ps.stdout.pipe(concat(function (body) {
+        vm.runInNewContext(body, {
+            require: require,
+            __dirname: process.cwd(),
+            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);
+    });
+});
+
+test('bare inserts dynamic __filename,__dirname', function (t) {
+    t.plan(2);
+    
+    var file = path.join(tmpdir, 'dirname-filename.js');
+
+    fs.writeFileSync(
+        file,
+        fs.readFileSync(path.resolve(__dirname, 'bare/dirname-filename.js'))
+    );
+
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        file,
+        '--bare'
+    ]);
+    
+    ps.stdout.pipe(concat(function (body) {
+        vm.runInNewContext(body, {
+            require: require,
+            __dirname: process.cwd(),
+            console: {
+                log: function (msg) {
+                    t.same(msg, [
+                        path.dirname(file),
+                        file
+                    ]);
+                }
+            }
+        });
+    }));
+    ps.stdin.end();
+    
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+    });
+});
+
+test('bare inserts dynamic __filename,__dirname with basedir', function (t) {
+    t.plan(2);
+    
+    var file = 'dirname-filename.js';
+    var ps = spawn(process.execPath, [
+        path.resolve(__dirname, '../bin/cmd.js'),
+        file,
+        '--bare',
+        '--basedir=' + path.join(__dirname, 'bare')
+    ]);
+    
+    ps.stdout.pipe(concat(function (body) {
+        vm.runInNewContext(body, {
+            require: require,
+            __dirname: process.cwd(),
+            console: {
+                log: function (msg) {
+                    t.same(msg, [
+                        __dirname,
+                        path.join(__dirname, file)
+                    ]);
+                }
+            }
+        });
+    }));
+    ps.stdin.end();
+    
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+    });
+});

node_modules/browserify/test/bare/dirname-filename.js

@@ -0,0 +1,4 @@
+console.log([
+  __dirname,
+  __filename
+]);

node_modules/browserify/test/bare/main.js

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

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

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

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

node_modules/browserify/test/bin_tr_error.js

@@ -0,0 +1,27 @@
+var browserify = require('../');
+var spawn = require('child_process').spawn;
+var test = require('tap').test;
+var path = require('path')
+var semver = require('semver');
+
+// TODO this should be fixable I guess
+var flaky = process.platform === 'win32' && semver.satisfies(process.version, 'v0.10.x');
+
+test('function transform', { skip: flaky }, 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')
+    });
+});

node_modules/browserify/test/bin_tr_error/main.js

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

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

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

node_modules/browserify/test/bom/hello.js

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

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

node_modules/browserify/test/browser_field_file/package.json

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

node_modules/browserify/test/browser_field_file/wow.js

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+{
+  "main": "main.js"
+}

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

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

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

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

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

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

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

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

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

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

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

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

node_modules/browserify/test/browser_field_resolve/c/x.js

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

node_modules/browserify/test/browser_field_resolve/d/main.js

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

node_modules/browserify/test/browser_field_resolve/d/package.json

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

node_modules/browserify/test/browser_field_resolve/d/x.js

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

node_modules/browserify/test/browser_field_resolve/e/main.js

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

node_modules/browserify/test/browser_field_resolve/e/package.json

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

node_modules/browserify/test/browser_field_resolve/e/x.js

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

node_modules/browserify/test/browser_field_resolve/f/main.js

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

node_modules/browserify/test/browser_field_resolve/f/package.json

@@ -0,0 +1,5 @@
+{
+  "browser": {
+    "aaa/what": "./x.js"
+  }
+}

node_modules/browserify/test/browser_field_resolve/f/x.js

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

node_modules/browserify/test/browser_field_resolve/g/main.js

@@ -0,0 +1,2 @@
+try { var x = require('./x') } catch (err) {}
+console.log(x)

node_modules/browserify/test/browser_field_resolve/g/package.json

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

node_modules/browserify/test/browser_field_resolve/g/x.js

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

node_modules/browserify/test/browser_field_resolve/h/main.js

@@ -0,0 +1,2 @@
+try { var x = require('./x.js') } catch (err) {}
+console.log(x)

node_modules/browserify/test/browser_field_resolve/h/package.json

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

node_modules/browserify/test/browser_field_resolve/h/x.js

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

node_modules/browserify/test/browser_field_resolve/i/browser.js

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

node_modules/browserify/test/browser_field_resolve/i/main.js

@@ -0,0 +1,2 @@
+var x = require('./x.js')
+console.log(x)

node_modules/browserify/test/browser_field_resolve/i/package.json

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

node_modules/browserify/test/browser_field_resolve/i/x.js

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

node_modules/browserify/test/browser_field_resolve/j/browser.js

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

node_modules/browserify/test/browser_field_resolve/j/main.js

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

node_modules/browserify/test/browser_field_resolve/j/package.json

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

node_modules/browserify/test/browser_field_resolve/j/x.js

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

node_modules/browserify/test/browser_field_resolve/k/main.js

@@ -0,0 +1,2 @@
+var zzz = require('x/zzz')
+console.log(zzz)

node_modules/browserify/test/browser_field_resolve/k/node_modules/x/hey.js

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

node_modules/browserify/test/browser_field_resolve/k/node_modules/x/package.json

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

node_modules/browserify/test/browser_field_resolve/l/main.js

@@ -0,0 +1,2 @@
+var zzz = require('x/zzz')
+console.log(zzz)

node_modules/browserify/test/browser_field_resolve/l/node_modules/x/hey.js

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

node_modules/browserify/test/browser_field_resolve/l/node_modules/x/package.json

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