sprockets-browserify 0.1.0

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,26 @@
+{
+  "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",
+  "_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,42 @@
+{
+  "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",
+  "_id": "buffer-browserify@0.0.5",
+  "_from": "buffer-browserify@~0.0.1"
+}

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

data/node_modules/browserify/node_modules/coffee-script/CNAME

@@ -0,0 +1 @@
+coffeescript.org

data/node_modules/browserify/node_modules/coffee-script/CONTRIBUTING.md

@@ -0,0 +1,9 @@
+## How to contribute to CoffeeScript
+
+* Before you open a ticket or send a pull request, [search](https://github.com/jashkenas/coffee-script/issues) for previous discussions about the same feature or issue. Add to the earlier ticket if you find one.
+
+* Before sending a pull request for a feature, be sure to have [tests](https://github.com/jashkenas/coffee-script/tree/master/test).
+
+* Use the same coding style as the rest of the [codebase](https://github.com/jashkenas/coffee-script/tree/master/src). If you're just getting started with CoffeeScript, there's a nice [style guide](https://github.com/polarmobile/coffeescript-style-guide).
+
+* In your pull request, do not add documentation to `index.html` or re-build the minified `coffee-script.js` file. We'll do those things before cutting a new release.

data/node_modules/browserify/node_modules/coffee-script/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009-2012 Jeremy Ashkenas
+
+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.

data/node_modules/browserify/node_modules/coffee-script/README

@@ -0,0 +1,51 @@
+
+            {
+         }   }   {
+        {   {  }  }
+         }   }{  {
+        {  }{  }  }                    _____       __  __
+       ( }{ }{  { )                   / ____|     / _|/ _|
+     .- { { }  { }} -.               | |     ___ | |_| |_ ___  ___
+    (  ( } { } { } }  )              | |    / _ \|  _|  _/ _ \/ _ \
+    |`-..________ ..-'|              | |___| (_) | | | ||  __/  __/
+    |                 |               \_____\___/|_| |_| \___|\___|
+    |                 ;--.
+    |                (__  \            _____           _       _
+    |                 | )  )          / ____|         (_)     | |
+    |                 |/  /          | (___   ___ _ __ _ _ __ | |_
+    |                 (  /            \___ \ / __| '__| | '_ \| __|
+    |                 |/              ____) | (__| |  | | |_) | |_
+    |                 |              |_____/ \___|_|  |_| .__/ \__|
+     `-.._________..-'                                  | |
+                                                        |_|
+
+
+  CoffeeScript is a little language that compiles into JavaScript.
+
+  Install Node.js, and then the CoffeeScript compiler:
+  sudo bin/cake install
+
+  Or, if you have the Node Package Manager installed:
+  npm install -g coffee-script
+  (Leave off the -g if you don't wish to install globally.)
+
+  Execute a script:
+  coffee /path/to/script.coffee
+
+  Compile a script:
+  coffee -c /path/to/script.coffee
+
+  For documentation, usage, and examples, see:
+  http://coffeescript.org/
+
+  To suggest a feature, report a bug, or general discussion:
+  http://github.com/jashkenas/coffee-script/issues/
+
+  If you'd like to chat, drop by #coffeescript on Freenode IRC,
+  or on webchat.freenode.net.
+
+  The source repository:
+  git://github.com/jashkenas/coffee-script.git
+
+  All contributors are listed here:
+  http://github.com/jashkenas/coffee-script/contributors

data/node_modules/browserify/node_modules/coffee-script/Rakefile

@@ -0,0 +1,79 @@
+require 'rubygems'
+require 'erb'
+require 'fileutils'
+require 'rake/testtask'
+require 'json'
+
+desc "Build the documentation page"
+task :doc do
+  source = 'documentation/index.html.erb'
+  child = fork { exec "bin/coffee -bcw -o documentation/js documentation/coffee/*.coffee" }
+  at_exit { Process.kill("INT", child) }
+  Signal.trap("INT") { exit }
+  loop do
+    mtime = File.stat(source).mtime
+    if !@mtime || mtime > @mtime
+      rendered = ERB.new(File.read(source)).result(binding)
+      File.open('index.html', 'w+') {|f| f.write(rendered) }
+    end
+    @mtime = mtime
+    sleep 1
+  end
+end
+
+desc "Build coffee-script-source gem"
+task :gem do
+  require 'rubygems'
+  require 'rubygems/package'
+
+  gemspec = Gem::Specification.new do |s|
+    s.name      = 'coffee-script-source'
+    s.version   = JSON.parse(File.read('package.json'))["version"]
+    s.date      = Time.now.strftime("%Y-%m-%d")
+
+    s.homepage    = "http://jashkenas.github.com/coffee-script/"
+    s.summary     = "The CoffeeScript Compiler"
+    s.description = <<-EOS
+      CoffeeScript is a little language that compiles into JavaScript.
+      Underneath all of those embarrassing braces and semicolons,
+      JavaScript has always had a gorgeous object model at its heart.
+      CoffeeScript is an attempt to expose the good parts of JavaScript
+      in a simple way.
+    EOS
+
+    s.files = [
+      'lib/coffee_script/coffee-script.js',
+      'lib/coffee_script/source.rb'
+    ]
+
+    s.authors           = ['Jeremy Ashkenas']
+    s.email             = 'jashkenas@gmail.com'
+    s.rubyforge_project = 'coffee-script-source'
+    s.license           = "MIT"
+  end
+
+  file = File.open("coffee-script-source.gem", "w")
+  Gem::Package.open(file, 'w') do |pkg|
+    pkg.metadata = gemspec.to_yaml
+
+    path = "lib/coffee_script/source.rb"
+    contents = <<-ERUBY
+module CoffeeScript
+  module Source
+    def self.bundled_path
+      File.expand_path("../coffee-script.js", __FILE__)
+    end
+  end
+end
+    ERUBY
+    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
+      tar_io.write(contents)
+    end
+
+    contents = File.read("extras/coffee-script.js")
+    path = "lib/coffee_script/coffee-script.js"
+    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
+      tar_io.write(contents)
+    end
+  end
+end

data/node_modules/browserify/node_modules/coffee-script/bin/cake

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/coffee-script/cake').run();

data/node_modules/browserify/node_modules/coffee-script/bin/coffee

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/coffee-script/command').run();

data/node_modules/browserify/node_modules/coffee-script/extras/jsl.conf

@@ -0,0 +1,44 @@
+# JavaScriptLint configuration file for CoffeeScript.
+
++no_return_value              # function {0} does not always return a value
++duplicate_formal             # duplicate formal argument {0}
+-equal_as_assign              # test for equality (==) mistyped as assignment (=)?{0}
++var_hides_arg                # variable {0} hides argument
++redeclared_var               # redeclaration of {0} {1}
+-anon_no_return_value         # anonymous function does not always return a value
++missing_semicolon            # missing semicolon
++meaningless_block            # meaningless block; curly braces have no impact
+-comma_separated_stmts        # multiple statements separated by commas (use semicolons?)
++unreachable_code             # unreachable code
++missing_break                # missing break statement
+-missing_break_for_last_case  # missing break statement for last case in switch
+-comparison_type_conv         # comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)
+-inc_dec_within_stmt          # increment (++) and decrement (--) operators used as part of greater statement
+-useless_void                 # use of the void type may be unnecessary (void is always undefined)
++multiple_plus_minus          # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs
++use_of_label                 # use of label
+-block_without_braces         # block statement without curly braces
++leading_decimal_point        # leading decimal point may indicate a number or an object member
++trailing_decimal_point       # trailing decimal point may indicate a number or an object member
++octal_number                 # leading zeros make an octal number
++nested_comment               # nested comment
++misplaced_regex              # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
++ambiguous_newline            # unexpected end of line; it is ambiguous whether these lines are part of the same statement
++empty_statement              # empty statement or extra semicolon
+-missing_option_explicit      # the "option explicit" control comment is missing
++partial_option_explicit      # the "option explicit" control comment, if used, must be in the first script tag
++dup_option_explicit          # duplicate "option explicit" control comment
++useless_assign               # useless assignment
++ambiguous_nested_stmt        # block statements containing block statements should use curly braces to resolve ambiguity
++ambiguous_else_stmt          # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent)
+-missing_default_case         # missing default case in switch statement
++duplicate_case_in_switch     # duplicate case in switch statements
++default_not_at_end           # the default case is not at the end of the switch statement
++legacy_cc_not_understood     # couldn't understand control comment using /*@keyword@*/ syntax
++jsl_cc_not_understood        # couldn't understand control comment using /*jsl:keyword*/ syntax
++useless_comparison           # useless comparison; comparing identical expressions
++with_statement               # with statement hides undeclared variables; use temporary variable instead
++trailing_comma_in_array      # extra comma is not recommended in array initializers
++assign_to_function_call      # assignment to a function call
++parseint_missing_radix       # parseInt missing radix parameter
++lambda_assign_requires_semicolon