sprockets-browserify 0.2.0 → 0.3.0

data/node_modules/browserify/node_modules/concat-stream/node_modules/typedarray/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "typedarray",
+  "version": "0.0.5",
+  "description": "TypedArray polyfill for old browsers",
+  "main": "index.js",
+  "devDependencies": {
+    "tape": "~1.0.4"
+  },
+  "scripts": {
+    "test": "tape test/*.js test/server/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/substack/typedarray.git"
+  },
+  "homepage": "https://github.com/substack/typedarray",
+  "keywords": [
+    "ArrayBuffer",
+    "DataView",
+    "Float32Array",
+    "Float64Array",
+    "Int8Array",
+    "Int16Array",
+    "Int32Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Uint16Array",
+    "Uint32Array",
+    "typed",
+    "array",
+    "polyfill"
+  ],
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "license": "MIT",
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/6..latest",
+      "firefox/16..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "readme": "# typedarray\n\nTypedArray polyfill ripped from [this\nmodule](https://raw.github.com/inexorabletash/polyfill).\n\n[![build status](https://secure.travis-ci.org/substack/typedarray.png)](http://travis-ci.org/substack/typedarray)\n\n[![testling badge](https://ci.testling.com/substack/typedarray.png)](https://ci.testling.com/substack/typedarray)\n\n# example\n\n``` js\nvar Uint8Array = require('typedarray').Uint8Array;\nvar ua = new Uint8Array(5);\nua[1] = 256 + 55;\nconsole.log(ua[1]);\n```\n\noutput:\n\n```\n55\n```\n\n# methods\n\n``` js\nvar TA = require('typedarray')\n```\n\nThe `TA` object has the following constructors:\n\n* TA.ArrayBuffer\n* TA.DataView\n* TA.Float32Array\n* TA.Float64Array\n* TA.Int8Array\n* TA.Int16Array\n* TA.Int32Array\n* TA.Uint8Array\n* TA.Uint8ClampedArray\n* TA.Uint16Array\n* TA.Uint32Array\n\n# install\n\nWith [npm](https://npmjs.org) do:\n\n```\nnpm install typedarray\n```\n\n# license\n\nMIT\n",
+  "readmeFilename": "readme.markdown",
+  "bugs": {
+    "url": "https://github.com/substack/typedarray/issues"
+  },
+  "_id": "typedarray@0.0.5",
+  "dist": {
+    "shasum": "38d5adb949e98ac5d8f6ba6f0f949b2ad4452f63"
+  },
+  "_from": "typedarray@~0.0.5",
+  "_resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.5.tgz"
+}

data/node_modules/browserify/node_modules/concat-stream/node_modules/typedarray/readme.markdown

@@ -0,0 +1,55 @@
+# typedarray
+
+TypedArray polyfill ripped from [this
+module](https://raw.github.com/inexorabletash/polyfill).
+
+[![build status](https://secure.travis-ci.org/substack/typedarray.png)](http://travis-ci.org/substack/typedarray)
+
+[![testling badge](https://ci.testling.com/substack/typedarray.png)](https://ci.testling.com/substack/typedarray)
+
+# example
+
+``` js
+var Uint8Array = require('typedarray').Uint8Array;
+var ua = new Uint8Array(5);
+ua[1] = 256 + 55;
+console.log(ua[1]);
+```
+
+output:
+
+```
+55
+```
+
+# methods
+
+``` js
+var TA = require('typedarray')
+```
+
+The `TA` object has the following constructors:
+
+* TA.ArrayBuffer
+* TA.DataView
+* TA.Float32Array
+* TA.Float64Array
+* TA.Int8Array
+* TA.Int16Array
+* TA.Int32Array
+* TA.Uint8Array
+* TA.Uint8ClampedArray
+* TA.Uint16Array
+* TA.Uint32Array
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install typedarray
+```
+
+# license
+
+MIT

data/node_modules/browserify/node_modules/concat-stream/node_modules/typedarray/test/server/undef_globals.js

@@ -0,0 +1,19 @@
+var test = require('tape');
+var vm = require('vm');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/../../index.js', 'utf8');
+
+test('u8a without globals', function (t) {
+    var c = {
+        module: { exports: {} },
+    };
+    c.exports = c.module.exports;
+    vm.runInNewContext(src, c);
+    var TA = c.module.exports;
+    var ua = new(TA.Uint8Array)(5);
+    
+    t.equal(ua.length, 5);
+    ua[1] = 256 + 55;
+    t.equal(ua[1], 55);
+    t.end();
+});

data/node_modules/browserify/node_modules/concat-stream/node_modules/typedarray/test/tarray.js

@@ -0,0 +1,10 @@
+var TA = require('../');
+var test = require('tape');
+
+test('tiny u8a test', function (t) {
+    var ua = new(TA.Uint8Array)(5);
+    t.equal(ua.length, 5);
+    ua[1] = 256 + 55;
+    t.equal(ua[1], 55);
+    t.end();
+});

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

@@ -1,13 +1,13 @@
 {
   "name": "concat-stream",
-  "description": "writable stream that concatenates strings or data and calls a callback with the result",
+  "description": "writable stream that concatenates strings or binary data and calls a callback with the result",
   "tags": [
     "stream",
     "simple",
     "util",
     "utility"
   ],
-  "version": "0.1.1",
+  "version": "1.4.1",
   "author": {
     "name": "Max Ogden",
     "email": "max@maxogden.com"
@@ -20,10 +20,44 @@
     "url": "http://github.com/maxogden/node-concat-stream/issues"
   },
   "engines": [
-    "node >= 0.8.0"
+    "node >= 0.8"
   ],
-  "readme": "# concat-stream\n\n    npm install concat-stream\n\nthen\n\n    var concat = require('concat-stream')\n    var fs = require('fs')\n    \n    var read = fs.createReadStream('readme.md')\n    var write = concat(function(err, data) {})\n    \n    read.pipe(write)\n    \nworks with arrays too!\n\n    var write = concat(function(err, data) {})\n    write.write([1,2,3])\n    write.write([4,5,6])\n    write.end()\n    // data will be [1,2,3,4,5,6] in the above callback\n\nworks with buffers too! can't believe the deals!\n\n    var write = concat(function(err, data) {})\n    write.write(new Buffer('hello '))\n    write.write(new Buffer('world'))\n    write.end()\n    // data will be a buffer that toString()s to 'hello world' in the above callback\n    \nMIT LICENSE\n",
+  "main": "index.js",
+  "scripts": {
+    "test": "tape test/*.js test/server/*.js"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "inherits": "~2.0.1",
+    "typedarray": "~0.0.5",
+    "readable-stream": "~1.1.9"
+  },
+  "devDependencies": {
+    "tape": "~2.3.2"
+  },
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/17..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "readme": "# concat-stream\n\nWritable stream that concatenates strings or binary data and calls a callback with the result. Not a transform stream -- more of a stream sink.\n\n[![NPM](https://nodei.co/npm/concat-stream.png)](https://nodei.co/npm/concat-stream/)\n\n[![browser support](https://ci.testling.com/maxogden/concat-stream.png)](https://ci.testling.com/maxogden/concat-stream)\n\n### examples\n\n#### Buffers\n\n```js\nvar concat = require('concat-stream')\nvar fs = require('fs')\n    \nvar read = fs.createReadStream('readme.md')\nvar write = concat(function(data) {\n  // data is all of readme.md as a Buffer\n})\n    \nread.pipe(write)\n```\n\n#### Arrays\n\n```js\nvar write = concat(function(data) {})\nwrite.write([1,2,3])\nwrite.write([4,5,6])\nwrite.end()\n// data will be [1,2,3,4,5,6] in the above callback\n```\n\n#### Uint8Arrays\n\n```js\nvar write = concat(function(data) {})\nvar a = new Uint8Array(3)\na[0] = 97; a[1] = 98; a[2] = 99\nwrite.write(a)\nwrite.write('!')\nwrite.end(Buffer('!!1'))\n```\n\nSee `test/` for more examples\n\n# methods\n\n```js\nvar concat = require('concat-stream')\n```\n\n## var writable = concat(opts={}, cb)\n\nReturn a `writable` stream that will fire `cb(data)` with all of the data that\nwas written to the stream. Data can be written to `writable` as strings,\nBuffers, arrays of byte integers, and Uint8Arrays. \n\nBy default `concat-stream` will give you back the same data type as the type of the first buffer written to the stream. Use `opts.encoding` to set what format `data` should be returned as, e.g. if you if you don't want to rely on the built-in type checking or for some other reason.\n\n* `string` - get a string\n* `buffer` - get back a Buffer\n* `array` - get an array of byte integers\n* `uint8array`, `u8`, `uint8` - get back a Uint8Array\n* `object`, get back an array of Objects\n\nIf you don't specify an encoding, and the types can't be inferred (e.g. you write things that aren't int he list above), it will try to convert concat them into a `Buffer`.\n\n# license\n\nMIT LICENSE\n",
   "readmeFilename": "readme.md",
-  "_id": "concat-stream@0.1.1",
-  "_from": "concat-stream@~0.1.1"
+  "homepage": "https://github.com/maxogden/node-concat-stream",
+  "_id": "concat-stream@1.4.1",
+  "dist": {
+    "shasum": "67e2a399f4f8fd384e4943f1daa049138a2e47c5"
+  },
+  "_from": "concat-stream@~1.4.1",
+  "_resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.4.1.tgz"
 }

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

@@ -1,31 +1,72 @@
 # concat-stream
 
-    npm install concat-stream
+Writable stream that concatenates strings or binary data and calls a callback with the result. Not a transform stream -- more of a stream sink.
 
-then
+[![NPM](https://nodei.co/npm/concat-stream.png)](https://nodei.co/npm/concat-stream/)
 
-    var concat = require('concat-stream')
-    var fs = require('fs')
-    
-    var read = fs.createReadStream('readme.md')
-    var write = concat(function(err, data) {})
+[![browser support](https://ci.testling.com/maxogden/concat-stream.png)](https://ci.testling.com/maxogden/concat-stream)
+
+### examples
+
+#### Buffers
+
+```js
+var concat = require('concat-stream')
+var fs = require('fs')
     
-    read.pipe(write)
+var read = fs.createReadStream('readme.md')
+var write = concat(function(data) {
+  // data is all of readme.md as a Buffer
+})
     
-works with arrays too!
+read.pipe(write)
+```
 
-    var write = concat(function(err, data) {})
-    write.write([1,2,3])
-    write.write([4,5,6])
-    write.end()
-    // data will be [1,2,3,4,5,6] in the above callback
+#### Arrays
 
-works with buffers too! can't believe the deals!
+```js
+var write = concat(function(data) {})
+write.write([1,2,3])
+write.write([4,5,6])
+write.end()
+// data will be [1,2,3,4,5,6] in the above callback
+```
+
+#### Uint8Arrays
+
+```js
+var write = concat(function(data) {})
+var a = new Uint8Array(3)
+a[0] = 97; a[1] = 98; a[2] = 99
+write.write(a)
+write.write('!')
+write.end(Buffer('!!1'))
+```
+
+See `test/` for more examples
+
+# methods
+
+```js
+var concat = require('concat-stream')
+```
+
+## var writable = concat(opts={}, cb)
+
+Return a `writable` stream that will fire `cb(data)` with all of the data that
+was written to the stream. Data can be written to `writable` as strings,
+Buffers, arrays of byte integers, and Uint8Arrays. 
+
+By default `concat-stream` will give you back the same data type as the type of the first buffer written to the stream. Use `opts.encoding` to set what format `data` should be returned as, e.g. if you if you don't want to rely on the built-in type checking or for some other reason.
+
+* `string` - get a string
+* `buffer` - get back a Buffer
+* `array` - get an array of byte integers
+* `uint8array`, `u8`, `uint8` - get back a Uint8Array
+* `object`, get back an array of Objects
+
+If you don't specify an encoding, and the types can't be inferred (e.g. you write things that aren't int he list above), it will try to convert concat them into a `Buffer`.
+
+# license
 
-    var write = concat(function(err, data) {})
-    write.write(new Buffer('hello '))
-    write.write(new Buffer('world'))
-    write.end()
-    // data will be a buffer that toString()s to 'hello world' in the above callback
-    
 MIT LICENSE

data/node_modules/browserify/node_modules/concat-stream/test/array.js

@@ -0,0 +1,12 @@
+var concat = require('../')
+var test = require('tape')
+
+test('array stream', function (t) {
+  t.plan(1)
+  var arrays = concat({ encoding: 'array' }, function(out) {
+    t.deepEqual(out, [1,2,3,4,5,6])
+  })
+  arrays.write([1,2,3])
+  arrays.write([4,5,6])
+  arrays.end()
+})

data/node_modules/browserify/node_modules/concat-stream/test/buffer.js

@@ -0,0 +1,31 @@
+var concat = require('../')
+var test = require('tape')
+var TA = require('typedarray')
+var U8 = typeof Uint8Array !== 'undefined' ? Uint8Array : TA.Uint8Array
+
+test('buffer stream', function (t) {
+  t.plan(2)
+  var buffers = concat(function(out) {
+    t.ok(Buffer.isBuffer(out))
+    t.equal(out.toString('utf8'), 'pizza Array is not a stringy cat')
+  })
+  buffers.write(new Buffer('pizza Array is not a ', 'utf8'))
+  buffers.write(new Buffer('stringy cat'))
+  buffers.end()
+})
+
+test('buffer mixed writes', function (t) {
+  t.plan(2)
+  var buffers = concat(function(out) {
+    t.ok(Buffer.isBuffer(out))
+    t.equal(out.toString('utf8'), 'pizza Array is not a stringy cat555')
+  })
+  buffers.write(new Buffer('pizza'))
+  buffers.write(' Array is not a ')
+  buffers.write([ 115, 116, 114, 105, 110, 103, 121 ])
+  var u8 = new U8(4)
+  u8[0] = 32; u8[1] = 99; u8[2] = 97; u8[3] = 116
+  buffers.write(u8)
+  buffers.write(555)
+  buffers.end()
+})

data/node_modules/browserify/node_modules/concat-stream/test/infer.js

@@ -0,0 +1,14 @@
+var concat = require('../')
+var test = require('tape')
+
+test('type inference works as expected', function(t) {
+  var stream = concat()
+  t.equal(stream.inferEncoding(['hello']), 'array', 'array')
+  t.equal(stream.inferEncoding(new Buffer('hello')), 'buffer', 'buffer')
+  t.equal(stream.inferEncoding(undefined), 'buffer', 'buffer')
+  t.equal(stream.inferEncoding(new Uint8Array(1)), 'uint8array', 'uint8array')
+  t.equal(stream.inferEncoding('hello'), 'string', 'string')
+  t.equal(stream.inferEncoding({hello: "world"}), 'object', 'object')
+  t.equal(stream.inferEncoding(1), 'buffer', 'buffer')
+  t.end()
+})

data/node_modules/browserify/node_modules/concat-stream/test/nothing.js

@@ -0,0 +1,9 @@
+var concat = require('../')
+var test = require('tape')
+
+test('no callback stream', function (t) {
+  var stream = concat()
+  stream.write('space')
+  stream.end(' cats')
+  t.end()
+})

data/node_modules/browserify/node_modules/concat-stream/test/objects.js

@@ -0,0 +1,29 @@
+var concat = require('../')
+var test = require('tape')
+
+test('writing objects', function (t) {
+  var stream = concat({encoding: "objects"}, concatted)
+  function concatted(objs) {
+    t.equal(objs.length, 2)
+    t.deepEqual(objs[0], {"foo": "bar"})
+    t.deepEqual(objs[1], {"baz": "taco"})
+  }
+  stream.write({"foo": "bar"})
+  stream.write({"baz": "taco"})
+  stream.end()
+  t.end()
+})
+
+
+test('switch to objects encoding if no encoding specified and objects are written', function (t) {
+  var stream = concat(concatted)
+  function concatted(objs) {
+    t.equal(objs.length, 2)
+    t.deepEqual(objs[0], {"foo": "bar"})
+    t.deepEqual(objs[1], {"baz": "taco"})
+  }
+  stream.write({"foo": "bar"})
+  stream.write({"baz": "taco"})
+  stream.end()
+  t.end()
+})

data/node_modules/browserify/node_modules/concat-stream/test/server/ls.js

@@ -0,0 +1,16 @@
+var concat = require('../../')
+var spawn = require('child_process').spawn
+var exec = require('child_process').exec
+var test = require('tape')
+
+test('ls command', function (t) {
+  t.plan(1)
+  var cmd = spawn('ls', [ __dirname ])
+  cmd.stdout.pipe(
+    concat(function(out) {
+      exec('ls ' + __dirname, function (err, body) {
+        t.equal(out.toString('utf8'), body.toString('utf8'))
+      })
+    })
+  )
+})

data/node_modules/browserify/node_modules/concat-stream/test/string.js

@@ -0,0 +1,50 @@
+var concat = require('../')
+var test = require('tape')
+var TA = require('typedarray')
+var U8 = typeof Uint8Array !== 'undefined' ? Uint8Array : TA.Uint8Array
+
+test('string -> buffer stream', function (t) {
+  t.plan(2)
+  var strings = concat({ encoding: 'buffer'}, function(out) {
+    t.ok(Buffer.isBuffer(out))
+    t.equal(out.toString('utf8'), 'nacho dogs')
+  })
+  strings.write("nacho ")
+  strings.write("dogs")
+  strings.end()
+})
+
+test('string stream', function (t) {
+  t.plan(2)
+  var strings = concat({ encoding: 'string' }, function(out) {
+    t.equal(typeof out, 'string')
+    t.equal(out, 'nacho dogs')
+  })
+  strings.write("nacho ")
+  strings.write("dogs")
+  strings.end()
+})
+
+test('end chunk', function (t) {
+  t.plan(1)
+  var endchunk = concat({ encoding: 'string' }, function(out) {
+    t.equal(out, 'this is the end')
+  })
+  endchunk.write("this ")
+  endchunk.write("is the ")
+  endchunk.end("end")
+})
+
+test('string from mixed write encodings', function (t) {
+  t.plan(2)
+  var strings = concat({ encoding: 'string' }, function(out) {
+    t.equal(typeof out, 'string')
+    t.equal(out, 'nacho dogs')
+  })
+  strings.write('na')
+  strings.write(Buffer('cho'))
+  strings.write([ 32, 100 ])
+  var u8 = new U8(3)
+  u8[0] = 111; u8[1] = 103; u8[2] = 115;
+  strings.end(u8)
+})