snowball 0.1.21 → 0.1.22

data/node_modules/browserify/node_modules/buffer-browserify/node_modules/base64-js/README.md

@@ -0,0 +1,14 @@
+Intro
+=====
+
+`base64-js` does basic base64 encoding/decoding in pure JS. Many browsers already have this functionality, but it is for text data, not all-purpose binary data.
+
+Sometimes encoding/decoding binary data in the browser is useful, and that is what this module does.
+
+API
+===
+
+`base64-js` has two exposed functions, `toByteArray` and `fromByteArray`, which both take a single argument.
+
+* toByteArray- Takes a base64 string and returns a byte array
+* fromByteArray- Takes a byte array and returns a base64 string

data/node_modules/browserify/node_modules/buffer-browserify/node_modules/base64-js/lib/b64.js

@@ -0,0 +1,84 @@
+(function (exports) {
+	'use strict';
+
+	var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+	function b64ToByteArray(b64) {
+		var i, j, l, tmp, placeHolders, arr;
+	
+		if (b64.length % 4 > 0) {
+			throw 'Invalid string. Length must be a multiple of 4';
+		}
+
+		// the number of equal signs (place holders)
+		// if there are two placeholders, than the two characters before it
+		// represent one byte
+		// if there is only one, then the three characters before it represent 2 bytes
+		// this is just a cheap hack to not do indexOf twice
+		placeHolders = b64.indexOf('=');
+		placeHolders = placeHolders > 0 ? b64.length - placeHolders : 0;
+
+		// base64 is 4/3 + up to two characters of the original data
+		arr = [];//new Uint8Array(b64.length * 3 / 4 - placeHolders);
+
+		// if there are placeholders, only get up to the last complete 4 chars
+		l = placeHolders > 0 ? b64.length - 4 : b64.length;
+
+		for (i = 0, j = 0; i < l; i += 4, j += 3) {
+			tmp = (lookup.indexOf(b64[i]) << 18) | (lookup.indexOf(b64[i + 1]) << 12) | (lookup.indexOf(b64[i + 2]) << 6) | lookup.indexOf(b64[i + 3]);
+			arr.push((tmp & 0xFF0000) >> 16);
+			arr.push((tmp & 0xFF00) >> 8);
+			arr.push(tmp & 0xFF);
+		}
+
+		if (placeHolders === 2) {
+			tmp = (lookup.indexOf(b64[i]) << 2) | (lookup.indexOf(b64[i + 1]) >> 4);
+			arr.push(tmp & 0xFF);
+		} else if (placeHolders === 1) {
+			tmp = (lookup.indexOf(b64[i]) << 10) | (lookup.indexOf(b64[i + 1]) << 4) | (lookup.indexOf(b64[i + 2]) >> 2);
+			arr.push((tmp >> 8) & 0xFF);
+			arr.push(tmp & 0xFF);
+		}
+
+		return arr;
+	}
+
+	function uint8ToBase64(uint8) {
+		var i,
+			extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+			output = "",
+			temp, length;
+
+		function tripletToBase64 (num) {
+			return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
+		};
+
+		// go through the array every three bytes, we'll deal with trailing stuff later
+		for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+			temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
+			output += tripletToBase64(temp);
+		}
+
+		// pad the end with zeros, but make sure to not forget the extra bytes
+		switch (extraBytes) {
+			case 1:
+				temp = uint8[uint8.length - 1];
+				output += lookup[temp >> 2];
+				output += lookup[(temp << 4) & 0x3F];
+				output += '==';
+				break;
+			case 2:
+				temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]);
+				output += lookup[temp >> 10];
+				output += lookup[(temp >> 4) & 0x3F];
+				output += lookup[(temp << 2) & 0x3F];
+				output += '=';
+				break;
+		}
+
+		return output;
+	}
+
+	module.exports.toByteArray = b64ToByteArray;
+	module.exports.fromByteArray = uint8ToBase64;
+}());

data/node_modules/browserify/node_modules/buffer-browserify/node_modules/base64-js/package.json

@@ -0,0 +1,30 @@
+{
+  "author": {
+    "name": "T. Jameson Little",
+    "email": "t.jameson.little@gmail.com"
+  },
+  "name": "base64-js",
+  "description": "Base64 encoding/decoding in pure JS",
+  "version": "0.0.2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/beatgammit/deflate-js.git"
+  },
+  "main": "lib/b64.js",
+  "scripts": {
+    "test": "cd test; node runner.js; cd -"
+  },
+  "engines": {
+    "node": ">= 0.4"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "readme": "Intro\n=====\n\n`base64-js` does basic base64 encoding/decoding in pure JS. Many browsers already have this functionality, but it is for text data, not all-purpose binary data.\n\nSometimes encoding/decoding binary data in the browser is useful, and that is what this module does.\n\nAPI\n===\n\n`base64-js` has two exposed functions, `toByteArray` and `fromByteArray`, which both take a single argument.\n\n* toByteArray- Takes a base64 string and returns a byte array\n* fromByteArray- Takes a byte array and returns a base64 string\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/beatgammit/deflate-js/issues"
+  },
+  "homepage": "https://github.com/beatgammit/deflate-js",
+  "_id": "base64-js@0.0.2",
+  "_from": "base64-js@0.0.2"
+}

data/node_modules/browserify/node_modules/buffer-browserify/node_modules/base64-js/test/runner.js

@@ -0,0 +1,50 @@
+(function () {
+	'use strict';
+
+	var b64 = require('../lib/b64'),
+		checks = [
+			'a',
+			'aa',
+			'aaa',
+			'hi',
+			'hi!',
+			'hi!!',
+			'sup',
+			'sup?',
+			'sup?!'
+		],
+		res;
+
+	res = checks.some(function (check) {
+		var b64Str,
+			arr,
+			arr2,
+			str,
+			i,
+			l;
+
+		arr2 = [];
+		for (i = 0, l = check.length; i < l; i += 1) {
+			arr2.push(check.charCodeAt(i));
+		}
+		b64Str = b64.fromByteArray(arr2);
+
+		arr = b64.toByteArray(b64Str);
+		arr2 = [];
+		for (i = 0, l = arr.length; i < l; i += 1) {
+			arr2.push(String.fromCharCode(arr[i]));
+		}
+		str = arr2.join('');
+		if (check !== str) {
+			console.log('Fail:', check);
+			console.log('Base64:', b64Str);
+			return true;
+		}
+	});
+
+	if (res) {
+		console.log('Test failed');
+	} else {
+		console.log('All tests passed!');
+	}
+}());

data/node_modules/browserify/node_modules/buffer-browserify/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "buffer-browserify",
+  "version": "0.0.5",
+  "description": "buffer module compatibility for browserify",
+  "main": "index.js",
+  "browserify": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "base64-js": "0.0.2"
+  },
+  "devDependencies": {
+    "tap": "0.2.x"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/toots/buffer-browserify.git"
+  },
+  "keywords": [
+    "buffer",
+    "browserify",
+    "compatible",
+    "meatless",
+    "browser"
+  ],
+  "author": {
+    "name": "Romain Beauxis",
+    "email": "toots@rastageeks.org"
+  },
+  "scripts": {
+    "test": "node node_modules/tap/bin/tap.js test/*.js"
+  },
+  "license": "MIT/X11",
+  "engine": {
+    "node": ">=0.6"
+  },
+  "readme": "buffer-browserify\n===============\n\nThe buffer module from [node.js](http://nodejs.org/),\nbut for browsers.\n\nWhen you `require('buffer')` in\n[browserify](http://github.com/substack/node-browserify),\nthis module will be loaded.\n\nIt will also be loaded if you use the global `Buffer` variable.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/toots/buffer-browserify/issues"
+  },
+  "homepage": "https://github.com/toots/buffer-browserify",
+  "_id": "buffer-browserify@0.0.5",
+  "_from": "buffer-browserify@0.0.5"
+}

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

@@ -0,0 +1,218 @@
+var buffer = require('../index.js');
+var test = require('tap').test;
+
+test('utf8 buffer to base64', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("Ձאab", "utf8").toString("base64"),
+        new Buffer("Ձאab", "utf8").toString("base64")
+    );
+    t.end();
+});
+
+test('utf8 buffer to hex', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("Ձאab", "utf8").toString("hex"),
+        new Buffer("Ձאab", "utf8").toString("hex")
+    );
+    t.end();
+});
+
+test('utf8 to utf8', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("öäüõÖÄÜÕ", "utf8").toString("utf8"),
+        new Buffer("öäüõÖÄÜÕ", "utf8").toString("utf8")
+    );
+    t.end();
+});
+
+test('ascii buffer to base64', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("123456!@#$%^", "ascii").toString("base64"),
+        new Buffer("123456!@#$%^", "ascii").toString("base64")
+    );
+    t.end();
+});
+
+test('ascii buffer to hex', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("123456!@#$%^", "ascii").toString("hex"),
+        new Buffer("123456!@#$%^", "ascii").toString("hex")
+    );
+    t.end();
+});
+
+test('base64 buffer to utf8', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("1YHXkGFi", "base64").toString("utf8"),
+        new Buffer("1YHXkGFi", "base64").toString("utf8")
+    );
+    t.end();
+});
+
+test('hex buffer to utf8', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("d581d7906162", "hex").toString("utf8"),
+        new Buffer("d581d7906162", "hex").toString("utf8")
+    );
+    t.end();
+});
+
+test('base64 buffer to ascii', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("MTIzNDU2IUAjJCVe", "base64").toString("ascii"),
+        new Buffer("MTIzNDU2IUAjJCVe", "base64").toString("ascii")
+    );
+    t.end();
+});
+
+test('hex buffer to ascii', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("31323334353621402324255e", "hex").toString("ascii"),
+        new Buffer("31323334353621402324255e", "hex").toString("ascii")
+    );
+    t.end();
+});
+/*
+test('utf8 to ascii', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("öäüõÖÄÜÕ", "utf8").toString("ascii"),
+        new Buffer("öäüõÖÄÜÕ", "utf8").toString("ascii")
+    );
+    t.end();
+});
+*/
+
+test('base64 buffer to binary', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("MTIzNDU2IUAjJCVe", "base64").toString("binary"),
+        new Buffer("MTIzNDU2IUAjJCVe", "base64").toString("binary")
+    );
+    t.end();
+});
+
+test('hex buffer to binary', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("31323334353621402324255e", "hex").toString("binary"),
+        new Buffer("31323334353621402324255e", "hex").toString("binary")
+    );
+    t.end();
+});
+
+test('utf8 to binary', function (t) {
+    t.plan(1);
+    t.equal(
+        new buffer.Buffer("öäüõÖÄÜÕ", "utf8").toString("binary"),
+        new Buffer("öäüõÖÄÜÕ", "utf8").toString("binary")
+    );
+    t.end();
+});
+
+test("hex of write{Uint,Int}{8,16,32}{LE,BE}", function (t) {
+    t.plan(2*(2*2*2+2));
+    ["UInt","Int"].forEach(function(x){
+        [8,16,32].forEach(function(y){
+            var endianesses = (y === 8) ? [""] : ["LE","BE"];
+            endianesses.forEach(function(z){
+                var v1  = new buffer.Buffer(y / 8);
+                var v2  = new Buffer(y / 8);
+                var writefn  = "write" + x + y + z;
+                var val = (x === "Int") ? -3 : 3;
+                v1[writefn](val, 0);
+                v2[writefn](val, 0);
+                t.equal(
+                    v1.toString("hex"),
+                    v2.toString("hex")
+                );
+                var readfn = "read" + x + y + z;
+                t.equal(
+                    v1[readfn](0),
+                    v2[readfn](0)
+                );
+            });
+        });
+    });
+    t.end();
+});
+
+test("hex of write{Uint,Int}{8,16,32}{LE,BE} with overflow", function (t) {
+    t.plan(3*(2*2*2+2));
+    ["UInt","Int"].forEach(function(x){
+        [8,16,32].forEach(function(y){
+            var endianesses = (y === 8) ? [""] : ["LE","BE"];
+            endianesses.forEach(function(z){
+                var v1  = new buffer.Buffer(y / 8 - 1);
+                var v2  = new Buffer(y / 8 - 1);
+                var next = new buffer.Buffer(4);
+                next.writeUInt32BE(0, 0);
+                var writefn  = "write" + x + y + z;
+                var val = (x === "Int") ? -3 : 3;
+                v1[writefn](val, 0, true);
+                v2[writefn](val, 0, true);
+                t.equal(
+                    v1.toString("hex"),
+                    v2.toString("hex")
+                );
+                // check that nothing leaked to next buffer.
+                t.equal(next.readUInt32BE(0), 0);
+                // check that no bytes are read from next buffer.
+                next.writeInt32BE(~0, 0);
+                var readfn = "read" + x + y + z;
+                t.equal(
+                    v1[readfn](0, true),
+                    v2[readfn](0, true)
+                );
+            });
+        });
+    });
+    t.end();
+});
+
+test("concat() a varying number of buffers", function (t) {
+    t.plan(5);
+    var zero = [];
+    var one  = [ new buffer.Buffer('asdf') ];
+    var long = [];
+    for (var i = 0; i < 10; i++) long.push(new buffer.Buffer('asdf'));
+
+    var flatZero = buffer.Buffer.concat(zero);
+    var flatOne = buffer.Buffer.concat(one);
+    var flatLong = buffer.Buffer.concat(long);
+    var flatLongLen = buffer.Buffer.concat(long, 40);
+
+    t.equal(flatZero.length, 0);
+    t.equal(flatOne.toString(), 'asdf');
+    t.equal(flatOne, one[0]);
+    t.equal(flatLong.toString(), (new Array(10+1).join('asdf')));
+    t.equal(flatLongLen.toString(), (new Array(10+1).join('asdf')));
+    t.end();
+});
+
+test("buffer from buffer", function (t) {
+    t.plan(1);
+    var b1 = new buffer.Buffer('asdf');
+    var b2 = new buffer.Buffer(b1);
+    t.equal(b1.toString('hex'), b2.toString('hex'));
+    t.end();
+});
+
+test("fill", function(t) {
+    t.plan(1);
+    var b1 = new Buffer(10);
+    var b2 = new buffer.Buffer(10);
+    b1.fill(2);
+    b2.fill(2);
+    t.equal(b1.toString('hex'), b2.toString('hex'));
+    t.end();
+})