first commit

build/node_modules/google-closure-compiler-js/contrib/nodejs/assert.js

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's assert module
+ * @see http://nodejs.org/api/assert.html
+ * @see https://github.com/joyent/node/blob/master/lib/assert.js
+ */
+
+/**
+ * @param {*} value
+ * @param {string} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+var assert = function(value, message) {};
+
+/**
+ * @param {{message: string, actual: *, expected: *, operator: string}} options
+ * @constructor
+ * @extends Error
+ */
+assert.AssertionError = function(options) {};
+
+/**
+ * @return {string}
+ */
+assert.AssertionError.prototype.toString;
+
+/**
+ * @param {*} value
+ * @param {string=} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.ok;
+
+/**
+ * @param {*} actual
+ * @param {*} expected
+ * @param {string} message
+ * @param {string} operator
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.fail;
+
+/**
+ * @param {*} actual
+ * @param {*} expected
+ * @param {string} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.equal;
+
+/**
+ * @param {*} actual
+ * @param {*} expected
+ * @param {string} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.notEqual;
+
+/**
+ * @param {*} actual
+ * @param {*} expected
+ * @param {string} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.deepEqual;
+
+/**
+ * @param {*} actual
+ * @param {*} expected
+ * @param {string} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.notDeepEqual;
+
+/**
+ * @param {*} actual
+ * @param {*} expected
+ * @param {string} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.strictEqual;
+
+/**
+ * @param {*} actual
+ * @param {*} expected
+ * @param {string} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.notStrictEqual;
+
+/**
+ * @name assert.throws
+ * @function
+ * @param {function()} block
+ * @param {Function|RegExp|function(*)} error
+ * @param {string=} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.throws;
+
+/**
+ * @param {function()} block
+ * @param {Function|RegExp|function(*)} error
+ * @param {string=} message
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.doesNotThrow;
+
+/**
+ * @param {*} value
+ * @return {void}
+ * @throws {assert.AssertionError}
+ */
+assert.ifError;
+
+module.exports = assert;

build/node_modules/google-closure-compiler-js/contrib/nodejs/buffer.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's buffer module.
+ * @see http://nodejs.org/api/buffer.html
+ * @see https://github.com/joyent/node/blob/master/lib/buffer.js
+ */
+
+/**
+ * @const
+ */
+var buffer = {};
+
+/** @const {function(new:Buffer, ...?)} */
+buffer.Buffer;
+
+/**
+ * @param {number} size
+ * @constructor
+ */
+buffer.SlowBuffer = function(size) {};
+
+/**
+ *
+ * @param {string} string
+ * @param {number|string} offset
+ * @param {number|string=} length
+ * @param {number|string=} encoding
+ * @return {*}
+ */
+buffer.SlowBuffer.prototype.write;
+
+/**
+ * @param {number} start
+ * @param {number} end
+ * @return {Buffer}
+ */
+buffer.SlowBuffer.prototype.slice;
+
+/**
+ * @return {string}
+ */
+buffer.SlowBuffer.prototype.toString;

build/node_modules/google-closure-compiler-js/contrib/nodejs/child_process.js

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's child_process module. Depends on the
+ *     events module.
+ * @externs
+ * @see http://nodejs.org/api/child_process.html
+ * @see https://github.com/joyent/node/blob/master/lib/child_process.js
+ */
+
+var events = require('events');
+var stream = require('stream');
+
+/**
+ * @const
+ */
+var child_process = {};
+
+/**
+ * @constructor
+ * @param {...*} var_args
+ * @extends events.EventEmitter
+ */
+child_process.ChildProcess = function(var_args) {}; // Private?
+
+/**
+ * @type {stream.ReadableStream}
+ */
+child_process.ChildProcess.prototype.stdin;
+
+/**
+ * @type {stream.WritableStream}
+ */
+child_process.ChildProcess.prototype.stdout;
+
+/**
+ * @type {stream.WritableStream}
+ */
+child_process.ChildProcess.prototype.stderr;
+
+/**
+ * @type {number}
+ */
+child_process.ChildProcess.prototype.pid;
+
+/**
+ * @param {string=} signal
+ * @return {void}
+ */
+child_process.ChildProcess.prototype.kill;
+
+/**
+ * @param {Object.<string,*>} message
+ * @param {*} sendHandle
+ * @return {void}
+ */
+child_process.ChildProcess.prototype.send;
+
+/**
+ * @return {void}
+ */
+child_process.ChildProcess.prototype.disconnect;
+
+/**
+ * @typedef {{cwd: string, stdio: (Array|string), customFds: Array, env: Object.<string,*>, detached: boolean, uid: number, gid: number, encoding: string, timeout: number, maxBuffer: number, killSignal: string}}
+ */
+child_process.Options;
+
+/**
+ * @param {string} command
+ * @param {Array.<string>=} args
+ * @param {child_process.Options=} options
+ * @return {child_process.ChildProcess}
+ */
+child_process.ChildProcess.spawn;
+
+/**
+ * @param {string} command
+ * @param {child_process.Options|function(Error, Buffer, Buffer)=} options
+ * @param {function(Error, Buffer, Buffer)=} callback
+ * @return {child_process.ChildProcess}
+ */
+child_process.exec;
+
+/**
+ * @param {string} command
+ * @param {child_process.Options} options
+ * @return {!Buffer|string}
+ */
+child_process.execSync;
+
+/**
+ * @param {string} file
+ * @param {Array.<string>} args
+ * @param {child_process.Options} options
+ * @param {function(Error, Buffer, Buffer)} callback
+ * @return {child_process.ChildProcess}
+ */
+child_process.execFile;
+
+/**
+ * @param {string} file
+ * @param {Array.<string>} args
+ * @param {child_process.Options} options
+ * @return {!Buffer|string}
+ */
+child_process.execFileSync;
+
+/**
+ * @param {string} modulePath
+ * @param {Array.<string>=} args
+ * @param {child_process.Options=} options
+ * @return {child_process.ChildProcess}
+ */
+child_process.fork;
+
+module.exports = child_process;

build/node_modules/google-closure-compiler-js/contrib/nodejs/cluster.js

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's cluster module. Depends on the events module.
+ * @see http://nodejs.org/api/cluster.html
+ * @see https://github.com/joyent/node/blob/master/lib/cluster.js
+ */
+
+var child_process = require('child_process');
+var events = require('events');
+
+/**
+ * @const
+ */
+var cluster = new events.EventEmitter();
+
+/**
+ * @typedef {{exec: string, args: Array.<string>, silent: boolean}}
+ */
+cluster.Settings;
+
+/**
+ * @type {cluster.Settings}
+ */
+cluster.settings;
+
+/**
+ * @type {boolean}
+ */
+cluster.isMaster;
+
+/**
+ * @type {boolean}
+ */
+cluster.isWorker;
+
+/**
+ * @param {cluster.Settings=} settings
+ * @return {void}
+ */
+cluster.setupMaster;
+
+/**
+ * @param {Object.<string,*>} env
+ * @return {cluster.Worker}
+ */
+cluster.fork;
+
+/**
+ * @param {function()=} callback
+ * @return {void}
+ */
+cluster.disconnect;
+
+/**
+ * @type {?cluster.Worker}
+ */
+cluster.worker;
+
+/**
+ * @type {?Object.<string,cluster.Worker>}
+ */
+cluster.workers;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+cluster.Worker = function() {};
+
+/**
+ * @type {string}
+ */
+cluster.Worker.prototype.id;
+
+/**
+ * @type {child_process.ChildProcess}
+ */
+cluster.Worker.prototype.process;
+
+/**
+ * @type {boolean}
+ */
+cluster.Worker.prototype.suicide;
+
+/**
+ * @param {Object} message
+ * @param {*=} sendHandle
+ * @return {void}
+ */
+cluster.Worker.prototype.send;
+
+/**
+ * @return {void}
+ */
+cluster.Worker.prototype.destroy;
+
+/**
+ * @return {void}
+ */
+cluster.Worker.prototype.disconnect;
+
+module.exports = cluster;

build/node_modules/google-closure-compiler-js/contrib/nodejs/crypto.js

@@ -0,0 +1,538 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's crypto module. Depends on the buffer module.
+ * @see http://nodejs.org/api/crypto.html
+ * @see https://github.com/joyent/node/blob/master/lib/crypto.js
+ */
+
+var stream = require('stream');
+
+/**
+ * @const
+ */
+var crypto = {};
+
+/**
+ * @type {string}
+ */
+crypto.DEFAULT_ENCODING;
+
+/**
+ * @constructor
+ */
+crypto.Credentials = function () {};
+
+/** @type {string|Buffer} */
+crypto.Credentials.prototype.pfx;
+
+/** @type {string|Buffer} */
+crypto.Credentials.prototype.key;
+
+/** @type {string} */
+crypto.Credentials.prototype.passphrase;
+
+/** @type {string|Buffer} */
+crypto.Credentials.prototype.cert;
+
+/** @type {Array.<string|Buffer>} */
+crypto.Credentials.prototype.ca;
+
+/** @type {Array.<string>|string} */
+crypto.Credentials.prototype.crl;
+
+/** @type {string} */
+crypto.Credentials.prototype.ciphers;
+
+/**
+ * @param {Object.<string,string>=} details
+ * @return {crypto.Credentials}
+ */
+crypto.createCredentials;
+
+/**
+ * @param {string} algorithm
+ * @return {crypto.Hash}
+ */
+crypto.createHash;
+
+/**
+ * @param {string} algorithm
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Transform
+ */
+crypto.Hash = function(algorithm, options) {};
+
+/**
+ * @param {string|Buffer} data
+ * @param {string=} input_encoding
+ * @return {void}
+ */
+crypto.Hash.prototype.update;
+
+/**
+ * @param {string=} encoding
+ * @return {string}
+ */
+crypto.Hash.prototype.digest;
+
+/**
+ * @param {string} algorithm
+ * @param {string|Buffer} key
+ * @return {crypto.Hmac}
+ */
+crypto.createHmac;
+
+/**
+ * @param {string} hmac
+ * @param {string|Buffer} key
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Transform
+ */
+crypto.Hmac = function(hmac, key, options) {};
+
+/**
+ * @param {string|Buffer} data
+ * @return {void}
+ */
+crypto.Hmac.prototype.update;
+
+/**
+ * @param {string} encoding
+ * @return {void}
+ */
+crypto.Hmac.prototype.digest;
+
+/**
+ * @param {string} algorithm
+ * @param {string|Buffer} password
+ * @return {crypto.Cipher}
+ */
+crypto.createCipher;
+
+/**
+ * @param {string} algorithm
+ * @param {string|Buffer} key
+ * @param {string|Buffer} iv
+ * @return {crypto.Cipheriv}
+ */
+crypto.createCipheriv;
+
+/**
+ * @param {string|Buffer} cipher
+ * @param {string} password
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Transform
+ */
+crypto.Cipher = function(cipher, password, options) {};
+
+/**
+ * @param {string|Buffer} data
+ * @param {string=} input_encoding
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Cipher.prototype.update;
+
+/**
+ * @name crypto.Cipher.prototype.final
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Cipher.prototype.final;
+
+/**
+ * @param {boolean=} auto_padding
+ * @return {void}
+ */
+crypto.Cipher.prototype.setAutoPadding;
+
+/**
+ * Note:  Cipheriv mixes update, final, and setAutoPadding from Cipher but
+ * doesn't inherit directly from Cipher.
+ *
+ * @param {string} cipher
+ * @param {string|Buffer} key
+ * @param {string|Buffer} iv
+ * @constructor
+ * @extends stream.Transform
+ */
+crypto.Cipheriv = function(cipher, key, iv) {};
+
+/**
+ * @param {string|Buffer} data
+ * @param {string=} input_encoding
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Cipheriv.prototype.update;
+
+/**
+ * @name crypto.Cipheriv.prototype.final
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Cipheriv.prototype.final;
+
+/**
+ * @param {boolean=} auto_padding
+ * @return {void}
+ */
+crypto.Cipheriv.prototype.setAutoPadding;
+
+/**
+ * @param {string} algorithm
+ * @param {string|Buffer} password
+ * @return {crypto.Decipher}
+ */
+crypto.createDecipher;
+
+/**
+ * @param {string} algorithm
+ * @param {string|Buffer} key
+ * @param {string|Buffer} iv
+ * @return {crypto.Decipheriv}
+ */
+crypto.createDecipheriv;
+
+/**
+ * Note:  Decipher mixes update, final, and setAutoPadding from Cipher but
+ * doesn't inherit directly from Cipher.
+ *
+ * @param {string|Buffer} cipher
+ * @param {string|Buffer} password
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Transform
+ */
+crypto.Decipher = function(cipher, password, options) {}
+
+/**
+ * @param {string|Buffer} data
+ * @param {string=} input_encoding
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Decipher.prototype.update;
+
+/**
+ * @name crypto.Decipher.prototype.final
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Decipher.prototype.final;
+
+/**
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Decipher.prototype.finaltol;
+
+/**
+ * @param {boolean=} auto_padding
+ * @return {void}
+ */
+crypto.Decipher.prototype.setAutoPadding;
+
+/**
+ * Note:  Decipheriv mixes update, final, and setAutoPadding from Cipher but
+ * doesn't inherit directly from Cipher.
+ *
+ * @param {string|Buffer|crypto.Decipheriv} cipher
+ * @param {string|Buffer} key
+ * @param {string|Buffer} iv
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Transform
+ */
+crypto.Decipheriv = function(cipher, key, iv, options) {};
+
+/**
+ * @param {string|Buffer} data
+ * @param {string=} input_encoding
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Decipheriv.prototype.update;
+
+/**
+ * @name crypto.Decipheriv.prototype.final
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Decipheriv.prototype.final;
+
+/**
+ * @param {string=} output_encoding
+ * @return {string|Buffer}
+ */
+crypto.Decipheriv.prototype.finaltol;
+
+/**
+ * @param {boolean=} auto_padding
+ * @return {void}
+ */
+crypto.Decipheriv.prototype.setAutoPadding;
+
+/**
+ * @param {string} algorithm
+ * @return {crypto.Sign}
+ */
+crypto.createSign;
+
+/**
+ * @param {string} algorithm
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Writable
+ */
+crypto.Sign = function(algorithm, options) {};
+
+/**
+ * @param {string|Buffer} data
+ * @return {void}
+ */
+crypto.Sign.prototype.update;
+
+/**
+ * @param {string} private_key
+ * @param {string=} output_format
+ * @return {string|Buffer}
+ */
+crypto.Sign.prototype.sign;
+
+/**
+ * @param {string} algorithm
+ * @return crypto.Verify
+ */
+crypto.createVerify;
+
+/**
+ * @param {string} algorithm
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Writable
+ */
+crypto.Verify = function(algorithm, options) {};
+
+/**
+ * @param {string|Buffer} data
+ * @return {void}
+ */
+crypto.Verify.prototype.update;
+
+/**
+ * @param {string} object
+ * @param {string|Buffer} signature
+ * @param {string=} signature_format
+ * @return {boolean}
+ */
+crypto.Verify.prototype.verify;
+
+/**
+ * @param {number} prime
+ * @param {string=} encoding
+ * @return {crypto.DiffieHellman}
+ */
+crypto.createDiffieHellman;
+
+/**
+ * @param {number} sizeOrKey
+ * @param {string=} encoding
+ * @constructor
+ */
+crypto.DiffieHellman = function(sizeOrKey, encoding) {};
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellman.prototype.generateKeys;
+
+/**
+ * @param {string|Buffer} key
+ * @param {string=} inEnc
+ * @param {string=} outEnc
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellman.prototype.computeSecret;
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellman.prototype.getPrime;
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellman.prototype.getGenerator;
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellman.prototype.getPublicKey;
+
+/**
+ * @param {string} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellman.prototype.getPrivateKey = function(encoding) {}
+
+/**
+ * @param {string|Buffer} key
+ * @param {string=} encoding
+ * @return {crypto.DiffieHellman}
+ */
+crypto.DiffieHellman.prototype.setPublicKey;
+
+/**
+ * @param {string|Buffer} key
+ * @param {string=} encoding
+ * @return {crypto.DiffieHellman}
+ */
+crypto.DiffieHellman.prototype.setPrivateKey;
+
+/**
+ * Note:  DiffieHellmanGroup mixes DiffieHellman but doesn't inherit directly.
+ *
+ * @param {string} name
+ * @constructor
+ */
+crypto.DiffieHellmanGroup = function(name) {};
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellmanGroup.prototype.generateKeys;
+
+/**
+ * @param {string|Buffer} key
+ * @param {string=} inEnc
+ * @param {string=} outEnc
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellmanGroup.prototype.computeSecret;
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellmanGroup.prototype.getPrime;
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellmanGroup.prototype.getGenerator;
+
+/**
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellmanGroup.prototype.getPublicKey;
+
+/**
+ * @param {string} encoding
+ * @return {string|Buffer}
+ */
+crypto.DiffieHellmanGroup.prototype.getPrivateKey = function(encoding) {}
+
+/**
+ * @param {string|Buffer} key
+ * @param {string=} encoding
+ * @return {crypto.DiffieHellmanGroup}
+ */
+crypto.DiffieHellmanGroup.prototype.setPublicKey;
+
+/**
+ * @param {string|Buffer} key
+ * @param {string=} encoding
+ * @return {crypto.DiffieHellmanGroup}
+ */
+crypto.DiffieHellmanGroup.prototype.setPrivateKey;
+
+/**
+ * @param {string} group_name
+ * @return {crypto.DiffieHellmanGroup}
+ */
+crypto.getDiffieHellman;
+
+/**
+ * @param {string|Buffer} password
+ * @param {string|Buffer} salt
+ * @param {number} iterations
+ * @param {number} keylen
+ * @param {function(*, string)} callback
+ * @return {void}
+ */
+crypto.pbkdf2;
+
+/**
+ * @param {string|Buffer} password
+ * @param {string|Buffer} salt
+ * @param {number} iterations
+ * @param {number} keylen
+ * @return {void}
+ */
+crypto.pbkdf2Sync;
+
+/**
+ * @param {number} size
+ * @param {function(Error, Buffer)=} callback
+ * @return {void}
+ */
+crypto.randomBytes;
+
+/**
+ * @param {number} size
+ * @param {function(Error, Buffer)=} callback
+ * @return {void}
+ */
+crypto.pseudoRandomBytes;
+
+/**
+ * @param {number} size
+ * @param {function(Error, Buffer)=} callback
+ * @return {void}
+ */
+crypto.rng;
+
+/**
+ * @param {number} size
+ * @param {function(Error, Buffer)=} callback
+ * @return {void}
+ */
+crypto.prng;
+
+/**
+ * @return {Array.<string>}
+ */
+crypto.getCiphers;
+
+/**
+ * @return {Array.<string>}
+ */
+crypto.getHashes;
+
+module.exports = crypto;

build/node_modules/google-closure-compiler-js/contrib/nodejs/dgram.js

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's dgram module. Depends on the events module.
+ * @see http://nodejs.org/api/dgram.html
+ * @see https://github.com/joyent/node/blob/master/lib/dgram.js
+ */
+
+var events = require('events');
+
+/**
+ * @const
+ */
+var dgram = {};
+
+/**
+ * @param {string} type
+ * @param {function(...)=} callback
+ * @return {dgram.Socket}
+ */
+dgram.createSocket;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+dgram.Socket = function() {};
+
+/**
+ * @param {Buffer} buf
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} port
+ * @param {string} address
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+dgram.Socket.prototype.send;
+
+/**
+ * @param {number} port
+ * @param {string=} address
+ * @return {void}
+ */
+dgram.Socket.prototype.bind;
+
+/**
+ * @return {void}
+ */
+dgram.Socket.prototype.close;
+
+/**
+ * @return {string}
+ */
+dgram.Socket.prototype.address;
+
+/**
+ * @param {boolean} flag
+ * @return {void}
+ */
+dgram.Socket.prototype.setBroadcast;
+
+/**
+ * @param {number} ttl
+ * @return {number}
+ */
+dgram.Socket.prototype.setTTL;
+
+/**
+ * @param {number} ttl
+ * @return {number}
+ */
+dgram.Socket.prototype.setMulticastTTL;
+
+/**
+ * @param {boolean} flag
+ * @return {void}
+ */
+dgram.Socket.prototype.setMulticastLoopback;
+
+/**
+ * @param {string} multicastAddress
+ * @param {string=} multicastInterface
+ * @return {void}
+ */
+dgram.Socket.prototype.addMembership;
+
+/**
+ * @param {string} multicastAddress
+ * @param {string=} multicastInterface
+ * @return {void}
+ */
+dgram.Socket.prototype.dropMembership;
+
+module.exports = dgram;

build/node_modules/google-closure-compiler-js/contrib/nodejs/dns.js

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's dns module.
+ * @see http://nodejs.org/api/dns.html
+ * @see https://github.com/joyent/node/blob/master/lib/dns.js
+ */
+
+/**
+ * @const
+ */
+var dns = {};
+
+/**
+ * @param {string} domain
+ * @param {string|function(Error,string,string)} family
+ * @param {function(?Error,string,string)=} callback
+ * @return {void}
+ */
+dns.lookup;
+
+/**
+ * @param {string} domain
+ * @param {string|function(?Error,Array)} rrtype
+ * @param {function(?Error,Array)=} callback
+ * @return {void}
+ */
+dns.resolve;
+
+/**
+ * @param {string} domain
+ * @param {function(?Error,Array)} callback
+ * @return {void}
+ */
+dns.resolve4;
+
+/**
+ * @param {string} domain
+ * @param {function(?Error,Array)} callback
+ * @return {void}
+ */
+dns.resolve6;
+
+/**
+ * @param {string} domain
+ * @param {function(?Error,Array)}callback
+ * @return {void}
+ */
+dns.resolveMx;
+
+/**
+ * @param {string} domain
+ * @param {function(?Error,Array)}callback
+ * @return {void}
+ */
+dns.resolveTxt;
+
+/**
+ * @param {string} domain
+ * @param {function(?Error,Array)}callback
+ * @return {void}
+ */
+dns.resolveSrv;
+
+/**
+ * @param {string} domain
+ * @param {function(?Error,Array)}callback
+ * @return {void}
+ */
+dns.resolveNs;
+
+/**
+ * @param {string} domain
+ * @param {function(?Error,Array)}callback
+ * @return {void}
+ */
+dns.resolveCname;
+
+/**
+ * @param {string} ip
+ * @param {function(?Error,Array)}callback
+ * @return {void}
+ */
+dns.reverse;
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.NODATA = 'ENODATA';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.FORMERR = 'EFORMERR';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.SERVFAIL = 'ESERVFAIL';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.NOTFOUND = 'ENOTFOUND';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.NOTIMP = 'ENOTIMP';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.REFUSED = 'EREFUSED';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.BADQUERY = 'EBADQUERY';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.BADNAME = 'EBADNAME';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.BADFAMILY = 'EBADFAMILY';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.BADRESP = 'EBADRESP';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.CONNREFUSED = 'ECONNREFUSED';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.TIMEOUT = 'ETIMEOUT';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.EOF = 'EOF';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.FILE = 'EFILE';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.NOMEM = 'ENOMEM';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.DESTRUCTION = 'EDESTRUCTION';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.BADSTR = 'EBADSTR';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.BADFLAGS = 'EBADFLAGS';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.NONAME = 'ENONAME';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.BADHINTS = 'EBADHINTS';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.NOTINITIALIZED = 'ENOTINITIALIZED';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.LOADIPHLPAPI = 'ELOADIPHLPAPI';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.ADDRGETNETWORKPARAMS = 'EADDRGETNETWORKPARAMS';
+
+/**
+ * @type {string}
+ * @const
+ */
+dns.CANCELLED = 'ECANCELLED';
+
+module.exports = dns;

build/node_modules/google-closure-compiler-js/contrib/nodejs/domain.js

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's domain module. Depends on the events module.
+ * @see http://nodejs.org/api/domain.html
+ * @see https://github.com/joyent/node/blob/master/lib/domain.js
+ */
+
+var events = require('events');
+
+/**
+ * @const
+ */
+var domain = {};
+
+/**
+ * @type {domain.Domain}
+ */
+domain.active;
+
+/**
+ * @return {domain.Domain}
+ */
+domain.create;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+domain.Domain = function () {};
+
+/**
+ * @param {function()} fn
+ */
+domain.Domain.prototype.run;
+
+/**
+ * @type {Array}
+ */
+domain.Domain.prototype.members;
+
+/**
+ * @param {events.EventEmitter} emitter
+ * @return {void}
+ */
+domain.Domain.prototype.add;
+
+/**
+ * @param {events.EventEmitter} emitter
+ * @return {void}
+ */
+domain.Domain.prototype.remove;
+
+/**
+ * @param {function(...*)} callback
+ * @return {function(...*)}
+ */
+domain.Domain.prototype.bind;
+
+/**
+ * @param {function(...*)} callback
+ * @return {function(...*)}
+ */
+domain.Domain.prototype.intercept;
+
+/**
+ * @return {void}
+ */
+domain.Domain.prototype.dispose;
+
+// Undocumented
+
+/**
+ * @return {void}
+ */
+domain.Domain.prototype.enter;
+
+/**
+ * @return {void}
+ */
+domain.Domain.prototype.exit;
+
+module.exports = domain;

build/node_modules/google-closure-compiler-js/contrib/nodejs/events.js

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's "events" module.
+ * @see http://nodejs.org/api/events.html
+ * @see https://github.com/joyent/node/blob/master/lib/events.js
+ */
+
+/**
+ * @const
+ */
+var events = {};
+
+/**
+ * @constructor
+ */
+events.EventEmitter = function() {};
+
+/**
+ * @param {string} event
+ * @param {function(...)} listener
+ * @return {events.EventEmitter}
+ */
+events.EventEmitter.prototype.addListener;
+
+/**
+ * @param {string} event
+ * @param {function(...)} listener
+ * @return {events.EventEmitter}
+ */
+events.EventEmitter.prototype.on;
+
+/**
+ * @param {string} event
+ * @param {function(...)} listener
+ * @return {events.EventEmitter}
+ */
+events.EventEmitter.prototype.once;
+
+/**
+ * @param {string} event
+ * @param {function(...)} listener
+ * @return {events.EventEmitter}
+ */
+events.EventEmitter.prototype.removeListener;
+
+/**
+ * @param {string=} event
+ * @return {events.EventEmitter}
+ */
+events.EventEmitter.prototype.removeAllListeners;
+
+/**
+ * @param {number} n
+ * @return {void}
+ */
+events.EventEmitter.prototype.setMaxListeners;
+
+/**
+ * @param {string} event
+ * @return {Array.<function(...)>}
+ */
+events.EventEmitter.prototype.listeners;
+
+/**
+ * @param {string} event
+ * @param {...*} var_args
+ * @return {boolean}
+ */
+events.EventEmitter.prototype.emit;
+
+// Undocumented
+
+/**
+ * @type {boolean}
+ */
+events.usingDomains;
+
+/**
+ * @param {events.EventEmitter} emitter
+ * @param {string} type
+ * @return {void}
+ */
+events.EventEmitter.listenerCount;
+
+module.exports = events;

build/node_modules/google-closure-compiler-js/contrib/nodejs/fs.js

@@ -0,0 +1,672 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's fs module. Depends on the stream and events module.
+ * @see http://nodejs.org/api/fs.html
+ * @see https://github.com/joyent/node/blob/master/lib/fs.js
+ */
+
+var events = require('events');
+var stream = require('stream');
+
+/** @const */
+var fs = {};
+
+/**
+ * @param {string} oldPath
+ * @param {string} newPath
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.rename;
+
+/**
+ * @param {string} oldPath
+ * @param {string} newPath
+ * @return {void}
+ */
+fs.renameSync;
+
+/**
+ * @param {*} fd
+ * @param {number} len
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.truncate;
+
+/**
+ * @param {*} fd
+ * @param {number} len
+ * @return {void}
+ */
+fs.truncateSync;
+
+/**
+ * @param {string} path
+ * @param {number} uid
+ * @param {number} gid
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.chown;
+
+/**
+ * @param {string} path
+ * @param {number} uid
+ * @param {number} gid
+ * @return {void}
+ */
+fs.chownSync;
+
+/**
+ * @param {*} fd
+ * @param {number} uid
+ * @param {number} gid
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.fchown;
+
+/**
+ * @param {*} fd
+ * @param {number} uid
+ * @param {number} gid
+ * @return {void}
+ */
+fs.fchownSync;
+
+/**
+ * @param {string} path
+ * @param {number} uid
+ * @param {number} gid
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.lchown;
+
+/**
+ * @param {string} path
+ * @param {number} uid
+ * @param {number} gid
+ * @return {void}
+ */
+fs.lchownSync;
+
+/**
+ * @param {string} path
+ * @param {number} mode
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.chmod;
+
+/**
+ * @param {string} path
+ * @param {number} mode
+ * @return {void}
+ */
+fs.chmodSync;
+
+/**
+ * @param {*} fd
+ * @param {number} mode
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.fchmod;
+
+/**
+ * @param {*} fd
+ * @param {number} mode
+ * @return {void}
+ */
+fs.fchmodSync;
+
+/**
+ * @param {string} path
+ * @param {number} mode
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.lchmod;
+
+/**
+ * @param {string} path
+ * @param {number} mode
+ * @return {void}
+ */
+fs.lchmodSync;
+
+/**
+ * @param {string} path
+ * @param {function(string, fs.Stats)=} callback
+ * @return {void}
+ */
+fs.stat;
+
+/**
+ * @param {string} path
+ * @return {fs.Stats}
+ * @nosideeffects
+ */
+fs.statSync = function(path) {}
+
+/**
+ * @param {*} fd
+ * @param {function(string, fs.Stats)=} callback
+ * @return {void}
+ */
+fs.fstat;
+
+/**
+ * @param {*} fd
+ * @return {fs.Stats}
+ * @nosideeffects
+ */
+fs.fstatSync = function(fd) {}
+
+/**
+ * @param {string} path
+ * @param {function(string, fs.Stats)=} callback
+ * @return {void}
+ */
+fs.lstat;
+
+/**
+ * @param {string} path
+ * @return {fs.Stats}
+ * @nosideeffects
+ */
+fs.lstatSync = function(path) {}
+
+/**
+ * @param {string} srcpath
+ * @param {string} dstpath
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.link;
+
+/**
+ * @param {string} srcpath
+ * @param {string} dstpath
+ * @return {void}
+ */
+fs.linkSync;
+
+/**
+ * @param {string} srcpath
+ * @param {string} dstpath
+ * @param {string=} type
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.symlink;
+
+/**
+ * @param {string} srcpath
+ * @param {string} dstpath
+ * @param {string=} type
+ * @return {void}
+ */
+fs.symlinkSync;
+
+/**
+ * @param {string} path
+ * @param {function(string, string)=} callback
+ * @return {void}
+ */
+fs.readlink;
+
+/**
+ * @param {string} path
+ * @return {string}
+ * @nosideeffects
+ */
+fs.readlinkSync;
+
+/**
+ * @param {string} path
+ * @param {Object.<string,string>|function(string, string)=} cache
+ * @param {function(string, string)=} callback
+ * @return {void}
+ */
+fs.realpath;
+
+/**
+ * @param {string} path
+ * @param {Object.<string,string>=} cache
+ * @return {string}
+ * @nosideeffects
+ */
+fs.realpathSync;
+
+/**
+ * @param {string} path
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.unlink;
+
+/**
+ * @param {string} path
+ * @return {void}
+ */
+fs.unlinkSync;
+
+/**
+ * @param {string} path
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.rmdir;
+
+/**
+ * @param {string} path
+ * @return {void}
+ */
+fs.rmdirSync;
+
+/**
+ * @param {string} path
+ * @param {number=} mode
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.mkdir;
+
+/**
+ * @param {string} path
+ * @param {number=} mode
+ * @return {void}
+ */
+fs.mkdirSync;
+
+/**
+ * @param {string} path
+ * @param {function(string,Array.<string>)=} callback
+ * @return {void}
+ */
+fs.readdir;
+
+/**
+ * @param {string} path
+ * @return {Array.<string>}
+ * @nosideeffects
+ */
+fs.readdirSync;
+
+/**
+ * @param {*} fd
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.close;
+
+/**
+ * @param {*} fd
+ * @return {void}
+ */
+fs.closeSync;
+
+/**
+ * @param {string} path
+ * @param {string} flags
+ * @param {number=} mode
+ * @param {function(string, *)=} callback
+ * @return {void}
+ */
+fs.open;
+
+/**
+ * @param {string} path
+ * @param {string} flags
+ * @param {number=} mode
+ * @return {*}
+ * @nosideeffects
+ */
+fs.openSync;
+
+/**
+ * @param {string} path
+ * @param {number|Date} atime
+ * @param {number|Date} mtime
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.utimes;
+
+/**
+ * @param {string} path
+ * @param {number|Date} atime
+ * @param {number|Date} mtime
+ * @return {void}
+ */
+fs.utimesSync;
+
+/**
+ * @param {*} fd
+ * @param {number|Date} atime
+ * @param {number|Date} mtime
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.futimes;
+
+/**
+ * @param {*} fd
+ * @param {number|Date} atime
+ * @param {number|Date} mtime
+ * @return {void}
+ */
+fs.futimesSync;
+
+/**
+ * @param {*} fd
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+fs.fsync;
+
+/**
+ * @param {*} fd
+ * @return {void}
+ */
+fs.fsyncSync;
+
+/**
+ * @param {*} fd
+ * @param {*} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} position
+ * @param {function(string, number, *)=} callback
+ * @return {void}
+ */
+fs.write;
+
+/**
+ * @param {*} fd
+ * @param {*} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} position
+ * @return {number}
+ */
+fs.writeSync;
+
+/**
+ * @param {*} fd
+ * @param {*} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} position
+ * @param {function(string, number, *)=} callback
+ * @return {void}
+ */
+fs.read;
+
+/**
+ * @param {*} fd
+ * @param {*} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} position
+ * @return {number}
+ * @nosideeffects
+ */
+fs.readSync;
+
+/**
+ * @param {string} filename
+ * @param {string|function(string, *)=}encoding
+ * @param {function(string, *)=} callback
+ * @return {void}
+ */
+fs.readFile;
+
+/**
+ * @param {string} filename
+ * @param {string=} encoding
+ * @return {string|Buffer}
+ * @nosideeffects
+ */
+fs.readFileSync;
+
+/**
+ * @param {string} filename
+ * @param {*} data
+ * @param {string|function(string)=} encoding
+ * @param {function(string)=} callback
+ * @return {void}
+ */
+fs.writeFile;
+
+/**
+ * @param {string} filename
+ * @param {*} data
+ * @param {string=} encoding
+ * @return {void}
+ */
+fs.writeFileSync;
+
+/**
+ * @param {string} filename
+ * @param {*} data
+ * @param {string|function(string)=} encoding
+ * @param {function(string)=} callback
+ * @return {void}
+ */
+fs.appendFile;
+
+/**
+ * @param {string} filename
+ * @param {*} data
+ * @param {string|function(string)=} encoding
+ * @return {void}
+ */
+fs.appendFileSync;
+
+/**
+ * @param {string} filename
+ * @param {{persistent: boolean, interval: number}|function(*,*)=} options
+ * @param {function(*,*)=} listener
+ * @return {void}
+ */
+fs.watchFile;
+
+/**
+ * @param {string} filename
+ * @param {function(string, string)=} listener
+ * @return {void}
+ */
+fs.unwatchFile;
+
+/**
+ *
+ * @param {string} filename
+ * @param {{persistent: boolean}|function(string, string)=} options
+ * @param {function(string, string)=} listener
+ * @return {fs.FSWatcher}
+ */
+fs.watch;
+
+/**
+ * @param {string} path
+ * @param {function(boolean)} callback
+ * @return {void}
+ */
+fs.exists;
+
+/**
+ * @param {string} path
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.existsSync;
+
+/**
+ * @constructor
+ */
+fs.Stats = function () {};
+
+/**
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.Stats.prototype.isFile;
+
+/**
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.Stats.prototype.isDirectory;
+
+/**
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.Stats.prototype.isBlockDevice;
+
+/**
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.Stats.prototype.isCharacterDevice;
+
+/**
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.Stats.prototype.isSymbolicLink;
+
+/**
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.Stats.prototype.isFIFO;
+
+/**
+ * @return {boolean}
+ * @nosideeffects
+ */
+fs.Stats.prototype.isSocket;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.dev = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.ino = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.mode = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.nlink = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.uid = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.gid = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.rdev = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.size = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.blkSize = 0;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.blocks = 0;
+
+/**
+ * @type {Date}
+ */
+fs.Stats.prototype.atime;
+
+/**
+ * @type {Date}
+ */
+fs.Stats.prototype.mtime;
+
+/**
+ * @type {Date}
+ */
+fs.Stats.prototype.ctime;
+
+/**
+ * @param {string} path
+ * @param {{flags: string, encoding: ?string, fd: *, mode: number, bufferSize: number}=} options
+ * @return {fs.ReadStream}
+ * @nosideeffects
+ */
+fs.createReadStream;
+
+/**
+ * @constructor
+ * @extends stream.ReadableStream
+ */
+fs.ReadStream = function () {};
+
+/**
+ * @param {string} path
+ * @param {{flags: string, encoding: ?string, mode: number}=} options
+ * @return {fs.WriteStream}
+ * @nosideeffects
+ */
+fs.createWriteStream;
+
+/**
+ * @constructor
+ * @extends stream.WritableStream
+ */
+fs.WriteStream = function () {};
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+fs.FSWatcher = function () {};
+
+/**
+ * @return {void}
+ */
+fs.FSWatcher.prototype.close;

build/node_modules/google-closure-compiler-js/contrib/nodejs/globals.js

@@ -0,0 +1,696 @@
+/*
+ * Copyright 2014 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview NodeJS built-ins.
+ * @externs
+ * @author nicholas.j.santos@gmail.com (Nick Santos)
+ */
+
+/** @const {string} */
+var __filename;
+
+/** @const {string} */
+var __dirname;
+
+/**
+ * @param {string} name
+ * @return {?}
+ */
+function require(name) {}
+
+// http://nodejs.org/api/timers.html
+
+/**
+ * The ID returned by setTimeout.
+ * @constructor
+ */
+function TimeoutId() {}
+
+/** @see http://nodejs.org/api/timers.html#timers_unref */
+TimeoutId.prototype.unref = function() {};
+
+/** @see http://nodejs.org/api/timers.html#timers_ref */
+TimeoutId.prototype.ref = function() {};
+
+
+/**
+ * @param {Function} fn
+ * @param {number} ms
+ * @param {...?} var_args
+ * @return {TimeoutId}
+ * @see http://nodejs.org/api/timers.html#timers_settimeout_callback_delay_arg
+ */
+function setTimeout(fn, ms, var_args) {}
+
+/**
+ * @param {TimeoutId} id
+ * @see http://nodejs.org/api/timers.html#timers_cleartimeout_timeoutid
+ */
+function clearTimeout(id) {}
+
+/**
+ * @param {Function} fn
+ * @param {number} ms
+ * @param {...?} var_args
+ * @return {TimeoutId}
+ * @see http://nodejs.org/api/timers.html#timers_setinterval_callback_delay_arg
+ */
+function setInterval(fn, ms, var_args) {}
+
+/**
+ * @param {TimeoutId} id
+ * @see http://nodejs.org/api/timers.html#timers_clearinterval_intervalid
+ */
+function clearInterval(id) {}
+
+/**
+ * The ID returned by setImmediate.
+ * @constructor
+ */
+function ImmediateId() {}
+
+/**
+ * @param {Function} fn
+ * @param {...?} var_args
+ * @return {ImmediateId}
+ * @see http://nodejs.org/api/timers.html#timers_setimmediate_callback_delay_arg
+ */
+function setImmediate(fn, var_args) {}
+
+/**
+ * @param {ImmediateId} id
+ * @see http://nodejs.org/api/timers.html#timers_clearimmediate_immediateid
+ */
+function clearImmediate(id) {}
+
+
+// http://nodejs.org/api/process.html
+
+/** @constructor */
+function Process() {}
+
+/**
+ * @return {void}
+ * @see http://nodejs.org/api/process.html#process_process_abort
+ */
+Process.prototype.abort = function () {};
+
+/**
+ * @type {string}
+ * @see http://nodejs.org/api/process.html#process_process_arch
+ */
+Process.prototype.arch;
+
+/**
+ * @type {!Array<string>}
+ * @see http://nodejs.org/api/process.html#process_process_argv
+ */
+Process.prototype.argv;
+
+/**
+ * @param {string} directory
+ * @see http://nodejs.org/api/process.html#process_process_chdir_directory
+ */
+Process.prototype.chdir = function (directory) {};
+
+/**
+ * @type {*}
+ * @see http://nodejs.org/api/process.html#process_process_config
+ */
+Process.prototype.config;
+
+/**
+ * @type {boolean}
+ * @see http://nodejs.org/api/process.html#process_process_connected
+ */
+Process.prototype.connected;
+
+/**
+ * @return {string}
+ * @see http://nodejs.org/api/process.html#process_process_cwd
+ */
+Process.prototype.cwd = function () {};
+
+/**
+ * @return {void}
+ * @see http://nodejs.org/api/process.html#process_process_disconnect
+ */
+Process.prototype.disconnect = function () {};
+
+/**
+ * @type {*}
+ * @see http://nodejs.org/api/process.html#process_process_env
+ */
+Process.prototype.env;
+
+/**
+ * @param {number=} code
+ * @see http://nodejs.org/api/process.html#process_process_exit_code
+ */
+Process.prototype.exit = function (code) {};
+
+/**
+ * @param {number} pid
+ * @param {string|number} signal
+ * @see http://nodejs.org/api/process.html#process_process_kill_pid_signal
+ */
+Process.prototype.kill = function (pid, signal) {};
+
+/**
+ * @param {!Function} fn
+ * @param {...*} var_args
+ * @see http://nodejs.org/api/process.html#process_process_nexttick_callback_arg
+ */
+Process.prototype.nextTick = function (fn, var_args) {};
+
+/**
+ * @type {string}
+ * @see http://nodejs.org/api/process.html#process_process_pid
+ */
+Process.prototype.pid;
+
+/**
+ * @type {string}
+ * @see http://nodejs.org/api/process.html#process_process_platform
+ */
+Process.prototype.platform;
+
+/**
+ * @type {*}
+ * @see http://nodejs.org/api/process.html#process_process_release
+ */
+Process.prototype.release;
+
+/**
+ * @return {number}
+ * @see http://nodejs.org/api/process.html#process_process_uptime
+ */
+Process.prototype.uptime = function () {};
+
+/**
+ * @type {string}
+ * @see http://nodejs.org/api/process.html#process_process_version
+ */
+Process.prototype.version;
+
+/**
+ * @type {*}
+ * @see http://nodejs.org/api/process.html#process_process_versions
+ */
+Process.prototype.versions;
+
+/** @const {Process} */
+var process;
+
+/**
+ * @constructor
+ * @see http://trac.webkit.org/browser/trunk/Source/WebCore/page/Console.idl
+ * @see http://trac.webkit.org/browser/trunk/Source/WebCore/page/Console.cpp
+ */
+function Console() {};
+
+/**
+ * @param {*} condition
+ * @param {...*} var_args
+ */
+Console.prototype.assert = function(condition, var_args) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.error = function(var_args) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.info = function(var_args) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.log = function(var_args) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.warn = function(var_args) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.debug = function(var_args) {};
+
+/**
+ * @param {*} value
+ */
+Console.prototype.dir = function(value) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.dirxml = function(var_args) {};
+
+/**
+ * @param {!Object} data
+ * @param {*=} opt_columns
+ */
+Console.prototype.table = function(data, opt_columns) {};
+
+/**
+ * @return {undefined}
+ */
+Console.prototype.trace = function() {};
+
+/**
+ * @param {*} value
+ */
+Console.prototype.count = function(value) {};
+
+/**
+ * @param {*} value
+ */
+Console.prototype.markTimeline = function(value) {};
+
+/**
+ * @param {string=} opt_title
+ */
+Console.prototype.profile = function(opt_title) {};
+
+/**
+ * @param {string=} opt_title
+ */
+Console.prototype.profileEnd = function(opt_title) {};
+
+/**
+ * @param {string} name
+ */
+Console.prototype.time = function(name) {};
+
+/**
+ * @param {string} name
+ */
+Console.prototype.timeEnd = function(name) {};
+
+/**
+ * @param {*} value
+ */
+Console.prototype.timeStamp = function(value) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.group = function(var_args) {};
+
+/**
+ * @param {...*} var_args
+ */
+Console.prototype.groupCollapsed = function(var_args) {};
+
+/** @return {void} */
+Console.prototype.groupEnd = function() {};
+
+/** @return {void} */
+Console.prototype.clear = function() {};
+
+/**
+ * @type {!Console}
+ */
+var console;
+
+
+
+/**
+ * @param {...*} var_args
+ * @constructor
+ * @nosideeffects
+ */
+var Buffer = function (var_args) {};
+
+/**
+ * @param {string} encoding
+ * @return {boolean}
+ */
+Buffer.isEncoding;
+
+/**
+ * @param {*} obj
+ * @return {boolean}
+ * @nosideeffects
+ */
+Buffer.isBuffer;
+
+/**
+ * @param {string} string
+ * @param {string=} encoding
+ * @return {number}
+ * @nosideeffects
+ */
+Buffer.byteLength;
+
+/**
+ * @param {Array.<Buffer>} list
+ * @param {number=} totalLength
+ * @return {Buffer}
+ * @nosideeffects
+ */
+Buffer.concat;
+
+/**
+ * @param {number} offset
+ * @return {*}
+ */
+Buffer.prototype.get;
+
+/**
+ * @param {number} offset
+ * @param {*} v
+ */
+Buffer.prototype.set;
+
+/**
+ * @param {string} string
+ * @param {number|string=} offset
+ * @param {number|string=} length
+ * @param {number|string=} encoding
+ * @return {*}
+ */
+Buffer.prototype.write;
+
+/**
+ * @return {Array}
+ */
+Buffer.prototype.toJSON;
+
+/**
+ * @type {number}
+ */
+Buffer.prototype.length;
+
+/**
+ * @param {Buffer} targetBuffer
+ * @param {number=} targetStart
+ * @param {number=} sourceStart
+ * @param {number=} sourceEnd
+ * @return {Buffer}
+ */
+Buffer.prototype.copy;
+
+/**
+ * @param {number=} start
+ * @param {number=} end
+ * @return {Buffer}
+ * @nosideeffects
+ */
+Buffer.prototype.slice;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readUInt8;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readUInt16LE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readUInt16BE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readUInt32LE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readUInt32BE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readInt8;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readInt16LE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readInt16BE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readInt32LE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readInt32BE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readFloatLE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readFloatBE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readDoubleLE;
+
+/**
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.readDoubleBE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeUInt8;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeUInt16LE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeUInt16BE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeUInt32LE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeUInt32BE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeInt8;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeInt16LE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeInt16BE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeInt32LE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeInt32BE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeFloatLE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeFloatBE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeDoubleLE;
+
+/**
+ * @param {number} value
+ * @param {number} offset
+ * @param {boolean=} noAssert
+ * @return {number}
+ */
+Buffer.prototype.writeDoubleBE;
+
+/**
+ * @param {*} value
+ * @param {number=} offset
+ * @param {number=} end
+ * @return {void}
+ */
+Buffer.prototype.fill;
+
+/**
+ * @param {string=} encoding
+ * @param {number=} start
+ * @param {number=} end
+ * @return {string}
+ * @nosideeffects
+ */
+Buffer.prototype.toString;
+
+/**
+ * @type {number}
+ */
+Buffer.INSPECT_MAX_BYTES = 50;
+
+//
+// Legacy
+//
+
+/**
+ * @param {number=} start
+ * @param {number=} end
+ * @return {Buffer}
+ */
+Buffer.prototype.utf8Slice;
+
+/**
+ * @param {number=} start
+ * @param {number=} end
+ * @return {Buffer}
+ */
+Buffer.prototype.binarySlice;
+
+/**
+ * @param {number=} start
+ * @param {number=} end
+ * @return {Buffer}
+ */
+Buffer.prototype.asciiSlice;
+
+/**
+ * @param {string} string
+ * @param {number=} offset
+ * @return {Buffer}
+ */
+Buffer.prototype.utf8Write;
+
+/**
+ * @param {string} string
+ * @param {number=} offset
+ * @return {Buffer}
+ */
+Buffer.prototype.binaryWrite;
+
+/**
+ * @param {string} string
+ * @param {number=} offset
+ * @return {Buffer}
+ */
+Buffer.prototype.asciiWrite;

build/node_modules/google-closure-compiler-js/contrib/nodejs/http.js

@@ -0,0 +1,252 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's http module. Depends on the events module.
+ * @see http://nodejs.org/api/http.html
+ * @see https://github.com/joyent/node/blob/master/lib/http.js
+ */
+
+var events = require('events');
+var net = require('net');
+var stream = require('stream');
+
+/** @const */
+var http = {};
+
+/**
+ * @typedef {function(http.IncomingMessage, http.ServerResponse)}
+ */
+http.requestListener;
+
+/**
+ * @param {http.requestListener=} listener
+ * @return {http.Server}
+ */
+http.createServer;
+
+/**
+ * @param {http.requestListener=} listener
+ * @constructor
+ * @extends events.EventEmitter
+ */
+http.Server = function(listener) {};
+
+/**
+ * @param {(number|string)} portOrPath
+ * @param {(string|Function)=} hostnameOrCallback
+ * @param {Function=} callback
+ */
+http.Server.prototype.listen;
+
+/**
+ * @return {void}
+ */
+http.Server.prototype.close;
+
+/**
+ * @constructor
+ * @extends stream.Readable
+ */
+http.IncomingMessage = function() {};
+
+/**
+ * @type {?string}
+ * */
+http.IncomingMessage.prototype.method;
+
+/**
+ * @type {?string}
+ */
+http.IncomingMessage.prototype.url;
+
+/**
+ * @type {Object}
+ * */
+http.IncomingMessage.prototype.headers;
+
+/**
+ * @type {Object}
+ * */
+http.IncomingMessage.prototype.trailers;
+
+/**
+ * @type {string}
+ */
+http.IncomingMessage.prototype.httpVersion;
+
+/**
+ * @type {string}
+ */
+http.IncomingMessage.prototype.httpVersionMajor;
+
+/**
+ * @type {string}
+ */
+http.IncomingMessage.prototype.httpVersionMinor;
+
+/**
+ * @type {*}
+ */
+http.IncomingMessage.prototype.connection;
+
+/**
+ * @type {?number}
+ */
+http.IncomingMessage.prototype.statusCode;
+
+/**
+ * @type {net.Socket}
+ */
+http.IncomingMessage.prototype.socket;
+
+/**
+ * @param {number} msecs
+ * @param {function()} callback
+ * @return {void}
+ */
+http.IncomingMessage.prototype.setTimeout;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ * @private
+ */
+http.ServerResponse = function() {};
+
+/**
+ * @return {void}
+ */
+http.ServerResponse.prototype.writeContinue;
+
+/**
+ * @param {number} statusCode
+ * @param {*=} reasonPhrase
+ * @param {*=} headers
+ */
+http.ServerResponse.prototype.writeHead;
+
+/**
+ * @type {number}
+ */
+http.ServerResponse.prototype.statusCode;
+
+/**
+ * @param {string} name
+ * @param {string} value
+ * @return {void}
+ */
+http.ServerResponse.prototype.setHeader;
+
+/**
+ * @param {string} name
+ * @return {string|undefined} value
+ */
+http.ServerResponse.prototype.getHeader;
+
+/**
+ * @param {string} name
+ * @return {void}
+ */
+http.ServerResponse.prototype.removeHeader;
+
+/**
+ * @param {string|Array|Buffer} chunk
+ * @param {string=} encoding
+ * @return {void}
+ */
+http.ServerResponse.prototype.write;
+
+/**
+ * @param {Object} headers
+ * @return {void}
+ */
+http.ServerResponse.prototype.addTrailers;
+
+/**
+ * @param {(string|Array|Buffer)=} data
+ * @param {string=} encoding
+ * @return {void}
+ */
+http.ServerResponse.prototype.end;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ * @private
+ */
+http.ClientRequest = function() {};
+
+/**
+ * @param {string|Array|Buffer} chunk
+ * @param {string=} encoding
+ * @return {void}
+ */
+http.ClientRequest.prototype.write;
+
+/**
+ * @param {(string|Array|Buffer)=} data
+ * @param {string=} encoding
+ * @return {void}
+ */
+http.ClientRequest.prototype.end;
+
+/**
+ * @return {void}
+ */
+http.ClientRequest.prototype.abort;
+
+/**
+ * @param {Object} options
+ * @param {function(http.IncomingMessage)} callback
+ * @return {http.ClientRequest}
+ */
+http.request;
+
+/**
+ * @param {Object} options
+ * @param {function(http.IncomingMessage)} callback
+ * @return {http.ClientRequest}
+ */
+http.get;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+http.Agent = function() {};
+
+/**
+ * @type {number}
+ */
+http.Agent.prototype.maxSockets;
+
+/**
+ * @type {number}
+ */
+http.Agent.prototype.sockets;
+
+/**
+ * @type {Array.<http.ClientRequest>}
+ */
+http.Agent.prototype.requests;
+
+/**
+ * @type {http.Agent}
+ */
+http.globalAgent;
+
+module.exports = http;

build/node_modules/google-closure-compiler-js/contrib/nodejs/https.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's https module. Depends on the tls module.
+ * @see http://nodejs.org/api/https.html
+ * @see https://github.com/joyent/node/blob/master/lib/https.js
+ */
+
+var http = require('http');
+var tls = require('tls');
+
+/** @const */
+var https = {};
+
+/**
+ * @constructor
+ * @extends tls.Server
+ */
+https.Server = function() {};
+
+/**
+ * @param {...*} var_args
+ * @return {void}
+ */
+https.Server.prototype.listen;
+
+/**
+ * @param {function()=} callback
+ * @return {void}
+ */
+https.Server.prototype.close;
+
+/**
+ * @param {tls.CreateOptions} options
+ * @param {function(http.IncomingMessage, http.ServerResponse)=} requestListener
+ * @return {!https.Server}
+ */
+https.createServer;
+
+/**
+ * @typedef {{host: ?string, hostname: ?string, port: ?number, method: ?string, path: ?string, headers: ?Object.<string,string>, auth: ?string, agent: ?(https.Agent|boolean), pfx: ?(string|Buffer), key: ?(string|Buffer), passphrase: ?string, cert: ?(string|Buffer), ca: ?Array.<string>, ciphers: ?string, rejectUnauthorized: ?boolean}}
+ */
+https.ConnectOptions;
+
+/**
+ * @param {https.ConnectOptions|string} options
+ * @param {function(http.IncomingMessage)} callback
+ * @return {http.ClientRequest}
+ */
+https.request;
+
+/**
+ * @param {https.ConnectOptions|string} options
+ * @param {function(http.IncomingMessage)} callback
+ * @return {http.ClientRequest}
+ */
+https.get;
+
+/**
+ * @constructor
+ * @extends http.Agent
+ */
+https.Agent = function() {};
+
+/**
+ * @type {https.Agent}
+ */
+https.globalAgent;
+
+module.exports = https;

build/node_modules/google-closure-compiler-js/contrib/nodejs/net.js

@@ -0,0 +1,219 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's net module. Depends on the events and buffer modules.
+ * @see http://nodejs.org/api/net.html
+ * @see https://github.com/joyent/node/blob/master/lib/net.js
+ */
+
+var events = require('events');
+
+/**
+ * @const
+ */
+var net = {};
+
+/**
+ * @typedef {{allowHalfOpen: ?boolean}}
+ */
+net.CreateOptions;
+
+/**
+ * @param {(net.CreateOptions|function(...))=} options
+ * @param {function(...)=} connectionListener
+ * @return {net.Server}
+ */
+net.createServer;
+
+/**
+ * @typedef {{port: ?number, host: ?string, localAddress: ?string, path: ?string, allowHalfOpen: ?boolean}}
+ */
+net.ConnectOptions;
+
+/**
+ * @param {net.ConnectOptions|number|string} arg1
+ * @param {(function(...)|string)=} arg2
+ * @param {function(...)=} arg3
+ * @return {void}
+ */
+net.connect;
+
+/**
+ * @param {net.ConnectOptions|number|string} arg1
+ * @param {(function(...)|string)=} arg2
+ * @param {function(...)=} arg3
+ * @return {void}
+ */
+net.createConnection;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+net.Server = function() {};
+
+/**
+ *
+ * @param {number|*} port
+ * @param {(string|number|function(...))=} host
+ * @param {(number|function(...))=} backlog
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+net.Server.prototype.listen;
+
+/**
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+net.Server.prototype.close;
+
+/**
+ * @return {{port: number, family: string, address: string}}
+ */
+net.Server.prototype.address;
+
+/**
+ * @type {number}
+ */
+net.Server.prototype.maxConnectinos;
+
+/**
+ * @type {number}
+ */
+net.Server.prototype.connections;
+
+/**
+ * @constructor
+ * @param {{fd: ?*, type: ?string, allowHalfOpen: ?boolean}=} options
+ * @extends events.EventEmitter
+ */
+net.Socket = function(options) {};
+
+/**
+ * @param {number|string|function(...)} port
+ * @param {(string|function(...))=} host
+ * @param {function(...)=} connectListener
+ * @return {void}
+ */
+net.Socket.prototype.connect;
+
+/**
+ * @type {number}
+ */
+net.Socket.prototype.bufferSize;
+
+/**
+ * @param {?string=} encoding
+ * @return {void}
+ */
+net.Socket.prototype.setEncoding;
+
+/**
+ * @param {string|Buffer} data
+ * @param {(string|function(...))=}encoding
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+net.Socket.prototype.write;
+
+/**
+ * @param {(string|Buffer)=}data
+ * @param {string=} encoding
+ * @return {void}
+ */
+net.Socket.prototype.end;
+
+/**
+ * @return {void}
+ */
+net.Socket.prototype.destroy = function() {};
+
+/**
+ * @return {void}
+ */
+net.Socket.prototype.pause = function() {};
+
+/**
+ * @return {void}
+ */
+net.Socket.prototype.resume;
+
+/**
+ * @param {number} timeout
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+net.Socket.prototype.setTimeout;
+
+/**
+ * @param {boolean=} noDelay
+ * @return {void}
+ */
+net.Socket.prototype.setNoDelay;
+
+/**
+ * @param {(boolean|number)=} enable
+ * @param {number=} initialDelay
+ * @return {void}
+ */
+net.Socket.prototype.setKeepAlive;
+
+/**
+ * @return {string}
+ */
+net.Socket.prototype.address;
+
+/**
+ * @type {?string}
+ */
+net.Socket.prototype.remoteAddress;
+
+/**
+ * @type {?number}
+ */
+net.Socket.prototype.remotePort;
+
+/**
+ * @type {number}
+ */
+net.Socket.prototype.bytesRead;
+
+/**
+ * @type {number}
+ */
+net.Socket.prototype.bytesWritten;
+
+/**
+ * @param {*} input
+ * @return {number}
+ */
+net.isIP;
+
+/**
+ * @param {*} input
+ * @return {boolean}
+ */
+net.isIPv4;
+
+/**
+ * @param {*} input
+ * @return {boolean}
+ */
+net.isIPv6;
+
+module.exports = net;

build/node_modules/google-closure-compiler-js/contrib/nodejs/os.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's os module.
+ * @see http://nodejs.org/api/os.html
+ */
+
+/** @const */
+var os = {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ */
+os.tmpDir;
+
+/**
+ * @return {string}
+ * @nosideeffects
+ */
+os.hostname;
+
+/**
+ * @return {string}
+ * @nosideeffects
+ */
+os.type;
+
+/**
+ * @return {string}
+ * @nosideeffects
+ */
+os.platform;
+
+/**
+ * @return {string}
+ * @nosideeffects
+ */
+os.arch;
+
+/**
+ * @return {string}
+ * @nosideeffects
+ */
+os.release;
+
+/**
+ * @return {number}
+ * @nosideeffects
+ */
+os.uptime;
+
+/**
+ * @return {Array.<number>}
+ * @nosideeffects
+ */
+os.loadavg;
+
+/**
+ * @return {number}
+ * @nosideeffects
+ */
+os.totalmem;
+
+/**
+ * @return {number}
+ * @nosideeffects
+ */
+os.freemem;
+
+/**
+ * @typedef {{model: string, speed: number, times: {user: number, nice: number, sys: number, idle: number, irg: number}}}
+ */
+var osCpusInfo;
+
+/**
+ * @return {Array.<osCpusInfo>}
+ * @nosideeffects
+ */
+os.cpus;
+
+/**
+ * @typedef {{address: string, family: string, internal: boolean}}
+ */
+var osNetworkInterfacesInfo;
+
+/**
+ * @return {Object.<string,osNetworkInterfacesInfo>}
+ * @nosideeffects
+ */
+os.networkInterfaces;
+
+/**
+ * @type {string}
+ */
+os.EOL;
+
+module.exports = os;

build/node_modules/google-closure-compiler-js/contrib/nodejs/path.js

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's path module.
+ * @externs
+ * @see http://nodejs.org/api/path.html
+ */
+
+/**
+ * @const
+ */
+var path = {};
+
+/**
+ * @param {string} p
+ * @return {string}
+ * @nosideeffects
+ */
+path.normalize;
+
+/**
+ * @param {...string} var_args
+ * @return {string}
+ * @nosideeffects
+ */
+path.join;
+
+/**
+ * @param {string} from
+ * @param {string=} to
+ * @return {string}
+ * @nosideeffects
+ */
+path.resolve;
+
+/**
+ * @param {string} from
+ * @param {string} to
+ * @return {string}
+ * @nosideeffects
+ */
+path.relative;
+
+/**
+ * @param {string} p
+ * @return {string}
+ * @nosideeffects
+ */
+path.dirname;
+
+/**
+ * @param {string} p
+ * @param {string=} ext
+ * @return {string}
+ * @nosideeffects
+ */
+path.basename;
+
+/**
+ * @param {string} p
+ * @return {string}
+ * @nosideeffects
+ */
+path.extname;
+
+/**
+ * @param {string} p
+ * @return {boolean}
+ * @nosideeffects
+ */
+path.isAbsolute;
+
+/**
+ * @type {string}
+ */
+path.sep;
+
+/**
+ * @type {string}
+ */
+path.delimiter;
+
+module.exports = path;

build/node_modules/google-closure-compiler-js/contrib/nodejs/punycode.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's punycode module.
+ * @see http://nodejs.org/api/punycode.html
+ * @see https://github.com/joyent/node/blob/master/lib/punycode.js
+ */
+
+/**
+ * @const
+ */
+var punycode = {};
+
+/**
+ * @param {string} string
+ * @return {string}
+ */
+punycode.decode;
+
+/**
+ * @param {string} string
+ * @return {string}
+ */
+punycode.encode;
+
+/**
+ * @param {string} domain
+ * @return {string}
+ */
+punycode.toUnicode;
+
+/**
+ * @param {string} domain
+ * @return {string}
+ */
+punycode.toASCII;
+
+/**
+ * @type {Object.<string,*>}
+ */
+punycode.ucs2 = {};
+
+/**
+ * @param {string} string
+ * @return {Array.<number>}
+ */
+punycode.ucs2.decode;
+
+/**
+ * @param {Array.<number>} codePoints
+ * @return {string}
+ */
+punycode.ucs2.encode;
+
+/**
+ * @type {string}
+ */
+punycode.version;
+
+module.exports = punycode;

build/node_modules/google-closure-compiler-js/contrib/nodejs/querystring.js

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's querystring module.
+ * @see http://nodejs.org/api/querystring.html
+ * @see https://github.com/joyent/node/blob/master/lib/querystring.js
+ */
+
+/**
+ * @const
+ */
+var querystring = {};
+
+/**
+ * @param {Object.<string,*>} obj
+ * @param {string=} sep
+ * @param {string=} eq
+ * @return {string}
+ * @nosideeffects
+ */
+querystring.stringify;
+
+/**
+ * @param {string} str
+ * @param {string=} sep
+ * @param {string=} eq
+ * @param {*=} options
+ * @return {Object.<string|!Array.<string>>}
+ * @nosideeffects
+ */
+querystring.parse;
+
+/**
+ * @param {string} str
+ * @return {string}
+ */
+querystring.escape;
+
+/**
+ * @param {string} str
+ * @return {string}
+ */
+querystring.unescape;
+
+/**
+ * @param {Buffer} s
+ * @param {boolean} decodeSpaces
+ * @return {void}
+ */
+querystring.unescapeBuffer;
+
+module.exports = querystring;

build/node_modules/google-closure-compiler-js/contrib/nodejs/readline.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's readline module. Depends on the events module.
+ * @see http://nodejs.org/api/readline.html
+ */
+
+var events = require('events');
+var stream = require('stream');
+
+/**
+ * @const
+ */
+var readline = {};
+
+/**
+ * @param {{input: stream.ReadableStream, output: stream.WritableStream, completer: function(string, function(*, Array)=), terminal: boolean}} options
+ * @return {readline.Interface}
+ */
+readline.createInterface;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+readline.Interface = function() {};
+
+/**
+ * @param {string} prompt
+ * @param {number} length
+ * @return {void}
+ */
+readline.Interface.prototype.setPrompt;
+
+/**
+ * @param {boolean=} preserveCursor
+ * @return {void}
+ */
+readline.Interface.prototype.prompt;
+
+/**
+ * @param {string} query
+ * @param {function(string)} callback
+ * @return {void}
+ */
+readline.Interface.prototype.question;
+
+/**
+ * @return {void}
+ */
+readline.Interface.prototype.pause;
+
+/**
+ * @return {void}
+ */
+readline.Interface.prototype.resume;
+
+/**
+ * @return {void}
+ */
+readline.Interface.prototype.close;
+
+/**
+ * @param {string} data
+ * @param {Object.<string,*>=} key
+ * @return {void}
+ */
+readline.Interface.prototype.write;
+
+module.exports = readline;

build/node_modules/google-closure-compiler-js/contrib/nodejs/repl.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's repl module. Depends on the events and stream modules.
+ * @see http://nodejs.org/api/repl.html
+ * @see https://github.com/joyent/node/blob/master/lib/repl.js
+ */
+
+var events = require('events');
+var stream = require('stream');
+
+/**
+ * @const
+ */
+var repl = {};
+
+/**
+ * @param {{prompt: ?string, input: ?stream.Readable, output: ?stream.Writable, terminal: ?boolean, eval: ?function(string), useColors: ?boolean, useGlobal: ?boolean, ignoreUndefined: ?boolean, writer: ?function(string)}} options
+ * @return {repl.REPLServer}
+ */
+repl.start;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+repl.REPLServer = function() {};
+
+/**
+ * @type {Object.<string,*>}
+ */
+repl.REPLServer.prototype.context;
+
+module.exports = repl;

build/node_modules/google-closure-compiler-js/contrib/nodejs/stream.js

@@ -0,0 +1,254 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's stream module. Depends on the events module.
+ * @see http://nodejs.org/api/stream.html
+ * @see https://github.com/joyent/node/blob/master/lib/stream.js
+ */
+
+var events = require('events');
+
+/** @const */
+var stream = {};
+
+/**
+ * @constructor
+ * @param {Object=} options
+ * @extends events.EventEmitter
+ */
+stream.Stream = function(options) {};
+
+/**
+ * @param {stream.Writable} dest
+ * @param {{end: boolean}=} pipeOpts
+ * @return {stream.Writable}
+ */
+stream.Stream.prototype.pipe;
+
+/**
+ * @constructor
+ * @param {Object=} options
+ * @extends stream.Stream
+ */
+stream.Readable = function(options) {};
+
+/**
+ * @type {boolean}
+ * @deprecated
+ */
+stream.Readable.prototype.readable;
+
+/**
+ * @protected
+ * @param {string|Buffer|null} chunk
+ * @return {boolean}
+ */
+stream.Readable.prototype.push;
+
+/**
+ * @param {string|Buffer|null} chunk
+ * @return {boolean}
+ */
+stream.Readable.prototype.unshift;
+
+/**
+ * @param {string} enc
+ * @return {void}
+ */
+stream.Readable.prototype.setEncoding;
+
+/**
+ * @param {number=} n
+ * @return {Buffer|string|null}
+ */
+stream.Readable.prototype.read;
+
+/**
+ * @protected
+ * @param {number} n
+ * @return {void}
+ */
+stream.Readable.prototype._read;
+
+/**
+ * @param {stream.Writable=} dest
+ * @return {stream.Readable}
+ */
+stream.Readable.prototype.unpipe;
+
+/**
+ * @return {void}
+ */
+stream.Readable.prototype.resume;
+
+/**
+ * @return {void}
+ */
+stream.Readable.prototype.pause;
+
+/**
+ * @param {stream.Stream} stream
+ * @return {stream.Readable}
+ */
+stream.Readable.prototype.wrap;
+
+/**
+ * @constructor
+ * @extends stream.Readable
+ */
+stream.ReadableStream = function() {};
+
+/**
+ * @type {boolean}
+ */
+stream.ReadableStream.prototype.readable;
+
+/**
+ * @param {string=} encoding
+ * @return {void}
+ */
+stream.ReadableStream.prototype.setEncoding;
+
+/**
+ * @return {void}
+ */
+stream.ReadableStream.prototype.destroy;
+
+/**
+ * @constructor
+ * @param {Object=} options
+ * @extends stream.Stream
+ */
+stream.Writable = function(options) {};
+
+/**
+ * @deprecated
+ * @type {boolean}
+ */
+stream.Writable.prototype.writable;
+
+/**
+ * @param {string|Buffer} chunk
+ * @param {string=} encoding
+ * @param {function(*=)=} cb
+ * @return {boolean}
+ */
+stream.Writable.prototype.write;
+
+/**
+ * @protected
+ * @param {string|Buffer} chunk
+ * @param {string} encoding
+ * @param {function(*=)} cb
+ * @return {void}
+ */
+stream.Writable.prototype._write;
+
+/**
+ * @param {string|Buffer=} chunk
+ * @param {string=} encoding
+ * @param {function(*=)=} cb
+ * @return {void}
+ */
+stream.Writable.prototype.end;
+
+/**
+ * @constructor
+ * @extends stream.Writable
+ */
+stream.WritableStream = function() {};
+
+/**
+ * @return {void}
+ */
+stream.WritableStream.prototype.drain;
+
+/**
+ * @type {boolean}
+ */
+stream.WritableStream.prototype.writable;
+
+/**
+ * @param {string|Buffer} buffer
+ * @param {string=} encoding
+ * @return {void}
+ */
+stream.WritableStream.prototype.write;
+
+/**
+ * @param {string|Buffer=} buffer
+ * @param {string=} encoding
+ * @param {function(*=)=} cb
+ * @return {void}
+ */
+stream.WritableStream.prototype.end;
+
+/**
+ * @return {void}
+ */
+stream.WritableStream.prototype.destroy;
+
+/**
+ * @return {void}
+ */
+stream.WritableStream.prototype.destroySoon;
+
+/**
+ * @constructor
+ * @param {Object=} options
+ * @extends stream.Readable
+ * Xextends stream.Writable
+ */
+stream.Duplex = function(options) {};
+
+/**
+ * @type {boolean}
+ */
+stream.Duplex.prototype.allowHalfOpen;
+
+
+/**
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Duplex
+ */
+stream.Transform = function(options) {};
+
+/**
+ * @protected
+ * @param {string|Buffer} chunk
+ * @param {string} encoding
+ * @param {function(*=)} cb
+ * @return {void}
+ */
+stream.Transform._transform;
+
+/**
+ * @protected
+ * @param {function(*=)} cb
+ * @return {void}
+ */
+stream.Transform._flush;
+
+/**
+ * @param {Object=} options
+ * @constructor
+ * @extends stream.Transform
+ */
+stream.PassThrough = function(options) {};
+
+module.exports = stream;

build/node_modules/google-closure-compiler-js/contrib/nodejs/string_decoder.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's string_decoder module. Depends on the buffer module.
+ * @see http://nodejs.org/api/string_decoder.html
+ * @see https://github.com/joyent/node/blob/master/lib/string_decoder.js
+ */
+
+/**
+ * @param {string} encoding
+ * @constructor
+ */
+var StringDecoder = function(encoding) {};
+
+/**
+ * @param {Buffer} buffer
+ * @return {string}
+ */
+StringDecoder.prototype.write;
+
+/**
+ * @return {string}
+ */
+StringDecoder.prototype.toString;
+
+/**
+ * @param {Buffer} buffer
+ * @return {number}
+ */
+StringDecoder.prototype.detectIncompleteChar;
+
+/**
+ * @param {Buffer} buffer
+ * @return {string}
+ */
+StringDecoder.prototype.end;
+
+module.exports = StringDecoder;

build/node_modules/google-closure-compiler-js/contrib/nodejs/tls.js

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's tls module. Depends on the stream module.
+ * @see http://nodejs.org/api/tls.html
+ * @see https://github.com/joyent/node/blob/master/lib/tls.js
+ */
+
+var crypto = require('crypto');
+var events = require('events');
+var net = require('net');
+var stream = require('stream');
+
+/**
+ * @const
+ */
+var tls = {};
+
+/**
+ * @constructor
+ */
+tls.CreateOptions = function () {};
+
+/** @type {boolean} */
+tls.CreateOptions.prototype.honorCipherOrder;
+
+/** @type {boolean} */
+tls.CreateOptions.prototype.requestCert;
+
+/** @type {boolean} */
+tls.CreateOptions.prototype.rejectUnauthorized;
+
+/** @type {Array|Buffer} */
+tls.CreateOptions.prototype.NPNProtocols;
+
+/** @type {function(string)} */
+tls.CreateOptions.prototype.SNICallback;
+
+/** @type {string} */
+tls.CreateOptions.prototype.sessionIdContext;
+
+/**
+ *
+ * @param {tls.CreateOptions} options
+ * @param {function(...)=} secureConnectionListener
+ * @return {tls.Server}
+ */
+tls.createServer;
+
+/**
+ * @typedef {{host: string, port: number, socket: *, pfx: (string|Buffer), key: (string|Buffer), passphrase: string, cert: (string|Buffer), ca: Array.<string>, rejectUnauthorized: boolean, NPNProtocols: Array.<string|Buffer>, servername: string}}
+ */
+tls.ConnectOptions;
+
+/**
+ *
+ * @param {number|tls.ConnectOptions} port
+ * @param {(string|tls.ConnectOptions|function(...))=} host
+ * @param {(tls.ConnectOptions|function(...))=} options
+ * @param {function(...)=} callback
+ * @return {void}
+ */
+tls.connect = function(port, host, options, callback) {};
+
+/**
+ * @param {crypto.Credentials=} credentials
+ * @param {boolean=} isServer
+ * @param {boolean=} requestCert
+ * @param {boolean=} rejectUnauthorized
+ * @return {tls.SecurePair}
+ */
+tls.createSecurePair;
+
+/**
+ * @constructor
+ * @extends events.EventEmitter
+ */
+tls.SecurePair = function() {};
+
+/**
+ * @constructor
+ * @extends net.Server
+ */
+tls.Server = function() {};
+
+/**
+ * @param {string} hostname
+ * @param {string|Buffer} credentials
+ * @return {void}
+ */
+tls.Server.prototype.addContext = function(hostname, credentials) {};
+
+/**
+ * @constructor
+ * @extends stream.Duplex
+ */
+tls.CleartextStream = function() {};
+
+/**
+ * @type {boolean}
+ */
+tls.CleartextStream.prototype.authorized;
+
+/**
+ * @type {?string}
+ */
+tls.CleartextStream.prototype.authorizationError;
+
+/**
+ * @return {Object.<string,(string|Object.<string,string>)>}
+ */
+tls.CleartextStream.prototype.getPeerCertificate;
+
+/**
+ * @return {{name: string, version: string}}
+ */
+tls.CleartextStream.prototype.getCipher;
+
+/**
+ * @return {{port: number, family: string, address: string}}
+ */
+tls.CleartextStream.prototype.address;
+
+/**
+ * @type {string}
+ */
+tls.CleartextStream.prototype.remoteAddress;
+
+/**
+ * @type {number}
+ */
+tls.CleartextStream.prototype.remotePort;
+
+module.exports = tls;

build/node_modules/google-closure-compiler-js/contrib/nodejs/tty.js

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's tty module. Depends on the net module.
+ * @see http://nodejs.org/api/tty.html
+ * @see https://github.com/joyent/node/blob/master/lib/tty.js
+ */
+
+var net = require('net');
+
+/**
+ * @const
+ */
+var tty = {};
+
+/**
+ * @param {*} fd
+ * @return {boolean}
+ */
+tty.isatty;
+
+/**
+ * @param {boolean} mode
+ * @return {void}
+ */
+tty.setRawMode;
+
+/**
+ * @constructor
+ * @extends net.Socket
+ */
+tty.ReadStream = function() {};
+
+/**
+ * @type {boolean}
+ */
+tty.ReadStream.prototype.isRaw;
+
+/**
+ * @param {boolean} mode
+ * @return {void}
+ */
+tty.ReadStream.prototype.setRawMode;
+
+/**
+ * @constructor
+ * @extends net.Socket
+ */
+tty.WriteStream = function() {};
+
+/**
+ * @type {number}
+ */
+tty.WriteStream.prototype.columns;
+
+/**
+ * @type {number}
+ */
+tty.WriteStream.prototype.rows;
+
+module.exports = tty;

build/node_modules/google-closure-compiler-js/contrib/nodejs/url.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's url module.
+ * @see http://nodejs.org/api/url.html
+ * @see https://github.com/joyent/node/blob/master/lib/url.js
+ */
+
+/**
+ * @const
+ */
+var url = {};
+
+/**
+ * @typedef {{href: ?string, protocol: ?string, host: ?string, auth: ?string, hostname: ?string, port: ?string, pathname: ?string, search: ?string, path: ?string, query: ?string, hash: ?string}}
+ */
+var URL;
+
+/**
+ * @param {string} urlStr
+ * @param {boolean=} parseQueryString
+ * @param {boolean=} slashesDenoteHost
+ * @return {URL}
+ * @nosideeffects
+ */
+url.parse;
+
+/**
+ * @param {URL} urlObj
+ * @return {string}
+ * @nosideeffects
+ */
+url.format;
+
+/**
+ * @param {string} from
+ * @param {string} to
+ * @return {string}
+ * @nosideeffects
+ */
+url.resolve;
+
+module.exports = url;

build/node_modules/google-closure-compiler-js/contrib/nodejs/util.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's util module. Depends on the stream module.
+ * @see http://nodejs.org/api/util.html
+ * @see https://github.com/joyent/node/blob/master/lib/util.js
+ */
+
+/**
+ * @const
+ */
+var util = {};
+
+/**
+ * @param {string} format
+ * @param {...*} var_args
+ * @return {string}
+ * @nosideeffects
+ */
+util.format;
+
+/**
+ * @param {string} string
+ * @return {void}
+ */
+util.debug;
+
+/**
+ * @param {...*} var_args
+ * @return {void}
+ */
+util.error;
+
+/**
+ * @param {...*} var_args
+ * @return {void}
+ */
+util.puts;
+
+/**
+ * @param {...*} var_args
+ * @return {void}
+ */
+util.print;
+
+/**
+ * @param {string} string
+ * @return {void}
+ */
+util.log;
+
+/**
+ * @param {*} object
+ * @param {{showHidden: (boolean|undefined),
+ *          depth: (number|null|undefined),
+ *          colors: (boolean|undefined),
+ *          customInspect: (boolean|undefined)}=} options
+ * @return {string}
+ * @nosideeffects
+ */
+util.inspect;
+
+/**
+ * @param {*} object
+ * @return {boolean}
+ * @nosideeffects
+ */
+util.isArray;
+
+/**
+ * @param {*} object
+ * @return {boolean}
+ * @nosideeffects
+ */
+util.isRegExp;
+
+/**
+ * @param {*} object
+ * @return {boolean}
+ * @nosideeffects
+ */
+util.isDate;
+
+/**
+ * @param {*} object
+ * @return {boolean}
+ * @nosideeffects
+ */
+util.isError;
+
+/**
+ * @param {Function} constructor
+ * @param {Function} superConstructor
+ * @return {void}
+ */
+util.inherits;
+
+module.exports = util;

build/node_modules/google-closure-compiler-js/contrib/nodejs/vm.js

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's vm module.
+ * @see http://nodejs.org/api/vm.html
+ * @see https://github.com/joyent/node/blob/master/lib/vm.js
+ */
+
+/**
+ * @const
+ */
+var vm = {};
+
+/**
+ * @constructor
+ */
+vm.Context = function() {}; // Does not really exist
+
+/**
+ * @param {string} code
+ * @param {string=} filename
+ */
+vm.runInThisContext;
+
+/**
+ * @param {string} code
+ * @param {Object.<string,*>=} sandbox
+ * @param {string=} filename
+ * @return {void}
+ */
+vm.runInNewContext;
+
+/**
+ * @param {string} code
+ * @param {vm.Context} context
+ * @param {string=} filename
+ * @return {void}
+ */
+vm.runInContext;
+
+/**
+ * @param {Object.<string,*>=} initSandbox
+ * @return {vm.Context}
+ * @nosideeffects
+ */
+vm.createContext;
+
+/**
+ * @constructor
+ */
+vm.Script = function() {};
+
+/**
+ * @param {string} code
+ * @param {string=} filename
+ * @return {vm.Script}
+ * @nosideeffects
+ */
+vm.createScript;
+
+/**
+ * @return {void}
+ */
+vm.Script.prototype.runInThisContext;
+
+/**
+ * @param {Object.<string,*>=} sandbox
+ * @return {void}
+ */
+vm.Script.prototype.runInNewContext;
+
+module.exports = vm;

build/node_modules/google-closure-compiler-js/contrib/nodejs/zlib.js

@@ -0,0 +1,386 @@
+/*
+ * Copyright 2012 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for node's zlib module. Depends on the events and buffer modules.
+ * @see http://nodejs.org/api/zlib.html
+ * @see https://github.com/joyent/node/blob/master/lib/zlib.js
+ */
+
+var stream = require('stream');
+
+/**
+ * @const
+ */
+var zlib = {};
+
+/**
+ * @typedef {{chunkSize: ?number, windowBits: ?number, level: ?number, memLevel: ?number, strategy: ?number, dictionary: ?Object}}
+ */
+zlib.Options;
+
+
+
+/**
+ * @constructor
+ * @extends stream.Transform
+ */
+zlib.Zlib = function() {};
+
+/**
+ * @param {zlib.Options} options
+ * @constructor
+ * @extends zlib.Zlib
+ */
+zlib.Gzip = function(options) {};
+
+/**
+ * @param {zlib.Options} options
+ * @constructor
+ * @extends zlib.Zlib
+ */
+zlib.Gunzip = function(options) {};
+
+/**
+ * @param {zlib.Options} options
+ * @constructor
+ * @extends zlib.Zlib
+ */
+zlib.Deflate = function(options) {};
+
+/**
+ * @param {zlib.Options} options
+ * @constructor
+ * @extends zlib.Zlib
+ */
+zlib.Inflate = function(options) {};
+
+/**
+ * @param {zlib.Options} options
+ * @constructor
+ * @extends zlib.Zlib
+ */
+zlib.DeflateRaw = function(options) {};
+
+/**
+ * @param {zlib.Options} options
+ * @constructor
+ * @extends zlib.Zlib
+ */
+zlib.InflateRaw = function(options) {};
+
+/**
+ * @param {zlib.Options} options
+ * @constructor
+ * @extends zlib.Zlib
+ */
+zlib.Unzip = function(options) {};
+
+
+
+/**
+ * @param {zlib.Options} options
+ * @return {zlib.Gzip}
+ */
+zlib.createGzip;
+
+/**
+ * @param {zlib.Options} options
+ * @return {zlib.Gunzip}
+ */
+zlib.createGunzip;
+
+/**
+ * @param {zlib.Options} options
+ * @return {zlib.Deflate}
+ */
+zlib.createDeflate;
+/**
+ * @param {zlib.Options} options
+ * @return {zlib.Inflate}
+ */
+zlib.createInflate;
+
+/**
+ * @param {zlib.Options} options
+ * @return {zlib.DeflateRaw}
+ */
+zlib.createDeflateRaw;
+
+/**
+ * @param {zlib.Options} options
+ * @return {zlib.InflateRaw}
+ */
+zlib.createInflateRaw;
+
+/**
+ * @param {zlib.Options} options
+ * @return {zlib.Unzip}
+ */
+zlib.createUnzip;
+
+
+
+/**
+ * @param {string|Buffer} buf
+ * @param {function(...)} callback
+ * @return {void}
+ */
+zlib.deflate;
+
+/**
+ * @param {string|Buffer} buf
+ * @param {function(...)} callback
+ * @return {void}
+ */
+zlib.deflateRaw;
+
+/**
+ * @param {string|Buffer} buf
+ * @param {function(...)} callback
+ * @return {void}
+ */
+zlib.gzip;
+
+/**
+ * @param {string|Buffer} buf
+ * @param {function(...)} callback
+ * @return {void}
+ */
+zlib.gunzip;
+
+/**
+ * @param {string|Buffer} buf
+ * @param {function(...)} callback
+ * @return {void}
+ */
+zlib.inflate;
+
+/**
+ * @param {string|Buffer} buf
+ * @param {function(...)} callback
+ * @return {void}
+ */
+zlib.inflateRaw;
+
+/**
+ * @param {string|Buffer} buf
+ * @param {function(...)} callback
+ * @return {void}
+ */
+zlib.unzip;
+
+
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_NO_FLUSH = 0;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_PARTIAL_FLUSH = 1;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_SYNC_FLUSH = 2;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_FULL_FLUSH = 3;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_FINISH = 4;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_BLOCK = 5;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_TREES = 6;
+
+
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_OK = 0;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_STREAM_END = 1;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_NEED_DICT = 2;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_ERRNO = -1;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_STREAM_ERROR = -2;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_DATA_ERROR = -3;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_MEM_ERROR = -4;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_BUF_ERROR = -5;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_VERSION_ERROR = -6;
+
+
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_NO_COMPRESSION = 0;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_BEST_SPEED = 1;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_BEST_COMPRESSION = 9;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_DEFAULT_COMPRESSION = -1;
+
+
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_FILTERED = 1;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_HUFFMAN_ONLY = 2;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_RLE = 3;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_FIXED = 4;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_DEFAULT_STRATEGY = 0;
+
+
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_BINARY = 0;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_TEXT = 1;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_ASCII = 1;
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_UNKNOWN = 2;
+
+
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_DEFLATED = 8;
+
+
+
+/**
+ * @type {number}
+ * @const
+ */
+zlib.Z_NULL = 0;
+
+module.exports = zlib;