snowball 0.1.21 → 0.1.22

data/node_modules/browserify/README.markdown

@@ -0,0 +1,172 @@
+browserify
+==========
+
+Make node-style require() work in the browser with a server-side build step,
+as if by magic!
+
+[![build status](https://secure.travis-ci.org/substack/node-browserify.png)](http://travis-ci.org/substack/node-browserify)
+
+![browserify!](http://substack.net/images/browserify/browserify.png)
+
+example
+=======
+
+Just write an `entry.js` to start with some `require()`s in it:
+
+````javascript
+// use relative requires
+var foo = require('./foo');
+var bar = require('../lib/bar');
+
+// or use modules installed by npm into node_modules/
+var gamma = require('gamma');
+
+var elem = document.getElementById('result');
+var x = foo(100) + bar('baz');
+elem.textContent = gamma(x);
+````
+
+Now just use the `browserify` command to build a bundle starting at `entry.js`:
+
+```
+$ browserify entry.js -o bundle.js
+```
+
+All of the modules that `entry.js` needs are included in the final bundle from a
+recursive walk using [detective](https://github.com/substack/node-detective).
+
+To use the bundle, just toss a `<script src="bundle.js"></script>` into your
+html!
+
+usage
+=====
+
+````
+Usage: browserify [entry files] {OPTIONS}
+
+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                                     
+  --exports      Export these core objects, comma-separated list
+                 with any of: require, process. If unspecified, the
+                 export behavior will be inferred.
+                                                                                
+  --ignore, -i   Ignore a file                                                  
+  --alias, -a    Register an alias with a colon separator: "to:from"
+                 Example: --alias 'jquery:jquery-browserify'                    
+  --cache, -c    Turn on caching at $HOME/.config/browserling/cache.json or use
+                 a file for caching.
+                                                                 [default: true]
+  --debug, -d    Switch on debugging mode with //@ sourceURL=...s.     [boolean]
+  --plugin, -p   Use a plugin.
+                 Example: --plugin aliasify                                     
+  --prelude      Include the code that defines require() in this bundle.
+                                                      [boolean]  [default: true]
+  --watch, -w    Watch for changes. The script will stay open and write updates
+                 to the output every time any of the bundled files change.
+                 This option only works in tandem with -o.                      
+  --verbose, -v  Write out how many bytes were written in -o mode. This is
+                 especially useful with --watch.                                
+  --help, -h     Show this message                                              
+
+````
+
+compatibility
+=============
+
+Many [npm](http://npmjs.org) modules that don't do IO will just work after being
+browserified. Others take more work.
+
+[coffee script](http://coffeescript.org/) should pretty much just work.
+Just do `browserify entry.coffee` or `require('./foo.coffee')`.
+
+Many node built-in modules have been wrapped to work in the browser.
+All you need to do is `require()` them like in node.
+
+* events
+* path
+* [vm](https://github.com/substack/vm-browserify)
+* [http](https://github.com/substack/http-browserify)
+* [crypto](https://github.com/dominictarr/crypto-browserify)
+* assert
+* url
+* buffer
+* buffer_ieee754
+* util
+* querystring
+* stream
+
+process
+-------
+
+Browserify makes available a faux `process` object to modules with these
+attributes:
+
+* nextTick(fn) - uses [the postMessage trick](http://dbaron.org/log/20100309-faster-timeouts)
+    for a faster `setTimeout(fn, 0)` if it can
+* title - set to 'browser' for browser code, 'node' in regular node code
+* browser - `true`, good for testing if you're in a browser or in node
+
+By default the process object is only available inside of files wrapped by
+browserify. To expose it, use `--exports=process`
+
+__dirname
+---------
+
+The faux directory name, scrubbed of true directory information so as not to
+expose your filesystem organization.
+
+__filename
+----------
+
+The faux file path, scrubbed of true path information so as not to expose your
+filesystem organization.
+
+package.json
+============
+
+In order to resolve main files for projects, the package.json "main" field is
+read.
+
+If a package.json has a "browserify" field, you can override the standard "main"
+behavior with something special just for browsers.
+
+See [dnode's
+package.json](https://github.com/substack/dnode/blob/9e24b97cf2ce931fbf6d7beb3731086b46bca887/package.json#L40)
+for an example of using the "browserify" field.
+
+more
+====
+
+* [browserify recipes](https://github.com/substack/node-browserify/blob/master/doc/recipes.markdown#recipes)
+* [browserify api reference](https://github.com/substack/node-browserify/blob/master/doc/methods.markdown#methods)
+* [browserify cdn](http://browserify.nodejitsu.com/)
+
+install
+=======
+
+With [npm](http://npmjs.org) do:
+
+```
+npm install -g browserify
+```
+
+test
+====
+
+To run the node tests with tap, do:
+
+```
+npm test
+```
+
+To run the [testling](http://testling.com) tests,
+create a [browserling](http://browserling.com) account then:
+
+```
+cd testling
+./test.sh
+```

data/node_modules/browserify/bin/cmd.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+var browserify = require('../');
+var fs = require('fs');
+var resolve = require('resolve');
+
+var argv = require('optimist')
+    .usage('Usage: browserify [entry files] {OPTIONS}')
+    .wrap(80)
+    .option('outfile', {
+        alias : 'o',
+        desc : 'Write the browserify bundle to this file.\n'
+            + 'If unspecified, browserify prints to stdout.'
+        ,
+    })
+    .option('require', {
+        alias : 'r',
+        desc : 'A module name or file to bundle.require()\n'
+            + 'Optionally use a colon separator to set the target.'
+        ,
+    })
+    .option('entry', {
+        alias : 'e',
+        desc : 'An entry point of your app'
+    })
+    .option('exports', {
+        desc : 'Export these core objects, comma-separated list\n'
+            + 'with any of: require, process. If unspecified, the\n'
+            + 'export behavior will be inferred.\n'
+    })
+    .option('ignore', {
+        alias : 'i',
+        desc : 'Ignore a file'
+    })
+    .option('alias', {
+        alias : 'a',
+        desc : 'Register an alias with a colon separator: "to:from"\n'
+            + "Example: --alias 'jquery:jquery-browserify'"
+        ,
+    })
+    .option('cache', {
+        alias : 'c',
+        desc : 'Turn on caching at $HOME/.config/browserling/cache.json '
+            + 'or use a file for caching.\n',
+        default : true,
+    })
+    .option('debug', {
+        alias : 'd',
+        desc : 'Switch on debugging mode with //@ sourceURL=...s.',
+        type : 'boolean'
+    })
+    .option('plugin', {
+        alias : 'p',
+        desc : 'Use a plugin.\n'
+            + 'Example: --plugin aliasify'
+        ,
+    })
+    .option('prelude', {
+        default : true,
+        type : 'boolean',
+        desc : 'Include the code that defines require() in this bundle.'
+    })
+    .option('watch', {
+        alias : 'w',
+        desc : 'Watch for changes. The script will stay open and write updates '
+            + 'to the output every time any of the bundled files change.\n'
+            + 'This option only works in tandem with -o.'
+        ,
+    })
+    .option('verbose', {
+        alias : 'v',
+        desc : 'Write out how many bytes were written in -o mode. '
+            + 'This is especially useful with --watch.'
+        ,
+    })
+    .option('help', {
+        alias : 'h',
+        desc : 'Show this message'
+    })
+    .check(function (argv) {
+        if (argv.help) throw ''
+        if (process.argv.length <= 2) throw 'Specify a parameter.'
+    })
+    .argv
+;
+
+var bundle = browserify({
+    watch : argv.watch,
+    cache : argv.cache,
+    debug : argv.debug,
+    exports : argv.exports && argv.exports.split(','),
+});
+
+bundle.on('syntaxError', function (err) {
+    console.error(err);
+    if (!argv.watch) {
+        process.exit(1);
+    }
+});
+
+if (argv.noprelude || argv.prelude === false) {
+    bundle.files = [];
+    bundle.prepends = [];
+}
+if (argv.ignore) bundle.ignore(argv.ignore);
+
+([].concat(argv.plugin || [])).forEach(function (plugin) {
+    var resolved = resolve.sync(plugin, { basedir : process.cwd() });
+    bundle.use(require(resolved));
+});
+
+([].concat(argv.alias || [])).forEach(function (alias) {
+    if (!alias.match(/:/)) {
+        console.error('aliases require a colon separator');
+        process.exit();
+    }
+    bundle.alias.apply(bundle, alias.split(':'));
+});
+
+([].concat(argv.require || [])).forEach(function (req) {
+    if (req.match(/:/)) {
+        var s = req.split(':');
+        bundle.require(s[0], { target : s[1] });
+        return;
+    }
+    
+    if (!/^[.\/]/.test(req)) {
+        try {
+            var res = resolve.sync(req, { basedir : process.cwd() });
+        }
+        catch (e) {
+            return bundle.require(req);
+        }
+        return bundle.require(res, { target : req });
+    }
+    bundle.require(req);
+});
+
+(argv._.concat(argv.entry || [])).forEach(function (entry) {
+    bundle.addEntry(entry);
+});
+
+if (argv.outfile) {
+    function write () {
+        var src = bundle.bundle();
+        if (!bundle.ok) return;
+        
+        fs.writeFile(argv.outfile, src, function () {
+            if (argv.verbose) {
+                console.log(Buffer(src).length + ' bytes written');
+            }
+        });
+    }
+    
+    write();
+    if (argv.watch) bundle.on('bundle', write)
+}
+else {
+    var src = bundle.bundle();
+    if (bundle.ok) console.log(src);
+}

data/node_modules/browserify/builtins/__browserify_process.js

@@ -0,0 +1,55 @@
+var process = module.exports = {};
+
+process.nextTick = (function () {
+    var canSetImmediate = typeof window !== 'undefined'
+        && window.setImmediate;
+    var canPost = typeof window !== 'undefined'
+        && window.postMessage && window.addEventListener
+    ;
+
+    if (canSetImmediate) {
+        return function (f) { return window.setImmediate(f) };
+    }
+
+    if (canPost) {
+        var queue = [];
+        window.addEventListener('message', function (ev) {
+            if (ev.source === window && ev.data === 'browserify-tick') {
+                ev.stopPropagation();
+                if (queue.length > 0) {
+                    var fn = queue.shift();
+                    fn();
+                }
+            }
+        }, true);
+
+        return function nextTick(fn) {
+            queue.push(fn);
+            window.postMessage('browserify-tick', '*');
+        };
+    }
+
+    return function nextTick(fn) {
+        setTimeout(fn, 0);
+    };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+    if (name === 'evals') return (require)('vm')
+    else throw new Error('No such module. (Possibly not yet loaded)')
+};
+
+(function () {
+    var cwd = '/';
+    var path;
+    process.cwd = function () { return cwd };
+    process.chdir = function (dir) {
+        if (!path) path = require('path');
+        cwd = path.resolve(dir, cwd);
+    };
+})();

data/node_modules/browserify/builtins/assert.js

@@ -0,0 +1,314 @@
+// UTILITY
+var util = require('util');
+var Buffer = require("buffer").Buffer;
+var pSlice = Array.prototype.slice;
+
+function objectKeys(object) {
+  if (Object.keys) return Object.keys(object);
+  var result = [];
+  for (var name in object) {
+    if (Object.prototype.hasOwnProperty.call(object, name)) {
+      result.push(name);
+    }
+  }
+  return result;
+}
+
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = module.exports = ok;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({ message: message,
+//                             actual: actual,
+//                             expected: expected })
+
+assert.AssertionError = function AssertionError(options) {
+  this.name = 'AssertionError';
+  this.message = options.message;
+  this.actual = options.actual;
+  this.expected = options.expected;
+  this.operator = options.operator;
+  var stackStartFunction = options.stackStartFunction || fail;
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, stackStartFunction);
+  }
+};
+util.inherits(assert.AssertionError, Error);
+
+function replacer(key, value) {
+  if (value === undefined) {
+    return '' + value;
+  }
+  if (typeof value === 'number' && (isNaN(value) || !isFinite(value))) {
+    return value.toString();
+  }
+  if (typeof value === 'function' || value instanceof RegExp) {
+    return value.toString();
+  }
+  return value;
+}
+
+function truncate(s, n) {
+  if (typeof s == 'string') {
+    return s.length < n ? s : s.slice(0, n);
+  } else {
+    return s;
+  }
+}
+
+assert.AssertionError.prototype.toString = function() {
+  if (this.message) {
+    return [this.name + ':', this.message].join(' ');
+  } else {
+    return [
+      this.name + ':',
+      truncate(JSON.stringify(this.actual, replacer), 128),
+      this.operator,
+      truncate(JSON.stringify(this.expected, replacer), 128)
+    ].join(' ');
+  }
+};
+
+// assert.AssertionError instanceof Error
+
+assert.AssertionError.__proto__ = Error.prototype;
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided.  All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+  throw new assert.AssertionError({
+    message: message,
+    actual: actual,
+    expected: expected,
+    operator: operator,
+    stackStartFunction: stackStartFunction
+  });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+function ok(value, message) {
+  if (!!!value) fail(value, true, message, '==', assert.ok);
+}
+assert.ok = ok;
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+  if (actual == expected) {
+    fail(actual, expected, message, '!=', assert.notEqual);
+  }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+  if (!_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+  }
+};
+
+function _deepEqual(actual, expected) {
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+
+  } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
+    if (actual.length != expected.length) return false;
+
+    for (var i = 0; i < actual.length; i++) {
+      if (actual[i] !== expected[i]) return false;
+    }
+
+    return true;
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  } else if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+
+  // 7.3. Other pairs that do not both pass typeof value == 'object',
+  // equivalence is determined by ==.
+  } else if (typeof actual != 'object' && typeof expected != 'object') {
+    return actual == expected;
+
+  // 7.4. For all other Object pairs, including Array objects, equivalence is
+  // determined by having the same number of owned properties (as verified
+  // with Object.prototype.hasOwnProperty.call), the same set of keys
+  // (although not necessarily the same order), equivalent values for every
+  // corresponding key, and an identical 'prototype' property. Note: this
+  // accounts for both named and indexed properties on Arrays.
+  } else {
+    return objEquiv(actual, expected);
+  }
+}
+
+function isUndefinedOrNull(value) {
+  return value === null || value === undefined;
+}
+
+function isArguments(object) {
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv(a, b) {
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+    return false;
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) return false;
+  //~~~I've managed to break Object.keys through screwy arguments passing.
+  //   Converting to array solves the problem.
+  if (isArguments(a)) {
+    if (!isArguments(b)) {
+      return false;
+    }
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return _deepEqual(a, b);
+  }
+  try {
+    var ka = objectKeys(a),
+        kb = objectKeys(b),
+        key, i;
+  } catch (e) {//happens when one is a string literal and the other isn't
+    return false;
+  }
+  // having the same number of owned properties (keys incorporates
+  // hasOwnProperty)
+  if (ka.length != kb.length)
+    return false;
+  //the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  //~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i])
+      return false;
+  }
+  //equivalent values for every corresponding key, and
+  //~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!_deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+  if (_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+  }
+};
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+  if (actual !== expected) {
+    fail(actual, expected, message, '===', assert.strictEqual);
+  }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as
+// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+  if (actual === expected) {
+    fail(actual, expected, message, '!==', assert.notStrictEqual);
+  }
+};
+
+function expectedException(actual, expected) {
+  if (!actual || !expected) {
+    return false;
+  }
+
+  if (expected instanceof RegExp) {
+    return expected.test(actual);
+  } else if (actual instanceof expected) {
+    return true;
+  } else if (expected.call({}, actual) === true) {
+    return true;
+  }
+
+  return false;
+}
+
+function _throws(shouldThrow, block, expected, message) {
+  var actual;
+
+  if (typeof expected === 'string') {
+    message = expected;
+    expected = null;
+  }
+
+  try {
+    block();
+  } catch (e) {
+    actual = e;
+  }
+
+  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+            (message ? ' ' + message : '.');
+
+  if (shouldThrow && !actual) {
+    fail('Missing expected exception' + message);
+  }
+
+  if (!shouldThrow && expectedException(actual, expected)) {
+    fail('Got unwanted exception' + message);
+  }
+
+  if ((shouldThrow && actual && expected &&
+      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+    throw actual;
+  }
+}
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+  _throws.apply(this, [true].concat(pSlice.call(arguments)));
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
+  _throws.apply(this, [false].concat(pSlice.call(arguments)));
+};
+
+assert.ifError = function(err) { if (err) {throw err;}};