sprockets-browserify 0.2.0 → 0.3.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MDRmOGE1YjA1M2NiMmUzYWFhOWY3ZWI5MzZhMzEyYjYwYjUwNzk0MA==
-  data.tar.gz: !binary |-
-    MTc5YjA5MjEyY2I1ZDg3Yzc5MjcyYTkxOTQyZDdjZTFlMjUwYzZhZA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    OWZjODA3ZmFjMWNiOWVlNWEyMmM2ZmI5MjI0MjRlNjUzYmI1YWM0MTYzMzQy
-    YTE1M2EyZGRhMzhhNjA4NDZiYzdmYjMxODFlMDM4MWU3YmVlZjZhNzM5MDQ3
-    ZGQ0ZDY2ZDRkZWUxZjdhYTgwZTRiOGM1OWEwZTRlNzQxZDU3ZmM=
-  data.tar.gz: !binary |-
-    ZmQwODVmYTI4NGZiMWQ0NjliMTE5NzI0MTE4YTZjYTM3YzM0YzgxOTdmMjlh
-    ZGM3ZjFlYWI0MTJlYzM5MDFkNWI3MTI4M2JiM2M3NTA2MmMwMWE2YWY4NjQ1
-    MTAwODg0MTBkMTRkOWI5ZTk2OTc5YjNlNTdhM2VjNWE0Zjk2NDc=
+SHA1:
+  metadata.gz: 1b19df7387f854be433555196f0ac57bf710bb1a
+  data.tar.gz: 254a9ee6c78fefa6d833fe5a38d9acc7f86efa25
+SHA512:
+  metadata.gz: 1c54af5533a6ec6a8996a4d10fba46f1c8a7dbb54084734ff85692cc3bd0db9a190e97b2100d87766ee4281b07a6bf23d8e9143680a927305a05f00646935641
+  data.tar.gz: 743af233c53e9f7d390ee3c4809c61a8b7e34d945bf3ea8ce313a249864b1a0546ace4b69688031a15aab216d85f64d3325d3fbf4d50a7bb5bc2c9e5de4ba1bb

data/node_modules/browserify/bin/advanced.txt

@@ -8,6 +8,11 @@ Advanced Options:
     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
@@ -25,6 +30,22 @@ Advanced Options:
     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. 
+ 
+  --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.
+
   --deps
   
     Instead of standard bundle output, print the dependency array generated by
@@ -34,3 +55,12 @@ Advanced Options:
  
     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, --g
+
+    Use a transform module on all files after any ordinary transforms have run.
+

data/node_modules/browserify/bin/args.js

@@ -3,33 +3,65 @@ var path = require('path');
 var spawn = require('child_process').spawn;
 var parseShell = require('shell-quote').parse;
 var duplexer = require('duplexer');
+var minimist = require('minimist');
 
 module.exports = function (args) {
-    var argv = require('optimist')(args)
-        .boolean(['deps','pack','ig','dg', 'im', 'd','list'])
-        .string(['s'])
-        .alias('insert-globals', 'ig')
-        .alias('detect-globals', 'dg')
-        .alias('ignore-missing', 'im')
-        .alias('debug', 'd')
-        .alias('standalone', 's')
-        .alias('ig', 'fast')
-        .alias('noparse', 'noParse')
-        .default('ig', false)
-        .default('im', false)
-        .default('dg', true) 
-        .default('d', false) 
-        .argv
-    ;
+    var argv = minimist(args, {
+        'boolean': [
+            'deps','pack','ig','dg', 'im', 'd','list',
+            'builtins','commondir', 'bare'
+        ],
+        string: [ 's' ],
+        alias: {
+            ig: [ 'insert-globals', 'fast' ],
+            dg: 'detect-globals',
+            im: 'ignore-missing',
+            igv: 'insert-global-vars',
+            d: 'debug',
+            s: 'standalone',
+            noparse: 'noParse',
+            bare: 'bear'
+        },
+        'default': {
+            ig: false,
+            im: false,
+            dg: true,
+            d: false,
+            builtins: true,
+            commondir: true
+        }
+    });
     
     var entries = argv._.concat(argv.e).concat(argv.entry)
     .filter(Boolean).map(function(entry) {
+        if (entry === '-') return process.stdin;
         return path.resolve(process.cwd(), entry);
     });
+    var requires = [].concat(argv.r, argv.require).filter(Boolean);
+    
+    if (entries.length + requires.length === 0 && !process.stdin.isTTY) {
+        entries.push(process.stdin);
+    }
+    
+    if (argv.s && entries.length === 0 && requires.length === 1) {
+        entries.push(requires[0]);
+        argv.r = argv.require = [];
+    }
+    
+    if (argv.bare) {
+        argv.builtins = false;
+        argv.commondir = false;
+        if (argv.igv === undefined) {
+            argv.igv = '__filename,__dirname';
+        }
+    }
     
     var b = browserify({
         noParse: [].concat(argv.noparse).filter(Boolean),
-        entries: entries
+        extensions: [].concat(argv.extension).filter(Boolean),
+        entries: entries,
+        builtins: argv.builtins === false ? false : undefined,
+        commondir: argv.commondir === false ? false : undefined
     });
     b.argv = argv;
     
@@ -37,6 +69,10 @@ module.exports = function (args) {
         .forEach(function (i) { b.ignore(i) })
     ;
     
+    [].concat(argv.u).concat(argv.exclude).filter(Boolean)
+        .forEach(function (u) { b.exclude(u) })
+    ;
+    
     [].concat(argv.r).concat(argv.require).filter(Boolean)
         .forEach(function (r) {
             var xs = r.split(':');
@@ -46,13 +82,29 @@ module.exports = function (args) {
     
     // resolve any external files and add them to the bundle as externals
     [].concat(argv.x).concat(argv.external).filter(Boolean)
-        .forEach(function (x) { b.external(path.resolve(process.cwd(), x)) })
+        .forEach(function (x) {
+            var xs = x.split(':');
+            if (xs.length === 1) {
+                opts = {};
+            } else {
+                x = xs[0];
+                opts = {expose: xs[1]};
+            }
+            if (/^[\/.]/.test(x)) b.external(path.resolve(process.cwd(), x),opts)
+            else b.external(x,opts)
+        })
     ;
     
-    [].concat(argv.t).concat(argv.transform).filter(Boolean)
+    [].concat(argv.t).concat(argv.transform)
+        .filter(Boolean)
         .forEach(function (t) { b.transform(t) })
     ;
     
+    [].concat(argv.g).concat(argv['global-transform'])
+        .filter(Boolean)
+        .forEach(function (t) { b.transform({ global: true }, t) })
+    ;
+    
     [].concat(argv.c).concat(argv.command).filter(Boolean)
         .forEach(function (c) {
             var cmd = parseShell(c);
@@ -90,6 +142,7 @@ module.exports = function (args) {
     var bundleOpts = {
         detectGlobals: argv['detect-globals'] !== false && argv.dg !== false,
         insertGlobals: argv['insert-globals'] || argv.ig,
+        insertGlobalVars: argv.igv ? argv.igv.split(',') : undefined,
         ignoreMissing: argv['ignore-missing'] || argv.im,
         debug: argv['debug'] || argv.d,
         standalone: argv['standalone'] || argv.s

data/node_modules/browserify/bin/cmd.js

@@ -4,6 +4,7 @@ var JSONStream = require('JSONStream');
 var through = require('through');
 
 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') {
@@ -13,7 +14,7 @@ if ((b.argv._[0] === 'help' && b.argv._[1]) === 'advanced'
     ;
 }
 if (b.argv._[0] === 'help' || b.argv.h || b.argv.help
-|| process.argv.length <= 2) {
+|| (process.argv.length <= 2 && process.stdin.isTTY)) {
     return fs.createReadStream(__dirname + '/usage.txt')
         .pipe(process.stdout)
         .on('close', function () { process.exit(1) })
@@ -36,13 +37,15 @@ if (b.argv.pack) {
 
 if (b.argv.deps) {
     var stringify = JSONStream.stringify();
-    var d = b.deps({ packageFilter: packageFilter });
+    var t = [].concat(b.argv.t).concat(b.argv.transform);
+    var d = b.deps({ packageFilter: packageFilter, transform: t });
     d.pipe(stringify).pipe(process.stdout);
     return;
 }
 
 if (b.argv.list) {
-    var d = b.deps({ packageFilter: packageFilter });
+    var t = [].concat(b.argv.t).concat(b.argv.transform);
+    var d = b.deps({ packageFilter: packageFilter, transform: t });
     d.pipe(through(function (dep) {
         this.queue(dep.id + '\n');
     })).pipe(process.stdout);

data/node_modules/browserify/bin/usage.txt

@@ -10,7 +10,9 @@ Standard Options:
 
       --entry, -e  An entry point of your app
   
-     --ignore, -i  Omit a file from the output bundle.
+     --ignore, -i  Replace a file with an empty stub.
+ 
+    --exclude, -u  Omit a file from the output bundle.
 
    --external, -x  Reference a file from another bundle.
   

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

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

data/node_modules/browserify/index.js

@@ -1,24 +1,38 @@
 var crypto = require('crypto');
 var through = require('through');
-var duplexer = require('duplexer');
+var pipeline = require('stream-combiner');
 var concatStream = require('concat-stream');
 var checkSyntax = require('syntax-error');
+var parents = require('parents');
+var deepEqual = require('deep-equal');
+var defined = require('defined');
+var builtins = require('./lib/builtins.js');
 
 var mdeps = require('module-deps');
 var browserPack = require('browser-pack');
+var depSorter = require('deps-sort');
 var browserResolve = require('browser-resolve');
 var insertGlobals = require('insert-module-globals');
 var umd = require('umd');
+var derequire = require('derequire');
 
 var path = require('path');
 var inherits = require('inherits');
 var EventEmitter = require('events').EventEmitter;
+var fs = require('fs');
 
-module.exports = function (opts) {
+var emptyModulePath = path.join(__dirname, 'lib/_empty.js');
+
+module.exports = function (opts, xopts) {
     if (opts === undefined) opts = {};
     if (typeof opts === 'string') opts = { entries: [ opts ] };
+    if (isStream(opts)) opts = { entries: [ opts ] };
     if (Array.isArray(opts)) opts = { entries: opts };
     
+    if (xopts) Object.keys(xopts).forEach(function (key) {
+        opts[key] = xopts[key];
+    });
+    
     var b = new Browserify(opts);
     [].concat(opts.entries).filter(Boolean).forEach(b.add.bind(b));
     return b;
@@ -38,24 +52,57 @@ function Browserify (opts) {
     self._pending = 0;
     self._entries = [];
     self._ignore = {};
+    self._exclude = {};
     self._external = {};
     self._expose = {};
     self._mapped = {};
+    
     self._transforms = [];
-    self._noParse =[];
-     
+    self._globalTransforms = [];
+    self._extensions = [ '.js', '.json' ]
+        .concat(opts.extensions).filter(Boolean)
+    ;
+    self._noParse = [];
+    self._pkgcache = {};
+    self._exposeAll = opts.exposeAll;
+    self._ignoreMissing = opts.ignoreMissing;
+    self._basedir = opts.basedir;
+    self._delegateResolve = opts.resolve || browserResolve;
+    
+    var sep = /^win/i.test(process.platform) ? ';' : ':';
+    self._paths = opts.paths || (process.env.NODE_PATH || '').split(sep);
+    
+    self._browserPack = opts.pack || function (params) {
+        params.raw = true;
+        params.sourceMapPrefix = '//#';
+        return browserPack(params);
+    };
+    
+    self._builtins = opts.builtins === false ? {} : opts.builtins || builtins;
+    if (opts.builtins === false) {
+        Object.keys(builtins).forEach(function (key) {
+            self._ignore[key] = true;
+            self._exclude[key] = true;
+        });
+    }
+    self._commondir = opts.commondir;
+    
     var noParse = [].concat(opts.noParse).filter(Boolean);
+    noParse.forEach(this.noParse.bind(this));
+}
+
+Browserify.prototype.noParse = function(file) {
+    var self = this;
     var cwd = process.cwd();
     var top = { id: cwd, filename: cwd + '/_fake.js', paths: [] };
-    noParse.forEach(function (file) {
-        self._noParse.push(file, path.resolve(file));
-        self._pending ++;
-        self._resolve(file, top, function (err, r) {
-            if (r) self._noParse.push(r);
-            if (--self._pending === 0) self.emit('_ready');
-        });
+    self._noParse.push(file, path.resolve(file));
+    self._pending ++;
+    self._resolve(file, top, function (err, r) {
+        if (r) self._noParse.push(r);
+        if (--self._pending === 0) self.emit('_ready');
     });
-}
+    return this;
+};
 
 Browserify.prototype.add = function (file) {
     this.require(file, { entry: true });
@@ -64,19 +111,37 @@ Browserify.prototype.add = function (file) {
 
 Browserify.prototype.require = function (id, opts) {
     var self = this;
+    if (isStream(id)) {
+        self.files.push(id);
+        return self;
+    }
+    
     if (opts === undefined) opts = { expose: id };
     
     self._pending ++;
     
-    var basedir = opts.basedir || process.cwd();
+    var basedir = opts.basedir || self._basedir || process.cwd();
     var fromfile = basedir + '/_fake.js';
     
-    var params = { filename: fromfile, packageFilter: packageFilter };
-    browserResolve(id, params, function (err, file) {
-        if (err) return self.emit('error', err);
-        if (!file) return self.emit('error', new Error(
-            'module ' + JSON.stringify(id) + ' not found in require()'
-        ));
+    var params = {
+        filename: fromfile,
+        modules: self._builtins,
+        packageFilter: packageFilter,
+        extensions: self._extensions,
+        paths: opts.paths || self._paths
+    };
+    
+    var order;
+    if (opts.entry) {
+        order = self._entries.length;
+        self._entries.push(null);
+    }
+    
+    self._delegateResolve(id, params, function (err, file) {
+        if ((err || !file) && !opts.external) {
+            if (err) return self.emit('error', err);
+            if (!file) return self.emit('error', notFound(id, fromFile));
+        }
         
         if (opts.expose) {
             self.exports[file] = hash(file);
@@ -86,15 +151,16 @@ Browserify.prototype.require = function (id, opts) {
                 self._mapped[opts.expose] = file;
             }
         }
-
+        
         if (opts.external) {
-            self._external[file] = true;
+            if (file) self._external[file] = true;
+            else self._external[id] = true;
         }
         else {
             self.files.push(file);
         }
         
-        if (opts.entry) self._entries.push(file);
+        if (opts.entry) self._entries[order] = file;
         
         if (--self._pending === 0) self.emit('_ready');
     });
@@ -109,8 +175,32 @@ Browserify.prototype.expose = function (name, file) {
 };
 
 Browserify.prototype.external = function (id, opts) {
-    opts = opts || {};
+    var self = this;
+    if (!opts) opts = {};
+    if (!opts.basedir) opts.basedir = self._basedir;
+    if (!opts.globalTransform) opts.globalTransform = self._globalTransforms;
+    
+    if (isBrowserify(id)) {
+        self._pending++;
+        
+        function captureDeps() {
+            var d = mdeps(id.files, opts);
+            d.pipe(through(write, end));
+            
+            function write (row) { self.external(row.id) }
+            function end () {
+                if (--self._pending === 0) self.emit('_ready');
+            }
+        }
+        if (id._pending === 0) return captureDeps();
+        return id.once('_ready', captureDeps);
+    }
+
     opts.external = true;
+    if (!opts.parse) {
+        this.noParse(id);
+        if (opts.expose) this.noParse(opts.expose);
+    }
     return this.require(id, opts);
 };
 
@@ -119,6 +209,12 @@ Browserify.prototype.ignore = function (file) {
     return this;
 };
 
+Browserify.prototype.exclude = function (file) {
+    this.ignore(file);
+    this._exclude[file] = true;
+    return this;
+};
+
 Browserify.prototype.bundle = function (opts, cb) {
     var self = this;
     if (typeof opts === 'function') {
@@ -130,9 +226,12 @@ Browserify.prototype.bundle = function (opts, cb) {
     if (opts.detectGlobals === undefined) opts.detectGlobals = true;
     if (opts.ignoreMissing === undefined) opts.ignoreMissing = false;
     if (opts.standalone === undefined) opts.standalone = false;
+
+    self._ignoreMissing = opts.ignoreMissing;
     
     opts.resolve = self._resolve.bind(self);
     opts.transform = self._transforms;
+    opts.globalTransform = self._globalTransforms;
     opts.noParse = self._noParse;
     opts.transformKey = [ 'browserify', 'transform' ];
     
@@ -141,7 +240,14 @@ Browserify.prototype.bundle = function (opts, cb) {
         if (parentFilter) pkg = parentFilter(pkg);
         return packageFilter(pkg);
     };
-    
+
+    if (cb) cb = (function (f) {
+        return function () {
+            if (f) f.apply(this, arguments);
+            f = null;
+        };
+    })(cb);
+
     if (self._pending) {
         var tr = through();
         self.on('_ready', function () {
@@ -151,50 +257,74 @@ Browserify.prototype.bundle = function (opts, cb) {
         });
         return tr;
     }
-    
+
     if (opts.standalone && self._entries.length !== 1) {
         process.nextTick(function () {
             p.emit('error', 'standalone only works with a single entry point');
         });
     }
     
+    var prevCache = opts.cache && copy(opts.cache);
     var d = (opts.deps || self.deps.bind(self))(opts);
     var g = opts.detectGlobals || opts.insertGlobals
         ? insertGlobals(self.files, {
             resolve: self._resolve.bind(self),
-            always: opts.insertGlobals
+            always: opts.insertGlobals,
+            vars: opts.insertGlobalVars,
+            basedir: opts.basedir || self._basedir,
+            commondir: defined(opts.commondir, self._commondir)
         })
         : through()
     ;
-    var p = self.pack(opts.debug, opts.standalone);
+    var p = self.pack(opts);
     if (cb) {
         p.on('error', cb);
-        p.pipe(concatStream(cb));
+        p.pipe(concatStream({ encoding: 'string' }, function (src) {
+            cb(null, opts.standalone ? derequire(src) : src);
+        }));
     }
-    
+    g.on('dep', function (dep) { self.emit('dep', dep) });
     d.on('error', p.emit.bind(p, 'error'));
     g.on('error', p.emit.bind(p, 'error'));
     d.pipe(through(function (dep) {
         if (self._noParse.indexOf(dep.id) >= 0
-        || (opts.cache && opts.cache[dep.id])) {
+        || (prevCache && prevCache[dep.id])) {
             p.write(dep);
         }
         else this.queue(dep)
     })).pipe(g).pipe(p);
     
+    if (opts.standalone) {
+        var output = through();
+        p.pipe(concatStream({ encoding: 'string' }, function (body) {
+            output.queue(derequire(body));
+            output.queue(null);
+        }));
+        return output;
+    }
     return p;
 };
 
-Browserify.prototype.transform = function (t) {
+Browserify.prototype.transform = function (opts, t) {
+    if (t === undefined) {
+        t = opts;
+        opts = {};
+    }
+    if (!opts) opts = {};
     if (typeof t === 'string' && /^\./.test(t)) {
         t = path.resolve(t);
     }
-    this._transforms.push(t);
+    if (opts.global) {
+        this._globalTransforms.push(t);
+    }
+    else this._transforms.push(t);
     return this;
 };
 
 Browserify.prototype.deps = function (opts) {
     var self = this;
+    if (!opts) opts = {};
+    
     if (self._pending) {
         var tr = through();
         self.on('_ready', function () {
@@ -203,8 +333,13 @@ Browserify.prototype.deps = function (opts) {
         return tr;
     }
     
+    opts.modules = self._builtins;
+    opts.extensions = self._extensions;
+    
+    if (!opts.basedir) opts.basedir = self._basedir;
     var d = mdeps(self.files, opts);
     
+    var index = 0;
     var tr = d.pipe(through(write));
     d.on('error', tr.emit.bind(tr, 'error'));
     return tr;
@@ -215,17 +350,34 @@ Browserify.prototype.deps = function (opts) {
         if (row.id === emptyModulePath) {
             row.source = '';
         }
+        if (/^\ufeff/.test(row.source)) {
+            row.source = row.source.replace(/^\ufeff/, '');
+        }
+        
+        row.deps = Object.keys(row.deps).reduce(function (acc, key) {
+            if (!self._exclude[key] && !self._external[key]
+            && !self._external[row.id]) {
+                acc[key] = row.deps[key];
+            }
+            return acc;
+        }, {});
         
         if (self._expose[row.id]) {
             this.queue({
+                id: row.id,
                 exposed: self._expose[row.id],
                 deps: {},
-                source: 'module.exports=require(\'' + hash(row.id) + '\');'
+                source: 'module.exports=require(\'' + hash(row.id) + '\');',
+                nomap: true
             });
         }
         
         if (self.exports[row.id]) row.exposed = self.exports[row.id];
 
+        if (self._exposeAll) {
+            row.exposed = hash(row.id);
+        }
+
         // skip adding this file if it is external
         if (self._external[row.id]) {
             return;
@@ -236,91 +388,154 @@ Browserify.prototype.deps = function (opts) {
         }
         
         var ix = self._entries.indexOf(row.id);
-        row.entry = ix >= 0;
+        if (row.entry === undefined || self.exports[row.id]) {
+            row.entry = ix >= 0;
+        }
         if (ix >= 0) row.order = ix;
         this.queue(row);
     }
 };
 
-Browserify.prototype.pack = function (debug, standalone) {
+Browserify.prototype.pack = function (opts) {
+    if (!opts) opts = {};
+    
     var self = this;
-    var packer = browserPack({ raw: true });
-    var ids = {};
-    var idIndex = 1;
+    var packer = self._browserPack(opts);
     
     var mainModule;
+    var hashes = {}, depList = {}, depHash = {};
+    var visited = {};
     
     var input = through(function (row_) {
         var row = copy(row_);
-        var ix;
         
-        if (debug) { 
+        if (opts.debug) { 
             row.sourceRoot = 'file://localhost'; 
-            row.sourceFile = row.id;
+            row.sourceFile = row.id.replace(/\\/g, '/');
         }
         
-        if (row.exposed) {
-            ix = row.exposed;
+        var dup = hashes[row.hash];
+        if (dup && sameDeps(depList[dup._id], row.deps)) {
+            row.source = 'module.exports=require('
+                + JSON.stringify(dup.id)
+                + ')'
+            ;
+            row.nomap = true;
         }
-        else {
-            ix = ids[row.id] !== undefined ? ids[row.id] : idIndex++;
+        else if (dup) {
+            row.source = 'arguments[4]['
+                + JSON.stringify(dup.id)
+                + '][0].apply(exports,arguments)'
+            ;
         }
-        if (ids[row.id] === undefined) ids[row.id] = ix;
+        else hashes[row.hash] = { _id: row.id, id: getId(row) };
         
         if (/^#!/.test(row.source)) row.source = '//' + row.source;
         var err = checkSyntax(row.source, row.id);
         if (err) return this.emit('error', err);
         
-        row.id = ix;
-        if (row.entry) mainModule = mainModule || ix;
-        row.deps = Object.keys(row.deps).reduce(function (acc, key) {
+        row.id = getId(row);
+        
+        if (row.entry) mainModule = mainModule || row.id;
+        
+        var deps = {};
+        Object.keys(row.deps || {}).forEach(function (key) {
             var file = row.deps[key];
-            
-            // reference external and exposed files directly by hash
-            if (self._external[file] || self.exports[file]) {
-                acc[key] = hash(file);
-                return acc;
+            var index = row.indexDeps && row.indexDeps[key];
+            if (self._exposeAll) {
+                index = hash(file);
             }
-            
-            if (ids[file] === undefined) ids[file] = idIndex++;
-            acc[key] = ids[file];
-            return acc;
-        }, {});
-        
+            deps[key] = getId({ id: file, index: index });
+        });
+        row.deps = deps;
+
         this.queue(row);
     });
     
+    function getId (row) {
+        if (row.exposed) {
+            return row.exposed;
+        }
+        else if (self._external[row.id] || self.exports[row.id]) {
+            return hash(row.id);
+        }
+        else if (self._expose[row.id]) {
+            return row.id;
+        }
+        else if (row.index === undefined) {
+            return row.id;
+        }
+        else return row.index;
+    }
+    
     var first = true;
     var hasExports = Object.keys(self.exports).length;
     var output = through(write, end);
     
-    function writePrelude () {
-        if (!first) return;
-        if (standalone) {
-            return output.queue(umd.prelude(standalone) + 'return ');
-        }
-        if (!hasExports) return output.queue(';');
-        output.queue('require=');
-    }
-    
-    input.pipe(packer);
-    packer.pipe(output);
-    return duplexer(input, output);
+    var sort = depSorter({ index: true });
+
+    input.on('data', function (row) { self.emit('row', row) });
+    return pipeline(through(hasher), sort, input, packer, output);
     
     function write (buf) {
-        if (first) writePrelude();
+        if (first) writePrelude.call(this);
         first = false;
         this.queue(buf);
     }
     
     function end () {
-        if (first) writePrelude();
-        if (standalone) {
-            output.queue('(' + mainModule + ')' + umd.postlude(standalone));
+        if (first) writePrelude.call(this);
+        if (opts.standalone) {
+            this.queue(
+                '\n(' + JSON.stringify(mainModule) + ')'
+                + umd.postlude(opts.standalone)
+            );
         }
-        this.queue('\n;');
+        if (opts.debug) this.queue('\n');
         this.queue(null);
     }
+    
+    function writePrelude () {
+        if (!first) return;
+        if (opts.standalone) {
+            return this.queue(umd.prelude(opts.standalone).trim() + 'return ');
+        }
+        if (hasExports) this.queue(
+            (opts.externalRequireName || 'require') + '='
+        );
+    }
+    
+    function hasher (row) {
+        row.hash = hash(row.source);
+        depList[row.id] = row.deps;
+        depHash[row.id] = row.hash;
+        this.queue(row);
+    }
+    
+    function sameDeps (a, b) {
+        var keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length) return false;
+        
+        for (var i = 0; i < keys.length; i++) {
+            var k = keys[i], ka = a[k], kb = b[k];
+            var ha = depHash[ka];
+            var hb = depHash[kb];
+            var da = depList[ka];
+            var db = depList[kb];
+            
+            if (ka === kb) continue;
+            if (ha !== hb) return false;
+            if (visited[da] && visited[db]) {
+                if (!deepEqual(da, db)) return false;
+            }
+            else {
+                visited[da] = true;
+                visited[db] = true;
+                if (!sameDeps(da, db)) return false;
+            }
+        }
+        return true;
+    }
 };
 
 var packageFilter = function (info) {
@@ -331,30 +546,92 @@ var packageFilter = function (info) {
     return info;
 };
 
-var emptyModulePath = require.resolve('./_empty');
 Browserify.prototype._resolve = function (id, parent, cb) {
-    if (this._ignore[id]) return cb(null, emptyModulePath);
     var self = this;
-    var result = function (file, x) {
+    if (self._ignore[id]) return cb(null, emptyModulePath);
+    
+    var result = function (file, pkg, x) {
         if (self._pending === 0) {
             self.emit('file', file, id, parent);
         }
-        cb(null, file, x);
+        if (pkg) {
+            cb(null, file, pkg, x);
+            self.emit('package', file, pkg);
+        }
+        else findPackage(path.dirname(file), function (err, pkgfile, pkg) {
+            if (err) return cb(err)
+            
+            if (pkg && typeof pkg === 'object') {
+                var pkg_ = pkg;
+                pkg = {};
+                if (typeof pkg_.browserify === 'string' && !pkg_.browser) {
+                    pkg.browser = pkg_.browserify;
+                }
+                if (typeof pkg_.browserify === 'object') {
+                    pkg.browserify = pkg_.browserify;
+                }
+            }
+            cb(null, file, pkg, x);
+            self.emit('package', file, pkg);
+        })
     };
     if (self._mapped[id]) return result(self._mapped[id]);
     
-    return browserResolve(id, parent, function(err, file) {
-        if (err) return cb(err);
-        if (!file) return cb(new Error('module '
-            + JSON.stringify(id) + ' not found from '
-            + JSON.stringify(parent.filename)
-        ));
+    parent.modules = self._builtins;
+    parent.extensions = self._extensions;
+    parent.paths = self._paths;
+    
+    if (self._external[id]) return cb(null, emptyModulePath);
+    
+    return self._delegateResolve(id, parent, function(err, file, pkg) {
+        var cannotFind = /Cannot find module/.test(err && err.message);
+        if (err && !cannotFind) return cb(err);
+        
+        if (!file && (self._external[id] || self._external[file])) {
+            return cb(null, emptyModulePath);
+        }
+        else if (!file && self._ignoreMissing) {
+            self.emit('missing', id, parent);
+            return cb(null, emptyModulePath);
+        }
+        else if (!file) {
+            return cb(notFound(id, parent.filename))
+        }
         
         if (self._ignore[file]) return cb(null, emptyModulePath);
-        if (self._external[file]) return result(file, true);
+        if (self._external[file]) return result(file, pkg, true);
         
-        result(file);
+        result(file, pkg);
     });
+     
+    function findPackage (basedir, cb) {
+        var dirs = parents(basedir);
+        (function next () {
+            var dir = dirs.shift();
+            if (dir === 'node_modules' || dir === undefined) {
+                return cb(null, null, null);
+            }
+            
+            var pkgfile = path.join(dir, 'package.json');
+            if (self._pkgcache[pkgfile]) {
+                cb(null, pkgfile, self._pkgcache[pkgfile]);
+            }
+            else readPackage(pkgfile, function (err, pkg) {
+                self._pkgcache[pkgfile] = pkg;
+                if (err) return next()
+                else cb(null, pkgfile, pkg)
+            });
+        })();
+    }
+    
+    function readPackage (pkgfile, cb) {
+        fs.readFile(pkgfile, function (err, src) {
+            if (err) return cb(err);
+            try { var pkg = JSON.parse(src) }
+            catch (e) {}
+            cb(null, pkg);
+        });
+    }
 };
 
 function copy (obj) {
@@ -363,3 +640,22 @@ function copy (obj) {
         return acc;
     }, {});
 }
+
+function isBrowserify (x) {
+    return x && typeof x === 'object' && typeof x.bundle === 'function';
+}
+
+function isStream (x) {
+    return x && typeof x === 'object' && typeof x.pipe === 'function';
+}
+
+function notFound (id, parent) {
+    var err = new Error('module '
+        + JSON.stringify(id) + ' not found from '
+        + JSON.stringify(parent)
+    );
+    err.type = 'not found';
+    err.filename = id;
+    err.parent = parent;
+    return err;
+}