diff options
Diffstat (limited to 'client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js')
| -rw-r--r-- | client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js | 21605 |
1 files changed, 21605 insertions, 0 deletions
diff --git a/client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js b/client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js new file mode 100644 index 000000000..717794363 --- /dev/null +++ b/client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js @@ -0,0 +1,21605 @@ +/* + * Copyright (c) 2015-2017, Matthieu Monsch. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ +(function (global){ +'use strict'; + +// compare and isBuffer taken from +// https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js +// original notice: + +/* + * ! The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> @license + * MIT + */ +function compare(a, b) { + if (a === b) { + return 0; + } + + var x = a.length; + var y = b.length; + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i]; + y = b[i]; + break; + } + } + + if (x < y) { + return -1; + } + if (y < x) { + return 1; + } + return 0; +} +function isBuffer(b) { + if (global.Buffer && typeof global.Buffer.isBuffer === 'function') { + return global.Buffer.isBuffer(b); + } + return !!(b != null && b._isBuffer); +} + +// based on node assert, original notice: + +// http://wiki.commonjs.org/wiki/Unit_Testing/1.0 +// +// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! +// +// Originally from narwhal.js (http://narwhaljs.org) +// Copyright (c) 2009 Thomas Robinson <280north.com> +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the 'Software'), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +var util = require('util/'); +var hasOwn = Object.prototype.hasOwnProperty; +var pSlice = Array.prototype.slice; +var functionsHaveNames = (function () { + return function foo() {}.name === 'foo'; +}()); +function pToString (obj) { + return Object.prototype.toString.call(obj); +} +function isView(arrbuf) { + if (isBuffer(arrbuf)) { + return false; + } + if (typeof global.ArrayBuffer !== 'function') { + return false; + } + if (typeof ArrayBuffer.isView === 'function') { + return ArrayBuffer.isView(arrbuf); + } + if (!arrbuf) { + return false; + } + if (arrbuf instanceof DataView) { + return true; + } + if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) { + return true; + } + return false; +} +// 1. The assert module provides functions that throw +// AssertionError's when particular conditions are not met. The +// assert module must conform to the following interface. + +var assert = module.exports = ok; + +// 2. The AssertionError is defined in assert. +// new assert.AssertionError({ message: message, +// actual: actual, +// expected: expected }) + +var regex = /\s*function\s+([^\(\s]*)\s*/; +// based on +// https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js +function getName(func) { + if (!util.isFunction(func)) { + return; + } + if (functionsHaveNames) { + return func.name; + } + var str = func.toString(); + var match = str.match(regex); + return match && match[1]; +} +assert.AssertionError = function AssertionError(options) { + this.name = 'AssertionError'; + this.actual = options.actual; + this.expected = options.expected; + this.operator = options.operator; + if (options.message) { + this.message = options.message; + this.generatedMessage = false; + } else { + this.message = getMessage(this); + this.generatedMessage = true; + } + var stackStartFunction = options.stackStartFunction || fail; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, stackStartFunction); + } else { + // non v8 browsers so we can have a stacktrace + var err = new Error(); + if (err.stack) { + var out = err.stack; + + // try to strip useless frames + var fn_name = getName(stackStartFunction); + var idx = out.indexOf('\n' + fn_name); + if (idx >= 0) { + // once we have located the function frame + // we need to strip out everything before it (and its line) + var next_line = out.indexOf('\n', idx + 1); + out = out.substring(next_line + 1); + } + + this.stack = out; + } + } +}; + +// assert.AssertionError instanceof Error +util.inherits(assert.AssertionError, Error); + +function truncate(s, n) { + if (typeof s === 'string') { + return s.length < n ? s : s.slice(0, n); + } else { + return s; + } +} +function inspect(something) { + if (functionsHaveNames || !util.isFunction(something)) { + return util.inspect(something); + } + var rawname = getName(something); + var name = rawname ? ': ' + rawname : ''; + return '[Function' + name + ']'; +} +function getMessage(self) { + return truncate(inspect(self.actual), 128) + ' ' + + self.operator + ' ' + + truncate(inspect(self.expected), 128); +} + +// At present only the three keys mentioned above are used and +// understood by the spec. Implementations or sub modules can pass +// other keys to the AssertionError's constructor - they will be +// ignored. + +// 3. All of the following functions must throw an AssertionError +// when a corresponding condition is not met, with a message that +// may be undefined if not provided. All assertion methods provide +// both the actual and expected values to the assertion error for +// display purposes. + +function fail(actual, expected, message, operator, stackStartFunction) { + throw new assert.AssertionError({ + message: message, + actual: actual, + expected: expected, + operator: operator, + stackStartFunction: stackStartFunction + }); +} + +// EXTENSION! allows for well behaved errors defined elsewhere. +assert.fail = fail; + +// 4. Pure assertion tests whether a value is truthy, as determined +// by !!guard. +// assert.ok(guard, message_opt); +// This statement is equivalent to assert.equal(true, !!guard, +// message_opt);. To test strictly for the value true, use +// assert.strictEqual(true, guard, message_opt);. + +function ok(value, message) { + if (!value) fail(value, true, message, '==', assert.ok); +} +assert.ok = ok; + +// 5. The equality assertion tests shallow, coercive equality with +// ==. +// assert.equal(actual, expected, message_opt); + +assert.equal = function equal(actual, expected, message) { + if (actual != expected) fail(actual, expected, message, '==', assert.equal); +}; + +// 6. The non-equality assertion tests for whether two objects are not equal +// with != assert.notEqual(actual, expected, message_opt); + +assert.notEqual = function notEqual(actual, expected, message) { + if (actual == expected) { + fail(actual, expected, message, '!=', assert.notEqual); + } +}; + +// 7. The equivalence assertion tests a deep equality relation. +// assert.deepEqual(actual, expected, message_opt); + +assert.deepEqual = function deepEqual(actual, expected, message) { + if (!_deepEqual(actual, expected, false)) { + fail(actual, expected, message, 'deepEqual', assert.deepEqual); + } +}; + +assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) { + if (!_deepEqual(actual, expected, true)) { + fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual); + } +}; + +function _deepEqual(actual, expected, strict, memos) { + // 7.1. All identical values are equivalent, as determined by ===. + if (actual === expected) { + return true; + } else if (isBuffer(actual) && isBuffer(expected)) { + return compare(actual, expected) === 0; + + // 7.2. If the expected value is a Date object, the actual value is + // equivalent if it is also a Date object that refers to the same time. + } else if (util.isDate(actual) && util.isDate(expected)) { + return actual.getTime() === expected.getTime(); + + // 7.3 If the expected value is a RegExp object, the actual value is + // equivalent if it is also a RegExp object with the same source and + // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). + } else if (util.isRegExp(actual) && util.isRegExp(expected)) { + return actual.source === expected.source && + actual.global === expected.global && + actual.multiline === expected.multiline && + actual.lastIndex === expected.lastIndex && + actual.ignoreCase === expected.ignoreCase; + + // 7.4. Other pairs that do not both pass typeof value == 'object', + // equivalence is determined by ==. + } else if ((actual === null || typeof actual !== 'object') && + (expected === null || typeof expected !== 'object')) { + return strict ? actual === expected : actual == expected; + + // If both values are instances of typed arrays, wrap their underlying + // ArrayBuffers in a Buffer each to increase performance + // This optimization requires the arrays to have the same type as checked by + // Object.prototype.toString (aka pToString). Never perform binary + // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their + // bit patterns are not identical. + } else if (isView(actual) && isView(expected) && + pToString(actual) === pToString(expected) && + !(actual instanceof Float32Array || + actual instanceof Float64Array)) { + return compare(new Uint8Array(actual.buffer), + new Uint8Array(expected.buffer)) === 0; + + // 7.5 For all other Object pairs, including Array objects, equivalence is + // determined by having the same number of owned properties (as verified + // with Object.prototype.hasOwnProperty.call), the same set of keys + // (although not necessarily the same order), equivalent values for every + // corresponding key, and an identical 'prototype' property. Note: this + // accounts for both named and indexed properties on Arrays. + } else if (isBuffer(actual) !== isBuffer(expected)) { + return false; + } else { + memos = memos || {actual: [], expected: []}; + + var actualIndex = memos.actual.indexOf(actual); + if (actualIndex !== -1) { + if (actualIndex === memos.expected.indexOf(expected)) { + return true; + } + } + + memos.actual.push(actual); + memos.expected.push(expected); + + return objEquiv(actual, expected, strict, memos); + } +} + +function isArguments(object) { + return Object.prototype.toString.call(object) == '[object Arguments]'; +} + +function objEquiv(a, b, strict, actualVisitedObjects) { + if (a === null || a === undefined || b === null || b === undefined) + return false; + // if one is a primitive, the other must be same + if (util.isPrimitive(a) || util.isPrimitive(b)) + return a === b; + if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) + return false; + var aIsArgs = isArguments(a); + var bIsArgs = isArguments(b); + if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) + return false; + if (aIsArgs) { + a = pSlice.call(a); + b = pSlice.call(b); + return _deepEqual(a, b, strict); + } + var ka = objectKeys(a); + var kb = objectKeys(b); + var key, i; + // having the same number of owned properties (keys incorporates + // hasOwnProperty) + if (ka.length !== kb.length) + return false; + // the same set of keys (although not necessarily the same order), + ka.sort(); + kb.sort(); + // ~~~cheap key test + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] !== kb[i]) + return false; + } + // equivalent values for every corresponding key, and + // ~~~possibly expensive deep test + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects)) + return false; + } + return true; +} + +// 8. The non-equivalence assertion tests for any deep inequality. +// assert.notDeepEqual(actual, expected, message_opt); + +assert.notDeepEqual = function notDeepEqual(actual, expected, message) { + if (_deepEqual(actual, expected, false)) { + fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); + } +}; + +assert.notDeepStrictEqual = notDeepStrictEqual; +function notDeepStrictEqual(actual, expected, message) { + if (_deepEqual(actual, expected, true)) { + fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual); + } +} + + +// 9. The strict equality assertion tests strict equality, as determined by ===. +// assert.strictEqual(actual, expected, message_opt); + +assert.strictEqual = function strictEqual(actual, expected, message) { + if (actual !== expected) { + fail(actual, expected, message, '===', assert.strictEqual); + } +}; + +// 10. The strict non-equality assertion tests for strict inequality, as +// determined by !==. assert.notStrictEqual(actual, expected, message_opt); + +assert.notStrictEqual = function notStrictEqual(actual, expected, message) { + if (actual === expected) { + fail(actual, expected, message, '!==', assert.notStrictEqual); + } +}; + +function expectedException(actual, expected) { + if (!actual || !expected) { + return false; + } + + if (Object.prototype.toString.call(expected) == '[object RegExp]') { + return expected.test(actual); + } + + try { + if (actual instanceof expected) { + return true; + } + } catch (e) { + // Ignore. The instanceof check doesn't work for arrow functions. + } + + if (Error.isPrototypeOf(expected)) { + return false; + } + + return expected.call({}, actual) === true; +} + +function _tryBlock(block) { + var error; + try { + block(); + } catch (e) { + error = e; + } + return error; +} + +function _throws(shouldThrow, block, expected, message) { + var actual; + + if (typeof block !== 'function') { + throw new TypeError('"block" argument must be a function'); + } + + if (typeof expected === 'string') { + message = expected; + expected = null; + } + + actual = _tryBlock(block); + + message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + + (message ? ' ' + message : '.'); + + if (shouldThrow && !actual) { + fail(actual, expected, 'Missing expected exception' + message); + } + + var userProvidedMessage = typeof message === 'string'; + var isUnwantedException = !shouldThrow && util.isError(actual); + var isUnexpectedException = !shouldThrow && actual && !expected; + + if ((isUnwantedException && + userProvidedMessage && + expectedException(actual, expected)) || + isUnexpectedException) { + fail(actual, expected, 'Got unwanted exception' + message); + } + + if ((shouldThrow && actual && expected && + !expectedException(actual, expected)) || (!shouldThrow && actual)) { + throw actual; + } +} + +// 11. Expected to throw an error: +// assert.throws(block, Error_opt, message_opt); + +assert.throws = function(block, /* optional */error, /* optional */message) { + _throws(true, block, error, message); +}; + +// EXTENSION! This is annoying to write outside this module. +assert.doesNotThrow = function(block, /* optional */error, /* optional */message) { + _throws(false, block, error, message); +}; + +assert.ifError = function(err) { if (err) throw err; }; + +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + if (hasOwn.call(obj, key)) keys.push(key); + } + return keys; +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"util/":47}],2:[function(require,module,exports){ + +},{}],3:[function(require,module,exports){ +'use strict'; + + +var TYPED_OK = (typeof Uint8Array !== 'undefined') && + (typeof Uint16Array !== 'undefined') && + (typeof Int32Array !== 'undefined'); + + +exports.assign = function (obj /* from1, from2, from3, ... */) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { continue; } + + if (typeof source !== 'object') { + throw new TypeError(source + 'must be non-object'); + } + + for (var p in source) { + if (source.hasOwnProperty(p)) { + obj[p] = source[p]; + } + } + } + + return obj; +}; + + +// reduce buffer size, avoiding mem copy +exports.shrinkBuf = function (buf, size) { + if (buf.length === size) { return buf; } + if (buf.subarray) { return buf.subarray(0, size); } + buf.length = size; + return buf; +}; + + +var fnTyped = { + arraySet: function (dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs + len), dest_offs); + return; + } + // Fallback to ordinary array + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function (chunks) { + var i, l, len, pos, chunk, result; + + // calculate data length + len = 0; + for (i = 0, l = chunks.length; i < l; i++) { + len += chunks[i].length; + } + + // join chunks + result = new Uint8Array(len); + pos = 0; + for (i = 0, l = chunks.length; i < l; i++) { + chunk = chunks[i]; + result.set(chunk, pos); + pos += chunk.length; + } + + return result; + } +}; + +var fnUntyped = { + arraySet: function (dest, src, src_offs, len, dest_offs) { + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function (chunks) { + return [].concat.apply([], chunks); + } +}; + + +// Enable/Disable typed arrays use, for testing +// +exports.setTyped = function (on) { + if (on) { + exports.Buf8 = Uint8Array; + exports.Buf16 = Uint16Array; + exports.Buf32 = Int32Array; + exports.assign(exports, fnTyped); + } else { + exports.Buf8 = Array; + exports.Buf16 = Array; + exports.Buf32 = Array; + exports.assign(exports, fnUntyped); + } +}; + +exports.setTyped(TYPED_OK); + +},{}],4:[function(require,module,exports){ +'use strict'; + +// Note: adler32 takes 12% for level 0 and 2% for level 6. +// It doesn't worth to make additional optimizationa as in original. +// Small size is preferable. + +function adler32(adler, buf, len, pos) { + var s1 = (adler & 0xffff) |0, + s2 = ((adler >>> 16) & 0xffff) |0, + n = 0; + + while (len !== 0) { + // Set limit ~ twice less than 5552, to keep + // s2 in 31-bits, because we force signed ints. + // in other case %= will fail. + n = len > 2000 ? 2000 : len; + len -= n; + + do { + s1 = (s1 + buf[pos++]) |0; + s2 = (s2 + s1) |0; + } while (--n); + + s1 %= 65521; + s2 %= 65521; + } + + return (s1 | (s2 << 16)) |0; +} + + +module.exports = adler32; + +},{}],5:[function(require,module,exports){ +'use strict'; + + +module.exports = { + + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + + /* + * Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + // Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + // Z_VERSION_ERROR: -6, + + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + + + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + // Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + + /* The deflate compression method */ + Z_DEFLATED: 8 + // Z_NULL: null // Use -1 or null inline, depending on var type +}; + +},{}],6:[function(require,module,exports){ +'use strict'; + +// Note: we can't get significant speed boost here. +// So write code to minimize size - no pregenerated tables +// and array tools dependencies. + + +// Use ordinary array, since untyped makes no boost here +function makeTable() { + var c, table = []; + + for (var n = 0; n < 256; n++) { + c = n; + for (var k = 0; k < 8; k++) { + c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1)); + } + table[n] = c; + } + + return table; +} + +// Create table on load. Just 255 signed longs. Not a problem. +var crcTable = makeTable(); + + +function crc32(crc, buf, len, pos) { + var t = crcTable, + end = pos + len; + + crc ^= -1; + + for (var i = pos; i < end; i++) { + crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF]; + } + + return (crc ^ (-1)); // >>> 0; +} + + +module.exports = crc32; + +},{}],7:[function(require,module,exports){ +'use strict'; + +var utils = require('../utils/common'); +var trees = require('./trees'); +var adler32 = require('./adler32'); +var crc32 = require('./crc32'); +var msg = require('./messages'); + +/* Public constants ========================================================== */ +/* =========================================================================== */ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +var Z_NO_FLUSH = 0; +var Z_PARTIAL_FLUSH = 1; +// var Z_SYNC_FLUSH = 2; +var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +// var Z_TREES = 6; + + +/* + * Return codes for the compression/decompression functions. Negative values are + * errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +// var Z_NEED_DICT = 2; +// var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +// var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +// var Z_VERSION_ERROR = -6; + + +/* compression levels */ +// var Z_NO_COMPRESSION = 0; +// var Z_BEST_SPEED = 1; +// var Z_BEST_COMPRESSION = 9; +var Z_DEFAULT_COMPRESSION = -1; + + +var Z_FILTERED = 1; +var Z_HUFFMAN_ONLY = 2; +var Z_RLE = 3; +var Z_FIXED = 4; +var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +// var Z_BINARY = 0; +// var Z_TEXT = 1; +// var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + + +/* The deflate compression method */ +var Z_DEFLATED = 8; + +/* ============================================================================ */ + + +var MAX_MEM_LEVEL = 9; +/* Maximum value for memLevel in deflateInit2 */ +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_MEM_LEVEL = 8; + + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ +var LITERALS = 256; +/* number of literal bytes 0..255 */ +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ +var D_CODES = 30; +/* number of distance codes */ +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ +var HEAP_SIZE = 2 * L_CODES + 1; +/* maximum heap size */ +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1); + +var PRESET_DICT = 0x20; + +var INIT_STATE = 42; +var EXTRA_STATE = 69; +var NAME_STATE = 73; +var COMMENT_STATE = 91; +var HCRC_STATE = 103; +var BUSY_STATE = 113; +var FINISH_STATE = 666; + +var BS_NEED_MORE = 1; /* + * block not completed, need more input or more + * output + */ +var BS_BLOCK_DONE = 2; /* block flush performed */ +var BS_FINISH_STARTED = 3; /* + * finish started, need only more output at next + * deflate + */ +var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */ + +var OS_CODE = 0x03; // Unix :) . Don't detect, use this default. + +function err(strm, errorCode) { + strm.msg = msg[errorCode]; + return errorCode; +} + +function rank(f) { + return ((f) << 1) - ((f) > 4 ? 9 : 0); +} + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + + +/* + * ========================================================================= + * Flush as much pending output as possible. All deflate() output goes through + * this function so some applications may wish to modify it to avoid allocating + * a large strm->output buffer and copying into it. (See also read_buf()). + */ +function flush_pending(strm) { + var s = strm.state; + + // _tr_flush_bits(s); + var len = s.pending; + if (len > strm.avail_out) { + len = strm.avail_out; + } + if (len === 0) { return; } + + utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); + strm.next_out += len; + s.pending_out += len; + strm.total_out += len; + strm.avail_out -= len; + s.pending -= len; + if (s.pending === 0) { + s.pending_out = 0; + } +} + + +function flush_block_only(s, last) { + trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last); + s.block_start = s.strstart; + flush_pending(s.strm); +} + + +function put_byte(s, b) { + s.pending_buf[s.pending++] = b; +} + + +/* + * ========================================================================= Put + * a short in the pending buffer. The 16-bit value is put in MSB order. IN + * assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +function putShortMSB(s, b) { +// put_byte(s, (Byte)(b >> 8)); +// put_byte(s, (Byte)(b & 0xff)); + s.pending_buf[s.pending++] = (b >>> 8) & 0xff; + s.pending_buf[s.pending++] = b & 0xff; +} + + +/* + * =========================================================================== + * Read a new buffer from the current input stream, update the adler32 and total + * number of bytes read. All deflate() input goes through this function so some + * applications may wish to modify it to avoid allocating a large strm->input + * buffer and copying from it. (See also flush_pending()). + */ +function read_buf(strm, buf, start, size) { + var len = strm.avail_in; + + if (len > size) { len = size; } + if (len === 0) { return 0; } + + strm.avail_in -= len; + + // zmemcpy(buf, strm->next_in, len); + utils.arraySet(buf, strm.input, strm.next_in, len, start); + if (strm.state.wrap === 1) { + strm.adler = adler32(strm.adler, buf, len, start); + } + + else if (strm.state.wrap === 2) { + strm.adler = crc32(strm.adler, buf, len, start); + } + + strm.next_in += len; + strm.total_in += len; + + return len; +} + + +/* + * =========================================================================== + * Set match_start to the longest match starting at the given string and return + * its length. Matches shorter or equal to prev_length are discarded, in which + * case the result is equal to prev_length and match_start is garbage. IN + * assertions: cur_match is the head of the hash chain for the current string + * (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 OUT + * assertion: the match length is not greater than s->lookahead. + */ +function longest_match(s, cur_match) { + var chain_length = s.max_chain_length; /* max hash chain length */ + var scan = s.strstart; /* current string */ + var match; /* matched string */ + var len; /* length of current match */ + var best_len = s.prev_length; /* best match length so far */ + var nice_match = s.nice_match; /* stop if match long enough */ + var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ? + s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/* NIL */; + + var _win = s.window; // shortcut + + var wmask = s.w_mask; + var prev = s.prev; + + /* + * Stop when cur_match becomes <= limit. To simplify the code, we prevent + * matches with the string of window index 0. + */ + + var strend = s.strstart + MAX_MATCH; + var scan_end1 = _win[scan + best_len - 1]; + var scan_end = _win[scan + best_len]; + + /* + * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + /* + * Do not look for matches beyond the end of the input. This is necessary to + * make deflate deterministic. + */ + if (nice_match > s.lookahead) { nice_match = s.lookahead; } + + // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need + // lookahead"); + + do { + // Assert(cur_match < s->strstart, "no future"); + match = cur_match; + + /* + * Skip to next match if the match length cannot increase or if the match + * length is less than 2. Note that the checks below for insufficient + * lookahead only occur occasionally for performance reasons. Therefore + * uninitialized memory will be accessed, and conditional jumps will be made + * that depend on those values. However the length of the match is limited + * to the lookahead, so the output of deflate is not affected by the + * uninitialized values. + */ + + if (_win[match + best_len] !== scan_end || + _win[match + best_len - 1] !== scan_end1 || + _win[match] !== _win[scan] || + _win[++match] !== _win[scan + 1]) { + continue; + } + + /* + * The check at best_len-1 can be removed because it will be made again + * later. (This heuristic is not always a win.) It is not necessary to + * compare scan[2] and match[2] since they are always equal when the other + * bytes match, given that the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2; + match++; + // Assert(*scan == *match, "match[2]?"); + + /* + * We check for insufficient lookahead only every 8th comparison; the 256th + * check will be made at strstart+258. + */ + do { + /* jshint noempty:false */ + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + scan < strend); + + // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + + if (len > best_len) { + s.match_start = cur_match; + best_len = len; + if (len >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; +} + + +/* + * =========================================================================== + * Fill the window when the lookahead becomes insufficient. Updates strstart and + * lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD OUT assertions: strstart <= + * window_size-MIN_LOOKAHEAD At least one byte has been read, or avail_in == 0; + * reads are performed for at least two bytes (required for the zip + * translate_eol option -- not supported here). + */ +function fill_window(s) { + var _w_size = s.w_size; + var p, n, m, more, str; + + // Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = s.window_size - s.lookahead - s.strstart; + + // JS ints have 32 bit, block below not needed + /* Deal with !@#$% 64K limit: */ + // if (sizeof(int) <= 2) { + // if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + // more = wsize; + // + // } else if (more == (unsigned)(-1)) { + // /* Very unlikely, but possible on 16 bit machine if + // * strstart == 0 && lookahead == 1 (input done a byte at time) + // */ + // more--; + // } + // } + + + /* + * If the window is almost full and there is insufficient lookahead, move + * the upper half to the lower one to make room in the upper half. + */ + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + + utils.arraySet(s.window, s.window, _w_size, _w_size, 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + /* we now have strstart >= MAX_DIST */ + s.block_start -= _w_size; + + /* + * Slide the hash table (could be avoided with 32 bit values at the + * expense of memory usage). We slide even when level == 0 to keep the + * hash table consistent if we switch back to level > 0 later. (Using + * level 0 permanently is not an optimal usage of zlib, so we don't care + * about this pathological case.) + */ + + n = s.hash_size; + p = n; + do { + m = s.head[--p]; + s.head[p] = (m >= _w_size ? m - _w_size : 0); + } while (--n); + + n = _w_size; + p = n; + do { + m = s.prev[--p]; + s.prev[p] = (m >= _w_size ? m - _w_size : 0); + /* + * If n is not on any hash chain, prev[n] is garbage but its value will + * never be used. + */ + } while (--n); + + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + + /* + * If there was no sliding: strstart <= WSIZE+MAX_DIST-1 && lookahead <= + * MIN_LOOKAHEAD - 1 && more == window_size - lookahead - strstart => more >= + * window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) => more >= + * window_size - 2*WSIZE + 2 In the BIG_MEM or MMAP case (not yet + * supported), window_size == input_size + MIN_LOOKAHEAD && strstart + + * s->lookahead <= input_size => more >= MIN_LOOKAHEAD. Otherwise, + * window_size == 2*WSIZE so more >= 2. If there was sliding, more >= WSIZE. + * So in all cases, more >= 2. + */ + // Assert(more >= 2, "more < 2"); + n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + + /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask; +// #if MIN_MATCH != 3 +// Call update_hash() MIN_MATCH-3 more times +// #endif + while (s.insert) { + /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + /* + * If the whole input has less than MIN_MATCH bytes, ins_h is garbage, but + * this is not important since only literal bytes will be emitted. + */ + + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + + /* + * If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by the + * longest match routines. Update the high water mark for the next time + * through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ +// if (s.high_water < s.window_size) { +// var curr = s.strstart + s.lookahead; +// var init = 0; +// +// if (s.high_water < curr) { +// /* Previous high water mark below current data -- zero WIN_INIT +// * bytes or up to end of window, whichever is less. +// */ +// init = s.window_size - curr; +// if (init > WIN_INIT) +// init = WIN_INIT; +// zmemzero(s->window + curr, (unsigned)init); +// s->high_water = curr + init; +// } +// else if (s->high_water < (ulg)curr + WIN_INIT) { +// /* High water mark at or above current data, but below current data +// * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up +// * to end of window, whichever is less. +// */ +// init = (ulg)curr + WIN_INIT - s->high_water; +// if (init > s->window_size - s->high_water) +// init = s->window_size - s->high_water; +// zmemzero(s->window + s->high_water, (unsigned)init); +// s->high_water += init; +// } +// } +// +// Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, +// "not enough room for search"); +} + +/* + * =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. This function does not insert new strings in the + * dictionary since uncompressible data is probably not useful. This function is + * used only for the level=0 compression option. NOTE: this function should be + * optimized to avoid extra copying from window to pending_buf. + */ +function deflate_stored(s, flush) { + /* + * Stored blocks are limited to 0xffff bytes, pending_buf is limited to + * pending_buf_size, and each stored block has a 5 byte header: + */ + var max_block_size = 0xffff; + + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s.lookahead <= 1) { + + // Assert(s->strstart < s->w_size+MAX_DIST(s) || + // s->block_start >= (long)s->w_size, "slide too late"); +// if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) || +// s.block_start >= s.w_size)) { +// throw new Error("slide too late"); +// } + + fill_window(s); + if (s.lookahead === 0 && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + + if (s.lookahead === 0) { + break; + } + /* flush the current block */ + } + // Assert(s->block_start >= 0L, "block gone"); +// if (s.block_start < 0) throw new Error("block gone"); + + s.strstart += s.lookahead; + s.lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + var max_start = s.block_start + max_block_size; + + if (s.strstart === 0 || s.strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + + + } + /* + * Flush if we may have to slide, otherwise block_start may become negative + * and the data will be gone: + */ + if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + + s.insert = 0; + + if (flush === Z_FINISH) { + /** * FLUSH_BLOCK(s, 1); ** */ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + + if (s.strstart > s.block_start) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_NEED_MORE; +} + +/* + * =========================================================================== + * Compress as much as possible from the input stream, return the current block + * state. This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +function deflate_fast(s, flush) { + var hash_head; /* head of the hash chain */ + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* + * Make sure that we always have enough lookahead, except at the end of the + * input file. We need MAX_MATCH bytes for the next match, plus MIN_MATCH + * bytes to insert the string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; /* flush the current block */ + } + } + + /* + * Insert the string window[strstart .. strstart+2] in the dictionary, and + * set hash_head to the head of the hash chain: + */ + hash_head = 0/* NIL */; + if (s.lookahead >= MIN_MATCH) { + /** * INSERT_STRING(s, s.strstart, hash_head); ** */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* + * Find the longest match, discarding those <= prev_length. At this point we + * have always match_length < MIN_MATCH + */ + if (hash_head !== 0/* NIL */ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) { + /* + * To simplify the code, we prevent matches with the string of window + * index 0 (in particular we have to avoid a match of the string with + * itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + } + if (s.match_length >= MIN_MATCH) { + // check_match(s, s.strstart, s.match_start, s.match_length); // for + // debug only + + /*********************************************************************** + * * _tr_tally_dist(s, s.strstart - s.match_start, s.match_length - + * MIN_MATCH, bflush); + **********************************************************************/ + bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + + /* + * Insert new strings in the hash table only if the match length is not + * too large. This saves time but degrades compression. + */ + if (s.match_length <= s.max_lazy_match/* max_insert_length */ && s.lookahead >= MIN_MATCH) { + s.match_length--; /* string at strstart already in table */ + do { + s.strstart++; + /** * INSERT_STRING(s, s.strstart, hash_head); ** */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + /* + * strstart never exceeds WSIZE-MAX_MATCH, so there are always + * MIN_MATCH bytes ahead. + */ + } while (--s.match_length !== 0); + s.strstart++; + } else + { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask; + +// #if MIN_MATCH != 3 +// Call UPDATE_HASH() MIN_MATCH-3 more times +// #endif + /* + * If lookahead < MIN_MATCH, ins_h is garbage, but it does not matter + * since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + // Tracevv((stderr,"%c", s.window[s.strstart])); + /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1); + if (flush === Z_FINISH) { + /** * FLUSH_BLOCK(s, 1); ** */ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* + * =========================================================================== + * Same as above, but achieves better compression. We use a lazy evaluation for + * matches: a match is finally adopted only if there is no better match at the + * next window position. + */ +function deflate_slow(s, flush) { + var hash_head; /* head of hash chain */ + var bflush; /* set if current block must be flushed */ + + var max_insert; + + /* Process the input block. */ + for (;;) { + /* + * Make sure that we always have enough lookahead, except at the end of the + * input file. We need MAX_MATCH bytes for the next match, plus MIN_MATCH + * bytes to insert the string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* + * Insert the string window[strstart .. strstart+2] in the dictionary, and + * set hash_head to the head of the hash chain: + */ + hash_head = 0/* NIL */; + if (s.lookahead >= MIN_MATCH) { + /** * INSERT_STRING(s, s.strstart, hash_head); ** */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* + * Find the longest match, discarding those <= prev_length. + */ + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH - 1; + + if (hash_head !== 0/* NIL */ && s.prev_length < s.max_lazy_match && + s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/* MAX_DIST(s) */) { + /* + * To simplify the code, we prevent matches with the string of window + * index 0 (in particular we have to avoid a match of the string with + * itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + + if (s.match_length <= 5 && + (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/* TOO_FAR */))) { + + /* + * If prev_match is also MIN_MATCH, match_start is garbage but we will + * ignore the current match anyway. + */ + s.match_length = MIN_MATCH - 1; + } + } + /* + * If there was a match at the previous step and the current match is not + * better, output the previous match: + */ + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + // check_match(s, s.strstart-1, s.prev_match, s.prev_length); + + /*********************************************************************** + * *_tr_tally_dist(s, s.strstart - 1 - s.prev_match, s.prev_length - + * MIN_MATCH, bflush); + **********************************************************************/ + bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); + /* + * Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not enough + * lookahead, the last two strings are not inserted in the hash table. + */ + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + /** * INSERT_STRING(s, s.strstart, hash_head); ** */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH - 1; + s.strstart++; + + if (bflush) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + } else if (s.match_available) { + /* + * If there was no match at the previous position, output a single + * literal. If there was a match but the current match is longer, + * truncate the previous match to a single literal. + */ + // Tracevv((stderr,"%c", s->window[s->strstart-1])); + /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */ + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + + if (bflush) { + /** * FLUSH_BLOCK_ONLY(s, 0) ** */ + flush_block_only(s, false); + /***/ + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + /* + * There is no previous match to compare with, wait for the next step to + * decide. + */ + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + // Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s.match_available) { + // Tracevv((stderr,"%c", s->window[s->strstart-1])); + /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */ + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH) { + /** * FLUSH_BLOCK(s, 1); ** */ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_BLOCK_DONE; +} + + +/* + * =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +function deflate_rle(s, flush) { + var bflush; /* set if current block must be flushed */ + var prev; /* byte at distance one to match */ + var scan, strend; /* scan goes up to strend for length of run */ + + var _win = s.window; + + for (;;) { + /* + * Make sure that we always have enough lookahead, except at the end of the + * input file. We need MAX_MATCH bytes for the longest run, plus one for the + * unrolled loop. + */ + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* See how many times the previous byte repeats */ + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + /* jshint noempty:false */ + } while (prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + // Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ + if (s.match_length >= MIN_MATCH) { + // check_match(s, s.strstart, s.strstart - 1, s.match_length); + + /** * _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ** */ + bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + /* No match, output a literal byte */ + // Tracevv((stderr,"%c", s->window[s->strstart])); + /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /** * FLUSH_BLOCK(s, 1); ** */ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* + * =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +function deflate_huff(s, flush) { + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we have a literal to write. */ + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + break; /* flush the current block */ + } + } + + /* Output a literal byte */ + s.match_length = 0; + // Tracevv((stderr,"%c", s->window[s->strstart])); + /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /** * FLUSH_BLOCK(s, 1); ** */ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /** * FLUSH_BLOCK(s, 0); ** */ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* + * Values for max_lazy_match, good_match and max_chain_length, depending on the + * desired pack level (0..9). The values given below have been tuned to exclude + * worst case performance for pathological files. Better values may be found for + * specific files. + */ +function Config(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; +} + +var configuration_table; + +configuration_table = [ + /* good lazy nice chain */ + new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */ + new Config(4, 4, 8, 4, deflate_fast), /* + * 1 max speed, no lazy + * matches + */ + new Config(4, 5, 16, 8, deflate_fast), /* 2 */ + new Config(4, 6, 32, 32, deflate_fast), /* 3 */ + + new Config(4, 4, 16, 16, deflate_slow), /* 4 lazy matches */ + new Config(8, 16, 32, 32, deflate_slow), /* 5 */ + new Config(8, 16, 128, 128, deflate_slow), /* 6 */ + new Config(8, 32, 128, 256, deflate_slow), /* 7 */ + new Config(32, 128, 258, 1024, deflate_slow), /* 8 */ + new Config(32, 258, 258, 4096, deflate_slow) /* 9 max compression */ +]; + + +/* + * =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +function lm_init(s) { + s.window_size = 2 * s.w_size; + + /** * CLEAR_HASH(s); ** */ + zero(s.head); // Fill with NIL (= 0); + + /* + * Set the default configuration parameters: + */ + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; +} + + +function DeflateState() { + this.strm = null; /* pointer back to this zlib stream */ + this.status = 0; /* as the name implies */ + this.pending_buf = null; /* output still pending */ + this.pending_buf_size = 0; /* size of pending_buf */ + this.pending_out = 0; /* next pending byte to output to the stream */ + this.pending = 0; /* nb of bytes in the pending buffer */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.gzhead = null; /* gzip header information to write */ + this.gzindex = 0; /* where in extra, name, or comment */ + this.method = Z_DEFLATED; /* can only be DEFLATED */ + this.last_flush = -1; /* value of flush param for previous deflate call */ + + this.w_size = 0; /* LZ77 window size (32K by default) */ + this.w_bits = 0; /* log2(w_size) (8..16) */ + this.w_mask = 0; /* w_size - 1 */ + + this.window = null; + /* + * Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always performed with + * a length multiple of the block size. + */ + + this.window_size = 0; + /* + * Actual size of window: 2*wSize, except when the user input buffer is + * directly used as sliding window. + */ + + this.prev = null; + /* + * Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. An + * index in this array is thus a window index modulo 32K. + */ + + this.head = null; /* Heads of the hash chains or NIL. */ + + this.ins_h = 0; /* hash index of string to be inserted */ + this.hash_size = 0; /* number of elements in hash table */ + this.hash_bits = 0; /* log2(hash_size) */ + this.hash_mask = 0; /* hash_size-1 */ + + this.hash_shift = 0; + /* + * Number of bits by which ins_h must be shifted at each input step. It must + * be such that after MIN_MATCH steps, the oldest byte no longer takes part + * in the hash key, that is: hash_shift * MIN_MATCH >= hash_bits + */ + + this.block_start = 0; + /* + * Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + this.match_length = 0; /* length of best match */ + this.prev_match = 0; /* previous match */ + this.match_available = 0; /* set if previous match exists */ + this.strstart = 0; /* start of string to insert */ + this.match_start = 0; /* start of matching string */ + this.lookahead = 0; /* number of valid bytes ahead in window */ + + this.prev_length = 0; + /* + * Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + this.max_chain_length = 0; + /* + * To speed up deflation, hash chains are never searched beyond this length. + * A higher limit improves compression ratio but degrades the speed. + */ + + this.max_lazy_match = 0; + /* + * Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ + // That's alias to max_lazy_match, don't use directly + // this.max_insert_length = 0; + /* + * Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + this.level = 0; /* compression level (1..9) */ + this.strategy = 0; /* favor or force Huffman coding */ + + this.good_match = 0; + /* Use a faster search when the previous match is longer than this */ + + this.nice_match = 0; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + + /* Didn't use ct_data typedef below to suppress compiler warning */ + + // struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + // struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths + // */ + + // Use flat array of DOUBLE size, with interleaved fata, + // because JS does not support effective + this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); + this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2); + this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + + this.l_desc = null; /* desc. for literal tree */ + this.d_desc = null; /* desc. for distance tree */ + this.bl_desc = null; /* desc. for bit length tree */ + + // ush bl_count[MAX_BITS+1]; + this.bl_count = new utils.Buf16(MAX_BITS + 1); + /* number of codes at each bit length for an optimal tree */ + + // int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + this.heap = new utils.Buf16(2 * L_CODES + 1); /* + * heap used to build the + * Huffman trees + */ + zero(this.heap); + + this.heap_len = 0; /* number of elements in the heap */ + this.heap_max = 0; /* element of largest frequency */ + /* + * The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + this.depth = new utils.Buf16(2 * L_CODES + 1); // uch depth[2*L_CODES+1]; + zero(this.depth); + /* + * Depth of each subtree used as tie breaker for trees of equal frequency + */ + + this.l_buf = 0; /* buffer index for literals or lengths */ + + this.lit_bufsize = 0; + /* + * Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: - frequencies can be kept in 16 bit counters - + * if compression is not successful for the first block, all input data is + * still in the window so we can still emit a stored block even when input + * comes from standard input. (This can also be done for all blocks if + * lit_bufsize is not greater than 32K.) - if compression is not successful + * for a file smaller than 64K, we can even emit a stored file instead of a + * stored block (saving 5 bytes). This is applicable only for zip (not gzip + * or zlib). - creating new Huffman trees less frequently may not provide + * fast adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by a highly + * compressible string table.) Smaller buffer sizes give fast adaptation but + * have of course the overhead of transmitting trees more frequently. - I + * can't count above 4 + */ + + this.last_lit = 0; /* running index in l_buf */ + + this.d_buf = 0; + /* + * Buffer index for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + this.opt_len = 0; /* bit length of current block with optimal trees */ + this.static_len = 0; /* bit length of current block with static trees */ + this.matches = 0; /* number of string matches in current block */ + this.insert = 0; /* bytes at end of window left to insert */ + + + this.bi_buf = 0; + /* + * Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + this.bi_valid = 0; + /* + * Number of valid bits in bi_buf. All bits above the last valid bit are + * always zero. + */ + + // Used for window memory init. We safely ignore it for JS. That makes + // sense only for pointers and memory check tools. + // this.high_water = 0; + /* + * High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when longest + * match routines access bytes past the input. This is then updated to the + * new high water mark. + */ +} + + +function deflateResetKeep(strm) { + var s; + + if (!strm || !strm.state) { + return err(strm, Z_STREAM_ERROR); + } + + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + + s = strm.state; + s.pending = 0; + s.pending_out = 0; + + if (s.wrap < 0) { + s.wrap = -s.wrap; + /* was made negative by deflate(..., Z_FINISH); */ + } + s.status = (s.wrap ? INIT_STATE : BUSY_STATE); + strm.adler = (s.wrap === 2) ? + 0 // crc32(0, Z_NULL, 0) + : + 1; // adler32(0, Z_NULL, 0) + s.last_flush = Z_NO_FLUSH; + trees._tr_init(s); + return Z_OK; +} + + +function deflateReset(strm) { + var ret = deflateResetKeep(strm); + if (ret === Z_OK) { + lm_init(strm.state); + } + return ret; +} + + +function deflateSetHeader(strm, head) { + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; } + strm.state.gzhead = head; + return Z_OK; +} + + +function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { + if (!strm) { // === Z_NULL + return Z_STREAM_ERROR; + } + var wrap = 1; + + if (level === Z_DEFAULT_COMPRESSION) { + level = 6; + } + + if (windowBits < 0) { /* suppress zlib wrapper */ + wrap = 0; + windowBits = -windowBits; + } + + else if (windowBits > 15) { + wrap = 2; /* write gzip wrapper instead */ + windowBits -= 16; + } + + + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) { + return err(strm, Z_STREAM_ERROR); + } + + + if (windowBits === 8) { + windowBits = 9; + } + /* until 256-byte window bug fixed */ + + var s = new DeflateState(); + + strm.state = s; + s.strm = strm; + + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + + s.window = new utils.Buf8(s.w_size * 2); + s.head = new utils.Buf16(s.hash_size); + s.prev = new utils.Buf16(s.w_size); + + // Don't need mem init magic for JS. + // s.high_water = 0; /* nothing written to s->window yet */ + + s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + s.pending_buf_size = s.lit_bufsize * 4; + + // overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); + // s->pending_buf = (uchf *) overlay; + s.pending_buf = new utils.Buf8(s.pending_buf_size); + + // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`) + // s->d_buf = overlay + s->lit_bufsize/sizeof(ush); + s.d_buf = 1 * s.lit_bufsize; + + // s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + s.l_buf = (1 + 2) * s.lit_bufsize; + + s.level = level; + s.strategy = strategy; + s.method = method; + + return deflateReset(strm); +} + +function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); +} + + +function deflate(strm, flush) { + var old_flush, s; + var beg, val; // for gzip header write only + + if (!strm || !strm.state || + flush > Z_BLOCK || flush < 0) { + return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; + } + + s = strm.state; + + if (!strm.output || + (!strm.input && strm.avail_in !== 0) || + (s.status === FINISH_STATE && flush !== Z_FINISH)) { + return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR); + } + + s.strm = strm; /* just in case */ + old_flush = s.last_flush; + s.last_flush = flush; + + /* Write the header */ + if (s.status === INIT_STATE) { + + if (s.wrap === 2) { // GZIP header + strm.adler = 0; // crc32(0L, Z_NULL, 0); + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { // s->gzhead == Z_NULL + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + } + else { + put_byte(s, (s.gzhead.text ? 1 : 0) + + (s.gzhead.hcrc ? 2 : 0) + + (!s.gzhead.extra ? 0 : 4) + + (!s.gzhead.name ? 0 : 8) + + (!s.gzhead.comment ? 0 : 16) + ); + put_byte(s, s.gzhead.time & 0xff); + put_byte(s, (s.gzhead.time >> 8) & 0xff); + put_byte(s, (s.gzhead.time >> 16) & 0xff); + put_byte(s, (s.gzhead.time >> 24) & 0xff); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, s.gzhead.os & 0xff); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 0xff); + put_byte(s, (s.gzhead.extra.length >> 8) & 0xff); + } + if (s.gzhead.hcrc) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } + else // DEFLATE header + { + var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8; + var level_flags = -1; + + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= (level_flags << 6); + if (s.strstart !== 0) { header |= PRESET_DICT; } + header += 31 - (header % 31); + + s.status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + strm.adler = 1; // adler32(0L, Z_NULL, 0); + } + } + +// #ifdef GZIP + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra/* != Z_NULL */) { + beg = s.pending; /* start of bytes to update crc */ + + while (s.gzindex < (s.gzhead.extra.length & 0xffff)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte(s, s.gzhead.extra[s.gzindex] & 0xff); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE; + } + } + else { + s.status = NAME_STATE; + } + } + if (s.status === NAME_STATE) { + if (s.gzhead.name/* != Z_NULL */) { + beg = s.pending; /* start of bytes to update crc */ + // int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE; + } + } + else { + s.status = COMMENT_STATE; + } + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment/* != Z_NULL */) { + beg = s.pending; /* start of bytes to update crc */ + // int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE; + } + } + else { + s.status = HCRC_STATE; + } + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + strm.adler = 0; // crc32(0L, Z_NULL, 0); + s.status = BUSY_STATE; + } + } + else { + s.status = BUSY_STATE; + } + } +// #endif + + /* Flush as much pending output as possible */ + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + /* + * Since avail_out is 0, deflate will be called again with more output + * space, but possibly with both pending and avail_in equal to zero. + * There won't be anything to do, but this is not an error situation so + * make sure we return OK instead of BUF_ERROR at next call of deflate: + */ + s.last_flush = -1; + return Z_OK; + } + + /* + * Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep returning + * Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && + flush !== Z_FINISH) { + return err(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR); + } + + /* + * Start a new block or continue the current one. + */ + if (strm.avail_in !== 0 || s.lookahead !== 0 || + (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) { + var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) : + (s.strategy === Z_RLE ? deflate_rle(s, flush) : + configuration_table[s.level].func(s, flush)); + + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* + * If flush != Z_NO_FLUSH && avail_out == 0, the next call of deflate + * should use the same flush parameter to make sure that the flush is + * complete. So we don't have to output an empty block here, this will + * be done at next call. This also ensures that for a very small output + * buffer, we emit at most one empty block. + */ + } + if (bstate === BS_BLOCK_DONE) { + if (flush === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } + else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + + trees._tr_stored_block(s, 0, 0, false); + /* + * For a full flush, this empty block will be recognized as a special + * marker by inflate_sync(). + */ + if (flush === Z_FULL_FLUSH) { + /** * CLEAR_HASH(s); ** */ /* forget history */ + zero(s.head); // Fill with NIL (= 0); + + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + // Assert(strm->avail_out > 0, "bug2"); + // if (strm.avail_out <= 0) { throw new Error("bug2");} + + if (flush !== Z_FINISH) { return Z_OK; } + if (s.wrap <= 0) { return Z_STREAM_END; } + + /* Write the trailer */ + if (s.wrap === 2) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + put_byte(s, (strm.adler >> 16) & 0xff); + put_byte(s, (strm.adler >> 24) & 0xff); + put_byte(s, strm.total_in & 0xff); + put_byte(s, (strm.total_in >> 8) & 0xff); + put_byte(s, (strm.total_in >> 16) & 0xff); + put_byte(s, (strm.total_in >> 24) & 0xff); + } + else + { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + + flush_pending(strm); + /* + * If avail_out is zero, the application will call deflate again to flush + * the rest. + */ + if (s.wrap > 0) { s.wrap = -s.wrap; } + /* write the trailer only once! */ + return s.pending !== 0 ? Z_OK : Z_STREAM_END; +} + +function deflateEnd(strm) { + var status; + + if (!strm/* == Z_NULL */ || !strm.state/* == Z_NULL */) { + return Z_STREAM_ERROR; + } + + status = strm.state.status; + if (status !== INIT_STATE && + status !== EXTRA_STATE && + status !== NAME_STATE && + status !== COMMENT_STATE && + status !== HCRC_STATE && + status !== BUSY_STATE && + status !== FINISH_STATE + ) { + return err(strm, Z_STREAM_ERROR); + } + + strm.state = null; + + return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; +} + + +/* + * ========================================================================= + * Initializes the compression dictionary from the given byte sequence without + * producing any compressed output. + */ +function deflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + + var s; + var str, n; + var wrap; + var avail; + var next; + var input; + var tmpDict; + + if (!strm/* == Z_NULL */ || !strm.state/* == Z_NULL */) { + return Z_STREAM_ERROR; + } + + s = strm.state; + wrap = s.wrap; + + if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) { + return Z_STREAM_ERROR; + } + + /* when using zlib wrappers, compute Adler-32 for provided dictionary */ + if (wrap === 1) { + /* adler32(strm->adler, dictionary, dictLength); */ + strm.adler = adler32(strm.adler, dictionary, dictLength, 0); + } + + s.wrap = 0; /* avoid computing Adler-32 in read_buf */ + + /* if dictionary would fill window, just replace the history */ + if (dictLength >= s.w_size) { + if (wrap === 0) { /* already empty otherwise */ + /** * CLEAR_HASH(s); ** */ + zero(s.head); // Fill with NIL (= 0); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + /* use the tail */ + // dictionary = dictionary.slice(dictLength - s.w_size); + tmpDict = new utils.Buf8(s.w_size); + utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + /* insert dictionary into window and hash */ + avail = strm.avail_in; + next = strm.next_in; + input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window(s); + while (s.lookahead >= MIN_MATCH) { + str = s.strstart; + n = s.lookahead - (MIN_MATCH - 1); + do { + /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + + s.prev[str & s.w_mask] = s.head[s.ins_h]; + + s.head[s.ins_h] = str; + str++; + } while (--n); + s.strstart = str; + s.lookahead = MIN_MATCH - 1; + fill_window(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK; +} + + +exports.deflateInit = deflateInit; +exports.deflateInit2 = deflateInit2; +exports.deflateReset = deflateReset; +exports.deflateResetKeep = deflateResetKeep; +exports.deflateSetHeader = deflateSetHeader; +exports.deflate = deflate; +exports.deflateEnd = deflateEnd; +exports.deflateSetDictionary = deflateSetDictionary; +exports.deflateInfo = 'pako deflate (from Nodeca project)'; + +/* + * Not implemented exports.deflateBound = deflateBound; exports.deflateCopy = + * deflateCopy; exports.deflateParams = deflateParams; exports.deflatePending = + * deflatePending; exports.deflatePrime = deflatePrime; exports.deflateTune = + * deflateTune; + */ + +},{"../utils/common":3,"./adler32":4,"./crc32":6,"./messages":11,"./trees":12}],8:[function(require,module,exports){ +'use strict'; + +// See state defs from inflate.js +var BAD = 30; /* got a data error -- remain here until reset */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ + +/* + * Decode literal, length, and distance codes and write out the resulting + * literal and match bytes until either not enough input or output is available, + * an end-of-block is encountered, or a data error is encountered. When large + * enough input and output buffers are supplied to inflate(), for example, a 16K + * input buffer and a 64K output buffer, more than 95% of the inflate execution + * time is spent in this routine. + * + * Entry assumptions: + * + * state.mode === LEN strm.avail_in >= 6 strm.avail_out >= 258 start >= + * strm.avail_out state.bits < 8 + * + * On return, state.mode is one of: + * + * LEN -- ran out of enough output space or enough available input TYPE -- + * reached end of block code, inflate() to interpret next block BAD -- error in + * block data + * + * Notes: + * - The maximum input bits used by a length/distance pair is 15 bits for the + * length code, 5 bits for the length extra, 15 bits for the distance code, and + * 13 bits for the distance extra. This totals 48 bits, or six bytes. Therefore + * if strm.avail_in >= 6, then there is enough input to avoid checking for + * available input while decoding. + * - The maximum bytes that a single length/distance pair can output is 258 + * bytes, which is the maximum length that can be coded. inflate_fast() requires + * strm.avail_out >= 258 for each loop to avoid checking for output space. + */ +module.exports = function inflate_fast(strm, start) { + var state; + var _in; /* local strm.input */ + var last; /* have enough input while in < last */ + var _out; /* local strm.output */ + var beg; /* inflate()'s initial strm.output */ + var end; /* while out < end, enough space available */ +// #ifdef INFLATE_STRICT + var dmax; /* maximum distance from zlib header */ +// #endif + var wsize; /* window size or zero if not using window */ + var whave; /* valid bytes in the window */ + var wnext; /* window write index */ + // Use `s_window` instead `window`, avoid conflict with instrumentation + // tools + var s_window; /* allocated sliding window, if wsize != 0 */ + var hold; /* local strm.hold */ + var bits; /* local strm.bits */ + var lcode; /* local strm.lencode */ + var dcode; /* local strm.distcode */ + var lmask; /* mask for first level of length codes */ + var dmask; /* mask for first level of distance codes */ + var here; /* retrieved table entry */ + var op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + var len; /* match length, unused bytes */ + var dist; /* match distance */ + var from; /* where to copy match from */ + var from_source; + + + var input, output; // JS specific, because we have no pointers + + /* copy state to local variables */ + state = strm.state; + // here = state.here; + _in = strm.next_in; + input = strm.input; + last = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); +// #ifdef INFLATE_STRICT + dmax = state.dmax; +// #endif + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + + + /* + * decode literals and length/distances until end-of-block or not enough + * input data or output space + */ + + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + + here = lcode[hold & lmask]; + + dolen: + for (;;) { // Goto emulation + op = here >>> 24/* here.bits */; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/* here.op */; + if (op === 0) { /* literal */ + // Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + output[_out++] = here & 0xffff/* here.val */; + } + else if (op & 16) { /* length base */ + len = here & 0xffff/* here.val */; + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len += hold & ((1 << op) - 1); + hold >>>= op; + bits -= op; + } + // Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + + dodist: + for (;;) { // goto emulation + op = here >>> 24/* here.bits */; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/* here.op */; + + if (op & 16) { /* distance base */ + dist = here & 0xffff/* here.val */; + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & ((1 << op) - 1); +// #ifdef INFLATE_STRICT + if (dist > dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } +// #endif + hold >>>= op; + bits -= op; + // Tracevv((stderr, "inflate: distance %u\n", dist)); + op = _out - beg; /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } + +// (!) This block is disabled in zlib defailts, +// don't enable it for binary compatibility +// #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// if (len <= op - whave) { +// do { +// output[_out++] = 0; +// } while (--len); +// continue top; +// } +// len -= op - whave; +// do { +// output[_out++] = 0; +// } while (--op > whave); +// if (op === 0) { +// from = _out - dist; +// do { +// output[_out++] = output[from++]; +// } while (--len); +// continue top; +// } +// #endif + } + from = 0; // window index + from_source = s_window; + if (wnext === 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + else if (wnext < op) { /* wrap around window */ + from += wsize + wnext - op; + op -= wnext; + if (op < len) { /* some from end of window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + } + else { /* contiguous in window */ + from += wnext - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + while (len > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len -= 3; + } + if (len) { + output[_out++] = from_source[from++]; + if (len > 1) { + output[_out++] = from_source[from++]; + } + } + } + else { + from = _out - dist; /* copy direct from output */ + do { /* minimum length is three */ + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len -= 3; + } while (len > 2); + if (len) { + output[_out++] = output[from++]; + if (len > 1) { + output[_out++] = output[from++]; + } + } + } + } + else if ((op & 64) === 0) { /* 2nd level distance code */ + here = dcode[(here & 0xffff)/* here.val */ + (hold & ((1 << op) - 1))]; + continue dodist; + } + else { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } + else if ((op & 64) === 0) { /* 2nd level length code */ + here = lcode[(here & 0xffff)/* here.val */ + (hold & ((1 << op) - 1))]; + continue dolen; + } + else if (op & 32) { /* end-of-block */ + // Tracevv((stderr, "inflate: end of block\n")); + state.mode = TYPE; + break top; + } + else { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } while (_in < last && _out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + _in -= len; + bits -= len << 3; + hold &= (1 << bits) - 1; + + /* update state and return */ + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last)); + strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end)); + state.hold = hold; + state.bits = bits; + return; +}; + +},{}],9:[function(require,module,exports){ +'use strict'; + + +var utils = require('../utils/common'); +var adler32 = require('./adler32'); +var crc32 = require('./crc32'); +var inflate_fast = require('./inffast'); +var inflate_table = require('./inftrees'); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +/* Public constants ========================================================== */ +/* =========================================================================== */ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +// var Z_NO_FLUSH = 0; +// var Z_PARTIAL_FLUSH = 1; +// var Z_SYNC_FLUSH = 2; +// var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +var Z_TREES = 6; + + +/* + * Return codes for the compression/decompression functions. Negative values are + * errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +var Z_NEED_DICT = 2; +// var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +// var Z_VERSION_ERROR = -6; + +/* The deflate compression method */ +var Z_DEFLATED = 8; + + +/* STATES ==================================================================== */ +/* =========================================================================== */ + + +var HEAD = 1; /* i: waiting for magic header */ +var FLAGS = 2; /* i: waiting for method and flags (gzip) */ +var TIME = 3; /* i: waiting for modification time (gzip) */ +var OS = 4; /* + * i: waiting for extra flags and operating system + * (gzip) + */ +var EXLEN = 5; /* i: waiting for extra length (gzip) */ +var EXTRA = 6; /* i: waiting for extra bytes (gzip) */ +var NAME = 7; /* i: waiting for end of file name (gzip) */ +var COMMENT = 8; /* i: waiting for end of comment (gzip) */ +var HCRC = 9; /* i: waiting for header crc (gzip) */ +var DICTID = 10; /* i: waiting for dictionary check value */ +var DICT = 11; /* waiting for inflateSetDictionary() call */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ +var TYPEDO = 13; /* + * i: same, but skip check to exit inflate on new + * block + */ +var STORED = 14; /* + * i: waiting for stored size (length and + * complement) + */ +var COPY_ = 15; /* i/o: same as COPY below, but only first time in */ +var COPY = 16; /* + * i/o: waiting for input or output to copy stored + * block + */ +var TABLE = 17; /* i: waiting for dynamic block table lengths */ +var LENLENS = 18; /* i: waiting for code length code lengths */ +var CODELENS = 19; /* + * i: waiting for length/lit and distance code + * lengths + */ +var LEN_ = 20; /* i: same as LEN below, but only first time in */ +var LEN = 21; /* i: waiting for length/lit/eob code */ +var LENEXT = 22; /* i: waiting for length extra bits */ +var DIST = 23; /* i: waiting for distance code */ +var DISTEXT = 24; /* i: waiting for distance extra bits */ +var MATCH = 25; /* o: waiting for output space to copy string */ +var LIT = 26; /* o: waiting for output space to write literal */ +var CHECK = 27; /* i: waiting for 32-bit check value */ +var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */ +var DONE = 29; /* finished check, done -- remain here until reset */ +var BAD = 30; /* got a data error -- remain here until reset */ +var MEM = 31; /* + * got an inflate() memory error -- remain here until + * reset + */ +var SYNC = 32; /* + * looking for synchronization bytes to restart + * inflate() + */ + +/* =========================================================================== */ + + + +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +// var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_WBITS = MAX_WBITS; + + +function zswap32(q) { + return (((q >>> 24) & 0xff) + + ((q >>> 8) & 0xff00) + + ((q & 0xff00) << 8) + + ((q & 0xff) << 24)); +} + + +function InflateState() { + this.mode = 0; /* current inflate mode */ + this.last = false; /* true if processing last block */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.havedict = false; /* true if dictionary provided */ + this.flags = 0; /* gzip header method and flags (0 if zlib) */ + this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */ + this.check = 0; /* protected copy of check value */ + this.total = 0; /* protected copy of output count */ + // TODO: may be {} + this.head = null; /* where to save gzip header information */ + + /* sliding window */ + this.wbits = 0; /* log base 2 of requested window size */ + this.wsize = 0; /* window size or zero if not using window */ + this.whave = 0; /* valid bytes in the window */ + this.wnext = 0; /* window write index */ + this.window = null; /* allocated sliding window, if needed */ + + /* bit accumulator */ + this.hold = 0; /* input bit accumulator */ + this.bits = 0; /* number of bits in "in" */ + + /* for string and stored block copying */ + this.length = 0; /* literal or length of data to copy */ + this.offset = 0; /* distance back to copy string from */ + + /* for table and code decoding */ + this.extra = 0; /* extra bits needed */ + + /* fixed and dynamic code tables */ + this.lencode = null; /* starting table for length/literal codes */ + this.distcode = null; /* starting table for distance codes */ + this.lenbits = 0; /* index bits for lencode */ + this.distbits = 0; /* index bits for distcode */ + + /* dynamic table building */ + this.ncode = 0; /* number of code length code lengths */ + this.nlen = 0; /* number of length code lengths */ + this.ndist = 0; /* number of distance code lengths */ + this.have = 0; /* number of code lengths in lens[] */ + this.next = null; /* next available space in codes[] */ + + this.lens = new utils.Buf16(320); /* temporary storage for code lengths */ + this.work = new utils.Buf16(288); /* work area for code table building */ + + /* + * because we don't have pointers in js, we use lencode and distcode + * directly as buffers so we don't need codes + */ + // this.codes = new utils.Buf32(ENOUGH); /* space for code tables */ + this.lendyn = null; /* + * dynamic table for length/literal codes + * (JS specific) + */ + this.distdyn = null; /* + * dynamic table for distance codes (JS + * specific) + */ + this.sane = 0; /* if false, allow invalid distance too far */ + this.back = 0; /* bits back of last unprocessed length/lit */ + this.was = 0; /* initial length of match */ +} + +function inflateResetKeep(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ''; /* Z_NULL */ + if (state.wrap) { /* to support ill-conceived Java test suite */ + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null/* Z_NULL */; + state.hold = 0; + state.bits = 0; + // state.lencode = state.distcode = state.next = state.codes; + state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); + state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); + + state.sane = 1; + state.back = -1; + // Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +function inflateReset(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + +} + +function inflateReset2(strm, windowBits) { + var wrap; + var state; + + /* get the state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + + /* extract wrap request from windowBits parameter */ + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } + else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; + } + } + + /* set number of window bits, free window if different */ + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + + /* update state and reset the rest of it */ + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); +} + +function inflateInit2(strm, windowBits) { + var ret; + var state; + + if (!strm) { return Z_STREAM_ERROR; } + // strm.msg = Z_NULL; /* in case we return an error */ + + state = new InflateState(); + + // if (state === Z_NULL) return Z_MEM_ERROR; + // Tracev((stderr, "inflate: allocated\n")); + strm.state = state; + state.window = null/* Z_NULL */; + ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK) { + strm.state = null/* Z_NULL */; + } + return ret; +} + +function inflateInit(strm) { + return inflateInit2(strm, DEF_WBITS); +} + + +/* + * Return state with length and distance decoding tables and index sizes set to + * fixed code decoding. Normally this returns fixed tables from inffixed.h. If + * BUILDFIXED is defined, then instead this routine builds the tables the first + * time it's called, and returns those tables the first time and thereafter. + * This reduces the size of the code by about 2K bytes, in exchange for a little + * execution time. However, BUILDFIXED should not be used for threaded + * applications, since the rewriting of the tables and virgin may not be + * thread-safe. + */ +var virgin = true; + +var lenfix, distfix; // We have no pointers in JS, so keep tables separate + +function fixedtables(state) { + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + var sym; + + lenfix = new utils.Buf32(512); + distfix = new utils.Buf32(32); + + /* literal/length table */ + sym = 0; + while (sym < 144) { state.lens[sym++] = 8; } + while (sym < 256) { state.lens[sym++] = 9; } + while (sym < 280) { state.lens[sym++] = 7; } + while (sym < 288) { state.lens[sym++] = 8; } + + inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 }); + + /* distance table */ + sym = 0; + while (sym < 32) { state.lens[sym++] = 5; } + + inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 }); + + /* do this just once */ + virgin = false; + } + + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; +} + + +/* + * Update the window with the last wsize (normally 32K) bytes written before + * returning. If window does not exist yet, create it. This is only called when + * a window is already in use, or when output has been written during this + * inflate call, but the end of the deflate stream has not been reached yet. It + * is also called to create a window for dictionary data when a dictionary is + * loaded. + * + * Providing output buffers larger than 32K to inflate() should provide a speed + * advantage, since only the last 32K of output is copied to the sliding window + * upon return from inflate(), and since all distances after the first 32K of + * output will fall in the output data, making match copies simpler and faster. + * The advantage may be dependent on the size of the processor's data caches. + */ +function updatewindow(strm, src, end, copy) { + var dist; + var state = strm.state; + + /* if it hasn't been done already, allocate space for the window */ + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + + state.window = new utils.Buf8(state.wsize); + } + + /* copy state->wsize or less output bytes into the circular window */ + if (copy >= state.wsize) { + utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0); + state.wnext = 0; + state.whave = state.wsize; + } + else { + dist = state.wsize - state.wnext; + if (dist > copy) { + dist = copy; + } + // zmemcpy(state->window + state->wnext, end - copy, dist); + utils.arraySet(state.window, src, end - copy, dist, state.wnext); + copy -= dist; + if (copy) { + // zmemcpy(state->window, end - copy, copy); + utils.arraySet(state.window, src, end - copy, copy, 0); + state.wnext = copy; + state.whave = state.wsize; + } + else { + state.wnext += dist; + if (state.wnext === state.wsize) { state.wnext = 0; } + if (state.whave < state.wsize) { state.whave += dist; } + } + } + return 0; +} + +function inflate(strm, flush) { + var state; + var input, output; // input/output buffers + var next; /* next input INDEX */ + var put; /* next output INDEX */ + var have, left; /* available input and output */ + var hold; /* bit buffer */ + var bits; /* bits in bit buffer */ + var _in, _out; /* save starting available input and output */ + var copy; /* number of stored or match bytes to copy */ + var from; /* where to copy match bytes from */ + var from_source; + var here = 0; /* current decoding table entry */ + var here_bits, here_op, here_val; // paked "here" denormalized (JS specific) + // var last; /* parent table entry */ + var last_bits, last_op, last_val; // paked "last" denormalized (JS specific) + var len; /* length to copy for repeats, bits to drop */ + var ret; /* return code */ + var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */ + var opts; + + var n; // temporary var for NEED_BITS + + var order = /* permutation of code lengths */ + [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]; + + + if (!strm || !strm.state || !strm.output || + (!strm.input && strm.avail_in !== 0)) { + return Z_STREAM_ERROR; + } + + state = strm.state; + if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */ + + + // --- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + // --- + + _in = have; + _out = left; + ret = Z_OK; + + inf_leave: // goto emulation + for (;;) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + // === NEEDBITS(16); + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */ + state.check = 0/* crc32(0L, Z_NULL, 0) */; + // === CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + // ===// + + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + state.mode = FLAGS; + break; + } + state.flags = 0; /* expect zlib header */ + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 0xff)/* BITS(8) */ << 8) + (hold >> 8)) % 31) { + strm.msg = 'incorrect header check'; + state.mode = BAD; + break; + } + if ((hold & 0x0f)/* BITS(4) */ !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + // --- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + // ---// + len = (hold & 0x0f)/* BITS(4) */ + 8; + if (state.wbits === 0) { + state.wbits = len; + } + else if (len > state.wbits) { + strm.msg = 'invalid window size'; + state.mode = BAD; + break; + } + state.dmax = 1 << len; + // Tracev((stderr, "inflate: zlib header ok\n")); + strm.adler = state.check = 1/* adler32(0L, Z_NULL, 0) */; + state.mode = hold & 0x200 ? DICTID : TYPE; + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + break; + case FLAGS: + // === NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + state.flags = hold; + if ((state.flags & 0xff) !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + if (state.flags & 0xe000) { + strm.msg = 'unknown header flags set'; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = ((hold >> 8) & 1); + } + if (state.flags & 0x0200) { + // === CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + // ===// + } + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + state.mode = TIME; + /* falls through */ + case TIME: + // === NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + if (state.head) { + state.head.time = hold; + } + if (state.flags & 0x0200) { + // === CRC4(state.check, hold) + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + hbuf[2] = (hold >>> 16) & 0xff; + hbuf[3] = (hold >>> 24) & 0xff; + state.check = crc32(state.check, hbuf, 4, 0); + // === + } + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + state.mode = OS; + /* falls through */ + case OS: + // === NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + if (state.head) { + state.head.xflags = (hold & 0xff); + state.head.os = (hold >> 8); + } + if (state.flags & 0x0200) { + // === CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + // ===// + } + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + state.mode = EXLEN; + /* falls through */ + case EXLEN: + if (state.flags & 0x0400) { + // === NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 0x0200) { + // === CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + // ===// + } + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + } + else if (state.head) { + state.head.extra = null/* Z_NULL */; + } + state.mode = EXTRA; + /* falls through */ + case EXTRA: + if (state.flags & 0x0400) { + copy = state.length; + if (copy > have) { copy = have; } + if (copy) { + if (state.head) { + len = state.head.extra_len - state.length; + if (!state.head.extra) { + // Use untyped array for more conveniend processing later + state.head.extra = new Array(state.head.extra_len); + } + utils.arraySet( + state.head.extra, + input, + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + copy, + /* + * len + copy > state.head.extra_max - len ? + * state.head.extra_max : copy, + */ + len + ); + // zmemcpy(state.head.extra + len, next, + // len + copy > state.head.extra_max ? + // state.head.extra_max - len : copy); + } + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + state.length -= copy; + } + if (state.length) { break inf_leave; } + } + state.length = 0; + state.mode = NAME; + /* falls through */ + case NAME: + if (state.flags & 0x0800) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + // TODO: 2 or 1 bytes? + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /* state.head.name_max */)) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy < have); + + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + /* falls through */ + case COMMENT: + if (state.flags & 0x1000) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /* state.head.comm_max */)) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + /* falls through */ + case HCRC: + if (state.flags & 0x0200) { + // === NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + if (hold !== (state.check & 0xffff)) { + strm.msg = 'header crc mismatch'; + state.mode = BAD; + break; + } + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + } + if (state.head) { + state.head.hcrc = ((state.flags >> 9) & 1); + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE; + break; + case DICTID: + // === NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + strm.adler = state.check = zswap32(hold); + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + state.mode = DICT; + /* falls through */ + case DICT: + if (state.havedict === 0) { + // --- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + // --- + return Z_NEED_DICT; + } + strm.adler = state.check = 1/* adler32(0L, Z_NULL, 0) */; + state.mode = TYPE; + /* falls through */ + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; } + /* falls through */ + case TYPEDO: + if (state.last) { + // --- BYTEBITS() ---// + hold >>>= bits & 7; + bits -= bits & 7; + // ---// + state.mode = CHECK; + break; + } + // === NEEDBITS(3); */ + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + state.last = (hold & 0x01)/* BITS(1) */; + // --- DROPBITS(1) ---// + hold >>>= 1; + bits -= 1; + // ---// + + switch ((hold & 0x03)/* BITS(2) */) { + case 0: /* stored block */ + // Tracev((stderr, "inflate: stored block%s\n", + // state.last ? " (last)" : "")); + state.mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + // Tracev((stderr, "inflate: fixed codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = LEN_; /* decode codes */ + if (flush === Z_TREES) { + // --- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + // ---// + break inf_leave; + } + break; + case 2: /* dynamic block */ + // Tracev((stderr, "inflate: dynamic codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = TABLE; + break; + case 3: + strm.msg = 'invalid block type'; + state.mode = BAD; + } + // --- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + // ---// + break; + case STORED: + // --- BYTEBITS() ---// /* go to byte boundary */ + hold >>>= bits & 7; + bits -= bits & 7; + // ---// + // === NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) { + strm.msg = 'invalid stored block lengths'; + state.mode = BAD; + break; + } + state.length = hold & 0xffff; + // Tracev((stderr, "inflate: stored length %u\n", + // state.length)); + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + state.mode = COPY_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case COPY_: + state.mode = COPY; + /* falls through */ + case COPY: + copy = state.length; + if (copy) { + if (copy > have) { copy = have; } + if (copy > left) { copy = left; } + if (copy === 0) { break inf_leave; } + // --- zmemcpy(put, next, copy); --- + utils.arraySet(output, input, next, copy, put); + // ---// + have -= copy; + next += copy; + left -= copy; + put += copy; + state.length -= copy; + break; + } + // Tracev((stderr, "inflate: stored end\n")); + state.mode = TYPE; + break; + case TABLE: + // === NEEDBITS(14); */ + while (bits < 14) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + state.nlen = (hold & 0x1f)/* BITS(5) */ + 257; + // --- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + // ---// + state.ndist = (hold & 0x1f)/* BITS(5) */ + 1; + // --- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + // ---// + state.ncode = (hold & 0x0f)/* BITS(4) */ + 4; + // --- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + // ---// +// #ifndef PKZIP_BUG_WORKAROUND + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = 'too many length or distance symbols'; + state.mode = BAD; + break; + } +// #endif + // Tracev((stderr, "inflate: table sizes ok\n")); + state.have = 0; + state.mode = LENLENS; + /* falls through */ + case LENLENS: + while (state.have < state.ncode) { + // === NEEDBITS(3); + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + state.lens[order[state.have++]] = (hold & 0x07);// BITS(3); + // --- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + // ---// + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + // We have separate tables & no pointers. 2 commented lines below not + // needed. + // state.next = state.codes; + // state.lencode = state.next; + // Switch to use dynamic table + state.lencode = state.lendyn; + state.lenbits = 7; + + opts = { bits: state.lenbits }; + ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + + if (ret) { + strm.msg = 'invalid code lengths set'; + state.mode = BAD; + break; + } + // Tracev((stderr, "inflate: code lengths ok\n")); + state.have = 0; + state.mode = CODELENS; + /* falls through */ + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) - 1)];/* BITS(state.lenbits) */ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + // --- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + // ---// + } + if (here_val < 16) { + // --- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + // ---// + state.lens[state.have++] = here_val; + } + else { + if (here_val === 16) { + // === NEEDBITS(here.bits + 2); + n = here_bits + 2; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + // --- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + // ---// + if (state.have === 0) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + len = state.lens[state.have - 1]; + copy = 3 + (hold & 0x03);// BITS(2); + // --- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + // ---// + } + else if (here_val === 17) { + // === NEEDBITS(here.bits + 3); + n = here_bits + 3; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + // --- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + // ---// + len = 0; + copy = 3 + (hold & 0x07);// BITS(3); + // --- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + // ---// + } + else { + // === NEEDBITS(here.bits + 7); + n = here_bits + 7; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + // --- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + // ---// + len = 0; + copy = 11 + (hold & 0x7f);// BITS(7); + // --- DROPBITS(7) ---// + hold >>>= 7; + bits -= 7; + // ---// + } + if (state.have + copy > state.nlen + state.ndist) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + while (copy--) { + state.lens[state.have++] = len; + } + } + } + + /* handle error breaks in while */ + if (state.mode === BAD) { break; } + + /* check for end-of-block code (better have one) */ + if (state.lens[256] === 0) { + strm.msg = 'invalid code -- missing end-of-block'; + state.mode = BAD; + break; + } + + /* + * build code tables -- note: do not change the lenbits or distbits + * values here (9 and 6) without reading the comments in inftrees.h + * concerning the ENOUGH constants, which depend on those values + */ + state.lenbits = 9; + + opts = { bits: state.lenbits }; + ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not + // needed. + // state.next_index = opts.table_index; + state.lenbits = opts.bits; + // state.lencode = state.next; + + if (ret) { + strm.msg = 'invalid literal/lengths set'; + state.mode = BAD; + break; + } + + state.distbits = 6; + // state.distcode.copy(state.codes); + // Switch to use dynamic table + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not + // needed. + // state.next_index = opts.table_index; + state.distbits = opts.bits; + // state.distcode = state.next; + + if (ret) { + strm.msg = 'invalid distances set'; + state.mode = BAD; + break; + } + // Tracev((stderr, 'inflate: codes ok\n')); + state.mode = LEN_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case LEN_: + state.mode = LEN; + /* falls through */ + case LEN: + if (have >= 6 && left >= 258) { + // --- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + // --- + inflate_fast(strm, _out); + // --- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + // --- + + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /* BITS(state.lenbits) */ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if (here_bits <= bits) { break; } + // --- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + // ---// + } + if (here_op && (here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.lencode[last_val + + ((hold & ((1 << (last_bits + last_op)) - 1))/* + * BITS(last.bits + + * last.op) + */ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + // --- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + // ---// + } + // --- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + // ---// + state.back += last_bits; + } + // --- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + // ---// + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + // Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + state.mode = LIT; + break; + } + if (here_op & 32) { + // Tracevv((stderr, "inflate: end of block\n")); + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + /* falls through */ + case LENEXT: + if (state.extra) { + // === NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + state.length += hold & ((1 << state.extra) - 1)/* BITS(state.extra) */; + // --- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + // ---// + state.back += state.extra; + } + // Tracevv((stderr, "inflate: length %u\n", state.length)); + state.was = state.length; + state.mode = DIST; + /* falls through */ + case DIST: + for (;;) { + here = state.distcode[hold & ((1 << state.distbits) - 1)];/* BITS(state.distbits) */ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + // --- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + // ---// + } + if ((here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.distcode[last_val + + ((hold & ((1 << (last_bits + last_op)) - 1))/* + * BITS(last.bits + + * last.op) + */ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + // --- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + // ---// + } + // --- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + // ---// + state.back += last_bits; + } + // --- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + // ---// + state.back += here_bits; + if (here_op & 64) { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = (here_op) & 15; + state.mode = DISTEXT; + /* falls through */ + case DISTEXT: + if (state.extra) { + // === NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + state.offset += hold & ((1 << state.extra) - 1)/* BITS(state.extra) */; + // --- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + // ---// + state.back += state.extra; + } +// #ifdef INFLATE_STRICT + if (state.offset > state.dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +// #endif + // Tracevv((stderr, "inflate: distance %u\n", state.offset)); + state.mode = MATCH; + /* falls through */ + case MATCH: + if (left === 0) { break inf_leave; } + copy = _out - left; + if (state.offset > copy) { /* copy from window */ + copy = state.offset - copy; + if (copy > state.whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +// (!) This block is disabled in zlib defailts, +// don't enable it for binary compatibility +// #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// Trace((stderr, "inflate.c too far\n")); +// copy -= state.whave; +// if (copy > state.length) { copy = state.length; } +// if (copy > left) { copy = left; } +// left -= copy; +// state.length -= copy; +// do { +// output[put++] = 0; +// } while (--copy); +// if (state.length === 0) { state.mode = LEN; } +// break; +// #endif + } + if (copy > state.wnext) { + copy -= state.wnext; + from = state.wsize - copy; + } + else { + from = state.wnext - copy; + } + if (copy > state.length) { copy = state.length; } + from_source = state.window; + } + else { /* copy from output */ + from_source = output; + from = put - state.offset; + copy = state.length; + } + if (copy > left) { copy = left; } + left -= copy; + state.length -= copy; + do { + output[put++] = from_source[from++]; + } while (--copy); + if (state.length === 0) { state.mode = LEN; } + break; + case LIT: + if (left === 0) { break inf_leave; } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + // === NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + // Use '|' insdead of '+' to make sure that result is signed + hold |= input[next++] << bits; + bits += 8; + } + // ===// + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = + /* UPDATE(state.check, put - _out, _out); */ + (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out)); + + } + _out = left; + // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too + if ((state.flags ? hold : zswap32(hold)) !== state.check) { + strm.msg = 'incorrect data check'; + state.mode = BAD; + break; + } + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + // Tracev((stderr, "inflate: check matches trailer\n")); + } + state.mode = LENGTH; + /* falls through */ + case LENGTH: + if (state.wrap && state.flags) { + // === NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + // ===// + if (hold !== (state.total & 0xffffffff)) { + strm.msg = 'incorrect length check'; + state.mode = BAD; + break; + } + // === INITBITS(); + hold = 0; + bits = 0; + // ===// + // Tracev((stderr, "inflate: length matches trailer\n")); + } + state.mode = DONE; + /* falls through */ + case DONE: + ret = Z_STREAM_END; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR; + break inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + /* falls through */ + default: + return Z_STREAM_ERROR; + } + } + + // inf_leave <- here is real place for "goto inf_leave", emulated via "break + // inf_leave" + + /* + * Return from inflate(), updating the total counts and the check value. If + * there was no progress during the inflate() call, return a buffer error. + * Call updatewindow() to create and/or update the window state. Note: a + * memory error from inflate() is non-recoverable. + */ + + // --- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + // --- + + if (state.wsize || (_out !== strm.avail_out && state.mode < BAD && + (state.mode < CHECK || flush !== Z_FINISH))) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { + state.mode = MEM; + return Z_MEM_ERROR; + } + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = /* + * UPDATE(state.check, strm.next_out - _out, + * _out); + */ + (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out)); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + + (state.mode === TYPE ? 128 : 0) + + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) { + ret = Z_BUF_ERROR; + } + return ret; +} + +function inflateEnd(strm) { + + if (!strm || !strm.state /* || strm->zfree == (free_func)0 */) { + return Z_STREAM_ERROR; + } + + var state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK; +} + +function inflateGetHeader(strm, head) { + var state; + + /* check state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; } + + /* save header structure */ + state.head = head; + head.done = false; + return Z_OK; +} + +function inflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + + var state; + var dictid; + var ret; + + /* check state */ + if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; } + state = strm.state; + + if (state.wrap !== 0 && state.mode !== DICT) { + return Z_STREAM_ERROR; + } + + /* check for correct dictionary identifier */ + if (state.mode === DICT) { + dictid = 1; /* adler32(0, null, 0) */ + /* dictid = adler32(dictid, dictionary, dictLength); */ + dictid = adler32(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR; + } + } + /* + * copy dictionary to window using updatewindow(), which will amend the + * existing dictionary if appropriate + */ + ret = updatewindow(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM; + return Z_MEM_ERROR; + } + state.havedict = 1; + // Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +} + +exports.inflateReset = inflateReset; +exports.inflateReset2 = inflateReset2; +exports.inflateResetKeep = inflateResetKeep; +exports.inflateInit = inflateInit; +exports.inflateInit2 = inflateInit2; +exports.inflate = inflate; +exports.inflateEnd = inflateEnd; +exports.inflateGetHeader = inflateGetHeader; +exports.inflateSetDictionary = inflateSetDictionary; +exports.inflateInfo = 'pako inflate (from Nodeca project)'; + +/* + * Not implemented exports.inflateCopy = inflateCopy; + * exports.inflateGetDictionary = inflateGetDictionary; exports.inflateMark = + * inflateMark; exports.inflatePrime = inflatePrime; exports.inflateSync = + * inflateSync; exports.inflateSyncPoint = inflateSyncPoint; + * exports.inflateUndermine = inflateUndermine; + */ + +},{"../utils/common":3,"./adler32":4,"./crc32":6,"./inffast":8,"./inftrees":10}],10:[function(require,module,exports){ +'use strict'; + + +var utils = require('../utils/common'); + +var MAXBITS = 15; +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +// var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +var lbase = [ /* Length codes 257..285 base */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 +]; + +var lext = [ /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78 +]; + +var dbase = [ /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577, 0, 0 +]; + +var dext = [ /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64 +]; + +module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) +{ + var bits = opts.bits; + // here = opts.here; /* table entry for duplication */ + + var len = 0; /* a code's length in bits */ + var sym = 0; /* index of code symbols */ + var min = 0, max = 0; /* minimum and maximum code lengths */ + var root = 0; /* number of index bits for root table */ + var curr = 0; /* number of index bits for current table */ + var drop = 0; /* code bits to drop for sub-table */ + var left = 0; /* number of prefix codes available */ + var used = 0; /* code entries in table used */ + var huff = 0; /* Huffman code */ + var incr; /* for incrementing code, index */ + var fill; /* index for replicating entries */ + var low; /* low bits for current root entry */ + var mask; /* mask for low root bits */ + var next; /* next available space in table */ + var base = null; /* base value table to use */ + var base_index = 0; +// var shoextra; /* extra bits table to use */ + var end; /* use base and extra for symbol > end */ + var count = new utils.Buf16(MAXBITS + 1); // [MAXBITS+1]; /* number of codes + // of each length */ + var offs = new utils.Buf16(MAXBITS + 1); // [MAXBITS+1]; /* offsets in table + // for each length */ + var extra = null; + var extra_index = 0; + + var here_bits, here_op, here_val; + + /* + * Process a set of code lengths to create a canonical Huffman code. The + * code lengths are lens[0..codes-1]. Each length corresponds to the symbols + * 0..codes-1. The Huffman code is generated by first sorting the symbols by + * length from short to long, and retaining the symbol order for codes with + * equal lengths. Then the code starts with all zero bits for the first code + * of the shortest length, and the codes are integer increments for the same + * length, and zeros are appended as the length increases. For the deflate + * format, these bits are stored backwards from their more natural integer + * increment ordering, and so when the decoding tables are built in the + * large loop below, the integer codes are incremented backwards. + * + * This routine assumes, but does not check, that all of the entries in + * lens[] are in the range 0..MAXBITS. The caller must assure this. + * 1..MAXBITS is interpreted as that code length. zero means that that + * symbol does not occur in this code. + * + * The codes are sorted by computing a count of codes for each length, + * creating from that a table of starting indices for each length in the + * sorted table, and then entering the symbols in order in the sorted table. + * The sorted table is work[], with that space being provided by the caller. + * + * The length counts are used for other purposes as well, i.e. finding the + * minimum and maximum length codes, determining if there are any codes at + * all, checking for a valid set of lengths, and looking ahead at length + * counts to determine sub-table sizes when building the decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) { + count[len] = 0; + } + for (sym = 0; sym < codes; sym++) { + count[lens[lens_index + sym]]++; + } + + /* bound code lengths, force root to be within code lengths */ + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { break; } + } + if (root > max) { + root = max; + } + if (max === 0) { /* no symbols to code at all */ + // table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid + // code marker */ + // table.bits[opts.table_index] = 1; //here.bits = (var char)1; + // table.val[opts.table_index++] = 0; //here.val = (var short)0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + + // table.op[opts.table_index] = 64; + // table.bits[opts.table_index] = 1; + // table.val[opts.table_index++] = 0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + opts.bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min < max; min++) { + if (count[min] !== 0) { break; } + } + if (root < min) { + root = min; + } + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) { + return -1; + } /* over-subscribed */ + } + if (left > 0 && (type === CODES || max !== 1)) { + return -1; /* incomplete set */ + } + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) { + offs[len + 1] = offs[len] + count[len]; + } + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) { + if (lens[lens_index + sym] !== 0) { + work[offs[lens[lens_index + sym]]++] = sym; + } + } + + /* + * Create and fill in decoding tables. In this loop, the table being filled + * is at next and has curr index bits. The code being used is huff with + * length len. That code is converted to an index by dropping drop bits off + * of the bottom. For codes where len is less than drop + curr, those top + * drop + curr - len bits are incremented through all values to fill the + * table with replicated entries. + * + * root is the number of index bits for the root table. When len exceeds + * root, sub-tables are created pointed to by the root entry with an index + * of the low root bits of huff. This is saved in low to check for when a + * new sub-table should be started. drop is zero when the root table is + * being filled, and drop is root when sub-tables are being filled. + * + * When a new sub-table is needed, it is necessary to look ahead in the code + * lengths to determine what size sub-table is needed. The length counts are + * used for this, and so count[] is decremented as codes are entered in the + * tables. + * + * used keeps track of how many table entries have been allocated from the + * provided *table space. It is checked for LENS and DIST tables against the + * constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in the + * initial root table size constants. See the comments in inftrees.h for + * more information. + * + * sym increments through all symbols, and the loop terminates when all + * codes of length max, i.e. all codes, have been processed. This routine + * permits incomplete codes, so another loop after this one fills in the + * rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + // poor man optimization - use if-else instead of switch, + // to avoid deopts in old v8 + if (type === CODES) { + base = extra = work; /* dummy value--not used */ + end = 19; + + } else if (type === LENS) { + base = lbase; + base_index -= 257; + extra = lext; + extra_index -= 257; + end = 256; + + } else { /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize opts for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = table_index; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = -1; /* trigger new sub-table when len > root */ + used = 1 << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + var i = 0; + /* process all codes and make table entries */ + for (;;) { + i++; + /* create table entry */ + here_bits = len - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } + else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } + else { + here_op = 32 + 64; /* end of block */ + here_val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = 1 << (len - drop); + fill = 1 << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0; + } while (fill !== 0); + + /* backwards increment the len-bit code huff */ + incr = 1 << (len - 1); + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + + /* go to next symbol, update count, len */ + sym++; + if (--count[len] === 0) { + if (len === max) { break; } + len = lens[lens_index + work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) !== low) { + /* if first time, transition to sub-tables */ + if (drop === 0) { + drop = root; + } + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) { break; } + curr++; + left <<= 1; + } + + /* check for enough space */ + used += 1 << curr; + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + /* point entry in root table to sub-table */ + low = huff & mask; + /* + * table.op[low] = curr; table.bits[low] = root; table.val[low] = next - + * opts.table_index; + */ + table[low] = (root << 24) | (curr << 16) | (next - table_index) |0; + } + } + + /* + * fill in remaining table entry if code is incomplete (guaranteed to have + * at most one remaining entry, since if the code is incomplete, the maximum + * code length that was allowed to get this far is one bit) + */ + if (huff !== 0) { + // table.op[next + huff] = 64; /* invalid code marker */ + // table.bits[next + huff] = len - drop; + // table.val[next + huff] = 0; + table[next + huff] = ((len - drop) << 24) | (64 << 16) |0; + } + + /* set return parameters */ + // opts.table_index += used; + opts.bits = root; + return 0; +}; + +},{"../utils/common":3}],11:[function(require,module,exports){ +'use strict'; + +module.exports = { + 2: 'need dictionary', /* Z_NEED_DICT 2 */ + 1: 'stream end', /* Z_STREAM_END 1 */ + 0: '', /* Z_OK 0 */ + '-1': 'file error', /* Z_ERRNO (-1) */ + '-2': 'stream error', /* Z_STREAM_ERROR (-2) */ + '-3': 'data error', /* Z_DATA_ERROR (-3) */ + '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */ + '-5': 'buffer error', /* Z_BUF_ERROR (-5) */ + '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */ +}; + +},{}],12:[function(require,module,exports){ +'use strict'; + + +var utils = require('../utils/common'); + +/* Public constants ========================================================== */ +/* =========================================================================== */ + + +// var Z_FILTERED = 1; +// var Z_HUFFMAN_ONLY = 2; +// var Z_RLE = 3; +var Z_FIXED = 4; +// var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +var Z_BINARY = 0; +var Z_TEXT = 1; +// var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + +/* ============================================================================ */ + + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + +// From zutil.h + +var STORED_BLOCK = 0; +var STATIC_TREES = 1; +var DYN_TREES = 2; +/* The three kinds of block type */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +/* The minimum and maximum match lengths */ + +// From deflate.h +/* + * =========================================================================== + * Internal compression state. + */ + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ + +var LITERALS = 256; +/* number of literal bytes 0..255 */ + +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ + +var D_CODES = 30; +/* number of distance codes */ + +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ + +var HEAP_SIZE = 2 * L_CODES + 1; +/* maximum heap size */ + +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var Buf_size = 16; +/* size of bit buffer in bi_buf */ + + +/* + * =========================================================================== + * Constants + */ + +var MAX_BL_BITS = 7; +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +var END_BLOCK = 256; +/* end of block literal code */ + +var REP_3_6 = 16; +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +var REPZ_3_10 = 17; +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +var REPZ_11_138 = 18; +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +/* eslint-disable comma-spacing,array-bracket-spacing */ +var extra_lbits = /* extra bits for each length code */ + [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]; + +var extra_dbits = /* extra bits for each distance code */ + [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]; + +var extra_blbits = /* extra bits for each bit length code */ + [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]; + +var bl_order = + [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]; +/* eslint-enable comma-spacing,array-bracket-spacing */ + +/* + * The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +/* + * =========================================================================== + * Local data. These are initialized only once. + */ + +// We pre-fill arrays with 0 to avoid uninitialized gaps + +var DIST_CODE_LEN = 512; /* see definition of array dist_code below */ + +// !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1 +var static_ltree = new Array((L_CODES + 2) * 2); +zero(static_ltree); +/* + * The static literal tree. Since the bit lengths are imposed, there is no need + * for the L_CODES extra codes used during heap construction. However The codes + * 286 and 287 are needed to build a canonical tree (see _tr_init below). + */ + +var static_dtree = new Array(D_CODES * 2); +zero(static_dtree); +/* + * The static distance tree. (Actually a trivial tree since all codes use 5 + * bits.) + */ + +var _dist_code = new Array(DIST_CODE_LEN); +zero(_dist_code); +/* + * Distance codes. The first 256 values correspond to the distances 3 .. 258, + * the last 256 values correspond to the top 8 bits of the 15 bit distances. + */ + +var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1); +zero(_length_code); +/* length code for each normalized match length (0 == MIN_MATCH) */ + +var base_length = new Array(LENGTH_CODES); +zero(base_length); +/* First normalized length for each code (0 = MIN_MATCH) */ + +var base_dist = new Array(D_CODES); +zero(base_dist); +/* First normalized distance for each code (0 = distance of 1) */ + + +function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) { + + this.static_tree = static_tree; /* static tree or NULL */ + this.extra_bits = extra_bits; /* extra bits for each code or NULL */ + this.extra_base = extra_base; /* base index for extra_bits */ + this.elems = elems; /* max number of elements in the tree */ + this.max_length = max_length; /* max bit length for the codes */ + + // show if `static_tree` has data or dummy - needed for monomorphic objects + this.has_stree = static_tree && static_tree.length; +} + + +var static_l_desc; +var static_d_desc; +var static_bl_desc; + + +function TreeDesc(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; /* the dynamic tree */ + this.max_code = 0; /* largest code with non zero frequency */ + this.stat_desc = stat_desc; /* the corresponding static tree */ +} + + + +function d_code(dist) { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; +} + + +/* + * =========================================================================== + * Output a short LSB first on the stream. IN assertion: there is enough room in + * pendingBuf. + */ +function put_short(s, w) { +// put_byte(s, (uch)((w) & 0xff)); +// put_byte(s, (uch)((ush)(w) >> 8)); + s.pending_buf[s.pending++] = (w) & 0xff; + s.pending_buf[s.pending++] = (w >>> 8) & 0xff; +} + + +/* + * =========================================================================== + * Send a value on a given number of bits. IN assertion: length <= 16 and value + * fits in length bits. + */ +function send_bits(s, value, length) { + if (s.bi_valid > (Buf_size - length)) { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + put_short(s, s.bi_buf); + s.bi_buf = value >> (Buf_size - s.bi_valid); + s.bi_valid += length - Buf_size; + } else { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + s.bi_valid += length; + } +} + + +function send_code(s, c, tree) { + send_bits(s, tree[c * 2]/* .Code */, tree[c * 2 + 1]/* .Len */); +} + + +/* + * =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) IN assertion: 1 <= len <= 15 + */ +function bi_reverse(code, len) { + var res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len > 0); + return res >>> 1; +} + + +/* + * =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +function bi_flush(s) { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 0xff; + s.bi_buf >>= 8; + s.bi_valid -= 8; + } +} + + +/* + * =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. IN assertion: the fields freq and dad are set, + * heap[heap_max] and above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the array + * bl_count contains the frequencies for each bit length. The length opt_len is + * updated; static_len is also updated if stree is not null. + */ +function gen_bitlen(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var max_code = desc.max_code; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var extra = desc.stat_desc.extra_bits; + var base = desc.stat_desc.extra_base; + var max_length = desc.stat_desc.max_length; + var h; /* heap index */ + var n, m; /* iterate over the tree elements */ + var bits; /* bit length */ + var xbits; /* extra bits */ + var f; /* frequency */ + var overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) { + s.bl_count[bits] = 0; + } + + /* + * In a first pass, compute the optimal bit lengths (which may overflow in + * the case of the bit length tree). + */ + tree[s.heap[s.heap_max] * 2 + 1]/* .Len */ = 0; /* root of the heap */ + + for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n * 2 + 1]/* .Dad */ * 2 + 1]/* .Len */ + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n * 2 + 1]/* .Len */ = bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) { continue; } /* not a leaf node */ + + s.bl_count[bits]++; + xbits = 0; + if (n >= base) { + xbits = extra[n - base]; + } + f = tree[n * 2]/* .Freq */; + s.opt_len += f * (bits + xbits); + if (has_stree) { + s.static_len += f * (stree[n * 2 + 1]/* .Len */ + xbits); + } + } + if (overflow === 0) { return; } + + // Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { bits--; } + s.bl_count[bits]--; /* move one leaf down the tree */ + s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */ + s.bl_count[max_length]--; + /* + * The brother of the overflow item also moves one step up, but this does + * not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* + * Now recompute all bit lengths, scanning in increasing frequency. h is + * still equal to HEAP_SIZE. (It is simpler to reconstruct all lengths + * instead of fixing only the wrong ones. This idea is taken from 'ar' + * written by Haruhiko Okumura.) + */ + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > max_code) { continue; } + if (tree[m * 2 + 1]/* .Len */ !== bits) { + // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s.opt_len += (bits - tree[m * 2 + 1]/* .Len */) * tree[m * 2]/* .Freq */; + tree[m * 2 + 1]/* .Len */ = bits; + } + n--; + } + } +} + + +/* + * =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). IN assertion: the array bl_count contains the bit length statistics + * for the given tree and the field len is set for all tree elements. OUT + * assertion: the field code is set for all tree elements of non zero code + * length. + */ +function gen_codes(tree, max_code, bl_count) +// ct_data *tree; /* the tree to decorate */ +// int max_code; /* largest code with non zero frequency */ +// ushf *bl_count; /* number of codes at each bit length */ +{ + var next_code = new Array(MAX_BITS + 1); /* + * next code value for each bit + * length + */ + var code = 0; /* running code value */ + var bits; /* bit index */ + var n; /* code index */ + + /* + * The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits - 1]) << 1; + } + /* + * Check that the bit counts in bl_count are consistent. The last code must + * be all ones. + */ + // Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1, + // "inconsistent bit counts"); + // Tracev((stderr,"\ngen_codes: max_code %d ", max_code)); + + for (n = 0; n <= max_code; n++) { + var len = tree[n * 2 + 1]/* .Len */; + if (len === 0) { continue; } + /* Now reverse the bits */ + tree[n * 2]/* .Code */ = bi_reverse(next_code[len]++, len); + + // Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ", + // n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1)); + } +} + + +/* + * =========================================================================== + * Initialize the various 'constant' tables. + */ +function tr_static_init() { + var n; /* iterates over tree elements */ + var bits; /* bit counter */ + var length; /* length value */ + var code; /* code value */ + var dist; /* distance index */ + var bl_count = new Array(MAX_BITS + 1); + /* number of codes at each bit length for an optimal tree */ + + // do check in _tr_init() + // if (static_init_done) return; + + /* For some embedded targets, global variables are not initialized: */ +/* + * #ifdef NO_INIT_GLOBAL_POINTERS static_l_desc.static_tree = static_ltree; + * static_l_desc.extra_bits = extra_lbits; static_d_desc.static_tree = + * static_dtree; static_d_desc.extra_bits = extra_dbits; + * static_bl_desc.extra_bits = extra_blbits; #endif + */ + + /* Initialize the mapping length (0..255) -> length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES - 1; code++) { + base_length[code] = length; + for (n = 0; n < (1 << extra_lbits[code]); n++) { + _length_code[length++] = code; + } + } + // Assert (length == 256, "tr_static_init: length != 256"); + /* + * Note that the length 255 (match length 258) can be represented in two + * different ways: code 284 + 5 bits or code 285, so we overwrite + * length_code[255] to use the best encoding: + */ + _length_code[length - 1] = code; + + /* Initialize the mapping dist (0..32K) -> dist code (0..29) */ + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1 << extra_dbits[code]); n++) { + _dist_code[dist++] = code; + } + } + // Assert (dist == 256, "tr_static_init: dist != 256"); + dist >>= 7; /* from now on, all distances are divided by 128 */ + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { + _dist_code[256 + dist++] = code; + } + } + // Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) { + bl_count[bits] = 0; + } + + n = 0; + while (n <= 143) { + static_ltree[n * 2 + 1]/* .Len */ = 8; + n++; + bl_count[8]++; + } + while (n <= 255) { + static_ltree[n * 2 + 1]/* .Len */ = 9; + n++; + bl_count[9]++; + } + while (n <= 279) { + static_ltree[n * 2 + 1]/* .Len */ = 7; + n++; + bl_count[7]++; + } + while (n <= 287) { + static_ltree[n * 2 + 1]/* .Len */ = 8; + n++; + bl_count[8]++; + } + /* + * Codes 286 and 287 do not exist, but we must include them in the tree + * construction to get a canonical Huffman tree (longest code all ones) + */ + gen_codes(static_ltree, L_CODES + 1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n * 2 + 1]/* .Len */ = 5; + static_dtree[n * 2]/* .Code */ = bi_reverse(n, 5); + } + + // Now data ready and we can init static trees + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); + static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); + + // static_init_done = true; +} + + +/* + * =========================================================================== + * Initialize a new block. + */ +function init_block(s) { + var n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2]/* .Freq */ = 0; } + for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2]/* .Freq */ = 0; } + for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/* .Freq */ = 0; } + + s.dyn_ltree[END_BLOCK * 2]/* .Freq */ = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; +} + + +/* + * =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +function bi_windup(s) +{ + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + // put_byte(s, (Byte)s->bi_buf); + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; +} + +/* + * =========================================================================== + * Copy a stored block, storing first the length and its one's complement if + * requested. + */ +function copy_block(s, buf, len, header) +// DeflateState *s; +// charf *buf; /* the input data */ +// unsigned len; /* its length */ +// int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + + if (header) { + put_short(s, len); + put_short(s, ~len); + } +// while (len--) { +// put_byte(s, *buf++); +// } + utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); + s.pending += len; +} + +/* + * =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when the subtrees + * have equal frequency. This minimizes the worst case length. + */ +function smaller(tree, n, m, depth) { + var _n2 = n * 2; + var _m2 = m * 2; + return (tree[_n2]/* .Freq */ < tree[_m2]/* .Freq */ || + (tree[_n2]/* .Freq */ === tree[_m2]/* .Freq */ && depth[n] <= depth[m])); +} + +/* + * =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its two + * sons). + */ +function pqdownheap(s, tree, k) +// deflate_state *s; +// ct_data *tree; /* the tree to restore */ +// int k; /* node to move down */ +{ + var v = s.heap[k]; + var j = k << 1; /* left son of k */ + while (j <= s.heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s.heap_len && + smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s.heap[j], s.depth)) { break; } + + /* Exchange v with the smallest son */ + s.heap[k] = s.heap[j]; + k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s.heap[k] = v; +} + + +// inlined manually +// var SMALLEST = 1; + +/* + * =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +function compress_block(s, ltree, dtree) +// deflate_state *s; +// const ct_data *ltree; /* literal tree */ +// const ct_data *dtree; /* distance tree */ +{ + var dist; /* distance of matched string */ + var lc; /* match length or unmatched char (if dist == 0) */ + var lx = 0; /* running index in l_buf */ + var code; /* the code to send */ + var extra; /* number of extra bits to send */ + + if (s.last_lit !== 0) { + do { + dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]); + lc = s.pending_buf[s.l_buf + lx]; + lx++; + + if (dist === 0) { + send_code(s, lc, ltree); /* send a literal byte */ + // Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + // Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + // Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, + // "pendingBuf overflow"); + + } while (lx < s.last_lit); + } + + send_code(s, END_BLOCK, ltree); +} + + +/* + * =========================================================================== + * Construct one Huffman tree and assigns the code bit strings and lengths. + * Update the total bit length for the current block. IN assertion: the field + * freq is set for all tree elements. OUT assertions: the fields len and code + * are set to the optimal bit length and corresponding code. The length opt_len + * is updated; static_len is also updated if stree is not null. The field + * max_code is set. + */ +function build_tree(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var elems = desc.stat_desc.elems; + var n, m; /* iterate over heap elements */ + var max_code = -1; /* largest code with non zero frequency */ + var node; /* new node being created */ + + /* + * Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s.heap_len = 0; + s.heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n * 2]/* .Freq */ !== 0) { + s.heap[++s.heap_len] = max_code = n; + s.depth[n] = 0; + + } else { + tree[n * 2 + 1]/* .Len */ = 0; + } + } + + /* + * The pkzip format requires that at least one distance code exists, and + * that at least one bit should be sent even if there is only one possible + * code. So to avoid special checks later on we force at least two codes of + * non zero frequency. + */ + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0); + tree[node * 2]/* .Freq */ = 1; + s.depth[node] = 0; + s.opt_len--; + + if (has_stree) { + s.static_len -= stree[node * 2 + 1]/* .Len */; + } + /* node is 0 or 1 so it does not have extra bits */ + } + desc.max_code = max_code; + + /* + * The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = (s.heap_len >> 1/* int /2 */); n >= 1; n--) { pqdownheap(s, tree, n); } + + /* + * Construct the Huffman tree by repeatedly combining the least two frequent + * nodes. + */ + node = elems; /* next internal node of the tree */ + do { + // pqremove(s, tree, n); /* n = node of least frequency */ + /** * pqremove ** */ + n = s.heap[1/* SMALLEST */]; + s.heap[1/* SMALLEST */] = s.heap[s.heap_len--]; + pqdownheap(s, tree, 1/* SMALLEST */); + /***/ + + m = s.heap[1/* SMALLEST */]; /* m = node of next least frequency */ + + s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */ + s.heap[--s.heap_max] = m; + + /* Create a new node father of n and m */ + tree[node * 2]/* .Freq */ = tree[n * 2]/* .Freq */ + tree[m * 2]/* .Freq */; + s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; + tree[n * 2 + 1]/* .Dad */ = tree[m * 2 + 1]/* .Dad */ = node; + + /* and insert the new node in the heap */ + s.heap[1/* SMALLEST */] = node++; + pqdownheap(s, tree, 1/* SMALLEST */); + + } while (s.heap_len >= 2); + + s.heap[--s.heap_max] = s.heap[1/* SMALLEST */]; + + /* + * At this point, the fields freq and dad are set. We can now generate the + * bit lengths. + */ + gen_bitlen(s, desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes(tree, max_code, s.bl_count); +} + + +/* + * =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes in + * the bit length tree. + */ +function scan_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0 * 2 + 1]/* .Len */; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1]/* .Len */ = 0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]/* .Len */; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + s.bl_tree[curlen * 2]/* .Freq */ += count; + + } else if (curlen !== 0) { + + if (curlen !== prevlen) { s.bl_tree[curlen * 2]/* .Freq */++; } + s.bl_tree[REP_3_6 * 2]/* .Freq */++; + + } else if (count <= 10) { + s.bl_tree[REPZ_3_10 * 2]/* .Freq */++; + + } else { + s.bl_tree[REPZ_11_138 * 2]/* .Freq */++; + } + + count = 0; + prevlen = curlen; + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* + * =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +function send_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0 * 2 + 1]/* .Len */; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]/* .Len */; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + do { send_code(s, curlen, s.bl_tree); } while (--count !== 0); + + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count--; + } + // Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count - 3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count - 3, 3); + + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count - 11, 7); + } + + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* + * =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +function build_bl_tree(s) { + var max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, s.bl_desc); + /* + * opt_len now includes the length of the tree representations, except the + * lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* + * Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says 3 + * but the actual value used is 4.) + */ + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/* .Len */ !== 0) { + break; + } + } + /* Update opt_len to include the bit length tree and counts */ + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + // Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + // s->opt_len, s->static_len)); + + return max_blindex; +} + + +/* + * =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. IN + * assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +function send_all_trees(s, lcodes, dcodes, blcodes) +// deflate_state *s; +// int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + var rank; /* index in bl_order */ + + // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough + // codes"); + // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + // "too many codes"); + // Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + // Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/* .Len */, 3); + } + // Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */ + // Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */ + // Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + + +/* + * =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: - + * TEXT if the two conditions below are satisfied: a) There are no non-portable + * control characters belonging to the "black list" (0..6, 14..25, 28..31). b) + * There is at least one printable character belonging to the "white list" (9 + * {TAB}, 10 {LF}, 13 {CR}, 32..255). - BINARY otherwise. - The following + * partially-portable control characters form a "gray list" that is ignored in + * this detection algorithm: (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 + * {ESC}). IN assertion: the fields Freq of dyn_ltree are set. + */ +function detect_data_type(s) { + /* + * black_mask is the bit mask of black-listed bytes set bits 0..6, 14..25, + * and 28..31 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + var black_mask = 0xf3ffc07f; + var n; + + /* Check for non-textual ("black-listed") bytes. */ + for (n = 0; n <= 31; n++, black_mask >>>= 1) { + if ((black_mask & 1) && (s.dyn_ltree[n * 2]/* .Freq */ !== 0)) { + return Z_BINARY; + } + } + + /* Check for textual ("white-listed") bytes. */ + if (s.dyn_ltree[9 * 2]/* .Freq */ !== 0 || s.dyn_ltree[10 * 2]/* .Freq */ !== 0 || + s.dyn_ltree[13 * 2]/* .Freq */ !== 0) { + return Z_TEXT; + } + for (n = 32; n < LITERALS; n++) { + if (s.dyn_ltree[n * 2]/* .Freq */ !== 0) { + return Z_TEXT; + } + } + + /* + * There are no "black-listed" or "white-listed" bytes: this stream either + * is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + + +var static_init_done = false; + +/* + * =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +function _tr_init(s) +{ + + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + + s.bi_buf = 0; + s.bi_valid = 0; + + /* Initialize the first block of the first file: */ + init_block(s); +} + + +/* + * =========================================================================== + * Send a stored block + */ +function _tr_stored_block(s, buf, stored_len, last) +// DeflateState *s; +// charf *buf; /* input block */ +// ulg stored_len; /* length of input block */ +// int last; /* one if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */ + copy_block(s, buf, stored_len, true); /* with header */ +} + + +/* + * =========================================================================== + * Send one empty static block to give enough lookahead for inflate. This takes + * 10 bits, of which 7 may remain in the bit buffer. + */ +function _tr_align(s) { + send_bits(s, STATIC_TREES << 1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); +} + + +/* + * =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +function _tr_flush_block(s, buf, stored_len, last) +// DeflateState *s; +// charf *buf; /* input block, or NULL if too old */ +// ulg stored_len; /* length of input block */ +// int last; /* one if this is the last block for a file */ +{ + var opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + var max_blindex = 0; /* + * index of last bit length code of non zero + * freq + */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s.level > 0) { + + /* Check if the file is binary or text */ + if (s.strm.data_type === Z_UNKNOWN) { + s.strm.data_type = detect_data_type(s); + } + + /* Construct the literal and distance trees */ + build_tree(s, s.l_desc); + // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + + build_tree(s, s.d_desc); + // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + /* + * At this point, opt_len and static_len are the total bit lengths of the + * compressed block data, excluding the tree representations. + */ + + /* + * Build the bit length tree for the above two trees, and get the index in + * bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute the block lengths in bytes. */ + opt_lenb = (s.opt_len + 3 + 7) >>> 3; + static_lenb = (s.static_len + 3 + 7) >>> 3; + + // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + // opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + // s->last_lit)); + + if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; } + + } else { + // Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + + if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) { + /* 4: two words for the lengths */ + + /* + * The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. Otherwise + * we can't have processed more than WSIZE input bytes since the last block + * flush, because compression would have been successful. If LIT_BUFSIZE <= + * WSIZE, it is never too late to transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, last); + + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + + send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + + } else { + send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + // Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* + * The above check is made mod 2^32, for files larger than 512 MB and uLong + * implemented on 32 bits. + */ + init_block(s); + + if (last) { + bi_windup(s); + } + // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + // s->compressed_len-7*last)); +} + +/* + * =========================================================================== + * Save the match info and tally the frequency counts. Return true if the + * current block must be flushed. + */ +function _tr_tally(s, dist, lc) +// deflate_state *s; +// unsigned dist; /* distance of matched string */ +// unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + // var out_length, in_length, dcode; + + s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff; + + s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff; + s.last_lit++; + + if (dist === 0) { + /* lc is the unmatched char */ + s.dyn_ltree[lc * 2]/* .Freq */++; + } else { + s.matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + // Assert((ush)dist < (ush)MAX_DIST(s) && + // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + // (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/* .Freq */++; + s.dyn_dtree[d_code(dist) * 2]/* .Freq */++; + } + +// (!) This block is disabled in zlib defailts, +// don't enable it for binary compatibility + +// #ifdef TRUNCATE_BLOCK +// /* Try to guess if it is profitable to stop the current block here */ +// if ((s.last_lit & 0x1fff) === 0 && s.level > 2) { +// /* Compute an upper bound for the compressed length */ +// out_length = s.last_lit*8; +// in_length = s.strstart - s.block_start; +// +// for (dcode = 0; dcode < D_CODES; dcode++) { +// out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]); +// } +// out_length >>>= 3; +// //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", +// // s->last_lit, in_length, out_length, +// // 100L - out_length*100L/in_length)); +// if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int +// /2*/) { +// return true; +// } +// } +// #endif + + return (s.last_lit === s.lit_bufsize - 1); + /* + * We avoid equality with lit_bufsize because of wraparound at 64K on 16 bit + * machines and because stored blocks are restricted to 64K-1 bytes. + */ +} + +exports._tr_init = _tr_init; +exports._tr_stored_block = _tr_stored_block; +exports._tr_flush_block = _tr_flush_block; +exports._tr_tally = _tr_tally; +exports._tr_align = _tr_align; + +},{"../utils/common":3}],13:[function(require,module,exports){ +'use strict'; + + +function ZStream() { + /* next input byte */ + this.input = null; // JS specific, because we have no pointers + this.next_in = 0; + /* number of bytes available at input */ + this.avail_in = 0; + /* total number of input bytes read so far */ + this.total_in = 0; + /* next output byte should be put there */ + this.output = null; // JS specific, because we have no pointers + this.next_out = 0; + /* remaining free space at output */ + this.avail_out = 0; + /* total number of bytes output so far */ + this.total_out = 0; + /* last error message, NULL if no error */ + this.msg = ''/* Z_NULL */; + /* not visible by applications */ + this.state = null; + /* best guess about the data type: binary or text */ + this.data_type = 2/* Z_UNKNOWN */; + /* adler32 value of the uncompressed data */ + this.adler = 0; +} + +module.exports = ZStream; + +},{}],14:[function(require,module,exports){ +(function (process,Buffer){ +var msg = require('pako/lib/zlib/messages'); +var zstream = require('pako/lib/zlib/zstream'); +var zlib_deflate = require('pako/lib/zlib/deflate.js'); +var zlib_inflate = require('pako/lib/zlib/inflate.js'); +var constants = require('pako/lib/zlib/constants'); + +for (var key in constants) { + exports[key] = constants[key]; +} + +// zlib modes +exports.NONE = 0; +exports.DEFLATE = 1; +exports.INFLATE = 2; +exports.GZIP = 3; +exports.GUNZIP = 4; +exports.DEFLATERAW = 5; +exports.INFLATERAW = 6; +exports.UNZIP = 7; + +/** + * Emulate Node's zlib C++ layer for use by the JS layer in index.js + */ +function Zlib(mode) { + if (mode < exports.DEFLATE || mode > exports.UNZIP) + throw new TypeError("Bad argument"); + + this.mode = mode; + this.init_done = false; + this.write_in_progress = false; + this.pending_close = false; + this.windowBits = 0; + this.level = 0; + this.memLevel = 0; + this.strategy = 0; + this.dictionary = null; +} + +Zlib.prototype.init = function(windowBits, level, memLevel, strategy, dictionary) { + this.windowBits = windowBits; + this.level = level; + this.memLevel = memLevel; + this.strategy = strategy; + // dictionary not supported. + + if (this.mode === exports.GZIP || this.mode === exports.GUNZIP) + this.windowBits += 16; + + if (this.mode === exports.UNZIP) + this.windowBits += 32; + + if (this.mode === exports.DEFLATERAW || this.mode === exports.INFLATERAW) + this.windowBits = -this.windowBits; + + this.strm = new zstream(); + + switch (this.mode) { + case exports.DEFLATE: + case exports.GZIP: + case exports.DEFLATERAW: + var status = zlib_deflate.deflateInit2( + this.strm, + this.level, + exports.Z_DEFLATED, + this.windowBits, + this.memLevel, + this.strategy + ); + break; + case exports.INFLATE: + case exports.GUNZIP: + case exports.INFLATERAW: + case exports.UNZIP: + var status = zlib_inflate.inflateInit2( + this.strm, + this.windowBits + ); + break; + default: + throw new Error("Unknown mode " + this.mode); + } + + if (status !== exports.Z_OK) { + this._error(status); + return; + } + + this.write_in_progress = false; + this.init_done = true; +}; + +Zlib.prototype.params = function() { + throw new Error("deflateParams Not supported"); +}; + +Zlib.prototype._writeCheck = function() { + if (!this.init_done) + throw new Error("write before init"); + + if (this.mode === exports.NONE) + throw new Error("already finalized"); + + if (this.write_in_progress) + throw new Error("write already in progress"); + + if (this.pending_close) + throw new Error("close is pending"); +}; + +Zlib.prototype.write = function(flush, input, in_off, in_len, out, out_off, out_len) { + this._writeCheck(); + this.write_in_progress = true; + + var self = this; + process.nextTick(function() { + self.write_in_progress = false; + var res = self._write(flush, input, in_off, in_len, out, out_off, out_len); + self.callback(res[0], res[1]); + + if (self.pending_close) + self.close(); + }); + + return this; +}; + +// set method for Node buffers, used by pako +function bufferSet(data, offset) { + for (var i = 0; i < data.length; i++) { + this[offset + i] = data[i]; + } +} + +Zlib.prototype.writeSync = function(flush, input, in_off, in_len, out, out_off, out_len) { + this._writeCheck(); + return this._write(flush, input, in_off, in_len, out, out_off, out_len); +}; + +Zlib.prototype._write = function(flush, input, in_off, in_len, out, out_off, out_len) { + this.write_in_progress = true; + + if (flush !== exports.Z_NO_FLUSH && + flush !== exports.Z_PARTIAL_FLUSH && + flush !== exports.Z_SYNC_FLUSH && + flush !== exports.Z_FULL_FLUSH && + flush !== exports.Z_FINISH && + flush !== exports.Z_BLOCK) { + throw new Error("Invalid flush value"); + } + + if (input == null) { + input = new Buffer(0); + in_len = 0; + in_off = 0; + } + + if (out._set) + out.set = out._set; + else + out.set = bufferSet; + + var strm = this.strm; + strm.avail_in = in_len; + strm.input = input; + strm.next_in = in_off; + strm.avail_out = out_len; + strm.output = out; + strm.next_out = out_off; + + switch (this.mode) { + case exports.DEFLATE: + case exports.GZIP: + case exports.DEFLATERAW: + var status = zlib_deflate.deflate(strm, flush); + break; + case exports.UNZIP: + case exports.INFLATE: + case exports.GUNZIP: + case exports.INFLATERAW: + var status = zlib_inflate.inflate(strm, flush); + break; + default: + throw new Error("Unknown mode " + this.mode); + } + + if (status !== exports.Z_STREAM_END && status !== exports.Z_OK) { + this._error(status); + } + + this.write_in_progress = false; + return [strm.avail_in, strm.avail_out]; +}; + +Zlib.prototype.close = function() { + if (this.write_in_progress) { + this.pending_close = true; + return; + } + + this.pending_close = false; + + if (this.mode === exports.DEFLATE || this.mode === exports.GZIP || this.mode === exports.DEFLATERAW) { + zlib_deflate.deflateEnd(this.strm); + } else { + zlib_inflate.inflateEnd(this.strm); + } + + this.mode = exports.NONE; +}; + +Zlib.prototype.reset = function() { + switch (this.mode) { + case exports.DEFLATE: + case exports.DEFLATERAW: + var status = zlib_deflate.deflateReset(this.strm); + break; + case exports.INFLATE: + case exports.INFLATERAW: + var status = zlib_inflate.inflateReset(this.strm); + break; + } + + if (status !== exports.Z_OK) { + this._error(status); + } +}; + +Zlib.prototype._error = function(status) { + this.onerror(msg[status] + ': ' + this.strm.msg, status); + + this.write_in_progress = false; + if (this.pending_close) + this.close(); +}; + +exports.Zlib = Zlib; + +}).call(this,require('_process'),require("buffer").Buffer) +},{"_process":23,"buffer":16,"pako/lib/zlib/constants":5,"pako/lib/zlib/deflate.js":7,"pako/lib/zlib/inflate.js":9,"pako/lib/zlib/messages":11,"pako/lib/zlib/zstream":13}],15:[function(require,module,exports){ +(function (process,Buffer){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +var Transform = require('_stream_transform'); + +var binding = require('./binding'); +var util = require('util'); +var assert = require('assert').ok; + +// zlib doesn't provide these, so kludge them in following the same +// const naming scheme zlib uses. +binding.Z_MIN_WINDOWBITS = 8; +binding.Z_MAX_WINDOWBITS = 15; +binding.Z_DEFAULT_WINDOWBITS = 15; + +// fewer than 64 bytes per chunk is stupid. +// technically it could work with as few as 8, but even 64 bytes +// is absurdly low. Usually a MB or more is best. +binding.Z_MIN_CHUNK = 64; +binding.Z_MAX_CHUNK = Infinity; +binding.Z_DEFAULT_CHUNK = (16 * 1024); + +binding.Z_MIN_MEMLEVEL = 1; +binding.Z_MAX_MEMLEVEL = 9; +binding.Z_DEFAULT_MEMLEVEL = 8; + +binding.Z_MIN_LEVEL = -1; +binding.Z_MAX_LEVEL = 9; +binding.Z_DEFAULT_LEVEL = binding.Z_DEFAULT_COMPRESSION; + +// expose all the zlib constants +Object.keys(binding).forEach(function(k) { + if (k.match(/^Z/)) exports[k] = binding[k]; +}); + +// translation table for return codes. +exports.codes = { + Z_OK: binding.Z_OK, + Z_STREAM_END: binding.Z_STREAM_END, + Z_NEED_DICT: binding.Z_NEED_DICT, + Z_ERRNO: binding.Z_ERRNO, + Z_STREAM_ERROR: binding.Z_STREAM_ERROR, + Z_DATA_ERROR: binding.Z_DATA_ERROR, + Z_MEM_ERROR: binding.Z_MEM_ERROR, + Z_BUF_ERROR: binding.Z_BUF_ERROR, + Z_VERSION_ERROR: binding.Z_VERSION_ERROR +}; + +Object.keys(exports.codes).forEach(function(k) { + exports.codes[exports.codes[k]] = k; +}); + +exports.Deflate = Deflate; +exports.Inflate = Inflate; +exports.Gzip = Gzip; +exports.Gunzip = Gunzip; +exports.DeflateRaw = DeflateRaw; +exports.InflateRaw = InflateRaw; +exports.Unzip = Unzip; + +exports.createDeflate = function(o) { + return new Deflate(o); +}; + +exports.createInflate = function(o) { + return new Inflate(o); +}; + +exports.createDeflateRaw = function(o) { + return new DeflateRaw(o); +}; + +exports.createInflateRaw = function(o) { + return new InflateRaw(o); +}; + +exports.createGzip = function(o) { + return new Gzip(o); +}; + +exports.createGunzip = function(o) { + return new Gunzip(o); +}; + +exports.createUnzip = function(o) { + return new Unzip(o); +}; + + +// Convenience methods. +// compress/decompress a string or buffer in one step. +exports.deflate = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Deflate(opts), buffer, callback); +}; + +exports.deflateSync = function(buffer, opts) { + return zlibBufferSync(new Deflate(opts), buffer); +}; + +exports.gzip = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Gzip(opts), buffer, callback); +}; + +exports.gzipSync = function(buffer, opts) { + return zlibBufferSync(new Gzip(opts), buffer); +}; + +exports.deflateRaw = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new DeflateRaw(opts), buffer, callback); +}; + +exports.deflateRawSync = function(buffer, opts) { + return zlibBufferSync(new DeflateRaw(opts), buffer); +}; + +exports.unzip = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Unzip(opts), buffer, callback); +}; + +exports.unzipSync = function(buffer, opts) { + return zlibBufferSync(new Unzip(opts), buffer); +}; + +exports.inflate = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Inflate(opts), buffer, callback); +}; + +exports.inflateSync = function(buffer, opts) { + return zlibBufferSync(new Inflate(opts), buffer); +}; + +exports.gunzip = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Gunzip(opts), buffer, callback); +}; + +exports.gunzipSync = function(buffer, opts) { + return zlibBufferSync(new Gunzip(opts), buffer); +}; + +exports.inflateRaw = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new InflateRaw(opts), buffer, callback); +}; + +exports.inflateRawSync = function(buffer, opts) { + return zlibBufferSync(new InflateRaw(opts), buffer); +}; + +function zlibBuffer(engine, buffer, callback) { + var buffers = []; + var nread = 0; + + engine.on('error', onError); + engine.on('end', onEnd); + + engine.end(buffer); + flow(); + + function flow() { + var chunk; + while (null !== (chunk = engine.read())) { + buffers.push(chunk); + nread += chunk.length; + } + engine.once('readable', flow); + } + + function onError(err) { + engine.removeListener('end', onEnd); + engine.removeListener('readable', flow); + callback(err); + } + + function onEnd() { + var buf = Buffer.concat(buffers, nread); + buffers = []; + callback(null, buf); + engine.close(); + } +} + +function zlibBufferSync(engine, buffer) { + if (typeof buffer === 'string') + buffer = new Buffer(buffer); + if (!Buffer.isBuffer(buffer)) + throw new TypeError('Not a string or buffer'); + + var flushFlag = binding.Z_FINISH; + + return engine._processChunk(buffer, flushFlag); +} + +// generic zlib +// minimal 2-byte header +function Deflate(opts) { + if (!(this instanceof Deflate)) return new Deflate(opts); + Zlib.call(this, opts, binding.DEFLATE); +} + +function Inflate(opts) { + if (!(this instanceof Inflate)) return new Inflate(opts); + Zlib.call(this, opts, binding.INFLATE); +} + + + +// gzip - bigger header, same deflate compression +function Gzip(opts) { + if (!(this instanceof Gzip)) return new Gzip(opts); + Zlib.call(this, opts, binding.GZIP); +} + +function Gunzip(opts) { + if (!(this instanceof Gunzip)) return new Gunzip(opts); + Zlib.call(this, opts, binding.GUNZIP); +} + + + +// raw - no header +function DeflateRaw(opts) { + if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts); + Zlib.call(this, opts, binding.DEFLATERAW); +} + +function InflateRaw(opts) { + if (!(this instanceof InflateRaw)) return new InflateRaw(opts); + Zlib.call(this, opts, binding.INFLATERAW); +} + + +// auto-detect header. +function Unzip(opts) { + if (!(this instanceof Unzip)) return new Unzip(opts); + Zlib.call(this, opts, binding.UNZIP); +} + + +// the Zlib class they all inherit from +// This thing manages the queue of requests, and returns +// true or false if there is anything in the queue when +// you call the .write() method. + +function Zlib(opts, mode) { + this._opts = opts = opts || {}; + this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK; + + Transform.call(this, opts); + + if (opts.flush) { + if (opts.flush !== binding.Z_NO_FLUSH && + opts.flush !== binding.Z_PARTIAL_FLUSH && + opts.flush !== binding.Z_SYNC_FLUSH && + opts.flush !== binding.Z_FULL_FLUSH && + opts.flush !== binding.Z_FINISH && + opts.flush !== binding.Z_BLOCK) { + throw new Error('Invalid flush flag: ' + opts.flush); + } + } + this._flushFlag = opts.flush || binding.Z_NO_FLUSH; + + if (opts.chunkSize) { + if (opts.chunkSize < exports.Z_MIN_CHUNK || + opts.chunkSize > exports.Z_MAX_CHUNK) { + throw new Error('Invalid chunk size: ' + opts.chunkSize); + } + } + + if (opts.windowBits) { + if (opts.windowBits < exports.Z_MIN_WINDOWBITS || + opts.windowBits > exports.Z_MAX_WINDOWBITS) { + throw new Error('Invalid windowBits: ' + opts.windowBits); + } + } + + if (opts.level) { + if (opts.level < exports.Z_MIN_LEVEL || + opts.level > exports.Z_MAX_LEVEL) { + throw new Error('Invalid compression level: ' + opts.level); + } + } + + if (opts.memLevel) { + if (opts.memLevel < exports.Z_MIN_MEMLEVEL || + opts.memLevel > exports.Z_MAX_MEMLEVEL) { + throw new Error('Invalid memLevel: ' + opts.memLevel); + } + } + + if (opts.strategy) { + if (opts.strategy != exports.Z_FILTERED && + opts.strategy != exports.Z_HUFFMAN_ONLY && + opts.strategy != exports.Z_RLE && + opts.strategy != exports.Z_FIXED && + opts.strategy != exports.Z_DEFAULT_STRATEGY) { + throw new Error('Invalid strategy: ' + opts.strategy); + } + } + + if (opts.dictionary) { + if (!Buffer.isBuffer(opts.dictionary)) { + throw new Error('Invalid dictionary: it should be a Buffer instance'); + } + } + + this._binding = new binding.Zlib(mode); + + var self = this; + this._hadError = false; + this._binding.onerror = function(message, errno) { + // there is no way to cleanly recover. + // continuing only obscures problems. + self._binding = null; + self._hadError = true; + + var error = new Error(message); + error.errno = errno; + error.code = exports.codes[errno]; + self.emit('error', error); + }; + + var level = exports.Z_DEFAULT_COMPRESSION; + if (typeof opts.level === 'number') level = opts.level; + + var strategy = exports.Z_DEFAULT_STRATEGY; + if (typeof opts.strategy === 'number') strategy = opts.strategy; + + this._binding.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS, + level, + opts.memLevel || exports.Z_DEFAULT_MEMLEVEL, + strategy, + opts.dictionary); + + this._buffer = new Buffer(this._chunkSize); + this._offset = 0; + this._closed = false; + this._level = level; + this._strategy = strategy; + + this.once('end', this.close); +} + +util.inherits(Zlib, Transform); + +Zlib.prototype.params = function(level, strategy, callback) { + if (level < exports.Z_MIN_LEVEL || + level > exports.Z_MAX_LEVEL) { + throw new RangeError('Invalid compression level: ' + level); + } + if (strategy != exports.Z_FILTERED && + strategy != exports.Z_HUFFMAN_ONLY && + strategy != exports.Z_RLE && + strategy != exports.Z_FIXED && + strategy != exports.Z_DEFAULT_STRATEGY) { + throw new TypeError('Invalid strategy: ' + strategy); + } + + if (this._level !== level || this._strategy !== strategy) { + var self = this; + this.flush(binding.Z_SYNC_FLUSH, function() { + self._binding.params(level, strategy); + if (!self._hadError) { + self._level = level; + self._strategy = strategy; + if (callback) callback(); + } + }); + } else { + process.nextTick(callback); + } +}; + +Zlib.prototype.reset = function() { + return this._binding.reset(); +}; + +// This is the _flush function called by the transform class, +// internally, when the last chunk has been written. +Zlib.prototype._flush = function(callback) { + this._transform(new Buffer(0), '', callback); +}; + +Zlib.prototype.flush = function(kind, callback) { + var ws = this._writableState; + + if (typeof kind === 'function' || (kind === void 0 && !callback)) { + callback = kind; + kind = binding.Z_FULL_FLUSH; + } + + if (ws.ended) { + if (callback) + process.nextTick(callback); + } else if (ws.ending) { + if (callback) + this.once('end', callback); + } else if (ws.needDrain) { + var self = this; + this.once('drain', function() { + self.flush(callback); + }); + } else { + this._flushFlag = kind; + this.write(new Buffer(0), '', callback); + } +}; + +Zlib.prototype.close = function(callback) { + if (callback) + process.nextTick(callback); + + if (this._closed) + return; + + this._closed = true; + + this._binding.close(); + + var self = this; + process.nextTick(function() { + self.emit('close'); + }); +}; + +Zlib.prototype._transform = function(chunk, encoding, cb) { + var flushFlag; + var ws = this._writableState; + var ending = ws.ending || ws.ended; + var last = ending && (!chunk || ws.length === chunk.length); + + if (!chunk === null && !Buffer.isBuffer(chunk)) + return cb(new Error('invalid input')); + + // If it's the last chunk, or a final flush, we use the Z_FINISH flush flag. + // If it's explicitly flushing at some other time, then we use + // Z_FULL_FLUSH. Otherwise, use Z_NO_FLUSH for maximum compression + // goodness. + if (last) + flushFlag = binding.Z_FINISH; + else { + flushFlag = this._flushFlag; + // once we've flushed the last of the queue, stop flushing and + // go back to the normal behavior. + if (chunk.length >= ws.length) { + this._flushFlag = this._opts.flush || binding.Z_NO_FLUSH; + } + } + + var self = this; + this._processChunk(chunk, flushFlag, cb); +}; + +Zlib.prototype._processChunk = function(chunk, flushFlag, cb) { + var availInBefore = chunk && chunk.length; + var availOutBefore = this._chunkSize - this._offset; + var inOff = 0; + + var self = this; + + var async = typeof cb === 'function'; + + if (!async) { + var buffers = []; + var nread = 0; + + var error; + this.on('error', function(er) { + error = er; + }); + + do { + var res = this._binding.writeSync(flushFlag, + chunk, // in + inOff, // in_off + availInBefore, // in_len + this._buffer, // out + this._offset, // out_off + availOutBefore); // out_len + } while (!this._hadError && callback(res[0], res[1])); + + if (this._hadError) { + throw error; + } + + var buf = Buffer.concat(buffers, nread); + this.close(); + + return buf; + } + + var req = this._binding.write(flushFlag, + chunk, // in + inOff, // in_off + availInBefore, // in_len + this._buffer, // out + this._offset, // out_off + availOutBefore); // out_len + + req.buffer = chunk; + req.callback = callback; + + function callback(availInAfter, availOutAfter) { + if (self._hadError) + return; + + var have = availOutBefore - availOutAfter; + assert(have >= 0, 'have should not go down'); + + if (have > 0) { + var out = self._buffer.slice(self._offset, self._offset + have); + self._offset += have; + // serve some output to the consumer. + if (async) { + self.push(out); + } else { + buffers.push(out); + nread += out.length; + } + } + + // exhausted the output buffer, or used all the input create a new one. + if (availOutAfter === 0 || self._offset >= self._chunkSize) { + availOutBefore = self._chunkSize; + self._offset = 0; + self._buffer = new Buffer(self._chunkSize); + } + + if (availOutAfter === 0) { + // Not actually done. Need to reprocess. + // Also, update the availInBefore to the availInAfter value, + // so that if we have to hit it a third (fourth, etc.) time, + // it'll have the correct byte counts. + inOff += (availInBefore - availInAfter); + availInBefore = availInAfter; + + if (!async) + return true; + + var newReq = self._binding.write(flushFlag, + chunk, + inOff, + availInBefore, + self._buffer, + self._offset, + self._chunkSize); + newReq.callback = callback; // this same function + newReq.buffer = chunk; + return; + } + + if (!async) + return false; + + // finished with the chunk. + cb(); + } +}; + +util.inherits(Deflate, Zlib); +util.inherits(Inflate, Zlib); +util.inherits(Gzip, Zlib); +util.inherits(Gunzip, Zlib); +util.inherits(DeflateRaw, Zlib); +util.inherits(InflateRaw, Zlib); +util.inherits(Unzip, Zlib); + +}).call(this,require('_process'),require("buffer").Buffer) +},{"./binding":14,"_process":23,"_stream_transform":40,"assert":1,"buffer":16,"util":47}],16:[function(require,module,exports){ +/* + * ! The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> @license + * MIT + */ +/* eslint-disable no-proto */ + +'use strict' + +var base64 = require('base64-js') +var ieee754 = require('ieee754') + +exports.Buffer = Buffer +exports.SlowBuffer = SlowBuffer +exports.INSPECT_MAX_BYTES = 50 + +var K_MAX_LENGTH = 0x7fffffff +exports.kMaxLength = K_MAX_LENGTH + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: === true Use Uint8Array implementation + * (fastest) === false Print warning and recommend using `buffer` v4.x which has + * an Object implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari + * 5.1+, Opera 11.6+, iOS 4.2+. + * + * We report that the browser does not support typed arrays if the are not + * subclassable using __proto__. Firefox 4-29 lacks support for adding new + * properties to `Uint8Array` (See: + * https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support for + * __proto__ and has a buggy typed array implementation. + */ +Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() + +if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && + typeof console.error === 'function') { + console.error( + 'This browser lacks typed array (Uint8Array) support which is required by ' + + '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' + ) +} + +function typedArraySupport () { + // Can typed array instances can be augmented? + try { + var arr = new Uint8Array(1) + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} + return arr.foo() === 42 + } catch (e) { + return false + } +} + +function createBuffer (length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('Invalid typed array length') + } + // Return an augmented `Uint8Array` instance + var buf = new Uint8Array(length) + buf.__proto__ = Buffer.prototype + return buf +} + +/** + * The Buffer constructor returns instances of `Uint8Array` that have their + * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass + * of `Uint8Array`, so the returned instances will have all the node `Buffer` + * methods and the `Uint8Array` methods. Square bracket notation works as + * expected -- it returns a single octet. + * + * The `Uint8Array` prototype remains unmodified. + */ + +function Buffer (arg, encodingOrOffset, length) { + // Common case. + if (typeof arg === 'number') { + if (typeof encodingOrOffset === 'string') { + throw new Error( + 'If encoding is specified then the first argument must be a string' + ) + } + return allocUnsafe(arg) + } + return from(arg, encodingOrOffset, length) +} + +// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 +if (typeof Symbol !== 'undefined' && Symbol.species && + Buffer[Symbol.species] === Buffer) { + Object.defineProperty(Buffer, Symbol.species, { + value: null, + configurable: true, + enumerable: false, + writable: false + }) +} + +Buffer.poolSize = 8192 // not used by this implementation + +function from (value, encodingOrOffset, length) { + if (typeof value === 'number') { + throw new TypeError('"value" argument must not be a number') + } + + if (value instanceof ArrayBuffer) { + return fromArrayBuffer(value, encodingOrOffset, length) + } + + if (typeof value === 'string') { + return fromString(value, encodingOrOffset) + } + + return fromObject(value) +} + +/** + * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError if + * value is a number. Buffer.from(str[, encoding]) Buffer.from(array) + * Buffer.from(buffer) Buffer.from(arrayBuffer[, byteOffset[, length]]) + */ +Buffer.from = function (value, encodingOrOffset, length) { + return from(value, encodingOrOffset, length) +} + +// Note: Change prototype *after* Buffer.from is defined to workaround Chrome +// bug: +// https://github.com/feross/buffer/pull/148 +Buffer.prototype.__proto__ = Uint8Array.prototype +Buffer.__proto__ = Uint8Array + +function assertSize (size) { + if (typeof size !== 'number') { + throw new TypeError('"size" argument must be a number') + } else if (size < 0) { + throw new RangeError('"size" argument must not be negative') + } +} + +function alloc (size, fill, encoding) { + assertSize(size) + if (size <= 0) { + return createBuffer(size) + } + if (fill !== undefined) { + // Only pay attention to encoding if it's a string. This + // prevents accidentally sending in a number that would + // be interpretted as a start offset. + return typeof encoding === 'string' + ? createBuffer(size).fill(fill, encoding) + : createBuffer(size).fill(fill) + } + return createBuffer(size) +} + +/** + * Creates a new filled Buffer instance. alloc(size[, fill[, encoding]]) + */ +Buffer.alloc = function (size, fill, encoding) { + return alloc(size, fill, encoding) +} + +function allocUnsafe (size) { + assertSize(size) + return createBuffer(size < 0 ? 0 : checked(size) | 0) +} + +/** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer + * instance. + */ +Buffer.allocUnsafe = function (size) { + return allocUnsafe(size) +} +/** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer + * instance. + */ +Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(size) +} + +function fromString (string, encoding) { + if (typeof encoding !== 'string' || encoding === '') { + encoding = 'utf8' + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError('"encoding" must be a valid string encoding') + } + + var length = byteLength(string, encoding) | 0 + var buf = createBuffer(length) + + var actual = buf.write(string, encoding) + + if (actual !== length) { + // Writing a hex string, for example, that contains invalid characters will + // cause everything after the first invalid character to be ignored. (e.g. + // 'abxxcd' will be treated as 'ab') + buf = buf.slice(0, actual) + } + + return buf +} + +function fromArrayLike (array) { + var length = array.length < 0 ? 0 : checked(array.length) | 0 + var buf = createBuffer(length) + for (var i = 0; i < length; i += 1) { + buf[i] = array[i] & 255 + } + return buf +} + +function fromArrayBuffer (array, byteOffset, length) { + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('\'offset\' is out of bounds') + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('\'length\' is out of bounds') + } + + var buf + if (byteOffset === undefined && length === undefined) { + buf = new Uint8Array(array) + } else if (length === undefined) { + buf = new Uint8Array(array, byteOffset) + } else { + buf = new Uint8Array(array, byteOffset, length) + } + + // Return an augmented `Uint8Array` instance + buf.__proto__ = Buffer.prototype + return buf +} + +function fromObject (obj) { + if (Buffer.isBuffer(obj)) { + var len = checked(obj.length) | 0 + var buf = createBuffer(len) + + if (buf.length === 0) { + return buf + } + + obj.copy(buf, 0, 0, len) + return buf + } + + if (obj) { + if (isArrayBufferView(obj) || 'length' in obj) { + if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { + return createBuffer(0) + } + return fromArrayLike(obj) + } + + if (obj.type === 'Buffer' && Array.isArray(obj.data)) { + return fromArrayLike(obj.data) + } + } + + throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') +} + +function checked (length) { + // Note: cannot use `length < K_MAX_LENGTH` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= K_MAX_LENGTH) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') + } + return length | 0 +} + +function SlowBuffer (length) { + if (+length != length) { // eslint-disable-line eqeqeq + length = 0 + } + return Buffer.alloc(+length) +} + +Buffer.isBuffer = function isBuffer (b) { + return b != null && b._isBuffer === true +} + +Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + if (a === b) return 0 + + var x = a.length + var y = b.length + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i] + y = b[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +Buffer.isEncoding = function isEncoding (encoding) { + switch (String(encoding).toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'latin1': + case 'binary': + case 'base64': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } +} + +Buffer.concat = function concat (list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + + if (list.length === 0) { + return Buffer.alloc(0) + } + + var i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; ++i) { + length += list[i].length + } + } + + var buffer = Buffer.allocUnsafe(length) + var pos = 0 + for (i = 0; i < list.length; ++i) { + var buf = list[i] + if (!Buffer.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + buf.copy(buffer, pos) + pos += buf.length + } + return buffer +} + +function byteLength (string, encoding) { + if (Buffer.isBuffer(string)) { + return string.length + } + if (isArrayBufferView(string) || string instanceof ArrayBuffer) { + return string.byteLength + } + if (typeof string !== 'string') { + string = '' + string + } + + var len = string.length + if (len === 0) return 0 + + // Use a for loop to avoid recursion + var loweredCase = false + for (;;) { + switch (encoding) { + case 'ascii': + case 'latin1': + case 'binary': + return len + case 'utf8': + case 'utf-8': + case undefined: + return utf8ToBytes(string).length + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return len * 2 + case 'hex': + return len >>> 1 + case 'base64': + return base64ToBytes(string).length + default: + if (loweredCase) return utf8ToBytes(string).length // assume utf8 + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} +Buffer.byteLength = byteLength + +function slowToString (encoding, start, end) { + var loweredCase = false + + // No need to verify that "this.length <= MAX_UINT32" since it's a read-only + // property of a typed array. + + // This behaves neither like String nor Uint8Array in that we set start/end + // to their upper/lower bounds if the value passed is out of range. + // undefined is handled specially as per ECMA-262 6th Edition, + // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. + if (start === undefined || start < 0) { + start = 0 + } + // Return early if start > this.length. Done here to prevent potential + // uint32 + // coercion fail below. + if (start > this.length) { + return '' + } + + if (end === undefined || end > this.length) { + end = this.length + } + + if (end <= 0) { + return '' + } + + // Force coersion to uint32. This will also coerce falsey/NaN values to 0. + end >>>= 0 + start >>>= 0 + + if (end <= start) { + return '' + } + + if (!encoding) encoding = 'utf8' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'latin1': + case 'binary': + return latin1Slice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } +} + +// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) +// to detect a Buffer instance. It's not possible to use `instanceof Buffer` +// reliably in a browserify context because there could be multiple different +// copies of the 'buffer' package in use. This method works even for Buffer +// instances that were created from another copy of the `buffer` package. +// See: https://github.com/feross/buffer/issues/154 +Buffer.prototype._isBuffer = true + +function swap (b, n, m) { + var i = b[n] + b[n] = b[m] + b[m] = i +} + +Buffer.prototype.swap16 = function swap16 () { + var len = this.length + if (len % 2 !== 0) { + throw new RangeError('Buffer size must be a multiple of 16-bits') + } + for (var i = 0; i < len; i += 2) { + swap(this, i, i + 1) + } + return this +} + +Buffer.prototype.swap32 = function swap32 () { + var len = this.length + if (len % 4 !== 0) { + throw new RangeError('Buffer size must be a multiple of 32-bits') + } + for (var i = 0; i < len; i += 4) { + swap(this, i, i + 3) + swap(this, i + 1, i + 2) + } + return this +} + +Buffer.prototype.swap64 = function swap64 () { + var len = this.length + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits') + } + for (var i = 0; i < len; i += 8) { + swap(this, i, i + 7) + swap(this, i + 1, i + 6) + swap(this, i + 2, i + 5) + swap(this, i + 3, i + 4) + } + return this +} + +Buffer.prototype.toString = function toString () { + var length = this.length + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) +} + +Buffer.prototype.equals = function equals (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return true + return Buffer.compare(this, b) === 0 +} + +Buffer.prototype.inspect = function inspect () { + var str = '' + var max = exports.INSPECT_MAX_BYTES + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '<Buffer ' + str + '>' +} + +Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { + if (!Buffer.isBuffer(target)) { + throw new TypeError('Argument must be a Buffer') + } + + if (start === undefined) { + start = 0 + } + if (end === undefined) { + end = target ? target.length : 0 + } + if (thisStart === undefined) { + thisStart = 0 + } + if (thisEnd === undefined) { + thisEnd = this.length + } + + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError('out of range index') + } + + if (thisStart >= thisEnd && start >= end) { + return 0 + } + if (thisStart >= thisEnd) { + return -1 + } + if (start >= end) { + return 1 + } + + start >>>= 0 + end >>>= 0 + thisStart >>>= 0 + thisEnd >>>= 0 + + if (this === target) return 0 + + var x = thisEnd - thisStart + var y = end - start + var len = Math.min(x, y) + + var thisCopy = this.slice(thisStart, thisEnd) + var targetCopy = target.slice(start, end) + + for (var i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i] + y = targetCopy[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, +// OR the last index of `val` in `buffer` at offset <= `byteOffset`. +// +// Arguments: +// - buffer - a Buffer to search +// - val - a string, Buffer, or number +// - byteOffset - an index into `buffer`; will be clamped to an int32 +// - encoding - an optional encoding, relevant is val is a string +// - dir - true for indexOf, false for lastIndexOf +function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { + // Empty buffer means no match + if (buffer.length === 0) return -1 + + // Normalize byteOffset + if (typeof byteOffset === 'string') { + encoding = byteOffset + byteOffset = 0 + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000 + } + byteOffset = +byteOffset // Coerce to Number. + if (numberIsNaN(byteOffset)) { + // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : (buffer.length - 1) + } + + // Normalize byteOffset: negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = buffer.length + byteOffset + if (byteOffset >= buffer.length) { + if (dir) return -1 + else byteOffset = buffer.length - 1 + } else if (byteOffset < 0) { + if (dir) byteOffset = 0 + else return -1 + } + + // Normalize val + if (typeof val === 'string') { + val = Buffer.from(val, encoding) + } + + // Finally, search either indexOf (if dir is true) or lastIndexOf + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1 + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir) + } else if (typeof val === 'number') { + val = val & 0xFF // Search for a byte value [0-255] + if (typeof Uint8Array.prototype.indexOf === 'function') { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) + } + } + return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) + } + + throw new TypeError('val must be string, number or Buffer') +} + +function arrayIndexOf (arr, val, byteOffset, encoding, dir) { + var indexSize = 1 + var arrLength = arr.length + var valLength = val.length + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase() + if (encoding === 'ucs2' || encoding === 'ucs-2' || + encoding === 'utf16le' || encoding === 'utf-16le') { + if (arr.length < 2 || val.length < 2) { + return -1 + } + indexSize = 2 + arrLength /= 2 + valLength /= 2 + byteOffset /= 2 + } + } + + function read (buf, i) { + if (indexSize === 1) { + return buf[i] + } else { + return buf.readUInt16BE(i * indexSize) + } + } + + var i + if (dir) { + var foundIndex = -1 + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize + } else { + if (foundIndex !== -1) i -= i - foundIndex + foundIndex = -1 + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength + for (i = byteOffset; i >= 0; i--) { + var found = true + for (var j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false + break + } + } + if (found) return i + } + } + + return -1 +} + +Buffer.prototype.includes = function includes (val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1 +} + +Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true) +} + +Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false) +} + +function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + var remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; ++i) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (numberIsNaN(parsed)) return i + buf[offset + i] = parsed + } + return i +} + +function utf8Write (buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) +} + +function asciiWrite (buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length) +} + +function latin1Write (buf, string, offset, length) { + return asciiWrite(buf, string, offset, length) +} + +function base64Write (buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length) +} + +function ucs2Write (buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) +} + +Buffer.prototype.write = function write (string, offset, length, encoding) { + // Buffer#write(string) + if (offset === undefined) { + encoding = 'utf8' + length = this.length + offset = 0 + // Buffer#write(string, encoding) + } else if (length === undefined && typeof offset === 'string') { + encoding = offset + length = this.length + offset = 0 + // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset = offset >>> 0 + if (isFinite(length)) { + length = length >>> 0 + if (encoding === undefined) encoding = 'utf8' + } else { + encoding = length + length = undefined + } + } else { + throw new Error( + 'Buffer.write(string, encoding, offset[, length]) is no longer supported' + ) + } + + var remaining = this.length - offset + if (length === undefined || length > remaining) length = remaining + + if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { + throw new RangeError('Attempt to write outside buffer bounds') + } + + if (!encoding) encoding = 'utf8' + + var loweredCase = false + for (;;) { + switch (encoding) { + case 'hex': + return hexWrite(this, string, offset, length) + + case 'utf8': + case 'utf-8': + return utf8Write(this, string, offset, length) + + case 'ascii': + return asciiWrite(this, string, offset, length) + + case 'latin1': + case 'binary': + return latin1Write(this, string, offset, length) + + case 'base64': + // Warning: maxLength not taken into account in base64Write + return base64Write(this, string, offset, length) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return ucs2Write(this, string, offset, length) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.toJSON = function toJSON () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } +} + +function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } +} + +function utf8Slice (buf, start, end) { + end = Math.min(buf.length, end) + var res = [] + + var i = start + while (i < end) { + var firstByte = buf[i] + var codePoint = null + var bytesPerSequence = (firstByte > 0xEF) ? 4 + : (firstByte > 0xDF) ? 3 + : (firstByte > 0xBF) ? 2 + : 1 + + if (i + bytesPerSequence <= end) { + var secondByte, thirdByte, fourthByte, tempCodePoint + + switch (bytesPerSequence) { + case 1: + if (firstByte < 0x80) { + codePoint = firstByte + } + break + case 2: + secondByte = buf[i + 1] + if ((secondByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) + if (tempCodePoint > 0x7F) { + codePoint = tempCodePoint + } + } + break + case 3: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) + if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { + codePoint = tempCodePoint + } + } + break + case 4: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + fourthByte = buf[i + 3] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) + if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { + codePoint = tempCodePoint + } + } + } + } + + if (codePoint === null) { + // we did not generate a valid codePoint so insert a + // replacement char (U+FFFD) and advance only 1 byte + codePoint = 0xFFFD + bytesPerSequence = 1 + } else if (codePoint > 0xFFFF) { + // encode to utf16 (surrogate pair dance) + codePoint -= 0x10000 + res.push(codePoint >>> 10 & 0x3FF | 0xD800) + codePoint = 0xDC00 | codePoint & 0x3FF + } + + res.push(codePoint) + i += bytesPerSequence + } + + return decodeCodePointsArray(res) +} + +// Based on http://stackoverflow.com/a/22747272/680742, the browser with +// the lowest limit is Chrome, with 0x10000 args. +// We go 1 magnitude less, for safety +var MAX_ARGUMENTS_LENGTH = 0x1000 + +function decodeCodePointsArray (codePoints) { + var len = codePoints.length + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints) // avoid extra + // slice() + } + + // Decode in chunks to avoid "call stack size exceeded". + var res = '' + var i = 0 + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ) + } + return res +} + +function asciiSlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7F) + } + return ret +} + +function latin1Slice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]) + } + return ret +} + +function hexSlice (buf, start, end) { + var len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + var out = '' + for (var i = start; i < end; ++i) { + out += toHex(buf[i]) + } + return out +} + +function utf16leSlice (buf, start, end) { + var bytes = buf.slice(start, end) + var res = '' + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) + } + return res +} + +Buffer.prototype.slice = function slice (start, end) { + var len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len + if (start < 0) start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) end = 0 + } else if (end > len) { + end = len + } + + if (end < start) end = start + + var newBuf = this.subarray(start, end) + // Return an augmented `Uint8Array` instance + newBuf.__proto__ = Buffer.prototype + return newBuf +} + +/* + * Need to make sure that buffer isn't trying to write out of bounds. + */ +function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') + if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') +} + +Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + + return val +} + +Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + checkOffset(offset, byteLength, this.length) + } + + var val = this[offset + --byteLength] + var mul = 1 + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul + } + + return val +} + +Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) +} + +Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) +} + +Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var i = byteLength + var mul = 1 + var val = this[offset + --i] + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) return (this[offset]) + return ((0xff - this[offset] + 1) * -1) +} + +Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) +} + +Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) +} + +Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) +} + +function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') + if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') + if (offset + ext > buf.length) throw new RangeError('Index out of range') +} + +Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var mul = 1 + var i = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var i = byteLength - 1 + var mul = 1 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + return offset + 2 +} + +Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + return offset + 2 +} + +Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + return offset + 4 +} + +Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + return offset + 4 +} + +Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + var limit = Math.pow(2, (8 * byteLength) - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = 0 + var mul = 1 + var sub = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + var limit = Math.pow(2, (8 * byteLength) - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = byteLength - 1 + var mul = 1 + var sub = 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) + if (value < 0) value = 0xff + value + 1 + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + return offset + 2 +} + +Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + return offset + 2 +} + +Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + return offset + 4 +} + +Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + return offset + 4 +} + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError('Index out of range') + if (offset < 0) throw new RangeError('Index out of range') +} + +function writeFloat (buf, value, offset, littleEndian, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + } + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 +} + +Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) +} + +function writeDouble (buf, value, offset, littleEndian, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + } + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 +} + +Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) +} + +// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) +Buffer.prototype.copy = function copy (target, targetStart, start, end) { + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (targetStart >= target.length) targetStart = target.length + if (!targetStart) targetStart = 0 + if (end > 0 && end < start) end = start + + // Copy 0 bytes; we're done + if (end === start) return 0 + if (target.length === 0 || this.length === 0) return 0 + + // Fatal error conditions + if (targetStart < 0) { + throw new RangeError('targetStart out of bounds') + } + if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') + if (end < 0) throw new RangeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) end = this.length + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start + } + + var len = end - start + var i + + if (this === target && start < targetStart && targetStart < end) { + // descending copy from end + for (i = len - 1; i >= 0; --i) { + target[i + targetStart] = this[i + start] + } + } else if (len < 1000) { + // ascending copy from start + for (i = 0; i < len; ++i) { + target[i + targetStart] = this[i + start] + } + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, start + len), + targetStart + ) + } + + return len +} + +// Usage: +// buffer.fill(number[, offset[, end]]) +// buffer.fill(buffer[, offset[, end]]) +// buffer.fill(string[, offset[, end]][, encoding]) +Buffer.prototype.fill = function fill (val, start, end, encoding) { + // Handle string cases: + if (typeof val === 'string') { + if (typeof start === 'string') { + encoding = start + start = 0 + end = this.length + } else if (typeof end === 'string') { + encoding = end + end = this.length + } + if (val.length === 1) { + var code = val.charCodeAt(0) + if (code < 256) { + val = code + } + } + if (encoding !== undefined && typeof encoding !== 'string') { + throw new TypeError('encoding must be a string') + } + if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { + throw new TypeError('Unknown encoding: ' + encoding) + } + } else if (typeof val === 'number') { + val = val & 255 + } + + // Invalid ranges are not set to a default, so can range check early. + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError('Out of range index') + } + + if (end <= start) { + return this + } + + start = start >>> 0 + end = end === undefined ? this.length : end >>> 0 + + if (!val) val = 0 + + var i + if (typeof val === 'number') { + for (i = start; i < end; ++i) { + this[i] = val + } + } else { + var bytes = Buffer.isBuffer(val) + ? val + : new Buffer(val, encoding) + var len = bytes.length + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len] + } + } + + return this +} + +// HELPER FUNCTIONS +// ================ + +var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g + +function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, + // base64-js does not + str = str.trim().replace(INVALID_BASE64_RE, '') + // Node converts strings with length < 2 to '' + if (str.length < 2) return '' + // Node allows for non-padded base64 strings (missing trailing ===), + // base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str +} + +function toHex (n) { + if (n < 16) return '0' + n.toString(16) + return n.toString(16) +} + +function utf8ToBytes (string, units) { + units = units || Infinity + var codePoint + var length = string.length + var leadSurrogate = null + var bytes = [] + + for (var i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i) + + // is surrogate component + if (codePoint > 0xD7FF && codePoint < 0xE000) { + // last char was a lead + if (!leadSurrogate) { + // no lead yet + if (codePoint > 0xDBFF) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } + + // valid lead + leadSurrogate = codePoint + + continue + } + + // 2 leads in a row + if (codePoint < 0xDC00) { + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = codePoint + continue + } + + // valid surrogate pair + codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + } + + leadSurrogate = null + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break + bytes.push(codePoint) + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break + bytes.push( + codePoint >> 0x6 | 0xC0, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break + bytes.push( + codePoint >> 0xC | 0xE0, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break + bytes.push( + codePoint >> 0x12 | 0xF0, + codePoint >> 0xC & 0x3F | 0x80, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else { + throw new Error('Invalid code point') + } + } + + return bytes +} + +function asciiToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray +} + +function utf16leToBytes (str, units) { + var c, hi, lo + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break + + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray +} + +function base64ToBytes (str) { + return base64.toByteArray(base64clean(str)) +} + +function blitBuffer (src, dst, offset, length) { + for (var i = 0; i < length; ++i) { + if ((i + offset >= dst.length) || (i >= src.length)) break + dst[i + offset] = src[i] + } + return i +} + +// Node 0.10 supports `ArrayBuffer` but lacks `ArrayBuffer.isView` +function isArrayBufferView (obj) { + return (typeof ArrayBuffer.isView === 'function') && ArrayBuffer.isView(obj) +} + +function numberIsNaN (obj) { + return obj !== obj // eslint-disable-line no-self-compare +} + +},{"base64-js":17,"ieee754":18}],17:[function(require,module,exports){ +'use strict' + +exports.byteLength = byteLength +exports.toByteArray = toByteArray +exports.fromByteArray = fromByteArray + +var lookup = [] +var revLookup = [] +var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array + +var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' +for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i] + revLookup[code.charCodeAt(i)] = i +} + +revLookup['-'.charCodeAt(0)] = 62 +revLookup['_'.charCodeAt(0)] = 63 + +function placeHoldersCount (b64) { + var len = b64.length + if (len % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // the number of equal signs (place holders) + // if there are two placeholders, than the two characters before it + // represent one byte + // if there is only one, then the three characters before it represent 2 + // bytes + // this is just a cheap hack to not do indexOf twice + return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0 +} + +function byteLength (b64) { + // base64 is 4/3 + up to two characters of the original data + return (b64.length * 3 / 4) - placeHoldersCount(b64) +} + +function toByteArray (b64) { + var i, l, tmp, placeHolders, arr + var len = b64.length + placeHolders = placeHoldersCount(b64) + + arr = new Arr((len * 3 / 4) - placeHolders) + + // if there are placeholders, only get up to the last complete 4 chars + l = placeHolders > 0 ? len - 4 : len + + var L = 0 + + for (i = 0; i < l; i += 4) { + tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)] + arr[L++] = (tmp >> 16) & 0xFF + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + if (placeHolders === 2) { + tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4) + arr[L++] = tmp & 0xFF + } else if (placeHolders === 1) { + tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2) + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + return arr +} + +function tripletToBase64 (num) { + return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] +} + +function encodeChunk (uint8, start, end) { + var tmp + var output = [] + for (var i = start; i < end; i += 3) { + tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) + output.push(tripletToBase64(tmp)) + } + return output.join('') +} + +function fromByteArray (uint8) { + var tmp + var len = uint8.length + var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes + var output = '' + var parts = [] + var maxChunkLength = 16383 // must be multiple of 3 + + // go through the array every three bytes, we'll deal with trailing stuff + // later + for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { + parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + if (extraBytes === 1) { + tmp = uint8[len - 1] + output += lookup[tmp >> 2] + output += lookup[(tmp << 4) & 0x3F] + output += '==' + } else if (extraBytes === 2) { + tmp = (uint8[len - 2] << 8) + (uint8[len - 1]) + output += lookup[tmp >> 10] + output += lookup[(tmp >> 4) & 0x3F] + output += lookup[(tmp << 2) & 0x3F] + output += '=' + } + + parts.push(output) + + return parts.join('') +} + +},{}],18:[function(require,module,exports){ +exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] + + i += d + + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) +} + +exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 + } + + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + + buffer[offset + i - d] |= s * 128 +} + +},{}],19:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +function EventEmitter() { + this._events = this._events || {}; + this._maxListeners = this._maxListeners || undefined; +} +module.exports = EventEmitter; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +EventEmitter.defaultMaxListeners = 10; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; +}; + +EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; + + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } else { + // At least give some kind of context to the user + var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); + err.context = er; + throw err; + } + } + } + + handler = this._events[type]; + + if (isUndefined(handler)) + return false; + + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + args = Array.prototype.slice.call(arguments, 1); + handler.apply(this, args); + } + } else if (isObject(handler)) { + args = Array.prototype.slice.call(arguments, 1); + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } + + return true; +}; + +EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } + + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } + + return this; +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + var fired = false; + + function g() { + this.removeListener(type, g); + + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + + g.listener = listener; + this.on(type, g); + + return this; +}; + +// emits a 'removeListener' event iff the listener was removed +EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events || !this._events[type]) + return this; + + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; + } + } + + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); + } + + return this; +}; + +EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; + + if (!this._events) + return this; + + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } + + listeners = this._events[type]; + + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else if (listeners) { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); + } + delete this._events[type]; + + return this; +}; + +EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; +}; + +EventEmitter.prototype.listenerCount = function(type) { + if (this._events) { + var evlistener = this._events[type]; + + if (isFunction(evlistener)) + return 1; + else if (evlistener) + return evlistener.length; + } + return 0; +}; + +EventEmitter.listenerCount = function(emitter, type) { + return emitter.listenerCount(type); +}; + +function isFunction(arg) { + return typeof arg === 'function'; +} + +function isNumber(arg) { + return typeof arg === 'number'; +} + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} + +function isUndefined(arg) { + return arg === void 0; +} + +},{}],20:[function(require,module,exports){ +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + }; +} else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } +} + +},{}],21:[function(require,module,exports){ +/* + * ! Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> @license + * MIT + */ + +// The _isBuffer check is for Safari 5-7 support, because it's missing +// Object.prototype.constructor. Remove this eventually +module.exports = function (obj) { + return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) +} + +function isBuffer (obj) { + return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) +} + +// For Node v0.10 support. Remove this eventually. +function isSlowBuffer (obj) { + return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) +} + +},{}],22:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// resolves . and .. elements in a path array with directory names there +// must be no slashes, empty elements, or device names (c:\) in the array +// (so also no leading and trailing slashes - it does not distinguish +// relative and absolute paths) +function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; +} + +// Split a filename into [root, dir, basename, ext], unix version +// 'root' is just a slash, or nothing. +var splitPathRe = + /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; +var splitPath = function(filename) { + return splitPathRe.exec(filename).slice(1); +}; + +// path.resolve([from ...], to) +// posix version +exports.resolve = function() { + var resolvedPath = '', + resolvedAbsolute = false; + + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : process.cwd(); + + // Skip empty and invalid entries + if (typeof path !== 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + continue; + } + + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + + // Normalize the path + resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; +}; + +// path.normalize(path) +// posix version +exports.normalize = function(path) { + var isAbsolute = exports.isAbsolute(path), + trailingSlash = substr(path, -1) === '/'; + + // Normalize the path + path = normalizeArray(filter(path.split('/'), function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + + return (isAbsolute ? '/' : '') + path; +}; + +// posix version +exports.isAbsolute = function(path) { + return path.charAt(0) === '/'; +}; + +// posix version +exports.join = function() { + var paths = Array.prototype.slice.call(arguments, 0); + return exports.normalize(filter(paths, function(p, index) { + if (typeof p !== 'string') { + throw new TypeError('Arguments to path.join must be strings'); + } + return p; + }).join('/')); +}; + + +// path.relative(from, to) +// posix version +exports.relative = function(from, to) { + from = exports.resolve(from).substr(1); + to = exports.resolve(to).substr(1); + + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + + return outputParts.join('/'); +}; + +exports.sep = '/'; +exports.delimiter = ':'; + +exports.dirname = function(path) { + var result = splitPath(path), + root = result[0], + dir = result[1]; + + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + + return root + dir; +}; + + +exports.basename = function(path, ext) { + var f = splitPath(path)[2]; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + return f; +}; + + +exports.extname = function(path) { + return splitPath(path)[3]; +}; + +function filter (xs, f) { + if (xs.filter) return xs.filter(f); + var res = []; + for (var i = 0; i < xs.length; i++) { + if (f(xs[i], i, xs)) res.push(xs[i]); + } + return res; +} + +// String.prototype.substr - negative index don't work in IE8 +var substr = 'ab'.substr(-1) === 'b' + ? function (str, start, len) { return str.substr(start, len) } + : function (str, start, len) { + if (start < 0) start = str.length + start; + return str.substr(start, len); + } +; + +}).call(this,require('_process')) +},{"_process":23}],23:[function(require,module,exports){ +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + // normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. + // doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the + // global object for 'this', hopfully our context correct otherwise + // it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + // normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. + // doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the + // global object for 'this', hopfully our context correct otherwise + // it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs + // setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + +},{}],24:[function(require,module,exports){ +module.exports = require('./lib/_stream_duplex.js'); + +},{"./lib/_stream_duplex.js":25}],25:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a duplex stream is just a stream that is both readable and writable. +// Since JS doesn't have multiple prototypal inheritance, this class +// prototypally inherits from Readable, and then parasitically from +// Writable. + +'use strict'; + +/* <replacement> */ + +var processNextTick = require('process-nextick-args'); +/* </replacement> */ + +/* <replacement> */ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + keys.push(key); + }return keys; +}; +/* </replacement> */ + +module.exports = Duplex; + +/* <replacement> */ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/* </replacement> */ + +var Readable = require('./_stream_readable'); +var Writable = require('./_stream_writable'); + +util.inherits(Duplex, Readable); + +var keys = objectKeys(Writable.prototype); +for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; +} + +function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); + + Readable.call(this, options); + Writable.call(this, options); + + if (options && options.readable === false) this.readable = false; + + if (options && options.writable === false) this.writable = false; + + this.allowHalfOpen = true; + if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; + + this.once('end', onend); +} + +// the no-half-open enforcer +function onend() { + // if we allow half-open state, or if the writable side ended, + // then we're ok. + if (this.allowHalfOpen || this._writableState.ended) return; + + // no more data can be written. + // But allow more writes to happen in this tick. + processNextTick(onEndNT, this); +} + +function onEndNT(self) { + self.end(); +} + +Object.defineProperty(Duplex.prototype, 'destroyed', { + get: function () { + if (this._readableState === undefined || this._writableState === undefined) { + return false; + } + return this._readableState.destroyed && this._writableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (this._readableState === undefined || this._writableState === undefined) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + this._writableState.destroyed = value; + } +}); + +Duplex.prototype._destroy = function (err, cb) { + this.push(null); + this.end(); + + processNextTick(cb, err); +}; + +function forEach(xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} +},{"./_stream_readable":27,"./_stream_writable":29,"core-util-is":33,"inherits":20,"process-nextick-args":35}],26:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. + +'use strict'; + +module.exports = PassThrough; + +var Transform = require('./_stream_transform'); + +/* <replacement> */ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/* </replacement> */ + +util.inherits(PassThrough, Transform); + +function PassThrough(options) { + if (!(this instanceof PassThrough)) return new PassThrough(options); + + Transform.call(this, options); +} + +PassThrough.prototype._transform = function (chunk, encoding, cb) { + cb(null, chunk); +}; +},{"./_stream_transform":28,"core-util-is":33,"inherits":20}],27:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +'use strict'; + +/* <replacement> */ + +var processNextTick = require('process-nextick-args'); +/* </replacement> */ + +module.exports = Readable; + +/* <replacement> */ +var isArray = require('isarray'); +/* </replacement> */ + +/* <replacement> */ +var Duplex; +/* </replacement> */ + +Readable.ReadableState = ReadableState; + +/* <replacement> */ +var EE = require('events').EventEmitter; + +var EElistenerCount = function (emitter, type) { + return emitter.listeners(type).length; +}; +/* </replacement> */ + +/* <replacement> */ +var Stream = require('./internal/streams/stream'); +/* </replacement> */ + +// TODO(bmeurer): Change this back to const once hole checks are +// properly optimized away early in Ignition+TurboFan. +/* <replacement> */ +var Buffer = require('safe-buffer').Buffer; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Object.prototype.toString.call(obj) === '[object Uint8Array]' || Buffer.isBuffer(obj); +} +/* </replacement> */ + +/* <replacement> */ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/* </replacement> */ + +/* <replacement> */ +var debugUtil = require('util'); +var debug = void 0; +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function () {}; +} +/* </replacement> */ + +var BufferList = require('./internal/streams/BufferList'); +var destroyImpl = require('./internal/streams/destroy'); +var StringDecoder; + +util.inherits(Readable, Stream); + +var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; + +function prependListener(emitter, event, fn) { + // Sadly this is not cacheable as some libraries bundle their own + // event emitter implementation with them. + if (typeof emitter.prependListener === 'function') { + return emitter.prependListener(event, fn); + } else { + // This is a hack to make sure that our error handler is attached before any + // userland ones. NEVER DO THIS. This is here only because this code needs + // to continue to work with older versions of Node.js that do not include + // the prependListener() method. The goal is to eventually remove this hack. + if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; + } +} + +function ReadableState(options, stream) { + Duplex = Duplex || require('./_stream_duplex'); + + options = options || {}; + + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + var hwm = options.highWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = Math.floor(this.highWaterMark); + + // A linked list is used to store data chunks instead of an array because + // the + // linked list can remove elements from the beginning faster than + // array.shift() + this.buffer = new BufferList(); + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // a flag to be able to tell if the event 'readable'/'data' is emitted + // immediately, or on a later tick. We set this to true at first, because + // any actions that shouldn't happen until "later" should generally also + // not happen before the first read call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + + // has it been destroyed + this.destroyed = false; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + + // if true, a maybeReadMore has been scheduled + this.readingMore = false; + + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} + +function Readable(options) { + Duplex = Duplex || require('./_stream_duplex'); + + if (!(this instanceof Readable)) return new Readable(options); + + this._readableState = new ReadableState(options, this); + + // legacy + this.readable = true; + + if (options) { + if (typeof options.read === 'function') this._read = options.read; + + if (typeof options.destroy === 'function') this._destroy = options.destroy; + } + + Stream.call(this); +} + +Object.defineProperty(Readable.prototype, 'destroyed', { + get: function () { + if (this._readableState === undefined) { + return false; + } + return this._readableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._readableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + } +}); + +Readable.prototype.destroy = destroyImpl.destroy; +Readable.prototype._undestroy = destroyImpl.undestroy; +Readable.prototype._destroy = function (err, cb) { + this.push(null); + cb(err); +}; + +// Manually shove something into the read() buffer. +// This returns true if the highWaterMark has not been hit yet, +// similar to how Writable.write() returns true if you should +// write() some more. +Readable.prototype.push = function (chunk, encoding) { + var state = this._readableState; + var skipChunkCheck; + + if (!state.objectMode) { + if (typeof chunk === 'string') { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = Buffer.from(chunk, encoding); + encoding = ''; + } + skipChunkCheck = true; + } + } else { + skipChunkCheck = true; + } + + return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); +}; + +// Unshift should *always* be something directly out of read() +Readable.prototype.unshift = function (chunk) { + return readableAddChunk(this, chunk, null, true, false); +}; + +function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { + var state = stream._readableState; + if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else { + var er; + if (!skipChunkCheck) er = chunkInvalid(state, chunk); + if (er) { + stream.emit('error', er); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (typeof chunk !== 'string' && Object.getPrototypeOf(chunk) !== Buffer.prototype && !state.objectMode) { + chunk = _uint8ArrayToBuffer(chunk); + } + + if (addToFront) { + if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true); + } else if (state.ended) { + stream.emit('error', new Error('stream.push() after EOF')); + } else { + state.reading = false; + if (state.decoder && !encoding) { + chunk = state.decoder.write(chunk); + if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); + } else { + addChunk(stream, state, chunk, false); + } + } + } else if (!addToFront) { + state.reading = false; + } + } + + return needMoreData(state); +} + +function addChunk(stream, state, chunk, addToFront) { + if (state.flowing && state.length === 0 && !state.sync) { + stream.emit('data', chunk); + stream.read(0); + } else { + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); + + if (state.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state); +} + +function chunkInvalid(state, chunk) { + var er; + if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + return er; +} + +// if it's past the high water mark, we can push in some more. +// Also, if we have no data yet, we can stand some +// more bytes. This is to work around cases where hwm=0, +// such as the repl. Also, if the push() triggered a +// readable event, and the user called read(largeNumber) such that +// needReadable was set, then we ought to push more, so that another +// 'readable' event will be triggered. +function needMoreData(state) { + return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); +} + +Readable.prototype.isPaused = function () { + return this._readableState.flowing === false; +}; + +// backwards compatibility. +Readable.prototype.setEncoding = function (enc) { + if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; + this._readableState.decoder = new StringDecoder(enc); + this._readableState.encoding = enc; + return this; +}; + +// Don't raise the hwm > 8MB +var MAX_HWM = 0x800000; +function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + // Get the next highest power of 2 to prevent increasing hwm excessively in + // tiny amounts + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; +} + +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function howMuchToRead(n, state) { + if (n <= 0 || state.length === 0 && state.ended) return 0; + if (state.objectMode) return 1; + if (n !== n) { + // Only flow one buffer at a time + if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; + } + // If we're asking for more than the current hwm, then raise the hwm. + if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); + if (n <= state.length) return n; + // Don't have enough + if (!state.ended) { + state.needReadable = true; + return 0; + } + return state.length; +} + +// you can override either this method, or the async _read(n) below. +Readable.prototype.read = function (n) { + debug('read', n); + n = parseInt(n, 10); + var state = this._readableState; + var nOrig = n; + + if (n !== 0) state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { + debug('read: emitReadable', state.length, state.ended); + if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); + return null; + } + + n = howMuchToRead(n, state); + + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) endReadable(this); + return null; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + debug('need readable', doRead); + + // if we currently have less than the highWaterMark, then also read some + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + debug('length less than watermark', doRead); + } + + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) { + doRead = false; + debug('reading or ended', doRead); + } else if (doRead) { + debug('do read'); + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (!state.reading) n = howMuchToRead(nOrig, state); + } + + var ret; + if (n > 0) ret = fromList(n, state);else ret = null; + + if (ret === null) { + state.needReadable = true; + n = 0; + } else { + state.length -= n; + } + + if (state.length === 0) { + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (!state.ended) state.needReadable = true; + + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended) endReadable(this); + } + + if (ret !== null) this.emit('data', ret); + + return ret; +}; + +function onEofChunk(stream, state) { + if (state.ended) return; + if (state.decoder) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + + // emit 'readable' now to make sure it gets picked up. + emitReadable(stream); +} + +// Don't emit readable right away in sync mode, because this can trigger +// another read() call => stack overflow. This way, it might trigger +// a nextTick recursion warning, but that's not so bad. +function emitReadable(stream) { + var state = stream._readableState; + state.needReadable = false; + if (!state.emittedReadable) { + debug('emitReadable', state.flowing); + state.emittedReadable = true; + if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream); + } +} + +function emitReadable_(stream) { + debug('emit readable'); + stream.emit('readable'); + flow(stream); +} + +// at this point, the user has presumably seen the 'readable' event, +// and called read() to consume some data. that may have triggered +// in turn another _read(n) call, in which case reading = true if +// it's in progress. +// However, if we're not ended, or reading, and the length < hwm, +// then go ahead and try to read some more preemptively. +function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + processNextTick(maybeReadMore_, stream, state); + } +} + +function maybeReadMore_(stream, state) { + var len = state.length; + while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { + debug('maybeReadMore read 0'); + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break;else len = state.length; + } + state.readingMore = false; +} + +// abstract method. to be overridden in specific implementation classes. +// call cb(er, data) where data is <= n in length. +// for virtual (non-string, non-buffer) streams, "length" is somewhat +// arbitrary, and perhaps not very meaningful. +Readable.prototype._read = function (n) { + this.emit('error', new Error('_read() is not implemented')); +}; + +Readable.prototype.pipe = function (dest, pipeOpts) { + var src = this; + var state = this._readableState; + + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; + } + state.pipesCount += 1; + debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); + + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; + + var endFn = doEnd ? onend : unpipe; + if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn); + + dest.on('unpipe', onunpipe); + function onunpipe(readable, unpipeInfo) { + debug('onunpipe'); + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + + function onend() { + debug('onend'); + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + + var cleanedUp = false; + function cleanup() { + debug('cleanup'); + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', unpipe); + src.removeListener('data', ondata); + + cleanedUp = true; + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + + // If the user pushes more data while we're writing to dest then we'll end + // up + // in ondata again. However, we only want to increase awaitDrain once + // because + // dest will only emit one 'drain' event for the multiple writes. + // => Introduce a guard on increasing awaitDrain. + var increasedAwaitDrain = false; + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + increasedAwaitDrain = false; + var ret = dest.write(chunk); + if (false === ret && !increasedAwaitDrain) { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + // => Check whether `dest` is still a piping destination. + if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { + debug('false write response, pause', src._readableState.awaitDrain); + src._readableState.awaitDrain++; + increasedAwaitDrain = true; + } + src.pause(); + } + } + + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + debug('onerror', er); + unpipe(); + dest.removeListener('error', onerror); + if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); + } + + // Make sure our error handler is attached before userland ones. + prependListener(dest, 'error', onerror); + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + debug('onfinish'); + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + + function unpipe() { + debug('unpipe'); + src.unpipe(dest); + } + + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + debug('pipe resume'); + src.resume(); + } + + return dest; +}; + +function pipeOnDrain(src) { + return function () { + var state = src._readableState; + debug('pipeOnDrain', state.awaitDrain); + if (state.awaitDrain) state.awaitDrain--; + if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { + state.flowing = true; + flow(src); + } + }; +} + +Readable.prototype.unpipe = function (dest) { + var state = this._readableState; + var unpipeInfo = { hasUnpiped: false }; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) return this; + + if (!dest) dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + if (dest) dest.emit('unpipe', this, unpipeInfo); + return this; + } + + // slow case. multiple pipe destinations. + + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + + for (var i = 0; i < len; i++) { + dests[i].emit('unpipe', this, unpipeInfo); + }return this; + } + + // try to find the right one. + var index = indexOf(state.pipes, dest); + if (index === -1) return this; + + state.pipes.splice(index, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) state.pipes = state.pipes[0]; + + dest.emit('unpipe', this, unpipeInfo); + + return this; +}; + +// set up data events if they are asked for +// Ensure readable listeners eventually get something +Readable.prototype.on = function (ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + + if (ev === 'data') { + // Start flowing on next tick if stream isn't explicitly paused + if (this._readableState.flowing !== false) this.resume(); + } else if (ev === 'readable') { + var state = this._readableState; + if (!state.endEmitted && !state.readableListening) { + state.readableListening = state.needReadable = true; + state.emittedReadable = false; + if (!state.reading) { + processNextTick(nReadingNextTick, this); + } else if (state.length) { + emitReadable(this); + } + } + } + + return res; +}; +Readable.prototype.addListener = Readable.prototype.on; + +function nReadingNextTick(self) { + debug('readable nexttick read 0'); + self.read(0); +} + +// pause() and resume() are remnants of the legacy readable stream API +// If the user uses them, then switch into old mode. +Readable.prototype.resume = function () { + var state = this._readableState; + if (!state.flowing) { + debug('resume'); + state.flowing = true; + resume(this, state); + } + return this; +}; + +function resume(stream, state) { + if (!state.resumeScheduled) { + state.resumeScheduled = true; + processNextTick(resume_, stream, state); + } +} + +function resume_(stream, state) { + if (!state.reading) { + debug('resume read 0'); + stream.read(0); + } + + state.resumeScheduled = false; + state.awaitDrain = 0; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) stream.read(0); +} + +Readable.prototype.pause = function () { + debug('call pause flowing=%j', this._readableState.flowing); + if (false !== this._readableState.flowing) { + debug('pause'); + this._readableState.flowing = false; + this.emit('pause'); + } + return this; +}; + +function flow(stream) { + var state = stream._readableState; + debug('flow', state.flowing); + while (state.flowing && stream.read() !== null) {} +} + +// wrap an old-style stream as the async data source. +// This is *not* part of the readable stream interface. +// It is an ugly unfortunate mess of history. +Readable.prototype.wrap = function (stream) { + var state = this._readableState; + var paused = false; + + var self = this; + stream.on('end', function () { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) self.push(chunk); + } + + self.push(null); + }); + + stream.on('data', function (chunk) { + debug('wrapped data'); + if (state.decoder) chunk = state.decoder.write(chunk); + + // don't skip over falsy values in objectMode + if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; + + var ret = self.push(chunk); + if (!ret) { + paused = true; + stream.pause(); + } + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (this[i] === undefined && typeof stream[i] === 'function') { + this[i] = function (method) { + return function () { + return stream[method].apply(stream, arguments); + }; + }(i); + } + } + + // proxy certain important events. + for (var n = 0; n < kProxyEvents.length; n++) { + stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n])); + } + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + self._read = function (n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); + } + }; + + return self; +}; + +// exposed for testing purposes only. +Readable._fromList = fromList; + +// Pluck off n bytes from an array of buffers. +// Length is the combined lengths of all the buffers in the list. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function fromList(n, state) { + // nothing buffered + if (state.length === 0) return null; + + var ret; + if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { + // read it all, truncate the list + if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); + state.buffer.clear(); + } else { + // read part of list + ret = fromListPartial(n, state.buffer, state.decoder); + } + + return ret; +} + +// Extracts only enough buffered data to satisfy the amount requested. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function fromListPartial(n, list, hasStrings) { + var ret; + if (n < list.head.data.length) { + // slice is the same for buffers and strings + ret = list.head.data.slice(0, n); + list.head.data = list.head.data.slice(n); + } else if (n === list.head.data.length) { + // first chunk is a perfect match + ret = list.shift(); + } else { + // result spans more than one buffer + ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); + } + return ret; +} + +// Copies a specified amount of characters from the list of buffered data +// chunks. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function copyFromBufferString(n, list) { + var p = list.head; + var c = 1; + var ret = p.data; + n -= ret.length; + while (p = p.next) { + var str = p.data; + var nb = n > str.length ? str.length : n; + if (nb === str.length) ret += str;else ret += str.slice(0, n); + n -= nb; + if (n === 0) { + if (nb === str.length) { + ++c; + if (p.next) list.head = p.next;else list.head = list.tail = null; + } else { + list.head = p; + p.data = str.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; +} + +// Copies a specified amount of bytes from the list of buffered data chunks. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function copyFromBuffer(n, list) { + var ret = Buffer.allocUnsafe(n); + var p = list.head; + var c = 1; + p.data.copy(ret); + n -= p.data.length; + while (p = p.next) { + var buf = p.data; + var nb = n > buf.length ? buf.length : n; + buf.copy(ret, ret.length - n, 0, nb); + n -= nb; + if (n === 0) { + if (nb === buf.length) { + ++c; + if (p.next) list.head = p.next;else list.head = list.tail = null; + } else { + list.head = p; + p.data = buf.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; +} + +function endReadable(stream) { + var state = stream._readableState; + + // If we get here before consuming all the bytes, then that is a + // bug in node. Should never happen. + if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); + + if (!state.endEmitted) { + state.ended = true; + processNextTick(endReadableNT, state, stream); + } +} + +function endReadableNT(state, stream) { + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + } +} + +function forEach(xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +function indexOf(xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; +} +}).call(this,require('_process')) +},{"./_stream_duplex":25,"./internal/streams/BufferList":30,"./internal/streams/destroy":31,"./internal/streams/stream":32,"_process":23,"core-util-is":33,"events":19,"inherits":20,"isarray":34,"process-nextick-args":35,"safe-buffer":36,"string_decoder/":43,"util":2}],28:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a transform stream is a readable/writable stream where you do +// something with the data. Sometimes it's called a "filter", +// but that's not a great name for it, since that implies a thing where +// some bits pass through, and others are simply ignored. (That would +// be a valid example of a transform, of course.) +// +// While the output is causally related to the input, it's not a +// necessarily symmetric or synchronous transformation. For example, +// a zlib stream might take multiple plain-text writes(), and then +// emit a single compressed chunk some time in the future. +// +// Here's how this works: +// +// The Transform stream has all the aspects of the readable and writable +// stream classes. When you write(chunk), that calls _write(chunk,cb) +// internally, and returns false if there's a lot of pending writes +// buffered up. When you call read(), that calls _read(n) until +// there's enough pending readable data buffered up. +// +// In a transform stream, the written data is placed in a buffer. When +// _read(n) is called, it transforms the queued up data, calling the +// buffered _write cb's as it consumes chunks. If consuming a single +// written chunk would result in multiple output chunks, then the first +// outputted bit calls the readcb, and subsequent chunks just go into +// the read buffer, and will cause it to emit 'readable' if necessary. +// +// This way, back-pressure is actually determined by the reading side, +// since _read has to be called to start processing a new chunk. However, +// a pathological inflate type of transform can cause excessive buffering +// here. For example, imagine a stream where every byte of input is +// interpreted as an integer from 0-255, and then results in that many +// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in +// 1kb of data being output. In this case, you could write a very small +// amount of input, and end up with a very large amount of output. In +// such a pathological inflating mechanism, there'd be no way to tell +// the system to stop doing the transform. A single 4MB write could +// cause the system to run out of memory. +// +// However, even in such a pathological case, only a single written chunk +// would be consumed, and then the rest would wait (un-transformed) until +// the results of the previous transformed chunk were consumed. + +'use strict'; + +module.exports = Transform; + +var Duplex = require('./_stream_duplex'); + +/* <replacement> */ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/* </replacement> */ + +util.inherits(Transform, Duplex); + +function TransformState(stream) { + this.afterTransform = function (er, data) { + return afterTransform(stream, er, data); + }; + + this.needTransform = false; + this.transforming = false; + this.writecb = null; + this.writechunk = null; + this.writeencoding = null; +} + +function afterTransform(stream, er, data) { + var ts = stream._transformState; + ts.transforming = false; + + var cb = ts.writecb; + + if (!cb) { + return stream.emit('error', new Error('write callback called multiple times')); + } + + ts.writechunk = null; + ts.writecb = null; + + if (data !== null && data !== undefined) stream.push(data); + + cb(er); + + var rs = stream._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + stream._read(rs.highWaterMark); + } +} + +function Transform(options) { + if (!(this instanceof Transform)) return new Transform(options); + + Duplex.call(this, options); + + this._transformState = new TransformState(this); + + var stream = this; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; + + // we have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + + if (options) { + if (typeof options.transform === 'function') this._transform = options.transform; + + if (typeof options.flush === 'function') this._flush = options.flush; + } + + // When the writable side finishes, then flush out anything remaining. + this.once('prefinish', function () { + if (typeof this._flush === 'function') this._flush(function (er, data) { + done(stream, er, data); + });else done(stream); + }); +} + +Transform.prototype.push = function (chunk, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk, encoding); +}; + +// This is the part where you do stuff! +// override this function in implementation classes. +// 'chunk' is an input chunk. +// +// Call `push(newChunk)` to pass along transformed output +// to the readable side. You may call 'push' zero or more times. +// +// Call `cb(err)` when you are done with this chunk. If you pass +// an error, then that'll put the hurt on the whole operation. If you +// never call cb(), then you'll never get another chunk. +Transform.prototype._transform = function (chunk, encoding, cb) { + throw new Error('_transform() is not implemented'); +}; + +Transform.prototype._write = function (chunk, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); + } +}; + +// Doesn't matter what the args are here. +// _transform does all the work. +// That we got here means that the readable side wants more data. +Transform.prototype._read = function (n) { + var ts = this._transformState; + + if (ts.writechunk !== null && ts.writecb && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + // mark that we need a transform, so that any data that comes in + // will get processed, now that we've asked for it. + ts.needTransform = true; + } +}; + +Transform.prototype._destroy = function (err, cb) { + var _this = this; + + Duplex.prototype._destroy.call(this, err, function (err2) { + cb(err2); + _this.emit('close'); + }); +}; + +function done(stream, er, data) { + if (er) return stream.emit('error', er); + + if (data !== null && data !== undefined) stream.push(data); + + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + var ws = stream._writableState; + var ts = stream._transformState; + + if (ws.length) throw new Error('Calling transform done when ws.length != 0'); + + if (ts.transforming) throw new Error('Calling transform done when still transforming'); + + return stream.push(null); +} +},{"./_stream_duplex":25,"core-util-is":33,"inherits":20}],29:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// A bit simpler than readable streams. +// Implement an async ._write(chunk, encoding, cb), and it'll handle all +// the drain event emission and buffering. + +'use strict'; + +/* <replacement> */ + +var processNextTick = require('process-nextick-args'); +/* </replacement> */ + +module.exports = Writable; + +/* <replacement> */ +function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; + this.next = null; +} + +// It seems a linked list but it is not +// there will be only 2 of these for each stream +function CorkedRequest(state) { + var _this = this; + + this.next = null; + this.entry = null; + this.finish = function () { + onCorkedFinish(_this, state); + }; +} +/* </replacement> */ + +/* <replacement> */ +var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick; +/* </replacement> */ + +/* <replacement> */ +var Duplex; +/* </replacement> */ + +Writable.WritableState = WritableState; + +/* <replacement> */ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/* </replacement> */ + +/* <replacement> */ +var internalUtil = { + deprecate: require('util-deprecate') +}; +/* </replacement> */ + +/* <replacement> */ +var Stream = require('./internal/streams/stream'); +/* </replacement> */ + +/* <replacement> */ +var Buffer = require('safe-buffer').Buffer; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Object.prototype.toString.call(obj) === '[object Uint8Array]' || Buffer.isBuffer(obj); +} +/* </replacement> */ + +var destroyImpl = require('./internal/streams/destroy'); + +util.inherits(Writable, Stream); + +function nop() {} + +function WritableState(options, stream) { + Duplex = Duplex || require('./_stream_duplex'); + + options = options || {}; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + var hwm = options.highWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = Math.floor(this.highWaterMark); + + // if _final has been called + this.finalCalled = false; + + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // has it been destroyed + this.destroyed = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // when true all writes will be buffered until .uncork() call + this.corked = 0; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function (er) { + onwrite(stream, er); + }; + + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + + // the amount that is being written when _write is called. + this.writelen = 0; + + this.bufferedRequest = null; + this.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; + + // emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams + this.prefinished = false; + + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; + + // count buffered requests + this.bufferedRequestCount = 0; + + // allocate the first CorkedRequest, there is always + // one allocated and free to use, and we maintain at most two + this.corkedRequestsFree = new CorkedRequest(this); +} + +WritableState.prototype.getBuffer = function getBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; +}; + +(function () { + try { + Object.defineProperty(WritableState.prototype, 'buffer', { + get: internalUtil.deprecate(function () { + return this.getBuffer(); + }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') + }); + } catch (_) {} +})(); + +// Test _writableState for inheritance to account for Duplex streams, +// whose prototype chain only points to Readable. +var realHasInstance; +if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { + realHasInstance = Function.prototype[Symbol.hasInstance]; + Object.defineProperty(Writable, Symbol.hasInstance, { + value: function (object) { + if (realHasInstance.call(this, object)) return true; + + return object && object._writableState instanceof WritableState; + } + }); +} else { + realHasInstance = function (object) { + return object instanceof this; + }; +} + +function Writable(options) { + Duplex = Duplex || require('./_stream_duplex'); + + // Writable ctor is applied to Duplexes, too. + // `realHasInstance` is necessary because using plain `instanceof` + // would return false, as no `_writableState` property is attached. + + // Trying to use the custom `instanceof` for Writable here will also break + // the + // Node.js LazyTransform implementation, which has a non-trivial getter for + // `_writableState` that would lead to infinite recursion. + if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { + return new Writable(options); + } + + this._writableState = new WritableState(options, this); + + // legacy. + this.writable = true; + + if (options) { + if (typeof options.write === 'function') this._write = options.write; + + if (typeof options.writev === 'function') this._writev = options.writev; + + if (typeof options.destroy === 'function') this._destroy = options.destroy; + + if (typeof options.final === 'function') this._final = options.final; + } + + Stream.call(this); +} + +// Otherwise people can pipe Writable streams, which is just wrong. +Writable.prototype.pipe = function () { + this.emit('error', new Error('Cannot pipe, not readable')); +}; + +function writeAfterEnd(stream, cb) { + var er = new Error('write after end'); + // TODO: defer error events consistently everywhere, not just the cb + stream.emit('error', er); + processNextTick(cb, er); +} + +// Checks that a user-supplied chunk is valid, especially for the particular +// mode the stream is in. Currently this means that `null` is never accepted +// and undefined/non-string values are only allowed in object mode. +function validChunk(stream, state, chunk, cb) { + var valid = true; + var er = false; + + if (chunk === null) { + er = new TypeError('May not write null values to stream'); + } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + if (er) { + stream.emit('error', er); + processNextTick(cb, er); + valid = false; + } + return valid; +} + +Writable.prototype.write = function (chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + var isBuf = _isUint8Array(chunk) && !state.objectMode; + + if (isBuf && !Buffer.isBuffer(chunk)) { + chunk = _uint8ArrayToBuffer(chunk); + } + + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; + + if (typeof cb !== 'function') cb = nop; + + if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); + } + + return ret; +}; + +Writable.prototype.cork = function () { + var state = this._writableState; + + state.corked++; +}; + +Writable.prototype.uncork = function () { + var state = this._writableState; + + if (state.corked) { + state.corked--; + + if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); + } +}; + +Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + // node::ParseEncoding() requires lower case. + if (typeof encoding === 'string') encoding = encoding.toLowerCase(); + if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); + this._writableState.defaultEncoding = encoding; + return this; +}; + +function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { + chunk = Buffer.from(chunk, encoding); + } + return chunk; +} + +// if we're already writing something, then just put this +// in the queue, and wait our turn. Otherwise, call _write +// If we return false, then we need a drain event, so set that flag. +function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { + if (!isBuf) { + var newChunk = decodeChunk(state, chunk, encoding); + if (chunk !== newChunk) { + isBuf = true; + encoding = 'buffer'; + chunk = newChunk; + } + } + var len = state.objectMode ? 1 : chunk.length; + + state.length += len; + + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) state.needDrain = true; + + if (state.writing || state.corked) { + var last = state.lastBufferedRequest; + state.lastBufferedRequest = { + chunk: chunk, + encoding: encoding, + isBuf: isBuf, + callback: cb, + next: null + }; + if (last) { + last.next = state.lastBufferedRequest; + } else { + state.bufferedRequest = state.lastBufferedRequest; + } + state.bufferedRequestCount += 1; + } else { + doWrite(stream, state, false, len, chunk, encoding, cb); + } + + return ret; +} + +function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); + state.sync = false; +} + +function onwriteError(stream, state, sync, er, cb) { + --state.pendingcb; + + if (sync) { + // defer the callback if we are being called synchronously + // to avoid piling up things on the stack + processNextTick(cb, er); + // this can emit finish, and it will always happen + // after error + processNextTick(finishMaybe, stream, state); + stream._writableState.errorEmitted = true; + stream.emit('error', er); + } else { + // the caller expect this to happen before if + // it is async + cb(er); + stream._writableState.errorEmitted = true; + stream.emit('error', er); + // this can emit finish, but finish must + // always follow error + finishMaybe(stream, state); + } +} + +function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; +} + +function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + + onwriteStateUpdate(state); + + if (er) onwriteError(stream, state, sync, er, cb);else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(state); + + if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { + clearBuffer(stream, state); + } + + if (sync) { + /* <replacement> */ + asyncWrite(afterWrite, stream, state, finished, cb); + /* </replacement> */ + } else { + afterWrite(stream, state, finished, cb); + } + } +} + +function afterWrite(stream, state, finished, cb) { + if (!finished) onwriteDrain(stream, state); + state.pendingcb--; + cb(); + finishMaybe(stream, state); +} + +// Must force callback to be called on nextTick, so that we don't +// emit 'drain' before the write() consumer gets the 'false' return +// value, and has a chance to attach a 'drain' listener. +function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } +} + +// if there's something in the buffer waiting, then process it +function clearBuffer(stream, state) { + state.bufferProcessing = true; + var entry = state.bufferedRequest; + + if (stream._writev && entry && entry.next) { + // Fast case, write everything using _writev() + var l = state.bufferedRequestCount; + var buffer = new Array(l); + var holder = state.corkedRequestsFree; + holder.entry = entry; + + var count = 0; + var allBuffers = true; + while (entry) { + buffer[count] = entry; + if (!entry.isBuf) allBuffers = false; + entry = entry.next; + count += 1; + } + buffer.allBuffers = allBuffers; + + doWrite(stream, state, true, state.length, buffer, '', holder.finish); + + // doWrite is almost always async, defer these to save a bit of time + // as the hot path ends with doWrite + state.pendingcb++; + state.lastBufferedRequest = null; + if (holder.next) { + state.corkedRequestsFree = holder.next; + holder.next = null; + } else { + state.corkedRequestsFree = new CorkedRequest(state); + } + } else { + // Slow case, write chunks one-by-one + while (entry) { + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + + doWrite(stream, state, false, len, chunk, encoding, cb); + entry = entry.next; + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + break; + } + } + + if (entry === null) state.lastBufferedRequest = null; + } + + state.bufferedRequestCount = 0; + state.bufferedRequest = entry; + state.bufferProcessing = false; +} + +Writable.prototype._write = function (chunk, encoding, cb) { + cb(new Error('_write() is not implemented')); +}; + +Writable.prototype._writev = null; + +Writable.prototype.end = function (chunk, encoding, cb) { + var state = this._writableState; + + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); + + // .end() fully uncorks + if (state.corked) { + state.corked = 1; + this.uncork(); + } + + // ignore unnecessary end() calls. + if (!state.ending && !state.finished) endWritable(this, state, cb); +}; + +function needFinish(state) { + return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; +} +function callFinal(stream, state) { + stream._final(function (err) { + state.pendingcb--; + if (err) { + stream.emit('error', err); + } + state.prefinished = true; + stream.emit('prefinish'); + finishMaybe(stream, state); + }); +} +function prefinish(stream, state) { + if (!state.prefinished && !state.finalCalled) { + if (typeof stream._final === 'function') { + state.pendingcb++; + state.finalCalled = true; + processNextTick(callFinal, stream, state); + } else { + state.prefinished = true; + stream.emit('prefinish'); + } + } +} + +function finishMaybe(stream, state) { + var need = needFinish(state); + if (need) { + prefinish(stream, state); + if (state.pendingcb === 0) { + state.finished = true; + stream.emit('finish'); + } + } + return need; +} + +function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) processNextTick(cb);else stream.once('finish', cb); + } + state.ended = true; + stream.writable = false; +} + +function onCorkedFinish(corkReq, state, err) { + var entry = corkReq.entry; + corkReq.entry = null; + while (entry) { + var cb = entry.callback; + state.pendingcb--; + cb(err); + entry = entry.next; + } + if (state.corkedRequestsFree) { + state.corkedRequestsFree.next = corkReq; + } else { + state.corkedRequestsFree = corkReq; + } +} + +Object.defineProperty(Writable.prototype, 'destroyed', { + get: function () { + if (this._writableState === undefined) { + return false; + } + return this._writableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._writableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._writableState.destroyed = value; + } +}); + +Writable.prototype.destroy = destroyImpl.destroy; +Writable.prototype._undestroy = destroyImpl.undestroy; +Writable.prototype._destroy = function (err, cb) { + this.end(); + cb(err); +}; + +}).call(this,require('_process')) +},{"./_stream_duplex":25,"./internal/streams/destroy":31,"./internal/streams/stream":32,"_process":23,"core-util-is":33,"inherits":20,"process-nextick-args":35,"safe-buffer":36,"util-deprecate":37}],30:[function(require,module,exports){ +'use strict'; + +/* <replacement> */ + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Buffer = require('safe-buffer').Buffer; +/* </replacement> */ + +function copyBuffer(src, target, offset) { + src.copy(target, offset); +} + +module.exports = function () { + function BufferList() { + _classCallCheck(this, BufferList); + + this.head = null; + this.tail = null; + this.length = 0; + } + + BufferList.prototype.push = function push(v) { + var entry = { data: v, next: null }; + if (this.length > 0) this.tail.next = entry;else this.head = entry; + this.tail = entry; + ++this.length; + }; + + BufferList.prototype.unshift = function unshift(v) { + var entry = { data: v, next: this.head }; + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + }; + + BufferList.prototype.shift = function shift() { + if (this.length === 0) return; + var ret = this.head.data; + if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; + --this.length; + return ret; + }; + + BufferList.prototype.clear = function clear() { + this.head = this.tail = null; + this.length = 0; + }; + + BufferList.prototype.join = function join(s) { + if (this.length === 0) return ''; + var p = this.head; + var ret = '' + p.data; + while (p = p.next) { + ret += s + p.data; + }return ret; + }; + + BufferList.prototype.concat = function concat(n) { + if (this.length === 0) return Buffer.alloc(0); + if (this.length === 1) return this.head.data; + var ret = Buffer.allocUnsafe(n >>> 0); + var p = this.head; + var i = 0; + while (p) { + copyBuffer(p.data, ret, i); + i += p.data.length; + p = p.next; + } + return ret; + }; + + return BufferList; +}(); +},{"safe-buffer":36}],31:[function(require,module,exports){ +'use strict'; + +/* <replacement> */ + +var processNextTick = require('process-nextick-args'); +/* </replacement> */ + +// undocumented cb() API, needed for core, not for public API +function destroy(err, cb) { + var _this = this; + + var readableDestroyed = this._readableState && this._readableState.destroyed; + var writableDestroyed = this._writableState && this._writableState.destroyed; + + if (readableDestroyed || writableDestroyed) { + if (cb) { + cb(err); + } else if (err && (!this._writableState || !this._writableState.errorEmitted)) { + processNextTick(emitErrorNT, this, err); + } + return; + } + + // we set destroyed to true before firing error callbacks in order + // to make it re-entrance safe in case destroy() is called within callbacks + + if (this._readableState) { + this._readableState.destroyed = true; + } + + // if this is a duplex stream mark the writable part as destroyed as well + if (this._writableState) { + this._writableState.destroyed = true; + } + + this._destroy(err || null, function (err) { + if (!cb && err) { + processNextTick(emitErrorNT, _this, err); + if (_this._writableState) { + _this._writableState.errorEmitted = true; + } + } else if (cb) { + cb(err); + } + }); +} + +function undestroy() { + if (this._readableState) { + this._readableState.destroyed = false; + this._readableState.reading = false; + this._readableState.ended = false; + this._readableState.endEmitted = false; + } + + if (this._writableState) { + this._writableState.destroyed = false; + this._writableState.ended = false; + this._writableState.ending = false; + this._writableState.finished = false; + this._writableState.errorEmitted = false; + } +} + +function emitErrorNT(self, err) { + self.emit('error', err); +} + +module.exports = { + destroy: destroy, + undestroy: undestroy +}; +},{"process-nextick-args":35}],32:[function(require,module,exports){ +module.exports = require('events').EventEmitter; + +},{"events":19}],33:[function(require,module,exports){ +(function (Buffer){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// NOTE: These type checking functions intentionally don't use `instanceof` +// because it is fragile and can be easily faked with `Object.create()`. + +function isArray(arg) { + if (Array.isArray) { + return Array.isArray(arg); + } + return objectToString(arg) === '[object Array]'; +} +exports.isArray = isArray; + +function isBoolean(arg) { + return typeof arg === 'boolean'; +} +exports.isBoolean = isBoolean; + +function isNull(arg) { + return arg === null; +} +exports.isNull = isNull; + +function isNullOrUndefined(arg) { + return arg == null; +} +exports.isNullOrUndefined = isNullOrUndefined; + +function isNumber(arg) { + return typeof arg === 'number'; +} +exports.isNumber = isNumber; + +function isString(arg) { + return typeof arg === 'string'; +} +exports.isString = isString; + +function isSymbol(arg) { + return typeof arg === 'symbol'; +} +exports.isSymbol = isSymbol; + +function isUndefined(arg) { + return arg === void 0; +} +exports.isUndefined = isUndefined; + +function isRegExp(re) { + return objectToString(re) === '[object RegExp]'; +} +exports.isRegExp = isRegExp; + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} +exports.isObject = isObject; + +function isDate(d) { + return objectToString(d) === '[object Date]'; +} +exports.isDate = isDate; + +function isError(e) { + return (objectToString(e) === '[object Error]' || e instanceof Error); +} +exports.isError = isError; + +function isFunction(arg) { + return typeof arg === 'function'; +} +exports.isFunction = isFunction; + +function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; +} +exports.isPrimitive = isPrimitive; + +exports.isBuffer = Buffer.isBuffer; + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + +}).call(this,{"isBuffer":require("../../../../insert-module-globals/node_modules/is-buffer/index.js")}) +},{"../../../../insert-module-globals/node_modules/is-buffer/index.js":21}],34:[function(require,module,exports){ +var toString = {}.toString; + +module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; +}; + +},{}],35:[function(require,module,exports){ +(function (process){ +'use strict'; + +if (!process.version || + process.version.indexOf('v0.') === 0 || + process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { + module.exports = nextTick; +} else { + module.exports = process.nextTick; +} + +function nextTick(fn, arg1, arg2, arg3) { + if (typeof fn !== 'function') { + throw new TypeError('"callback" argument must be a function'); + } + var len = arguments.length; + var args, i; + switch (len) { + case 0: + case 1: + return process.nextTick(fn); + case 2: + return process.nextTick(function afterTickOne() { + fn.call(null, arg1); + }); + case 3: + return process.nextTick(function afterTickTwo() { + fn.call(null, arg1, arg2); + }); + case 4: + return process.nextTick(function afterTickThree() { + fn.call(null, arg1, arg2, arg3); + }); + default: + args = new Array(len - 1); + i = 0; + while (i < args.length) { + args[i++] = arguments[i]; + } + return process.nextTick(function afterTick() { + fn.apply(null, args); + }); + } +} + +}).call(this,require('_process')) +},{"_process":23}],36:[function(require,module,exports){ +/* eslint-disable node/no-deprecated-api */ +var buffer = require('buffer') +var Buffer = buffer.Buffer + +// alternative to using Object.keys for old browsers +function copyProps (src, dst) { + for (var key in src) { + dst[key] = src[key] + } +} +if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { + module.exports = buffer +} else { + // Copy properties from require('buffer') + copyProps(buffer, exports) + exports.Buffer = SafeBuffer +} + +function SafeBuffer (arg, encodingOrOffset, length) { + return Buffer(arg, encodingOrOffset, length) +} + +// Copy static methods from Buffer +copyProps(Buffer, SafeBuffer) + +SafeBuffer.from = function (arg, encodingOrOffset, length) { + if (typeof arg === 'number') { + throw new TypeError('Argument must not be a number') + } + return Buffer(arg, encodingOrOffset, length) +} + +SafeBuffer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + var buf = Buffer(size) + if (fill !== undefined) { + if (typeof encoding === 'string') { + buf.fill(fill, encoding) + } else { + buf.fill(fill) + } + } else { + buf.fill(0) + } + return buf +} + +SafeBuffer.allocUnsafe = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return Buffer(size) +} + +SafeBuffer.allocUnsafeSlow = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return buffer.SlowBuffer(size) +} + +},{"buffer":16}],37:[function(require,module,exports){ +(function (global){ + +/** + * Module exports. + */ + +module.exports = deprecate; + +/** + * Mark that a method should not be used. Returns a modified function which + * warns once by default. + * + * If `localStorage.noDeprecation = true` is set, then it is a no-op. + * + * If `localStorage.throwDeprecation = true` is set, then deprecated functions + * will throw an Error when invoked. + * + * If `localStorage.traceDeprecation = true` is set, then deprecated functions + * will invoke `console.trace()` instead of `console.error()`. + * + * @param {Function} + * fn - the function to deprecate + * @param {String} + * msg - the string to print to the console when `fn` is invoked + * @returns {Function} a new "deprecated" version of `fn` + * @api public + */ + +function deprecate (fn, msg) { + if (config('noDeprecation')) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (config('throwDeprecation')) { + throw new Error(msg); + } else if (config('traceDeprecation')) { + console.trace(msg); + } else { + console.warn(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +} + +/** + * Checks `localStorage` for boolean values for the given `name`. + * + * @param {String} + * name + * @returns {Boolean} + * @api private + */ + +function config (name) { + // accessing global.localStorage can trigger a DOMException in sandboxed + // iframes + try { + if (!global.localStorage) return false; + } catch (_) { + return false; + } + var val = global.localStorage[name]; + if (null == val) return false; + return String(val).toLowerCase() === 'true'; +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],38:[function(require,module,exports){ +module.exports = require('./readable').PassThrough + +},{"./readable":39}],39:[function(require,module,exports){ +exports = module.exports = require('./lib/_stream_readable.js'); +exports.Stream = exports; +exports.Readable = exports; +exports.Writable = require('./lib/_stream_writable.js'); +exports.Duplex = require('./lib/_stream_duplex.js'); +exports.Transform = require('./lib/_stream_transform.js'); +exports.PassThrough = require('./lib/_stream_passthrough.js'); + +},{"./lib/_stream_duplex.js":25,"./lib/_stream_passthrough.js":26,"./lib/_stream_readable.js":27,"./lib/_stream_transform.js":28,"./lib/_stream_writable.js":29}],40:[function(require,module,exports){ +module.exports = require('./readable').Transform + +},{"./readable":39}],41:[function(require,module,exports){ +module.exports = require('./lib/_stream_writable.js'); + +},{"./lib/_stream_writable.js":29}],42:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +module.exports = Stream; + +var EE = require('events').EventEmitter; +var inherits = require('inherits'); + +inherits(Stream, EE); +Stream.Readable = require('readable-stream/readable.js'); +Stream.Writable = require('readable-stream/writable.js'); +Stream.Duplex = require('readable-stream/duplex.js'); +Stream.Transform = require('readable-stream/transform.js'); +Stream.PassThrough = require('readable-stream/passthrough.js'); + +// Backwards-compat with node 0.4.x +Stream.Stream = Stream; + + + +// old-style streams. Note that the pipe method (the only relevant +// part of this class) is overridden in the Readable class. + +function Stream() { + EE.call(this); +} + +Stream.prototype.pipe = function(dest, options) { + var source = this; + + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } + + source.on('data', ondata); + + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + + dest.on('drain', ondrain); + + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + + dest.end(); + } + + + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + + if (typeof dest.destroy === 'function') dest.destroy(); + } + + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. + } + } + + source.on('error', onerror); + dest.on('error', onerror); + + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + + source.removeListener('end', onend); + source.removeListener('close', onclose); + + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + + dest.removeListener('close', cleanup); + } + + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; +}; + +},{"events":19,"inherits":20,"readable-stream/duplex.js":24,"readable-stream/passthrough.js":38,"readable-stream/readable.js":39,"readable-stream/transform.js":40,"readable-stream/writable.js":41}],43:[function(require,module,exports){ +'use strict'; + +var Buffer = require('safe-buffer').Buffer; + +var isEncoding = Buffer.isEncoding || function (encoding) { + encoding = '' + encoding; + switch (encoding && encoding.toLowerCase()) { + case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw': + return true; + default: + return false; + } +}; + +function _normalizeEncoding(enc) { + if (!enc) return 'utf8'; + var retried; + while (true) { + switch (enc) { + case 'utf8': + case 'utf-8': + return 'utf8'; + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return 'utf16le'; + case 'latin1': + case 'binary': + return 'latin1'; + case 'base64': + case 'ascii': + case 'hex': + return enc; + default: + if (retried) return; // undefined + enc = ('' + enc).toLowerCase(); + retried = true; + } + } +}; + +// Do not cache `Buffer.isEncoding` when checking encoding names as some +// modules monkey-patch it to support additional encodings +function normalizeEncoding(enc) { + var nenc = _normalizeEncoding(enc); + if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); + return nenc || enc; +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. +exports.StringDecoder = StringDecoder; +function StringDecoder(encoding) { + this.encoding = normalizeEncoding(encoding); + var nb; + switch (this.encoding) { + case 'utf16le': + this.text = utf16Text; + this.end = utf16End; + nb = 4; + break; + case 'utf8': + this.fillLast = utf8FillLast; + nb = 4; + break; + case 'base64': + this.text = base64Text; + this.end = base64End; + nb = 3; + break; + default: + this.write = simpleWrite; + this.end = simpleEnd; + return; + } + this.lastNeed = 0; + this.lastTotal = 0; + this.lastChar = Buffer.allocUnsafe(nb); +} + +StringDecoder.prototype.write = function (buf) { + if (buf.length === 0) return ''; + var r; + var i; + if (this.lastNeed) { + r = this.fillLast(buf); + if (r === undefined) return ''; + i = this.lastNeed; + this.lastNeed = 0; + } else { + i = 0; + } + if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); + return r || ''; +}; + +StringDecoder.prototype.end = utf8End; + +// Returns only complete characters in a Buffer +StringDecoder.prototype.text = utf8Text; + +// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer +StringDecoder.prototype.fillLast = function (buf) { + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); + this.lastNeed -= buf.length; +}; + +// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a +// continuation byte. +function utf8CheckByte(byte) { + if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; + return -1; +} + +// Checks at most 3 bytes at the end of a Buffer in order to detect an +// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) +// needed to complete the UTF-8 character (if applicable) are returned. +function utf8CheckIncomplete(self, buf, i) { + var j = buf.length - 1; + if (j < i) return 0; + var nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 1; + return nb; + } + if (--j < i) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 2; + return nb; + } + if (--j < i) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) { + if (nb === 2) nb = 0;else self.lastNeed = nb - 3; + } + return nb; + } + return 0; +} + +// Validates as many continuation bytes for a multi-byte UTF-8 character as +// needed or are available. If we see a non-continuation byte where we expect +// one, we "replace" the validated continuation bytes we've seen so far with +// UTF-8 replacement characters ('\ufffd'), to match v8's UTF-8 decoding +// behavior. The continuation byte check is included three times in the case +// where all of the continuation bytes for a character exist in the same buffer. +// It is also done this way as a slight performance increase instead of using a +// loop. +function utf8CheckExtraBytes(self, buf, p) { + if ((buf[0] & 0xC0) !== 0x80) { + self.lastNeed = 0; + return '\ufffd'.repeat(p); + } + if (self.lastNeed > 1 && buf.length > 1) { + if ((buf[1] & 0xC0) !== 0x80) { + self.lastNeed = 1; + return '\ufffd'.repeat(p + 1); + } + if (self.lastNeed > 2 && buf.length > 2) { + if ((buf[2] & 0xC0) !== 0x80) { + self.lastNeed = 2; + return '\ufffd'.repeat(p + 2); + } + } + } +} + +// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. +function utf8FillLast(buf) { + var p = this.lastTotal - this.lastNeed; + var r = utf8CheckExtraBytes(this, buf, p); + if (r !== undefined) return r; + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, p, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, p, 0, buf.length); + this.lastNeed -= buf.length; +} + +// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a +// partial character, the character's bytes are buffered until the required +// number of bytes are available. +function utf8Text(buf, i) { + var total = utf8CheckIncomplete(this, buf, i); + if (!this.lastNeed) return buf.toString('utf8', i); + this.lastTotal = total; + var end = buf.length - (total - this.lastNeed); + buf.copy(this.lastChar, 0, end); + return buf.toString('utf8', i, end); +} + +// For UTF-8, a replacement character for each buffered byte of a (partial) +// character needs to be added to the output. +function utf8End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + '\ufffd'.repeat(this.lastTotal - this.lastNeed); + return r; +} + +// UTF-16LE typically needs two bytes per character, but even if we have an even +// number of bytes available, we need to check if we end on a leading/high +// surrogate. In that case, we need to wait for the next two bytes in order to +// decode the last character properly. +function utf16Text(buf, i) { + if ((buf.length - i) % 2 === 0) { + var r = buf.toString('utf16le', i); + if (r) { + var c = r.charCodeAt(r.length - 1); + if (c >= 0xD800 && c <= 0xDBFF) { + this.lastNeed = 2; + this.lastTotal = 4; + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + return r.slice(0, -1); + } + } + return r; + } + this.lastNeed = 1; + this.lastTotal = 2; + this.lastChar[0] = buf[buf.length - 1]; + return buf.toString('utf16le', i, buf.length - 1); +} + +// For UTF-16LE we do not explicitly append special replacement characters if we +// end on a partial character, we simply let v8 handle that. +function utf16End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) { + var end = this.lastTotal - this.lastNeed; + return r + this.lastChar.toString('utf16le', 0, end); + } + return r; +} + +function base64Text(buf, i) { + var n = (buf.length - i) % 3; + if (n === 0) return buf.toString('base64', i); + this.lastNeed = 3 - n; + this.lastTotal = 3; + if (n === 1) { + this.lastChar[0] = buf[buf.length - 1]; + } else { + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + } + return buf.toString('base64', i, buf.length - n); +} + +function base64End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); + return r; +} + +// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) +function simpleWrite(buf) { + return buf.toString(this.encoding); +} + +function simpleEnd(buf) { + return buf && buf.length ? this.write(buf) : ''; +} +},{"safe-buffer":44}],44:[function(require,module,exports){ +arguments[4][36][0].apply(exports,arguments) +},{"buffer":16,"dup":36}],45:[function(require,module,exports){ +arguments[4][20][0].apply(exports,arguments) +},{"dup":20}],46:[function(require,module,exports){ +module.exports = function isBuffer(arg) { + return arg && typeof arg === 'object' + && typeof arg.copy === 'function' + && typeof arg.fill === 'function' + && typeof arg.readUInt8 === 'function'; +} +},{}],47:[function(require,module,exports){ +(function (process,global){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +var formatRegExp = /%[sdj%]/g; +exports.format = function(f) { + if (!isString(f)) { + var objects = []; + for (var i = 0; i < arguments.length; i++) { + objects.push(inspect(arguments[i])); + } + return objects.join(' '); + } + + var i = 1; + var args = arguments; + var len = args.length; + var str = String(f).replace(formatRegExp, function(x) { + if (x === '%%') return '%'; + if (i >= len) return x; + switch (x) { + case '%s': return String(args[i++]); + case '%d': return Number(args[i++]); + case '%j': + try { + return JSON.stringify(args[i++]); + } catch (_) { + return '[Circular]'; + } + default: + return x; + } + }); + for (var x = args[i]; i < len; x = args[++i]) { + if (isNull(x) || !isObject(x)) { + str += ' ' + x; + } else { + str += ' ' + inspect(x); + } + } + return str; +}; + + +// Mark that a method should not be used. +// Returns a modified function which warns once by default. +// If --no-deprecation is set, then it is a no-op. +exports.deprecate = function(fn, msg) { + // Allow for deprecating things in the process of starting up. + if (isUndefined(global.process)) { + return function() { + return exports.deprecate(fn, msg).apply(this, arguments); + }; + } + + if (process.noDeprecation === true) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (process.throwDeprecation) { + throw new Error(msg); + } else if (process.traceDeprecation) { + console.trace(msg); + } else { + console.error(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +}; + + +var debugs = {}; +var debugEnviron; +exports.debuglog = function(set) { + if (isUndefined(debugEnviron)) + debugEnviron = process.env.NODE_DEBUG || ''; + set = set.toUpperCase(); + if (!debugs[set]) { + if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { + var pid = process.pid; + debugs[set] = function() { + var msg = exports.format.apply(exports, arguments); + console.error('%s %d: %s', set, pid, msg); + }; + } else { + debugs[set] = function() {}; + } + } + return debugs[set]; +}; + + +/** + * Echos the value of a value. Trys to print the value out in the best way + * possible given the different types. + * + * @param {Object} + * obj The object to print out. + * @param {Object} + * opts Optional options object that alters the output. + */ +/* legacy: obj, showHidden, depth, colors */ +function inspect(obj, opts) { + // default options + var ctx = { + seen: [], + stylize: stylizeNoColor + }; + // legacy... + if (arguments.length >= 3) ctx.depth = arguments[2]; + if (arguments.length >= 4) ctx.colors = arguments[3]; + if (isBoolean(opts)) { + // legacy... + ctx.showHidden = opts; + } else if (opts) { + // got an "options" object + exports._extend(ctx, opts); + } + // set default options + if (isUndefined(ctx.showHidden)) ctx.showHidden = false; + if (isUndefined(ctx.depth)) ctx.depth = 2; + if (isUndefined(ctx.colors)) ctx.colors = false; + if (isUndefined(ctx.customInspect)) ctx.customInspect = true; + if (ctx.colors) ctx.stylize = stylizeWithColor; + return formatValue(ctx, obj, ctx.depth); +} +exports.inspect = inspect; + + +// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics +inspect.colors = { + 'bold' : [1, 22], + 'italic' : [3, 23], + 'underline' : [4, 24], + 'inverse' : [7, 27], + 'white' : [37, 39], + 'grey' : [90, 39], + 'black' : [30, 39], + 'blue' : [34, 39], + 'cyan' : [36, 39], + 'green' : [32, 39], + 'magenta' : [35, 39], + 'red' : [31, 39], + 'yellow' : [33, 39] +}; + +// Don't use 'blue' not visible on cmd.exe +inspect.styles = { + 'special': 'cyan', + 'number': 'yellow', + 'boolean': 'yellow', + 'undefined': 'grey', + 'null': 'bold', + 'string': 'green', + 'date': 'magenta', + // "name": intentionally not styling + 'regexp': 'red' +}; + + +function stylizeWithColor(str, styleType) { + var style = inspect.styles[styleType]; + + if (style) { + return '\u001b[' + inspect.colors[style][0] + 'm' + str + + '\u001b[' + inspect.colors[style][1] + 'm'; + } else { + return str; + } +} + + +function stylizeNoColor(str, styleType) { + return str; +} + + +function arrayToHash(array) { + var hash = {}; + + array.forEach(function(val, idx) { + hash[val] = true; + }); + + return hash; +} + + +function formatValue(ctx, value, recurseTimes) { + // Provide a hook for user-specified inspect functions. + // Check that value is an object with an inspect function on it + if (ctx.customInspect && + value && + isFunction(value.inspect) && + // Filter out the util module, it's inspect function is special + value.inspect !== exports.inspect && + // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes, ctx); + if (!isString(ret)) { + ret = formatValue(ctx, ret, recurseTimes); + } + return ret; + } + + // Primitive types cannot have properties + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } + + // Look up the keys of the object. + var keys = Object.keys(value); + var visibleKeys = arrayToHash(keys); + + if (ctx.showHidden) { + keys = Object.getOwnPropertyNames(value); + } + + // IE doesn't make error fields non-enumerable + // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx + if (isError(value) + && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { + return formatError(value); + } + + // Some type of object without properties can be shortcutted. + if (keys.length === 0) { + if (isFunction(value)) { + var name = value.name ? ': ' + value.name : ''; + return ctx.stylize('[Function' + name + ']', 'special'); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toString.call(value), 'date'); + } + if (isError(value)) { + return formatError(value); + } + } + + var base = '', array = false, braces = ['{', '}']; + + // Make Array say that they are Array + if (isArray(value)) { + array = true; + braces = ['[', ']']; + } + + // Make functions say that they are functions + if (isFunction(value)) { + var n = value.name ? ': ' + value.name : ''; + base = ' [Function' + n + ']'; + } + + // Make RegExps say that they are RegExps + if (isRegExp(value)) { + base = ' ' + RegExp.prototype.toString.call(value); + } + + // Make dates with properties first say the date + if (isDate(value)) { + base = ' ' + Date.prototype.toUTCString.call(value); + } + + // Make error with message first say the error + if (isError(value)) { + base = ' ' + formatError(value); + } + + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base + braces[1]; + } + + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } else { + return ctx.stylize('[Object]', 'special'); + } + } + + ctx.seen.push(value); + + var output; + if (array) { + output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); + }); + } + + ctx.seen.pop(); + + return reduceToSingleString(output, base, braces); +} + + +function formatPrimitive(ctx, value) { + if (isUndefined(value)) + return ctx.stylize('undefined', 'undefined'); + if (isString(value)) { + var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') + .replace(/'/g, "\\'") + .replace(/\\"/g, '"') + '\''; + return ctx.stylize(simple, 'string'); + } + if (isNumber(value)) + return ctx.stylize('' + value, 'number'); + if (isBoolean(value)) + return ctx.stylize('' + value, 'boolean'); + // For some reason typeof null is "object", so special case here. + if (isNull(value)) + return ctx.stylize('null', 'null'); +} + + +function formatError(value) { + return '[' + Error.prototype.toString.call(value) + ']'; +} + + +function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i = 0, l = value.length; i < l; ++i) { + if (hasOwnProperty(value, String(i))) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + String(i), true)); + } else { + output.push(''); + } + } + keys.forEach(function(key) { + if (!key.match(/^\d+$/)) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + key, true)); + } + }); + return output; +} + + +function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { + var name, str, desc; + desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; + if (desc.get) { + if (desc.set) { + str = ctx.stylize('[Getter/Setter]', 'special'); + } else { + str = ctx.stylize('[Getter]', 'special'); + } + } else { + if (desc.set) { + str = ctx.stylize('[Setter]', 'special'); + } + } + if (!hasOwnProperty(visibleKeys, key)) { + name = '[' + key + ']'; + } + if (!str) { + if (ctx.seen.indexOf(desc.value) < 0) { + if (isNull(recurseTimes)) { + str = formatValue(ctx, desc.value, null); + } else { + str = formatValue(ctx, desc.value, recurseTimes - 1); + } + if (str.indexOf('\n') > -1) { + if (array) { + str = str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n').substr(2); + } else { + str = '\n' + str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n'); + } + } + } else { + str = ctx.stylize('[Circular]', 'special'); + } + } + if (isUndefined(name)) { + if (array && key.match(/^\d+$/)) { + return str; + } + name = JSON.stringify('' + key); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.substr(1, name.length - 2); + name = ctx.stylize(name, 'name'); + } else { + name = name.replace(/'/g, "\\'") + .replace(/\\"/g, '"') + .replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, 'string'); + } + } + + return name + ': ' + str; +} + + +function reduceToSingleString(output, base, braces) { + var numLinesEst = 0; + var length = output.reduce(function(prev, cur) { + numLinesEst++; + if (cur.indexOf('\n') >= 0) numLinesEst++; + return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; + }, 0); + + if (length > 60) { + return braces[0] + + (base === '' ? '' : base + '\n ') + + ' ' + + output.join(',\n ') + + ' ' + + braces[1]; + } + + return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; +} + + +// NOTE: These type checking functions intentionally don't use `instanceof` +// because it is fragile and can be easily faked with `Object.create()`. +function isArray(ar) { + return Array.isArray(ar); +} +exports.isArray = isArray; + +function isBoolean(arg) { + return typeof arg === 'boolean'; +} +exports.isBoolean = isBoolean; + +function isNull(arg) { + return arg === null; +} +exports.isNull = isNull; + +function isNullOrUndefined(arg) { + return arg == null; +} +exports.isNullOrUndefined = isNullOrUndefined; + +function isNumber(arg) { + return typeof arg === 'number'; +} +exports.isNumber = isNumber; + +function isString(arg) { + return typeof arg === 'string'; +} +exports.isString = isString; + +function isSymbol(arg) { + return typeof arg === 'symbol'; +} +exports.isSymbol = isSymbol; + +function isUndefined(arg) { + return arg === void 0; +} +exports.isUndefined = isUndefined; + +function isRegExp(re) { + return isObject(re) && objectToString(re) === '[object RegExp]'; +} +exports.isRegExp = isRegExp; + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} +exports.isObject = isObject; + +function isDate(d) { + return isObject(d) && objectToString(d) === '[object Date]'; +} +exports.isDate = isDate; + +function isError(e) { + return isObject(e) && + (objectToString(e) === '[object Error]' || e instanceof Error); +} +exports.isError = isError; + +function isFunction(arg) { + return typeof arg === 'function'; +} +exports.isFunction = isFunction; + +function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; +} +exports.isPrimitive = isPrimitive; + +exports.isBuffer = require('./support/isBuffer'); + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + + +function pad(n) { + return n < 10 ? '0' + n.toString(10) : n.toString(10); +} + + +var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', + 'Oct', 'Nov', 'Dec']; + +// 26 Feb 16:19:34 +function timestamp() { + var d = new Date(); + var time = [pad(d.getHours()), + pad(d.getMinutes()), + pad(d.getSeconds())].join(':'); + return [d.getDate(), months[d.getMonth()], time].join(' '); +} + + +// log is just a thin wrapper to console.log that prepends a timestamp +exports.log = function() { + console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); +}; + + +/** + * Inherit the prototype methods from one constructor into another. + * + * The Function.prototype.inherits from lang.js rewritten as a standalone + * function (not on Function.prototype). NOTE: If this file is to be loaded + * during bootstrapping this function needs to be rewritten using some native + * functions as prototype setup using normal JavaScript does not work as + * expected during bootstrapping (see mirror.js in r114903). + * + * @param {function} + * ctor Constructor function which needs to inherit the prototype. + * @param {function} + * superCtor Constructor function to inherit prototype from. + */ +exports.inherits = require('inherits'); + +exports._extend = function(origin, add) { + // Don't do anything if add isn't an object + if (!add || !isObject(add)) return origin; + + var keys = Object.keys(add); + var i = keys.length; + while (i--) { + origin[keys[i]] = add[keys[i]]; + } + return origin; +}; + +function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} + +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"./support/isBuffer":46,"_process":23,"inherits":45}],48:[function(require,module,exports){ +/* jshint browserify: true */ + +'use strict'; + +/** + * Optional entry point for browser builds. + * + * To use it: `require('avsc/etc/browser/avsc-services')`. + */ + +var avroTypes = require('./avsc-types'), + services = require('../../lib/services'), + specs = require('../../lib/specs'), + utils = require('../../lib/utils'); + + +/** Slightly enhanced parsing, supporting IDL declarations. */ +function parse(any, opts) { + var schemaOrProtocol = specs.read(any); + return schemaOrProtocol.protocol ? + services.Service.forProtocol(schemaOrProtocol, opts) : + avroTypes.Type.forSchema(schemaOrProtocol, opts); +} + + +module.exports = { + Service: services.Service, + assembleProtocol: specs.assembleProtocol, + discoverProtocol: services.discoverProtocol, + parse: parse, + readProtocol: specs.readProtocol, + readSchema: specs.readSchema, +}; + +utils.copyOwnProperties(avroTypes, module.exports); + +},{"../../lib/services":53,"../../lib/specs":54,"../../lib/utils":56,"./avsc-types":49}],49:[function(require,module,exports){ +/* jshint browserify: true */ + +'use strict'; + +/** + * Optional entry point for browser builds. + * + * To use it: `require('avsc/etc/browser/avsc-types')`. + */ + +var types = require('../../lib/types'); + + +/** Basic parse method, only supporting JSON parsing. */ +function parse(any, opts) { + var schema; + if (typeof any == 'string') { + try { + schema = JSON.parse(any); + } catch (err) { + schema = any; + } + } else { + schema = any; + } + return types.Type.forSchema(schema, opts); +} + + +module.exports = { + Type: types.Type, + parse: parse, + types: types.builtins, + // Deprecated exports (not using `util.deprecate` since it causes stack + // overflow errors in the browser). + combine: types.Type.forTypes, + infer: types.Type.forValue +}; + +},{"../../lib/types":55}],50:[function(require,module,exports){ +(function (Buffer){ +/* jshint browserify: true */ + +'use strict'; + +/** + * Shim to enable schema fingerprint computation. + * + * MD5 implementation originally from [1], used with permission from the author, + * and lightly edited. + * + * [1] http://www.myersdaily.org/joseph/javascript/md5-text.html + * + */ + +function createHash(algorithm) { + if (algorithm !== 'md5') { + throw new Error('only md5 is supported in the browser'); + } + return new Hash(); +} + +function Hash() { this.data = undefined; } +Hash.prototype.end = function (data) { this.data = data; }; +Hash.prototype.read = function () { return md5(this.data); }; + +function md5cycle(x, k) { + var a = x[0], b = x[1], c = x[2], d = x[3]; + + a = ff(a, b, c, d, k[0], 7, -680876936); + d = ff(d, a, b, c, k[1], 12, -389564586); + c = ff(c, d, a, b, k[2], 17, 606105819); + b = ff(b, c, d, a, k[3], 22, -1044525330); + a = ff(a, b, c, d, k[4], 7, -176418897); + d = ff(d, a, b, c, k[5], 12, 1200080426); + c = ff(c, d, a, b, k[6], 17, -1473231341); + b = ff(b, c, d, a, k[7], 22, -45705983); + a = ff(a, b, c, d, k[8], 7, 1770035416); + d = ff(d, a, b, c, k[9], 12, -1958414417); + c = ff(c, d, a, b, k[10], 17, -42063); + b = ff(b, c, d, a, k[11], 22, -1990404162); + a = ff(a, b, c, d, k[12], 7, 1804603682); + d = ff(d, a, b, c, k[13], 12, -40341101); + c = ff(c, d, a, b, k[14], 17, -1502002290); + b = ff(b, c, d, a, k[15], 22, 1236535329); + + a = gg(a, b, c, d, k[1], 5, -165796510); + d = gg(d, a, b, c, k[6], 9, -1069501632); + c = gg(c, d, a, b, k[11], 14, 643717713); + b = gg(b, c, d, a, k[0], 20, -373897302); + a = gg(a, b, c, d, k[5], 5, -701558691); + d = gg(d, a, b, c, k[10], 9, 38016083); + c = gg(c, d, a, b, k[15], 14, -660478335); + b = gg(b, c, d, a, k[4], 20, -405537848); + a = gg(a, b, c, d, k[9], 5, 568446438); + d = gg(d, a, b, c, k[14], 9, -1019803690); + c = gg(c, d, a, b, k[3], 14, -187363961); + b = gg(b, c, d, a, k[8], 20, 1163531501); + a = gg(a, b, c, d, k[13], 5, -1444681467); + d = gg(d, a, b, c, k[2], 9, -51403784); + c = gg(c, d, a, b, k[7], 14, 1735328473); + b = gg(b, c, d, a, k[12], 20, -1926607734); + + a = hh(a, b, c, d, k[5], 4, -378558); + d = hh(d, a, b, c, k[8], 11, -2022574463); + c = hh(c, d, a, b, k[11], 16, 1839030562); + b = hh(b, c, d, a, k[14], 23, -35309556); + a = hh(a, b, c, d, k[1], 4, -1530992060); + d = hh(d, a, b, c, k[4], 11, 1272893353); + c = hh(c, d, a, b, k[7], 16, -155497632); + b = hh(b, c, d, a, k[10], 23, -1094730640); + a = hh(a, b, c, d, k[13], 4, 681279174); + d = hh(d, a, b, c, k[0], 11, -358537222); + c = hh(c, d, a, b, k[3], 16, -722521979); + b = hh(b, c, d, a, k[6], 23, 76029189); + a = hh(a, b, c, d, k[9], 4, -640364487); + d = hh(d, a, b, c, k[12], 11, -421815835); + c = hh(c, d, a, b, k[15], 16, 530742520); + b = hh(b, c, d, a, k[2], 23, -995338651); + + a = ii(a, b, c, d, k[0], 6, -198630844); + d = ii(d, a, b, c, k[7], 10, 1126891415); + c = ii(c, d, a, b, k[14], 15, -1416354905); + b = ii(b, c, d, a, k[5], 21, -57434055); + a = ii(a, b, c, d, k[12], 6, 1700485571); + d = ii(d, a, b, c, k[3], 10, -1894986606); + c = ii(c, d, a, b, k[10], 15, -1051523); + b = ii(b, c, d, a, k[1], 21, -2054922799); + a = ii(a, b, c, d, k[8], 6, 1873313359); + d = ii(d, a, b, c, k[15], 10, -30611744); + c = ii(c, d, a, b, k[6], 15, -1560198380); + b = ii(b, c, d, a, k[13], 21, 1309151649); + a = ii(a, b, c, d, k[4], 6, -145523070); + d = ii(d, a, b, c, k[11], 10, -1120210379); + c = ii(c, d, a, b, k[2], 15, 718787259); + b = ii(b, c, d, a, k[9], 21, -343485551); + + x[0] = add32(a, x[0]); + x[1] = add32(b, x[1]); + x[2] = add32(c, x[2]); + x[3] = add32(d, x[3]); +} + +function cmn(q, a, b, x, s, t) { + a = add32(add32(a, q), add32(x, t)); + return add32((a << s) | (a >>> (32 - s)), b); +} + +function ff(a, b, c, d, x, s, t) { + return cmn((b & c) | ((~b) & d), a, b, x, s, t); +} + +function gg(a, b, c, d, x, s, t) { + return cmn((b & d) | (c & (~d)), a, b, x, s, t); +} + +function hh(a, b, c, d, x, s, t) { + return cmn(b ^ c ^ d, a, b, x, s, t); +} + +function ii(a, b, c, d, x, s, t) { + return cmn(c ^ (b | (~d)), a, b, x, s, t); +} + +function md51(s) { + var n = s.length, + state = [1732584193, -271733879, -1732584194, 271733878], i; + for (i=64; i<=s.length; i+=64) { + md5cycle(state, md5blk(s.substring(i-64, i))); + } + + s = s.substring(i-64); + var tail = [0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0]; + for (i=0; i<s.length; i++) { + tail[i>>2] |= s.charCodeAt(i) << ((i%4) << 3); + } + tail[i>>2] |= 0x80 << ((i%4) << 3); + if (i > 55) { + md5cycle(state, tail); + for (i=0; i<16; i++) { + tail[i] = 0; + } + } + tail[14] = n*8; + md5cycle(state, tail); + return state; +} + +function md5blk(s) { + var md5blks = [], i; + for (i=0; i<64; i+=4) { + md5blks[i>>2] = s.charCodeAt(i) + + (s.charCodeAt(i+1) << 8) + + (s.charCodeAt(i+2) << 16) + + (s.charCodeAt(i+3) << 24); + } + return md5blks; +} + +function md5(s) { + var arr = md51(s); + var buf = new Buffer(16); + var i; + for (i = 0; i < 4; i++) { + buf.writeIntLE(arr[i], i * 4, 4); + } + return buf; +} + +function add32(a, b) { + return (a + b) & 0xFFFFFFFF; +} + +module.exports = { + createHash: createHash +}; + +}).call(this,require("buffer").Buffer) +},{"buffer":16}],51:[function(require,module,exports){ +/* jshint node: true */ + +'use strict'; + +/** Shim without file-system operations. */ + +function createError() { return new Error('unsupported in the browser'); } + +function createImportHook() { + return function (fpath, kind, cb) { cb(createError()); }; +} + +function createSyncImportHook() { + return function () { throw createError(); }; +} + + +module.exports = { + createImportHook: createImportHook, + createSyncImportHook: createSyncImportHook, + existsSync: function () { return false; }, + readFileSync: function () { throw createError(); } +}; + +},{}],52:[function(require,module,exports){ +(function (process,Buffer){ +/* jshint node: true */ + +// TODO: Add streams which prefix each record with its length. + +'use strict'; + +/** + * This module defines custom streams to write and read Avro files. + * + * In particular, the `Block{En,De}coder` streams are able to deal with Avro + * container files. None of the streams below depend on the filesystem however, + * this way they can also be used in the browser (for example to parse HTTP + * responses). + */ + +var types = require('./types'), + utils = require('./utils'), + stream = require('stream'), + util = require('util'), + zlib = require('zlib'); + + +var OPTS = {namespace: 'org.apache.avro.file'}; + +var LONG_TYPE = types.Type.forSchema('long', OPTS); + +var HEADER_TYPE = types.Type.forSchema({ + name: 'Header', + type: 'record', + fields : [ + {name: 'magic', type: {type: 'fixed', name: 'Magic', size: 4}}, + {name: 'meta', type: {type: 'map', values: 'bytes'}}, + {name: 'sync', type: {type: 'fixed', name: 'Sync', size: 16}} + ] +}, OPTS); + +var BLOCK_TYPE = types.Type.forSchema({ + name: 'Block', + type: 'record', + fields : [ + {name: 'count', type: 'long'}, + {name: 'data', type: 'bytes'}, + {name: 'sync', type: 'Sync'} + ] +}, OPTS); + +// First 4 bytes of an Avro object container file. +var MAGIC_BYTES = new Buffer('Obj\x01'); + +// Convenience. +var f = util.format; +var Tap = utils.Tap; + + +/** Duplex stream for decoding fragments. */ +function RawDecoder(schema, opts) { + opts = opts || {}; + + var noDecode = !!opts.noDecode; + stream.Duplex.call(this, { + readableObjectMode: !noDecode, + allowHalfOpen: false + }); + + this._type = types.Type.forSchema(schema); + this._tap = new Tap(new Buffer(0)); + this._writeCb = null; + this._needPush = false; + this._readValue = createReader(noDecode, this._type); + this._finished = false; + + this.on('finish', function () { + this._finished = true; + this._read(); + }); +} +util.inherits(RawDecoder, stream.Duplex); + +RawDecoder.prototype._write = function (chunk, encoding, cb) { + // Store the write callback and call it when we are done decoding all + // records + // in this chunk. If we call it right away, we risk loading the entire input + // in memory. We only need to store the latest callback since the stream API + // guarantees that `_write` won't be called again until we call the + // previous. + this._writeCb = cb; + + var tap = this._tap; + tap.buf = Buffer.concat([tap.buf.slice(tap.pos), chunk]); + tap.pos = 0; + if (this._needPush) { + this._needPush = false; + this._read(); + } +}; + +RawDecoder.prototype._read = function () { + this._needPush = false; + + var tap = this._tap; + var pos = tap.pos; + var val = this._readValue(tap); + if (tap.isValid()) { + this.push(val); + } else if (!this._finished) { + tap.pos = pos; + this._needPush = true; + if (this._writeCb) { + // This should only ever be false on the first read, and only if it + // happens before the first write. + this._writeCb(); + } + } else { + this.push(null); + } +}; + + +/** Duplex stream for decoding object container files. */ +function BlockDecoder(opts) { + opts = opts || {}; + + var noDecode = !!opts.noDecode; + stream.Duplex.call(this, { + allowHalfOpen: true, // For async decompressors. + readableObjectMode: !noDecode + }); + + this._rType = opts.readerSchema !== undefined ? + types.Type.forSchema(opts.readerSchema) : + undefined; + this._wType = null; + this._codecs = opts.codecs; + this._codec = undefined; + this._parseHook = opts.parseHook; + this._tap = new Tap(new Buffer(0)); + this._blockTap = new Tap(new Buffer(0)); + this._syncMarker = null; + this._readValue = null; + this._noDecode = noDecode; + this._queue = new utils.OrderedQueue(); + this._decompress = null; // Decompression function. + this._index = 0; // Next block index. + this._needPush = false; + this._finished = false; + + this.on('finish', function () { + this._finished = true; + if (this._needPush) { + this._read(); + } + }); +} +util.inherits(BlockDecoder, stream.Duplex); + +BlockDecoder.defaultCodecs = function () { + return { + 'null': function (buf, cb) { cb(null, buf); }, + 'deflate': zlib.inflateRaw + }; +}; + +BlockDecoder.getDefaultCodecs = BlockDecoder.defaultCodecs; + +BlockDecoder.prototype._decodeHeader = function () { + var tap = this._tap; + if (tap.buf.length < MAGIC_BYTES.length) { + // Wait until more data arrives. + return false; + } + + if (!MAGIC_BYTES.equals(tap.buf.slice(0, MAGIC_BYTES.length))) { + this.emit('error', new Error('invalid magic bytes')); + return false; + } + + var header = HEADER_TYPE._read(tap); + if (!tap.isValid()) { + return false; + } + + this._codec = (header.meta['avro.codec'] || 'null').toString(); + var codecs = this._codecs || BlockDecoder.getDefaultCodecs(); + this._decompress = codecs[this._codec]; + if (!this._decompress) { + this.emit('error', new Error(f('unknown codec: %s', this._codec))); + return; + } + + try { + var schema = JSON.parse(header.meta['avro.schema'].toString()); + if (this._parseHook) { + schema = this._parseHook(schema); + } + this._wType = types.Type.forSchema(schema); + } catch (err) { + this.emit('error', err); + return; + } + + this._readValue = createReader(this._noDecode, this._wType, this._rType); + this._syncMarker = header.sync; + this.emit('metadata', this._wType, this._codec, header); + return true; +}; + +BlockDecoder.prototype._write = function (chunk, encoding, cb) { + var tap = this._tap; + tap.buf = Buffer.concat([tap.buf, chunk]); + tap.pos = 0; + + if (!this._decodeHeader()) { + process.nextTick(cb); + return; + } + + // We got the header, switch to block decoding mode. Also, call it directly + // in case we already have all the data (in which case `_write` wouldn't get + // called anymore). + this._write = this._writeChunk; + this._write(new Buffer(0), encoding, cb); +}; + +BlockDecoder.prototype._writeChunk = function (chunk, encoding, cb) { + var tap = this._tap; + tap.buf = Buffer.concat([tap.buf.slice(tap.pos), chunk]); + tap.pos = 0; + + var nBlocks = 1; + var block; + while ((block = tryReadBlock(tap))) { + if (!this._syncMarker.equals(block.sync)) { + this.emit('error', new Error('invalid sync marker')); + return; + } + nBlocks++; + this._decompress(block.data, this._createBlockCallback(chunkCb)); + } + chunkCb(); + + function chunkCb() { + if (!--nBlocks) { + cb(); + } + } +}; + +BlockDecoder.prototype._createBlockCallback = function (cb) { + var self = this; + var index = this._index++; + + return function (cause, data) { + if (cause) { + var err = new Error(f('%s codec decompression error', self._codec)); + err.cause = cause; + self.emit('error', err); + cb(); + } else { + self._queue.push(new BlockData(index, data, cb)); + if (self._needPush) { + self._read(); + } + } + }; +}; + +BlockDecoder.prototype._read = function () { + this._needPush = false; + + var tap = this._blockTap; + if (tap.pos >= tap.buf.length) { + var data = this._queue.pop(); + if (!data) { + if (this._finished) { + this.push(null); + } else { + this._needPush = true; + } + return; // Wait for more data. + } + data.cb(); + tap.buf = data.buf; + tap.pos = 0; + } + + this.push(this._readValue(tap)); // The read is guaranteed valid. +}; + + +/** Duplex stream for encoding. */ +function RawEncoder(schema, opts) { + opts = opts || {}; + + stream.Transform.call(this, { + writableObjectMode: true, + allowHalfOpen: false + }); + + this._type = types.Type.forSchema(schema); + this._writeValue = function (tap, val) { + try { + this._type._write(tap, val); + } catch (err) { + this.emit('error', err); + } + }; + this._tap = new Tap(new Buffer(opts.batchSize || 65536)); +} +util.inherits(RawEncoder, stream.Transform); + +RawEncoder.prototype._transform = function (val, encoding, cb) { + var tap = this._tap; + var buf = tap.buf; + var pos = tap.pos; + + this._writeValue(tap, val); + if (!tap.isValid()) { + if (pos) { + // Emit any valid data. + this.push(copyBuffer(tap.buf, 0, pos)); + } + var len = tap.pos - pos; + if (len > buf.length) { + // Not enough space for last written object, need to resize. + tap.buf = new Buffer(2 * len); + } + tap.pos = 0; + this._writeValue(tap, val); // Rewrite last failed write. + } + + cb(); +}; + +RawEncoder.prototype._flush = function (cb) { + var tap = this._tap; + var pos = tap.pos; + if (pos) { + // This should only ever be false if nothing is written to the stream. + this.push(tap.buf.slice(0, pos)); + } + cb(); +}; + + +/** + * Duplex stream to write object container files. + * + * @param schema + * @param opts + * {Object} + * + `blockSize`, uncompressed. + `codec` + `codecs` + `noCheck` + + * `omitHeader`, useful to append to an existing block file. + */ +function BlockEncoder(schema, opts) { + opts = opts || {}; + + stream.Duplex.call(this, { + allowHalfOpen: true, // To support async compressors. + writableObjectMode: true + }); + + var type; + if (types.Type.isType(schema)) { + type = schema; + schema = undefined; + } else { + // Keep full schema to be able to write it to the header later. + type = types.Type.forSchema(schema); + } + + this._schema = schema; + this._type = type; + this._writeValue = function (tap, val) { + try { + this._type._write(tap, val); + } catch (err) { + this.emit('error', err); + } + }; + this._blockSize = opts.blockSize || 65536; + this._tap = new Tap(new Buffer(this._blockSize)); + this._codecs = opts.codecs; + this._codec = opts.codec || 'null'; + this._blockCount = 0; + this._syncMarker = opts.syncMarker || new utils.Lcg().nextBuffer(16); + this._queue = new utils.OrderedQueue(); + this._pending = 0; + this._finished = false; + this._needHeader = false; + this._needPush = false; + + var codec = this._codec; + this._compress = (this._codecs || BlockEncoder.getDefaultCodecs())[codec]; + if (!this._compress) { + throw new Error(f('unsupported codec: %s', codec)); + } + + if (opts.omitHeader !== undefined) { // Legacy option. + opts.writeHeader = opts.omitHeader ? 'never' : 'auto'; + } + switch (opts.writeHeader) { + case false: + case 'never': + break; + case undefined: // Backwards-compatibility (eager default would be better). + case 'auto': + this._needHeader = true; + break; + default: + this._writeHeader(); + } + + this.on('finish', function () { + this._finished = true; + if (this._blockCount) { + this._flushChunk(); + } else if (this._finished && this._needPush) { + // We don't need to check `_isPending` since `_blockCount` is always + // positive after the first flush. + this.push(null); + } + }); +} +util.inherits(BlockEncoder, stream.Duplex); + +BlockEncoder.defaultCodecs = function () { + return { + 'null': function (buf, cb) { cb(null, buf); }, + 'deflate': zlib.deflateRaw + }; +}; + +BlockEncoder.getDefaultCodecs = BlockEncoder.defaultCodecs; + +BlockEncoder.prototype._writeHeader = function () { + var schemaStr = JSON.stringify( + this._schema ? this._schema : this._type.getSchema({exportAttrs: true}) + ); + var meta = { + 'avro.schema': new Buffer(schemaStr), + 'avro.codec': new Buffer(this._codec) + }; + var Header = HEADER_TYPE.getRecordConstructor(); + var header = new Header(MAGIC_BYTES, meta, this._syncMarker); + this.push(header.toBuffer()); +}; + +BlockEncoder.prototype._write = function (val, encoding, cb) { + if (this._needHeader) { + this._writeHeader(); + this._needHeader = false; + } + + var tap = this._tap; + var pos = tap.pos; + var flushing = false; + + this._writeValue(tap, val); + if (!tap.isValid()) { + if (pos) { + this._flushChunk(pos, cb); + flushing = true; + } + var len = tap.pos - pos; + if (len > this._blockSize) { + // Not enough space for last written object, need to resize. + this._blockSize = len * 2; + } + tap.buf = new Buffer(this._blockSize); + tap.pos = 0; + this._writeValue(tap, val); // Rewrite last failed write. + } + this._blockCount++; + + if (!flushing) { + cb(); + } +}; + +BlockEncoder.prototype._flushChunk = function (pos, cb) { + var tap = this._tap; + pos = pos || tap.pos; + this._compress(tap.buf.slice(0, pos), this._createBlockCallback(cb)); + this._blockCount = 0; +}; + +BlockEncoder.prototype._read = function () { + var self = this; + var data = this._queue.pop(); + if (!data) { + if (this._finished && !this._pending) { + process.nextTick(function () { self.push(null); }); + } else { + this._needPush = true; + } + return; + } + + this.push(LONG_TYPE.toBuffer(data.count, true)); + this.push(LONG_TYPE.toBuffer(data.buf.length, true)); + this.push(data.buf); + this.push(this._syncMarker); + + if (!this._finished) { + data.cb(); + } +}; + +BlockEncoder.prototype._createBlockCallback = function (cb) { + var self = this; + var index = this._index++; + var count = this._blockCount; + this._pending++; + + return function (cause, data) { + if (cause) { + var err = new Error(f('%s codec compression error', self._codec)); + err.cause = cause; + self.emit('error', err); + return; + } + self._pending--; + self._queue.push(new BlockData(index, data, cb, count)); + if (self._needPush) { + self._needPush = false; + self._read(); + } + }; +}; + + +// Helpers. + +/** + * An indexed block. + * + * This can be used to preserve block order since compression and decompression + * can cause some some blocks to be returned out of order. The count is only + * used when encoding. + */ +function BlockData(index, buf, cb, count) { + this.index = index; + this.buf = buf; + this.cb = cb; + this.count = count | 0; +} + +/** Maybe get a block. */ +function tryReadBlock(tap) { + var pos = tap.pos; + var block = BLOCK_TYPE._read(tap); + if (!tap.isValid()) { + tap.pos = pos; + return null; + } + return block; +} + +/** Create bytes consumer, either reading or skipping records. */ +function createReader(noDecode, writerType, readerType) { + if (noDecode) { + return (function (skipper) { + return function (tap) { + var pos = tap.pos; + skipper(tap); + return tap.buf.slice(pos, tap.pos); + }; + })(writerType._skip); + } else if (readerType) { + var resolver = readerType.createResolver(writerType); + return function (tap) { return resolver._read(tap); }; + } else { + return function (tap) { return writerType._read(tap); }; + } +} + +/** Copy a buffer. This avoids creating a slice of the original buffer. */ +function copyBuffer(buf, pos, len) { + var copy = new Buffer(len); + buf.copy(copy, 0, pos, pos + len); + return copy; +} + + +module.exports = { + HEADER_TYPE: HEADER_TYPE, // For tests. + MAGIC_BYTES: MAGIC_BYTES, // Idem. + streams: { + BlockDecoder: BlockDecoder, + BlockEncoder: BlockEncoder, + RawDecoder: RawDecoder, + RawEncoder: RawEncoder + } +}; + +}).call(this,require('_process'),require("buffer").Buffer) +},{"./types":55,"./utils":56,"_process":23,"buffer":16,"stream":42,"util":47,"zlib":15}],53:[function(require,module,exports){ +(function (process,Buffer){ +/* jshint node: true */ + +// TODO: Add broadcast option to client `_emitMessage`, accessible for one-way +// messages. +// TODO: Add `server.mount` method to allow combining servers. The API is as +// follows: a mounted server's (i.e. the method's argument) handlers have lower +// precedence than the original server (i.e. `this`); the mounted server's +// middlewares are only invoked for its handlers. +// TODO: Change `objectMode` client and server channel option to `encoding` +// (accepting `'netty'`, `'standard'`, and `null` or `undefined`). Perhaps also +// expose encoders (API TBD). + +'use strict'; + +/** This module implements Avro's IPC/RPC logic. */ + +var types = require('./types'), + utils = require('./utils'), + events = require('events'), + stream = require('stream'), + util = require('util'); + + +// A few convenience imports. +var Tap = utils.Tap; +var Type = types.Type; +var debug = util.debuglog('avsc:services'); +var f = util.format; + +// Various useful types. We instantiate options once, to share the registry. +var OPTS = {namespace: 'org.apache.avro.ipc'}; + +var BOOLEAN_TYPE = Type.forSchema('boolean', OPTS); + +var MAP_BYTES_TYPE = Type.forSchema({type: 'map', values: 'bytes'}, OPTS); + +var STRING_TYPE = Type.forSchema('string', OPTS); + +var HANDSHAKE_REQUEST_TYPE = Type.forSchema({ + name: 'HandshakeRequest', + type: 'record', + fields: [ + {name: 'clientHash', type: {name: 'MD5', type: 'fixed', size: 16}}, + {name: 'clientProtocol', type: ['null', 'string'], 'default': null}, + {name: 'serverHash', type: 'MD5'}, + {name: 'meta', type: ['null', MAP_BYTES_TYPE], 'default': null} + ] +}, OPTS); + +var HANDSHAKE_RESPONSE_TYPE = Type.forSchema({ + name: 'HandshakeResponse', + type: 'record', + fields: [ + { + name: 'match', + type: { + name: 'HandshakeMatch', + type: 'enum', + symbols: ['BOTH', 'CLIENT', 'NONE'] + } + }, + {name: 'serverProtocol', type: ['null', 'string'], 'default': null}, + {name: 'serverHash', type: ['null', 'MD5'], 'default': null}, + {name: 'meta', type: ['null', MAP_BYTES_TYPE], 'default': null} + ] +}, OPTS); + +// Prefix used to differentiate between messages when sharing a stream. This +// length should be smaller than 16. The remainder is used for disambiguating +// between concurrent messages (the current value, 16, therefore supports ~64k +// concurrent messages). +var PREFIX_LENGTH = 16; + +// Internal message, used to check protocol compatibility. +var PING_MESSAGE = new Message( + '', // Empty name (invalid for other "normal" messages). + Type.forSchema({name: 'PingRequest', type: 'record', fields: []}, OPTS), + Type.forSchema(['string'], OPTS), + Type.forSchema('null', OPTS) +); + +/** An Avro message, containing its request, response, etc. */ +function Message(name, reqType, errType, resType, oneWay, doc) { + this.name = name; + if (!Type.isType(reqType, 'record')) { + throw new Error('invalid request type'); + } + this.requestType = reqType; + if ( + !Type.isType(errType, 'union') || + !Type.isType(errType.getTypes()[0], 'string') + ) { + throw new Error('invalid error type'); + } + this.errorType = errType; + if (oneWay) { + if (!Type.isType(resType, 'null') || errType.getTypes().length > 1) { + throw new Error('inapplicable one-way parameter'); + } + } + this.responseType = resType; + this.oneWay = !!oneWay; + this.doc = doc !== undefined ? '' + doc : undefined; + Object.freeze(this); +} + +Message.forSchema = function (name, schema, opts) { + opts = opts || {}; + if (!types.isValidName(name)) { + throw new Error(f('invalid message name: %s', name)); + } + // We use a record with a placeholder name here (the user might have set + // `noAnonymousTypes`, so we can't use an anonymous one). We remove it from + // the registry afterwards to avoid exposing it outside. + if (!Array.isArray(schema.request)) { + throw new Error(f('invalid message request: %s', name)); + } + var recordName = f('%s.%sRequest', OPTS.namespace, utils.capitalize(name)); + var reqType = Type.forSchema({ + name: recordName, + type: 'record', + namespace: opts.namespace || '', // Don't leak request namespace. + fields: schema.request + }, opts); + delete opts.registry[recordName]; + if (!schema.response) { + throw new Error(f('invalid message response: %s', name)); + } + var resType = Type.forSchema(schema.response, opts); + if (schema.errors !== undefined && !Array.isArray(schema.errors)) { + throw new Error(f('invalid message errors: %s', name)); + } + var errType = Type.forSchema(['string'].concat(schema.errors || []), opts); + var oneWay = !!schema['one-way']; + return new Message(name, reqType, errType, resType, oneWay, schema.doc); +}; + +Message.prototype.schema = Type.prototype.getSchema; + +Message.prototype._attrs = function (opts) { + var reqSchema = this.requestType._attrs(opts); + var schema = { + request: reqSchema.fields, + response: this.responseType._attrs(opts) + }; + var msgDoc = this.doc; + if (msgDoc !== undefined) { + schema.doc = msgDoc; + } + var errSchema = this.errorType._attrs(opts); + if (errSchema.length > 1) { + schema.errors = errSchema.slice(1); + } + if (this.oneWay) { + schema['one-way'] = true; + } + return schema; +}; + +// Deprecated. + +utils.addDeprecatedGetters( + Message, + ['name', 'errorType', 'requestType', 'responseType'] +); + +Message.prototype.isOneWay = util.deprecate( + function () { return this.oneWay; }, + 'use `.oneWay` directly instead of `.isOneWay()`' +); + +/** + * An Avro RPC service. + * + * This constructor shouldn't be called directly, but via the + * `Service.forProtocol` method. This function performs little logic to better + * support efficient copy. + */ +function Service(name, messages, types, ptcl, server) { + if (typeof name != 'string') { + // Let's be helpful in case this class is instantiated directly. + return Service.forProtocol(name, messages); + } + + this.name = name; + this._messagesByName = messages || {}; + this.messages = Object.freeze(utils.objectValues(this._messagesByName)); + + this._typesByName = types || {}; + this.types = Object.freeze(utils.objectValues(this._typesByName)); + + this.protocol = ptcl; + // We cache a string rather than a buffer to not retain an entire slab. + this._hashStr = utils.getHash(JSON.stringify(ptcl)).toString('binary'); + this.doc = ptcl.doc ? '' + ptcl.doc : undefined; + + // We add a server to each protocol for backwards-compatibility (to allow + // the + // use of `protocol.on`). This covers all cases except the use of the + // `strictErrors` option, which requires moving to the new API. + this._server = server || this.createServer({silent: true}); + Object.freeze(this); +} + +Service.Client = Client; + +Service.Server = Server; + +Service.compatible = function (clientSvc, serverSvc) { + try { + createReaders(clientSvc, serverSvc); + } catch (err) { + return false; + } + return true; +}; + +Service.forProtocol = function (ptcl, opts) { + opts = opts || {}; + + var name = ptcl.protocol; + if (!name) { + throw new Error('missing protocol name'); + } + if (ptcl.namespace !== undefined) { + opts.namespace = ptcl.namespace; + } else { + var match = /^(.*)\.[^.]+$/.exec(name); + if (match) { + opts.namespace = match[1]; + } + } + name = types.qualify(name, opts.namespace); + + if (ptcl.types) { + ptcl.types.forEach(function (obj) { Type.forSchema(obj, opts); }); + } + var msgs; + if (ptcl.messages) { + msgs = {}; + Object.keys(ptcl.messages).forEach(function (key) { + msgs[key] = Message.forSchema(key, ptcl.messages[key], opts); + }); + } + + return new Service(name, msgs, opts.registry, ptcl); +}; + +Service.isService = function (any) { + // Not fool-proof but likely sufficient. + return !!any && any.hasOwnProperty('_hashStr'); +}; + +Service.prototype.createClient = function (opts) { + var client = new Client(this, opts); + process.nextTick(function () { + // We delay this processing such that we can attach handlers to the client + // before any channels get created. + if (opts && opts.server) { + // Convenience in-memory client. This can be useful to make requests + // relatively efficiently to an in-process server. Note that it is still + // is less efficient than direct method calls (because of the + // serialization, which does provide "type-safety" though). + var obj = {objectMode: true}; + var pts = [new stream.PassThrough(obj), new stream.PassThrough(obj)]; + opts.server.createChannel({readable: pts[0], writable: pts[1]}, obj); + client.createChannel({readable: pts[1], writable: pts[0]}, obj); + } else if (opts && opts.transport) { + // Convenience functionality for the common single channel use-case: we + // add a single channel using default options to the client. + client.createChannel(opts.transport); + } + }); + return client; +}; + +Service.prototype.createServer = function (opts) { + return new Server(this, opts); +}; + +Object.defineProperty(Service.prototype, 'hash', { + enumerable: true, + get: function () { return new Buffer(this._hashStr, 'binary'); } +}); + +Service.prototype.message = function (name) { + return this._messagesByName[name]; +}; + +Service.prototype.type = function (name) { + return this._typesByName[name]; +}; + +Service.prototype.inspect = function () { + return f('<Service %j>', this.name); +}; + +// Deprecated methods. + +utils.addDeprecatedGetters( + Service, + ['message', 'messages', 'name', 'type', 'types'] +); + +Service.prototype.createEmitter = util.deprecate( + function (transport, opts) { + opts = opts || {}; + var client = this.createClient({ + cache: opts.cache, + buffering: false, + strictTypes: opts.strictErrors, + timeout: opts.timeout + }); + var channel = client.createChannel(transport, opts); + forwardErrors(client, channel); + return channel; + }, + 'use `.createClient()` instead of `.createEmitter()`' +); + +Service.prototype.createListener = util.deprecate( + function (transport, opts) { + if (opts && opts.strictErrors) { + throw new Error('use `.createServer()` to support strict errors'); + } + return this._server.createChannel(transport, opts); + }, + 'use `.createServer().createChannel()` instead of `.createListener()`' +); + +Service.prototype.emit = util.deprecate( + function (name, req, channel, cb) { + if (!channel || !this.equals(channel.client._svc$)) { + throw new Error('invalid emitter'); + } + + var client = channel.client; + // In case the method is overridden. + Client.prototype.emitMessage.call(client, name, req, cb && cb.bind(this)); + return channel.getPending(); + }, + 'create a client via `.createClient()` to emit messages instead of `.emit()`' +); + +Service.prototype.equals = util.deprecate( + function (any) { + return ( + Service.isService(any) && + this.getFingerprint().equals(any.getFingerprint()) + ); + }, + 'equality testing is deprecated, compare the `.protocol`s instead' +); + +Service.prototype.getFingerprint = util.deprecate( + function (algorithm) { + return utils.getHash(JSON.stringify(this.protocol), algorithm); + }, + 'use `.hash` instead of `.getFingerprint()`' +); + +Service.prototype.getSchema = util.deprecate( + Type.prototype.getSchema, + 'use `.protocol` instead of `.getSchema()`' +); + +Service.prototype.on = util.deprecate( + function (name, handler) { + var self = this; // This protocol. + this._server.onMessage(name, function (req, cb) { + return handler.call(self, req, this.channel, cb); + }); + return this; + }, + 'use `.createServer().onMessage()` instead of `.on()`' +); + +Service.prototype.subprotocol = util.deprecate( + function () { + var parent = this._server; + var opts = {strictTypes: parent._strict, cache: parent._cache}; + var server = new Server(parent.service, opts); + server._handlers = Object.create(parent._handlers); + return new Service( + this.name, + this._messagesByName, + this._typesByName, + this.protocol, + server + ); + }, + '`.subprotocol()` will be removed in 5.1' +); + +Service.prototype._attrs = function (opts) { + var ptcl = {protocol: this.name}; + + var types = []; + this.types.forEach(function (t) { + if (t.getName() === undefined) { + // Don't include any unnamed types (e.g. primitives). + return; + } + var typeSchema = t._attrs(opts); + if (typeof typeSchema != 'string') { + // Some of the named types might already have been defined in a + // previous type, in this case we don't include its reference. + types.push(typeSchema); + } + }); + if (types.length) { + ptcl.types = types; + } + + var msgNames = Object.keys(this._messagesByName); + if (msgNames.length) { + ptcl.messages = {}; + msgNames.forEach(function (name) { + ptcl.messages[name] = this._messagesByName[name]._attrs(opts); + }, this); + } + + if (opts && opts.exportAttrs && this.doc !== undefined) { + ptcl.doc = this.doc; + } + return ptcl; +}; + +/** Function to retrieve a remote service's protocol. */ +function discoverProtocol(transport, opts, cb) { + if (cb === undefined && typeof opts == 'function') { + cb = opts; + opts = undefined; + } + + var svc = new Service({protocol: 'Empty'}, OPTS); + var ptclStr; + svc.createClient({timeout: opts && opts.timeout}) + .createChannel(transport, { + scope: opts && opts.scope, + endWritable: typeof transport == 'function' // Stateless transports + // only. + }).once('handshake', function (hreq, hres) { + ptclStr = hres.serverProtocol; + this.destroy(true); + }) + .once('eot', function (pending, err) { + // Stateless transports will throw an interrupted error when the + // channel is destroyed, we ignore it here. + if (err && !/interrupted/.test(err)) { + cb(err); // Likely timeout. + } else { + cb(null, JSON.parse(ptclStr)); + } + }); +} + +/** Load-balanced message sender. */ +function Client(svc, opts) { + opts = opts || {}; + events.EventEmitter.call(this); + + // We have to suffix all client properties to be safe, since the message + // names aren't prefixed with clients (unlike servers). + this._svc$ = svc; + this._channels$ = []; // Active channels. + this._fns$ = []; // Middleware functions. + + this._buffering$ = !!opts.buffering; + this._cache$ = opts.cache || {}; // For backwards compatibility. + this._policy$ = opts.channelPolicy; + this._strict$ = !!opts.strictTypes; + this._timeout$ = utils.getOption(opts, 'timeout', 10000); + + if (opts.remoteProtocols) { + insertRemoteProtocols(this._cache$, opts.remoteProtocols, svc, true); + } + + this._svc$.messages.forEach(function (msg) { + this[msg.name] = this._createMessageHandler$(msg); + }, this); +} +util.inherits(Client, events.EventEmitter); + +Client.prototype.activeChannels = function () { + return this._channels$.slice(); +}; + +Client.prototype.createChannel = function (transport, opts) { + var objectMode = opts && opts.objectMode; + var channel; + if (typeof transport == 'function') { + var writableFactory; + if (objectMode) { + writableFactory = transport; + } else { + // We provide a default standard-compliant codec. This should support + // most use-cases (for example when speaking to the official Java and + // Python implementations over HTTP, or when this library is used for + // both the emitting and listening sides). + writableFactory = function (cb) { + var encoder = new FrameEncoder(); + var writable = transport(function (err, readable) { + if (err) { + cb(err); + return; + } + // Since the decoder isn't exposed (so can't have an error handler + // attached, we forward any errors to the client). Since errors + // would + // only get thrown when the decoder flushes (if there is trailing + // data), at which point the source will have ended, there is no + // need + // to add re-piping logic (destination errors trigger an unpipe). + var decoder = new FrameDecoder() + .once('error', function (err) { channel.destroy(err); }); + cb(null, readable.pipe(decoder)); + }); + if (writable) { + encoder.pipe(writable); + return encoder; + } + }; + } + channel = new StatelessClientChannel(this, writableFactory, opts); + } else { + var readable, writable; + if (isStream(transport)) { + readable = writable = transport; + } else { + readable = transport.readable; + writable = transport.writable; + } + if (!objectMode) { + // To ease communication with Java servers, we provide a default codec + // compatible with Java servers' `NettyTransportCodec`'s implementation. + var decoder = new NettyDecoder(); + readable = readable.pipe(decoder); + var encoder = new NettyEncoder(); + encoder.pipe(writable); + writable = encoder; + } + channel = new StatefulClientChannel(this, readable, writable, opts); + if (!objectMode) { + // Since we never expose the automatically created encoder and decoder, + // we release them ourselves here when the channel ends. (Unlike for + // stateless channels, it is conceivable for the underlying stream to be + // reused afterwards). + channel.once('eot', function () { + readable.unpipe(decoder); + encoder.unpipe(writable); + }); + // We also forward any (trailing data) error. + decoder.once('error', function (err) { channel.destroy(err); }); + } + } + var channels = this._channels$; + channels.push(channel); + channel.once('_drain', function () { + // Remove the channel from the list of active ones. + channels.splice(channels.indexOf(this), 1); + }); + // We restrict buffering to startup, otherwise we risk silently hiding + // errors + // (especially since channel timeouts don't apply yet). + this._buffering$ = false; + this.emit('channel', channel); + return channel; +}; + +Client.prototype.destroyChannels = function (opts) { + this._channels$.forEach(function (channel) { + channel.destroy(opts && opts.noWait); + }); +}; + +Client.prototype.emitMessage = function (name, req, opts, cb) { + var msg = getExistingMessage(this._svc$, name); + var wreq = new WrappedRequest(msg, {}, req); + this._emitMessage$(wreq, opts, cb); +}; + +Client.prototype.remoteProtocols = function () { + return getRemoteProtocols(this._cache$, true); +}; + +Object.defineProperty(Client.prototype, 'service', { + enumerable: true, + get: function () { return this._svc$; } +}); + +Client.prototype.use = function (/* fn ... */) { + var i, l, fn; + for (i = 0, l = arguments.length; i < l; i++) { + fn = arguments[i]; + this._fns$.push(fn.length < 3 ? fn(this) : fn); + } + return this; +}; + +Client.prototype._emitMessage$ = function (wreq, opts, cb) { + // Common logic between `client.emitMessage` and the "named" message + // methods. + if (!cb && typeof opts === 'function') { + cb = opts; + opts = undefined; + } + var self = this; + var channels = this._channels$; + var numChannels = channels.length; + if (!numChannels) { + if (this._buffering$) { + debug('no active client channels, buffering call'); + this.once('channel', function () { + this._emitMessage$(wreq, opts, cb); + }); + } else { + var err = new Error('no active channels'); + process.nextTick(function () { + if (cb) { + cb.call(new CallContext(wreq._msg), err); + } else { + self.emit('error', err); + } + }); + } + return; + } + + opts = opts || {}; + if (opts.timeout === undefined) { + opts.timeout = this._timeout$; + } + + var channel; + if (numChannels === 1) { + // Common case, optimized away. + channel = channels[0]; + } else if (this._policy$) { + channel = this._policy$(this._channels$.slice()); + } else { + // Random selection, cheap and likely good enough for most use-cases. + channel = channels[Math.floor(Math.random() * numChannels)]; + } + + channel._emit(wreq, opts, function (err, wres) { + var ctx = this; // Call context. + var errType = ctx.message.errorType; + if (err) { + // System error, likely the message wasn't sent (or an error occurred + // while decoding the response). + if (self._strict$) { + err = errType.clone(err.message, {wrapUnions: true}); + } + done(err); + return; + } + if (!wres) { + // This is a one way message. + done(); + return; + } + // Message transmission succeeded, we transmit the message data; massaging + // any error strings into actual `Error` objects in non-strict mode. + err = wres.error; + if (!self._strict$) { + // Try to coerce an eventual error into more idiomatic JavaScript types: + // `undefined` becomes `null` and a remote string "system" error is + // wrapped inside an actual `Error` object. + if (err === undefined) { + err = null; + } else { + if (Type.isType(errType, 'union:unwrapped')) { + if (typeof err == 'string') { + err = new Error(err); + } + } else if (err && err.string && typeof err.string == 'string') { + err = new Error(err.string); + } + } + } + done(err, wres.response); + + function done(err, res) { + if (cb) { + cb.call(ctx, err, res); + } else if (err) { + self.emit('error', err); + } + } + }); +}; + +Client.prototype._createMessageHandler$ = function (msg) { + // jshint -W054 + var fields = msg.requestType.getFields(); + var names = fields.map(function (f) { return f.getName(); }); + var body = 'return function ' + msg.name + '('; + if (names.length) { + body += names.join(', ') + ', '; + } + body += 'opts, cb) {\n'; + body += ' var req = {'; + body += names.map(function (n) { return n + ': ' + n; }).join(', '); + body += '};\n'; + body += ' return this.emitMessage(\'' + msg.name + '\', req, opts, cb);\n'; + body += '};'; + return (new Function(body))(); +}; + +/** Message receiver. */ +function Server(svc, opts) { + opts = opts || {}; + events.EventEmitter.call(this); + + this.service = svc; + this._handlers = {}; + this._fns = []; // Middleware functions. + this._channels = {}; // Active channels. + this._nextChannelId = 1; + + this._cache = opts.cache || {}; // Deprecated. + this._defaultHandler = opts.defaultHandler; + this._sysErrFormatter = opts.systemErrorFormatter; + this._silent = !!opts.silent; + this._strict = !!opts.strictTypes; + + if (opts.remoteProtocols) { + insertRemoteProtocols(this._cache, opts.remoteProtocols, svc, false); + } + + svc.messages.forEach(function (msg) { + var name = msg.name; + if (!opts.noCapitalize) { + name = utils.capitalize(name); + } + this['on' + name] = this._createMessageHandler(msg); + }, this); +} +util.inherits(Server, events.EventEmitter); + +Server.prototype.activeChannels = function () { + return utils.objectValues(this._channels); +}; + +Server.prototype.createChannel = function (transport, opts) { + var objectMode = opts && opts.objectMode; + var channel; + if (typeof transport == 'function') { + var readableFactory; + if (objectMode) { + readableFactory = transport; + } else { + readableFactory = function (cb) { + var decoder = new FrameDecoder() + .once('error', function (err) { channel.destroy(err); }); + return transport(function (err, writable) { + if (err) { + cb(err); + return; + } + var encoder = new FrameEncoder(); + encoder.pipe(writable); + cb(null, encoder); + }).pipe(decoder); + }; + } + channel = new StatelessServerChannel(this, readableFactory, opts); + } else { + var readable, writable; + if (isStream(transport)) { + readable = writable = transport; + } else { + readable = transport.readable; + writable = transport.writable; + } + if (!objectMode) { + var decoder = new NettyDecoder(); + readable = readable.pipe(decoder); + var encoder = new NettyEncoder(); + encoder.pipe(writable); + writable = encoder; + } + channel = new StatefulServerChannel(this, readable, writable, opts); + if (!objectMode) { + // Similar to client channels, since we never expose the encoder and + // decoder, we must release them ourselves here. + channel.once('eot', function () { + readable.unpipe(decoder); + encoder.unpipe(writable); + }); + decoder.once('error', function (err) { channel.destroy(err); }); + } + } + + if (!this.listeners('error').length) { + this.on('error', this._onError); + } + var channelId = this._nextChannelId++; + var channels = this._channels; + channels[channelId] = channel + .once('eot', function () { delete channels[channelId]; }); + this.emit('channel', channel); + return channel; +}; + +Server.prototype.onMessage = function (name, handler) { + getExistingMessage(this.service, name); // Check message existence. + this._handlers[name] = handler; + return this; +}; + +Server.prototype.remoteProtocols = function () { + return getRemoteProtocols(this._cache, false); +}; + +Server.prototype.use = function (/* fn ... */) { + var i, l, fn; + for (i = 0, l = arguments.length; i < l; i++) { + fn = arguments[i]; + this._fns.push(fn.length < 3 ? fn(this) : fn); + } + return this; +}; + +Server.prototype._createMessageHandler = function (msg) { + // jshint -W054 + var name = msg.name; + var fields = msg.requestType.fields; + var numArgs = fields.length; + var args = fields.length ? + ', ' + fields.map(function (f) { return 'req.' + f.name; }).join(', ') : + ''; + // We are careful to not lose the initial handler's number of arguments (or + // more specifically whether it would have access to the callback or not). + // This is useful to implement "smart promisification" logic downstream. + var body = 'return function (handler) {\n'; + body += ' if (handler.length > ' + numArgs + ') {\n'; + body += ' return this.onMessage(\'' + name + '\', function (req, cb) {\n'; + body += ' return handler.call(this' + args + ', cb);\n'; + body += ' });\n'; + body += ' } else {\n'; + body += ' return this.onMessage(\'' + name + '\', function (req) {\n'; + body += ' return handler.call(this' + args + ');\n'; + body += ' });\n'; + body += ' }\n'; + body += '};\n'; + return (new Function(body))(); +}; + +Server.prototype._onError = function (err) { + /* istanbul ignore if */ + if (!this._silent && err.rpcCode !== 'UNKNOWN_PROTOCOL') { + console.error(); + if (err.rpcCode) { + console.error(err.rpcCode); + console.error(err.cause); + } else { + console.error('INTERNAL_SERVER_ERROR'); + console.error(err); + } + } +}; + +/** Base message emitter class. See below for the two available variants. */ +function ClientChannel(client, opts) { + opts = opts || {}; + events.EventEmitter.call(this); + + this.client = client; + this.timeout = utils.getOption(opts, 'timeout', client._timeout$); + this._endWritable = !!utils.getOption(opts, 'endWritable', true); + this._prefix = normalizedPrefix(opts.scope); + + var cache = client._cache$; + var clientSvc = client._svc$; + var hash = opts.serverHash; + if (!hash) { + hash = clientSvc.hash; + } + var adapter = cache[hash]; + if (!adapter) { + // This might happen even if the server hash option was set if the cache + // doesn't contain the corresponding adapter. In this case we fall back to + // the client's protocol (as mandated by the spec). + hash = clientSvc.hash; + adapter = cache[hash] = new Adapter(clientSvc, clientSvc, hash); + } + this._adapter = adapter; + + this._registry = new Registry(this, PREFIX_LENGTH); + this.pending = 0; + this.destroyed = false; + this.draining = false; + this.once('_eot', function (pending, err) { + // Since this listener is only run once, we will only forward an error if + // it is present during the initial `destroy` call, which is OK. + debug('client channel EOT'); + this.destroyed = true; + this.emit('eot', pending, err); + }); +} +util.inherits(ClientChannel, events.EventEmitter); + +ClientChannel.prototype.destroy = function (noWait) { + debug('destroying client channel'); + if (!this.draining) { + this.draining = true; + this.emit('_drain'); + } + var registry = this._registry; + var pending = this.pending; + if (noWait) { + registry.clear(); + } + if (noWait || !pending) { + if (isError(noWait)) { + debug('fatal client channel error: %s', noWait); + this.emit('_eot', pending, noWait); + } else { + this.emit('_eot', pending); + } + } else { + debug('client channel entering drain mode (%s pending)', pending); + } +}; + +ClientChannel.prototype.ping = function (timeout, cb) { + if (!cb && typeof timeout == 'function') { + cb = timeout; + timeout = undefined; + } + var self = this; + var wreq = new WrappedRequest(PING_MESSAGE); + this._emit(wreq, {timeout: timeout}, function (err) { + if (cb) { + cb.call(self, err); + } else if (err) { + self.destroy(err); + } + }); +}; + +ClientChannel.prototype._createHandshakeRequest = function (adapter, noSvc) { + var svc = this.client._svc$; + return { + clientHash: svc.hash, + clientProtocol: noSvc ? null : JSON.stringify(svc.protocol), + serverHash: adapter._hash + }; +}; + +ClientChannel.prototype._emit = function (wreq, opts, cb) { + var msg = wreq._msg; + var wres = msg.oneWay ? undefined : new WrappedResponse(msg, {}); + var ctx = new CallContext(msg, this); + var self = this; + this.pending++; + process.nextTick(function () { + if (!msg.name) { + // Ping request, bypass middleware. + onTransition(wreq, wres, onCompletion); + } else { + self.emit('outgoingCall', ctx, opts); + var fns = self.client._fns$; + debug('starting client middleware chain (%s middleware)', fns.length); + chainMiddleware({ + fns: fns, + ctx: ctx, + wreq: wreq, + wres: wres, + onTransition: onTransition, + onCompletion: onCompletion, + onError: onError + }); + } + }); + + function onTransition(wreq, wres, prev) { + // Serialize the message. + var err, reqBuf; + if (self.destroyed) { + err = new Error('channel destroyed'); + } else { + try { + reqBuf = wreq.toBuffer(); + } catch (cause) { + err = serializationError( + f('invalid %j request', msg.name), + wreq, + [ + {name: 'headers', type: MAP_BYTES_TYPE}, + {name: 'request', type: msg.requestType} + ] + ); + } + } + if (err) { + prev(err); + return; + } + + // Generate the response callback. + var timeout = (opts && opts.timeout !== undefined) ? + opts.timeout : + self.timeout; + var id = self._registry.add(timeout, function (err, resBuf, adapter) { + if (!err && !msg.oneWay) { + try { + adapter._decodeResponse(resBuf, wres, msg); + } catch (cause) { + err = cause; + } + } + prev(err); + }); + id |= self._prefix; + + debug('sending message %s', id); + self._send(id, reqBuf, !!msg && msg.oneWay); + } + + function onCompletion(err) { + self.pending--; + cb.call(ctx, err, wres); + if (self.draining && !self.destroyed && !self.pending) { + self.destroy(); + } + } + + function onError(err) { + // This will happen if a middleware callback is called multiple times. We + // forward the error to the client rather than emit it on the channel since + // middleware are a client-level abstraction, so better handled there. + self.client.emit('error', err, self); + } +}; + +ClientChannel.prototype._getAdapter = function (hres) { + var hash = hres.serverHash; + var cache = this.client._cache$; + var adapter = cache[hash]; + if (adapter) { + return adapter; + } + var ptcl = JSON.parse(hres.serverProtocol); + var serverSvc = Service.forProtocol(ptcl); + adapter = new Adapter(this.client._svc$, serverSvc, hash, true); + return cache[hash] = adapter; +}; + +ClientChannel.prototype._matchesPrefix = function (id) { + return matchesPrefix(id, this._prefix); +}; + +ClientChannel.prototype._send = utils.abstractFunction; + +// Deprecated. + +utils.addDeprecatedGetters(ClientChannel, ['pending', 'timeout']); + +ClientChannel.prototype.getCache = util.deprecate( + function () { return this.client._cache$; }, + 'use `.remoteProtocols()` instead of `.getCache()`' +); + +ClientChannel.prototype.getProtocol = util.deprecate( + function () { + return this.client._svc$; + }, + 'use `.service` instead or `.getProtocol()`' +); + +ClientChannel.prototype.isDestroyed = util.deprecate( + function () { return this.destroyed; }, + 'use `.destroyed` instead of `.isDestroyed`' +); + +/** + * Factory-based client channel. + * + * This channel doesn't keep a persistent connection to the server and requires + * prepending a handshake to each message emitted. Usage examples include + * talking to an HTTP server (where the factory returns an HTTP request). + * + * Since each message will use its own writable/readable stream pair, the + * advantage of this channel is that it is able to keep track of which response + * corresponds to each request without relying on transport ordering. In + * particular, this means these channels are compatible with any server + * implementation. + */ +function StatelessClientChannel(client, writableFactory, opts) { + ClientChannel.call(this, client, opts); + this._writableFactory = writableFactory; + + if (!opts || !opts.noPing) { + // Ping the server to check whether the remote protocol is compatible. + // If not, this will throw an error on the channel. + debug('emitting ping request'); + this.ping(); + } +} +util.inherits(StatelessClientChannel, ClientChannel); + +StatelessClientChannel.prototype._send = function (id, reqBuf) { + var cb = this._registry.get(id); + var adapter = this._adapter; + var self = this; + process.nextTick(emit); + return true; + + function emit(retry) { + if (self.destroyed) { + // The request's callback will already have been called. + return; + } + + var hreq = self._createHandshakeRequest(adapter, !retry); + + var writable = self._writableFactory.call(self, function (err, readable) { + if (err) { + cb(err); + return; + } + readable.on('data', function (obj) { + debug('received response %s', obj.id); + // We don't check that the prefix matches since the ID likely hasn't + // been propagated to the response (see default stateless codec). + var buf = Buffer.concat(obj.payload); + try { + var parts = readHead(HANDSHAKE_RESPONSE_TYPE, buf); + var hres = parts.head; + if (hres.serverHash) { + adapter = self._getAdapter(hres); + } + } catch (cause) { + cb(cause); + return; + } + var match = hres.match; + debug('handshake match: %s', match); + self.emit('handshake', hreq, hres); + if (match === 'NONE') { + // Try again, including the full protocol this time. + process.nextTick(function() { emit(true); }); + } else { + // Change the default adapter. + self._adapter = adapter; + cb(null, parts.tail, adapter); + } + }); + }); + if (!writable) { + cb(new Error('invalid writable stream')); + return; + } + writable.write({ + id: id, + payload: [HANDSHAKE_REQUEST_TYPE.toBuffer(hreq), reqBuf] + }); + if (self._endWritable) { + writable.end(); + } + } +}; + +/** + * Multiplexing client channel. + * + * These channels reuse the same streams (both readable and writable) for all + * messages. This avoids a lot of overhead (e.g. creating new connections, + * re-issuing handshakes) but requires the underlying transport to support + * forwarding message IDs. + */ +function StatefulClientChannel(client, readable, writable, opts) { + ClientChannel.call(this, client, opts); + this._readable = readable; + this._writable = writable; + this._connected = !!(opts && opts.noPing); + this._readable.on('end', onEnd); + this._writable.on('finish', onFinish); + + var self = this; + var timer = null; + this.once('eot', function () { + if (timer) { + clearTimeout(timer); + timer = null; + } + if (!self._connected) { + // Clear any buffered calls (they are guaranteed to error out when + // reaching the transition phase). + self.emit('_ready'); + } + // Remove references to this channel to avoid potential memory leaks. + this._writable.removeListener('finish', onFinish); + if (this._endWritable) { + debug('ending transport'); + this._writable.end(); + } + this._readable + .removeListener('data', onPing) + .removeListener('data', onMessage) + .removeListener('end', onEnd); + }); + + var hreq; // For handshake events. + if (this._connected) { + this._readable.on('data', onMessage); + } else { + this._readable.on('data', onPing); + process.nextTick(ping); + if (self.timeout) { + timer = setTimeout(function () { + self.destroy(new Error('timeout')); + }, self.timeout); + } + } + + function ping(retry) { + if (self.destroyed) { + return; + } + hreq = self._createHandshakeRequest(self._adapter, !retry); + var payload = [ + HANDSHAKE_REQUEST_TYPE.toBuffer(hreq), + new Buffer([0, 0]) // No header, no data (empty message name). + ]; + // We can use a static ID here since we are guaranteed that this message is + // the only one on the channel (for this scope at least). + self._writable.write({id: self._prefix, payload: payload}); + } + + function onPing(obj) { + if (!self._matchesPrefix(obj.id)) { + debug('discarding unscoped response %s (still connecting)', obj.id); + return; + } + var buf = Buffer.concat(obj.payload); + try { + var hres = readHead(HANDSHAKE_RESPONSE_TYPE, buf).head; + if (hres.serverHash) { + self._adapter = self._getAdapter(hres); + } + } catch (cause) { + // This isn't a recoverable error. + self.destroy(cause); + return; + } + var match = hres.match; + debug('handshake match: %s', match); + self.emit('handshake', hreq, hres); + if (match === 'NONE') { + process.nextTick(function () { ping(true); }); + } else { + debug('successfully connected'); + if (timer) { + clearTimeout(timer); + timer = null; + } + self._readable.removeListener('data', onPing).on('data', onMessage); + self._connected = true; + self.emit('_ready'); + hreq = null; // Release reference. + } + } + + // Callback used after a connection has been established. + function onMessage(obj) { + var id = obj.id; + if (!self._matchesPrefix(id)) { + debug('discarding unscoped message %s', id); + return; + } + var cb = self._registry.get(id); + if (cb) { + process.nextTick(function () { + debug('received message %s', id); + // Ensure that the initial callback gets called asynchronously, even + // for completely synchronous transports (otherwise the number of + // pending requests will sometimes be inconsistent between stateful and + // stateless transports). + cb(null, Buffer.concat(obj.payload), self._adapter); + }); + } + } + + function onEnd() { self.destroy(true); } + function onFinish() { self.destroy(); } +} +util.inherits(StatefulClientChannel, ClientChannel); + +StatefulClientChannel.prototype._emit = function () { + // Override this method to allow calling `_emit` even before the channel is + // connected. Note that we don't perform this logic in `_send` since we want + // to guarantee that `'handshake'` events are emitted before any + // `'outgoingCall'` events. + if (this._connected || this.draining) { + ClientChannel.prototype._emit.apply(this, arguments); + } else { + debug('queuing request'); + var args = []; + var i, l; + for (i = 0, l = arguments.length; i < l; i++) { + args.push(arguments[i]); + } + this.once('_ready', function () { this._emit.apply(this, args); }); + } +}; + +StatefulClientChannel.prototype._send = function (id, reqBuf, oneWay) { + if (oneWay) { + var self = this; + // Clear the callback, passing in an empty header. + process.nextTick(function () { + self._registry.get(id)(null, new Buffer([0, 0, 0]), self._adapter); + }); + } + return this._writable.write({id: id, payload: [reqBuf]}); +}; + +/** The server-side emitter equivalent. */ +function ServerChannel(server, opts) { + opts = opts || {}; + events.EventEmitter.call(this); + + this.server = server; + this._endWritable = !!utils.getOption(opts, 'endWritable', true); + this._prefix = normalizedPrefix(opts.scope); + + var cache = server._cache; + var svc = server.service; + var hash = svc.hash; + if (!cache[hash]) { + // Add the channel's protocol to the cache if it isn't already there. This + // will save a handshake the first time on channels with the same protocol. + cache[hash] = new Adapter(svc, svc, hash); + } + this._adapter = null; + + this.destroyed = false; + this.draining = false; + this.pending = 0; + this.once('_eot', function (pending, err) { + debug('server channel EOT'); + this.emit('eot', pending, err); + }); +} +util.inherits(ServerChannel, events.EventEmitter); + +ServerChannel.prototype.destroy = function (noWait) { + if (!this.draining) { + this.draining = true; + this.emit('_drain'); + } + if (noWait || !this.pending) { + this.destroyed = true; + if (isError(noWait)) { + debug('fatal server channel error: %s', noWait); + this.emit('_eot', this.pending, noWait); + } else { + this.emit('_eot', this.pending); + } + } +}; + +ServerChannel.prototype._createHandshakeResponse = function (err, hreq) { + var svc = this.server.service; + var buf = svc.hash; + var serverMatch = hreq && hreq.serverHash.equals(buf); + return { + match: err ? 'NONE' : (serverMatch ? 'BOTH' : 'CLIENT'), + serverProtocol: serverMatch ? null : JSON.stringify(svc.protocol), + serverHash: serverMatch ? null : buf + }; +}; + +ServerChannel.prototype._getAdapter = function (hreq) { + var hash = hreq.clientHash; + var adapter = this.server._cache[hash]; + if (adapter) { + return adapter; + } + if (!hreq.clientProtocol) { + throw toRpcError('UNKNOWN_PROTOCOL'); + } + var ptcl = JSON.parse(hreq.clientProtocol); + var clientSvc = Service.forProtocol(ptcl); + adapter = new Adapter(clientSvc, this.server.service, hash, true); + return this.server._cache[hash] = adapter; +}; + +ServerChannel.prototype._matchesPrefix = function (id) { + return matchesPrefix(id, this._prefix); +}; + +ServerChannel.prototype._receive = function (reqBuf, adapter, cb) { + var self = this; + var wreq; + try { + wreq = adapter._decodeRequest(reqBuf); + } catch (cause) { + cb(self._encodeSystemError(toRpcError('INVALID_REQUEST', cause))); + return; + } + + var msg = wreq._msg; + var wres = new WrappedResponse(msg, {}); + if (!msg.name) { + // Ping message, we don't invoke middleware logic in this case. + wres.response = null; + cb(wres.toBuffer(), false); + return; + } + + var ctx = new CallContext(msg, this); + self.emit('incomingCall', ctx); + var fns = this.server._fns; + debug('starting server middleware chain (%s middleware)', fns.length); + self.pending++; + chainMiddleware({ + fns: fns, + ctx: ctx, + wreq: wreq, + wres: wres, + onTransition: onTransition, + onCompletion: onCompletion, + onError: onError + }); + + function onTransition(wreq, wres, prev) { + var handler = self.server._handlers[msg.name]; + if (!handler) { + // The underlying service hasn't implemented a handler. + var defaultHandler = self.server._defaultHandler; + if (defaultHandler) { + // We call the default handler with arguments similar (slightly + // simpler, there are no phases here) to middleware such that it can + // easily access the message name (useful to implement proxies). + defaultHandler.call(ctx, wreq, wres, prev); + } else { + var cause = new Error(f('no handler for %s', msg.name)); + prev(toRpcError('NOT_IMPLEMENTED', cause)); + } + } else { + var pending = !msg.oneWay; + try { + if (pending) { + handler.call(ctx, wreq.request, function (err, res) { + pending = false; + wres.error = err; + wres.response = res; + prev(); + }); + } else { + handler.call(ctx, wreq.request); + prev(); + } + } catch (err) { + // We catch synchronous failures (same as express) and return the + // failure. Note that the server process can still crash if an error + // is thrown after the handler returns but before the response is + // sent (again, same as express). We are careful to only trigger the + // response callback once, emitting the errors afterwards instead. + if (pending) { + pending = false; + prev(err); + } else { + onError(err); + } + } + } + } + + function onCompletion(err) { + self.pending--; + var server = self.server; + var resBuf; + if (!err) { + var resErr = wres.error; + var isStrict = server._strict; + if (!isStrict) { + if (isError(resErr)) { + // If the error type is wrapped, we must wrap the error too. + wres.error = msg.errorType.clone(resErr.message, {wrapUnions: true}); + } else if (resErr === null) { + // We also allow `null`'s as error in this mode, converting them to + // the Avro-compatible `undefined`. + resErr = wres.error = undefined; + } + if ( + resErr === undefined && + wres.response === undefined && + msg.responseType.isValid(null) + ) { + // Finally, for messages with `null` as acceptable response type, we + // allow `undefined`; converting them to `null`. This allows users + // to + // write a more natural `cb()` instead of `cb(null, null)`. + wres.response = null; + } + } + try { + resBuf = wres.toBuffer(); + } catch (cause) { + // Note that we don't add an RPC code here such that the client + // receives the default `INTERNAL_SERVER_ERROR` one. + if (wres.error !== undefined) { + err = serializationError( + f('invalid %j error', msg.name), // Sic. + wres, + [ + {name: 'headers', type: MAP_BYTES_TYPE}, + {name: 'error', type: msg.errorType} + ] + ); + } else { + err = serializationError( + f('invalid %j response', msg.name), + wres, + [ + {name: 'headers', type: MAP_BYTES_TYPE}, + {name: 'response', type: msg.responseType} + ] + ); + } + } + } + if (!resBuf) { + // The headers are only available if the message isn't one-way. + resBuf = self._encodeSystemError(err, wres.headers); + } else if (resErr !== undefined) { + server.emit('error', toRpcError('APPLICATION_ERROR', resErr)); + } + cb(resBuf, msg.oneWay); + if (self.draining && !self.pending) { + self.destroy(); + } + } + + function onError(err) { + // Similar to the client equivalent, we redirect this error to the server + // since middleware are defined at server-level. + self.server.emit('error', err, self); + } +}; + +// Deprecated. + +utils.addDeprecatedGetters(ServerChannel, ['pending']); + +ServerChannel.prototype.getCache = util.deprecate( + function () { return this.server._cache; }, + 'use `.remoteProtocols()` instead of `.getCache()`' +); + +ServerChannel.prototype.getProtocol = util.deprecate( + function () { + return this.server.service; + }, + 'use `.service` instead of `.getProtocol()`' +); + +ServerChannel.prototype.isDestroyed = util.deprecate( + function () { return this.destroyed; }, + 'use `.destroyed` instead of `.isDestroyed`' +); + +/** + * Encode an error and optional header into a valid Avro response. + * + * @param err + * {Error} Error to encode. + * @param header + * {Object} Optional response header. + */ +ServerChannel.prototype._encodeSystemError = function (err, header) { + var server = this.server; + server.emit('error', err, this); + var errStr; + if (server._sysErrFormatter) { + // Format the error into a string to send over the wire. + errStr = server._sysErrFormatter.call(this, err); + } else if (err.rpcCode) { + // By default, only forward the error's message when the RPC code is set + // (i.e. when this isn't an internal server error). + errStr = err.message; + } + var hdrBuf; + if (header) { + try { + // Propagate the header if possible. + hdrBuf = MAP_BYTES_TYPE.toBuffer(header); + } catch (cause) { + server.emit('error', cause, this); + } + } + return Buffer.concat([ + hdrBuf || new Buffer([0]), + new Buffer([1, 0]), // Error flag and first union index. + STRING_TYPE.toBuffer(errStr || 'internal server error') + ]); +}; + +/** + * Server channel for stateless transport. + * + * This channel expect a handshake to precede each message. + */ +function StatelessServerChannel(server, readableFactory, opts) { + ServerChannel.call(this, server, opts); + + this._writable = undefined; + var self = this; + var readable; + + process.nextTick(function () { + // Delay listening to allow handlers to be attached even if the factory is + // purely synchronous. + readable = readableFactory.call(self, function (err, writable) { + process.nextTick(function () { + // We delay once more here in case this call is synchronous, to allow + // the readable to always be populated first. + if (err) { + onFinish(err); + return; + } + self._writable = writable.on('finish', onFinish); + self.emit('_writable'); + }); + }).on('data', onRequest).on('end', onEnd); + }); + + + function onRequest(obj) { + var id = obj.id; + var buf = Buffer.concat(obj.payload); + var err; + try { + var parts = readHead(HANDSHAKE_REQUEST_TYPE, buf); + var hreq = parts.head; + var adapter = self._getAdapter(hreq); + } catch (cause) { + err = toRpcError('INVALID_HANDSHAKE_REQUEST', cause); + } + + var hres = self._createHandshakeResponse(err, hreq); + self.emit('handshake', hreq, hres); + if (err) { + done(self._encodeSystemError(err)); + } else { + self._receive(parts.tail, adapter, done); + } + + function done(resBuf) { + if (!self.destroyed) { + if (!self._writable) { + self.once('_writable', function () { done(resBuf); }); + return; + } + self._writable.write({ + id: id, + payload: [HANDSHAKE_RESPONSE_TYPE.toBuffer(hres), resBuf] + }); + } + if (self._writable && self._endWritable) { + self._writable.end(); + } + } + } + + function onEnd() { self.destroy(); } + + function onFinish(err) { + readable + .removeListener('data', onRequest) + .removeListener('end', onEnd); + self.destroy(err || true); + } +} +util.inherits(StatelessServerChannel, ServerChannel); + +/** + * Stateful transport listener. + * + * A handshake is done when the channel first receives a message, then all + * messages are sent without. + */ +function StatefulServerChannel(server, readable, writable, opts) { + ServerChannel.call(this, server, opts); + this._adapter = undefined; + this._writable = writable.on('finish', onFinish); + this._readable = readable.on('data', onHandshake).on('end', onEnd); + + this + .once('_drain', function () { + // Stop listening to incoming events. + this._readable + .removeListener('data', onHandshake) + .removeListener('data', onRequest) + .removeListener('end', onEnd); + }) + .once('eot', function () { + // Clean up any references to the channel on the underlying streams. + this._writable.removeListener('finish', onFinish); + if (this._endWritable) { + this._writable.end(); + } + }); + + var self = this; + + function onHandshake(obj) { + var id = obj.id; + if (!self._matchesPrefix(id)) { + return; + } + var buf = Buffer.concat(obj.payload); + var err; + try { + var parts = readHead(HANDSHAKE_REQUEST_TYPE, buf); + var hreq = parts.head; + self._adapter = self._getAdapter(hreq); + } catch (cause) { + err = toRpcError('INVALID_HANDSHAKE_REQUEST', cause); + } + var hres = self._createHandshakeResponse(err, hreq); + self.emit('handshake', hreq, hres); + if (err) { + // Either the client's protocol was unknown or it isn't compatible. + done(self._encodeSystemError(err)); + } else { + self._readable + .removeListener('data', onHandshake) + .on('data', onRequest); + self._receive(parts.tail, self._adapter, done); + } + + function done(resBuf) { + if (self.destroyed) { + return; + } + self._writable.write({ + id: id, + payload: [HANDSHAKE_RESPONSE_TYPE.toBuffer(hres), resBuf] + }); + } + } + + function onRequest(obj) { + // These requests are not prefixed with handshakes. + var id = obj.id; + if (!self._matchesPrefix(id)) { + return; + } + var reqBuf = Buffer.concat(obj.payload); + self._receive(reqBuf, self._adapter, function (resBuf, oneWay) { + if (self.destroyed || oneWay) { + return; + } + self._writable.write({id: id, payload: [resBuf]}); + }); + } + + function onEnd() { self.destroy(); } + + function onFinish() { self.destroy(true); } +} +util.inherits(StatefulServerChannel, ServerChannel); + +// Helpers. + +/** Enhanced request, used inside forward middleware functions. */ +function WrappedRequest(msg, hdrs, req) { + this._msg = msg; + this.headers = hdrs || {}; + this.request = req || {}; +} + +WrappedRequest.prototype.toBuffer = function () { + var msg = this._msg; + return Buffer.concat([ + MAP_BYTES_TYPE.toBuffer(this.headers), + STRING_TYPE.toBuffer(msg.name), + msg.requestType.toBuffer(this.request) + ]); +}; + +/** Enhanced response, used inside forward middleware functions. */ +function WrappedResponse(msg, hdr, err, res) { + this._msg = msg; + this.headers = hdr; + this.error = err; + this.response = res; +} + +WrappedResponse.prototype.toBuffer = function () { + var hdr = MAP_BYTES_TYPE.toBuffer(this.headers); + var hasError = this.error !== undefined; + return Buffer.concat([ + hdr, + BOOLEAN_TYPE.toBuffer(hasError), + hasError ? + this._msg.errorType.toBuffer(this.error) : + this._msg.responseType.toBuffer(this.response) + ]); +}; + +/** + * Context for all middleware and handlers. + * + * It exposes a `locals` object which can be used to pass information between + * each other during a given call. + */ +function CallContext(msg, channel) { + this.channel = channel; + this.locals = {}; + this.message = msg; + Object.freeze(this); +} + +/** + * Callback registry. + * + * Callbacks added must accept an error as first argument. This is used by + * client channels to store pending calls. This class isn't exposed by the + * public API. + */ +function Registry(ctx, prefixLength) { + this._ctx = ctx; // Context for all callbacks. + this._mask = ~0 >>> (prefixLength | 0); // 16 bits by default. + this._id = 0; // Unique integer ID for each call. + this._n = 0; // Number of pending calls. + this._cbs = {}; +} + +Registry.prototype.get = function (id) { return this._cbs[id & this._mask]; }; + +Registry.prototype.add = function (timeout, fn) { + this._id = (this._id + 1) & this._mask; + + var self = this; + var id = this._id; + var timer; + if (timeout > 0) { + timer = setTimeout(function () { cb(new Error('timeout')); }, timeout); + } + + this._cbs[id] = cb; + this._n++; + return id; + + function cb() { + if (!self._cbs[id]) { + // The callback has already run. + return; + } + delete self._cbs[id]; + self._n--; + if (timer) { + clearTimeout(timer); + } + fn.apply(self._ctx, arguments); + } +}; + +Registry.prototype.clear = function () { + Object.keys(this._cbs).forEach(function (id) { + this._cbs[id](new Error('interrupted')); + }, this); +}; + +/** + * Service resolution helper. + * + * It is used both by client and server channels, to respectively decode errors + * and responses, or requests. + */ +function Adapter(clientSvc, serverSvc, hash, isRemote) { + this._clientSvc = clientSvc; + this._serverSvc = serverSvc; + this._hash = hash; // Convenience to access it when creating handshakes. + this._isRemote = !!isRemote; + this._readers = createReaders(clientSvc, serverSvc); +} + +Adapter.prototype._decodeRequest = function (buf) { + var tap = new Tap(buf); + var hdr = MAP_BYTES_TYPE._read(tap); + var name = STRING_TYPE._read(tap); + var msg, req; + if (name) { + msg = this._serverSvc.message(name); + req = this._readers[name + '?']._read(tap); + } else { + msg = PING_MESSAGE; + } + if (!tap.isValid()) { + throw new Error(f('truncated %s request', name || 'ping$')); + } + return new WrappedRequest(msg, hdr, req); +}; + +Adapter.prototype._decodeResponse = function (buf, wres, msg) { + var tap = new Tap(buf); + utils.copyOwnProperties(MAP_BYTES_TYPE._read(tap), wres.headers, true); + var isError = BOOLEAN_TYPE._read(tap); + var name = msg.name; + if (name) { + var reader = this._readers[name + (isError ? '*' : '!')]; + msg = this._clientSvc.message(name); + if (isError) { + wres.error = reader._read(tap); + } else { + wres.response = reader._read(tap); + } + if (!tap.isValid()) { + throw new Error(f('truncated %s response', name)); + } + } else { + msg = PING_MESSAGE; + } +}; + +/** Standard "un-framing" stream. */ +function FrameDecoder() { + stream.Transform.call(this, {readableObjectMode: true}); + this._id = undefined; + this._buf = new Buffer(0); + this._bufs = []; + + this.on('finish', function () { this.push(null); }); +} +util.inherits(FrameDecoder, stream.Transform); + +FrameDecoder.prototype._transform = function (buf, encoding, cb) { + buf = Buffer.concat([this._buf, buf]); + var frameLength; + while ( + buf.length >= 4 && + buf.length >= (frameLength = buf.readInt32BE(0)) + 4 + ) { + if (frameLength) { + this._bufs.push(buf.slice(4, frameLength + 4)); + } else { + var bufs = this._bufs; + this._bufs = []; + this.push({id: null, payload: bufs}); + } + buf = buf.slice(frameLength + 4); + } + this._buf = buf; + cb(); +}; + +FrameDecoder.prototype._flush = function () { + if (this._buf.length || this._bufs.length) { + var bufs = this._bufs.slice(); + bufs.unshift(this._buf); + var err = toRpcError('TRAILING_DATA'); + // Attach the data to help debugging (e.g. if the encoded bytes contain a + // human-readable protocol like HTTP). + err.trailingData = Buffer.concat(bufs).toString(); + this.emit('error', err); + } +}; + +/** Standard framing stream. */ +function FrameEncoder() { + stream.Transform.call(this, {writableObjectMode: true}); + this.on('finish', function () { this.push(null); }); +} +util.inherits(FrameEncoder, stream.Transform); + +FrameEncoder.prototype._transform = function (obj, encoding, cb) { + var bufs = obj.payload; + var i, l, buf; + for (i = 0, l = bufs.length; i < l; i++) { + buf = bufs[i]; + this.push(intBuffer(buf.length)); + this.push(buf); + } + this.push(intBuffer(0)); + cb(); +}; + +/** Netty-compatible decoding stream. */ +function NettyDecoder() { + stream.Transform.call(this, {readableObjectMode: true}); + this._id = undefined; + this._frameCount = 0; + this._buf = new Buffer(0); + this._bufs = []; + + this.on('finish', function () { this.push(null); }); +} +util.inherits(NettyDecoder, stream.Transform); + +NettyDecoder.prototype._transform = function (buf, encoding, cb) { + buf = Buffer.concat([this._buf, buf]); + + while (true) { + if (this._id === undefined) { + if (buf.length < 8) { + this._buf = buf; + cb(); + return; + } + this._id = buf.readInt32BE(0); + this._frameCount = buf.readInt32BE(4); + buf = buf.slice(8); + } + + var frameLength; + while ( + this._frameCount && + buf.length >= 4 && + buf.length >= (frameLength = buf.readInt32BE(0)) + 4 + ) { + this._frameCount--; + this._bufs.push(buf.slice(4, frameLength + 4)); + buf = buf.slice(frameLength + 4); + } + + if (this._frameCount) { + this._buf = buf; + cb(); + return; + } else { + var obj = {id: this._id, payload: this._bufs}; + this._bufs = []; + this._id = undefined; + this.push(obj); + } + } +}; + +NettyDecoder.prototype._flush = FrameDecoder.prototype._flush; + +/** Netty-compatible encoding stream. */ +function NettyEncoder() { + stream.Transform.call(this, {writableObjectMode: true}); + this.on('finish', function () { this.push(null); }); +} +util.inherits(NettyEncoder, stream.Transform); + +NettyEncoder.prototype._transform = function (obj, encoding, cb) { + var bufs = obj.payload; + var l = bufs.length; + var buf; + // Header: [ ID, number of frames ] + buf = new Buffer(8); + buf.writeInt32BE(obj.id, 0); + buf.writeInt32BE(l, 4); + this.push(buf); + // Frames, each: [ length, bytes ] + var i; + for (i = 0; i < l; i++) { + buf = bufs[i]; + this.push(intBuffer(buf.length)); + this.push(buf); + } + cb(); +}; + +/** + * Returns a buffer containing an integer's big-endian representation. + * + * @param n + * {Number} Integer. + */ +function intBuffer(n) { + var buf = new Buffer(4); + buf.writeInt32BE(n); + return buf; +} + +/** + * Decode a type used as prefix inside a buffer. + * + * @param type + * {Type} The type of the prefix. + * @param buf + * {Buffer} Encoded bytes. + * + * This function will return an object `{head, tail}` where head contains the + * decoded value and tail the rest of the buffer. An error will be thrown if the + * prefix cannot be decoded. + */ +function readHead(type, buf) { + var tap = new Tap(buf); + var head = type._read(tap); + if (!tap.isValid()) { + throw new Error(f('truncated %s', type)); + } + return {head: head, tail: tap.buf.slice(tap.pos)}; +} + +/** + * Generate a decoder, optimizing the case where reader and writer are equal. + * + * @param rtype + * {Type} Reader's type. + * @param wtype + * {Type} Writer's type. + */ +function createReader(rtype, wtype) { + return rtype.equals(wtype) ? rtype : rtype.createResolver(wtype); +} + +/** + * Generate all readers for a given protocol combination. + * + * @param clientSvc + * {Service} Client service. + * @param serverSvc + * {Service} Client service. + */ +function createReaders(clientSvc, serverSvc) { + var obj = {}; + clientSvc.messages.forEach(function (c) { + var n = c.name; + var s = serverSvc.message(n); + try { + if (!s) { + throw new Error(f('missing server message: %s', n)); + } + if (s.oneWay !== c.oneWay) { + throw new Error(f('inconsistent one-way message: %s', n)); + } + obj[n + '?'] = createReader(s.requestType, c.requestType); + obj[n + '*'] = createReader(c.errorType, s.errorType); + obj[n + '!'] = createReader(c.responseType, s.responseType); + } catch (cause) { + throw toRpcError('INCOMPATIBLE_PROTOCOL', cause); + } + }); + return obj; +} + +/** + * Populate a cache from a list of protocols. + * + * @param cache + * {Object} Cache of adapters. + * @param svc + * {Service} The local service (either client or server). + * @param ptcls + * {Array} Array of protocols to insert. + * @param isClient + * {Boolean} Whether the local service is a client's or server's. + */ +function insertRemoteProtocols(cache, ptcls, svc, isClient) { + Object.keys(ptcls).forEach(function (hash) { + var ptcl = ptcls[hash]; + var clientSvc, serverSvc; + if (isClient) { + clientSvc = svc; + serverSvc = Service.forProtocol(ptcl); + } else { + clientSvc = Service.forProtocol(ptcl); + serverSvc = svc; + } + cache[hash] = new Adapter(clientSvc, serverSvc, hash, true); + }); +} + +/** + * Extract remote protocols from a cache + * + * @param cache + * {Object} Cache of adapters. + * @param isClient + * {Boolean} Whether the remote protocols extracted should be the + * servers' or clients'. + */ +function getRemoteProtocols(cache, isClient) { + var ptcls = {}; + Object.keys(cache).forEach(function (hs) { + var adapter = cache[hs]; + if (adapter._isRemote) { + var svc = isClient ? adapter._serverSvc : adapter._clientSvc; + ptcls[hs] = svc.protocol; + } + }); + return ptcls; +} + +/** + * Check whether something is an `Error`. + * + * @param any + * {Object} Any object. + */ +function isError(any) { + // Also not ideal, but avoids brittle `instanceof` checks. + return !!any && Object.prototype.toString.call(any) === '[object Error]'; +} + +/** + * Forward any errors emitted on the source to the destination. + * + * @param src + * {EventEmitter} The initial source of error events. + * @param dst + * {EventEmitter} The new target of the source's error events. The + * original source will be provided as second argument (the error + * being the first). + * + * As a convenience, the source will be returned. + */ +function forwardErrors(src, dst) { + return src.on('error', function (err) { + dst.emit('error', err, src); + }); +} + +/** + * Create an error. + * + * @param msg + * {String} Error message. + * @param cause + * {Error} The cause of the error. It is available as `cause` field + * on the outer error. + */ +function toError(msg, cause) { + var err = new Error(msg); + err.cause = cause; + return err; +} + +/** + * Mark an error. + * + * @param rpcCode + * {String} Code representing the failure. + * @param cause + * {Error} The cause of the error. It is available as `cause` field + * on the outer error. + * + * This is used to keep the argument of channels' `'error'` event errors. + */ +function toRpcError(rpcCode, cause) { + var err = toError(rpcCode.toLowerCase().replace(/_/g, ' '), cause); + err.rpcCode = (cause && cause.rpcCode) ? cause.rpcCode : rpcCode; + return err; +} + +/** + * Provide a helpful error to identify why serialization failed. + * + * @param err + * {Error} The error to decorate. + * @param obj + * {...} The object containing fields to validated. + * @param fields + * {Array} Information about the fields to validate. + */ +function serializationError(msg, obj, fields) { + var details = []; + var i, l, field; + for (i = 0, l = fields.length; i < l; i++) { + field = fields[i]; + field.type.isValid(obj[field.name], {errorHook: errorHook}); + } + var detailsStr = details + .map(function (obj) { + return f('%s = %j but expected %s', obj.path, obj.value, obj.type); + }) + .join(', '); + var err = new Error(f('%s (%s)', msg, detailsStr)); + err.details = details; + return err; + + function errorHook(parts, any, type) { + var strs = []; + var i, l, part; + for (i = 0, l = parts.length; i < l; i++) { + part = parts[i]; + if (isNaN(part)) { + strs.push('.' + part); + } else { + strs.push('[' + part + ']'); + } + } + details.push({ + path: field.name + strs.join(''), + value: any, + type: type + }); + } +} + +/** + * Compute a prefix of fixed length from a string. + * + * @param scope + * {String} Namespace to be hashed. + */ +function normalizedPrefix(scope) { + return scope ? + utils.getHash(scope).readInt16BE(0) << (32 - PREFIX_LENGTH) : + 0; +} + +/** + * Check whether an ID matches the prefix. + * + * @param id + * {Integer} Number to check. + * @param prefix + * {Integer} Already shifted prefix. + */ +function matchesPrefix(id, prefix) { + return ((id ^ prefix) >> (32 - PREFIX_LENGTH)) === 0; +} + +/** + * Check whether something is a stream. + * + * @param any + * {Object} Any object. + */ +function isStream(any) { + // This is a hacky way of checking that the transport is a stream-like + // object. We unfortunately can't use `instanceof Stream` checks since + // some libraries (e.g. websocket-stream) return streams which don't + // inherit from it. + return !!(any && any.pipe); +} + +/** + * Get a message, asserting that it exists. + * + * @param svc + * {Service} The protocol to look into. + * @param name + * {String} The message's name. + */ +function getExistingMessage(svc, name) { + var msg = svc.message(name); + if (!msg) { + throw new Error(f('unknown message: %s', name)); + } + return msg; +} + +/** + * Middleware logic. + * + * This is used both in clients and servers to intercept call handling (e.g. to + * populate headers, do access control). + * + * @param params + * {Object} The following parameters: + fns {Array} Array of + * middleware functions. + ctx {Object} Context used to call the + * middleware functions, onTransition, and onCompletion. + wreq + * {WrappedRequest} + wres {WrappedResponse} + onTransition + * {Function} End of forward phase callback. It accepts an eventual + * error as single argument. This will be used for the backward + * phase. This function is guaranteed to be called at most once. + + * onCompletion {Function} Final handler, it takes an error as unique + * argument. This function is guaranteed to be only at most once. + + * onError {Function} Error handler, called if an intermediate + * callback is called multiple times. + */ +function chainMiddleware(params) { + var args = [params.wreq, params.wres]; + var cbs = []; + var cause; // Backpropagated error. + forward(0); + + function forward(pos) { + var isDone = false; + if (pos < params.fns.length) { + params.fns[pos].apply(params.ctx, args.concat(function (err, cb) { + if (isDone) { + params.onError(toError('duplicate forward middleware call', err)); + return; + } + isDone = true; + if ( + err || ( + params.wres && ( // Non one-way messages. + params.wres.error !== undefined || + params.wres.response !== undefined + ) + ) + ) { + // Stop the forward phase, bypass the handler, and start the + // backward + // phase. Note that we ignore any callback argument in this case. + cause = err; + backward(); + return; + } + if (cb) { + cbs.push(cb); + } + forward(++pos); + })); + } else { + // Done with the middleware forward functions, call the handler. + params.onTransition.apply(params.ctx, args.concat(function (err) { + if (isDone) { + params.onError(toError('duplicate handler call', err)); + return; + } + isDone = true; + cause = err; + process.nextTick(backward); + })); + } + } + + function backward() { + var cb = cbs.pop(); + if (cb) { + var isDone = false; + cb.call(params.ctx, cause, function (err) { + if (isDone) { + params.onError(toError('duplicate backward middleware call', err)); + return; + } + // Substitute the error. + cause = err; + isDone = true; + backward(); + }); + } else { + // Done with all middleware calls. + params.onCompletion.call(params.ctx, cause); + } + } +} + + +module.exports = { + Adapter: Adapter, + HANDSHAKE_REQUEST_TYPE: HANDSHAKE_REQUEST_TYPE, + HANDSHAKE_RESPONSE_TYPE: HANDSHAKE_RESPONSE_TYPE, + Message: Message, + Registry: Registry, + Service: Service, + discoverProtocol: discoverProtocol, + streams: { + FrameDecoder: FrameDecoder, + FrameEncoder: FrameEncoder, + NettyDecoder: NettyDecoder, + NettyEncoder: NettyEncoder + } +}; + +}).call(this,require('_process'),require("buffer").Buffer) +},{"./types":55,"./utils":56,"_process":23,"buffer":16,"events":19,"stream":42,"util":47}],54:[function(require,module,exports){ +/* jshint node: true */ + +// TODO: Add minimal templating. +// TODO: Add option to prefix nested type declarations with the outer types' +// names. + +'use strict'; + +/** IDL to protocol (services) and schema (types) parsing logic. */ + +var files = require('./files'), + utils = require('./utils'), + path = require('path'), + util = require('util'); + + +var f = util.format; + + +// Default type references defined by Avro. +var TYPE_REFS = { + date: {type: 'int', logicalType: 'date'}, + decimal: {type: 'bytes', logicalType: 'decimal'}, + time_ms: {type: 'long', logicalType: 'time-millis'}, + timestamp_ms: {type: 'long', logicalType: 'timestamp-millis'} +}; + + +/** Assemble an IDL file into a decoded protocol. */ +function assembleProtocol(fpath, opts, cb) { + if (!cb && typeof opts == 'function') { + cb = opts; + opts = undefined; + } + opts = opts || {}; + if (!opts.importHook) { + opts.importHook = files.createImportHook(); + } + + // Types found in imports. We store them separately to be able to insert + // them + // in the correct order in the final attributes. + var importedTypes = []; + var protocol, imports; + opts.importHook(fpath, 'idl', function (err, str) { + if (err) { + cb(err); + return; + } + if (str === undefined) { + // Skipped import (likely already imported). + cb(null, {}); + return; + } + try { + var reader = new Reader(str, opts); + var obj = reader._readProtocol(str, opts); + } catch (err) { + err.path = fpath; // To help debug which file caused the error. + cb(err); + return; + } + protocol = obj.protocol; + imports = obj.imports; + fetchImports(); + }); + + function fetchImports() { + var info = imports.shift(); + if (!info) { + // We are done with this file. We prepend all imported types to this + // file's and we can return the final result. + if (importedTypes.length) { + protocol.types = protocol.types ? + importedTypes.concat(protocol.types) : + importedTypes; + } + cb(null, protocol); + } else { + var importPath = path.join(path.dirname(fpath), info.name); + if (info.kind === 'idl') { + assembleProtocol(importPath, opts, mergeImportedSchema); + } else { + // We are importing a protocol or schema file. + opts.importHook(importPath, info.kind, function (err, str) { + if (err) { + cb(err); + return; + } + switch (info.kind) { + case 'protocol': + case 'schema': + if (str === undefined) { + // Flag used to signal an already imported file by the default + // import hooks. Implementors who wish to disallow duplicate + // imports should provide a custom hook which throws an error + // when a duplicate import is detected. + mergeImportedSchema(null, {}); + return; + } + try { + var obj = JSON.parse(str); + } catch (err) { + err.path = importPath; + cb(err); + return; + } + var schema = info.kind === 'schema' ? {types: [obj]} : obj; + mergeImportedSchema(null, schema); + break; + default: + cb(new Error(f('invalid import kind: %s', info.kind))); + } + }); + } + } + } + + function mergeImportedSchema(err, importedSchema) { + if (err) { + cb(err); + return; + } + // Merge first the types (where we don't need to check for duplicates + // since instantiating the service will take care of it), then the messages + // (where we need to, as duplicates will overwrite each other). + (importedSchema.types || []).forEach(function (typeSchema) { + // Ensure the imported protocol's namespace is inherited correctly (it + // might be different from the current one). + if (typeSchema.namespace === undefined) { + var namespace = importedSchema.namespace; + if (!namespace) { + var match = /^(.*)\.[^.]+$/.exec(importedSchema.protocol); + if (match) { + namespace = match[1]; + } + } + typeSchema.namespace = namespace || ''; + } + importedTypes.push(typeSchema); + }); + try { + Object.keys(importedSchema.messages || {}).forEach(function (name) { + if (!protocol.messages) { + protocol.messages = {}; + } + if (protocol.messages[name]) { + throw new Error(f('duplicate message: %s', name)); + } + protocol.messages[name] = importedSchema.messages[name]; + }); + } catch (err) { + cb(err); + return; + } + fetchImports(); // Continue importing any remaining imports. + } +} + +// Parsing functions. + +/** + * Convenience function to parse multiple inputs into protocols and schemas. + * + * It should cover most basic use-cases but has a few limitations: + * + It doesn't allow passing options to the parsing step. + The protocol/type + * inference logic can be deceived. + * + * The parsing logic is as follows: + * + If `str` contains `path.sep` (on windows `\`, otherwise `/`) and is a path + * to an existing file, it will first be read as JSON, then as an IDL + * specification if JSON parsing failed. If either succeeds, the result is + * returned, otherwise the next steps are run using the file's content instead + * of the input path. + If `str` is a valid JSON string, it is parsed then + * returned. + If `str` is a valid IDL protocol specification, it is parsed and + * returned if no imports are present (and an error is thrown if there are any + * imports). + If `str` is a valid IDL type specification, it is parsed and + * returned. + If neither of the above cases apply, `str` is returned. + */ +function read(str) { + var schema; + if (typeof str == 'string' && ~str.indexOf(path.sep) && files.existsSync(str)) { + // Try interpreting `str` as path to a file contain a JSON schema or an IDL + // protocol. Note that we add the second check to skip primitive references + // (e.g. `"int"`, the most common use-case for `avro.parse`). + var contents = files.readFileSync(str, {encoding: 'utf8'}); + try { + return JSON.parse(contents); + } catch (err) { + var opts = {importHook: files.createSyncImportHook()}; + assembleProtocol(str, opts, function (err, protocolSchema) { + schema = err ? contents : protocolSchema; + }); + } + } else { + schema = str; + } + if (typeof schema != 'string' || schema === 'null') { + // This last predicate is to allow `read('null')` to work similarly to + // `read('int')` and other primitives (null needs to be handled separately + // since it is also a valid JSON identifier). + return schema; + } + try { + return JSON.parse(schema); + } catch (err) { + try { + return Reader.readProtocol(schema); + } catch (err) { + try { + return Reader.readSchema(schema); + } catch (err) { + return schema; + } + } + } +} + +function Reader(str, opts) { + opts = opts || {}; + + this._tk = new Tokenizer(str); + this._ackVoidMessages = !!opts.ackVoidMessages; + this._implicitTags = !opts.delimitedCollections; + this._typeRefs = opts.typeRefs || TYPE_REFS; +} + +Reader.readProtocol = function (str, opts) { + var reader = new Reader(str, opts); + var protocol = reader._readProtocol(); + if (protocol.imports.length) { + // Imports can only be resolved when the IDL file is provided via its + // path, we fail rather than silently ignore imports. + throw new Error('unresolvable import'); + } + return protocol.protocol; +}; + +Reader.readSchema = function (str, opts) { + var reader = new Reader(str, opts); + var javadoc = reader._readJavadoc(); + var schema = reader._readType(javadoc === undefined ? {} : {doc: javadoc}); + reader._tk.next({id: '(eof)'}); // Check that we have read everything. + return schema; +}; + +Reader.prototype._readProtocol = function () { + var tk = this._tk; + var imports = []; + var types = []; + var messages = {}; + var pos; + + // Outer declarations (outside of the protocol block). + this._readImports(imports); + var protocolSchema = {}; + var protocolJavadoc = this._readJavadoc(); + if (protocolJavadoc !== undefined) { + protocolSchema.doc = protocolJavadoc; + } + this._readAnnotations(protocolSchema); + tk.next({val: 'protocol'}); + if (!tk.next({val: '{', silent: true})) { + // Named protocol. + protocolSchema.protocol = tk.next({id: 'name'}).val; + tk.next({val: '{'}); + } + + // Inner declarations. + while (!tk.next({val: '}', silent: true})) { + if (!this._readImports(imports)) { + var javadoc = this._readJavadoc(); + var typeSchema = this._readType(); + var numImports = this._readImports(imports, true); + var message = undefined; + // We mark our position and try to parse a message from here. + pos = tk.pos; + if (!numImports && (message = this._readMessage(typeSchema))) { + // Note that if any imports were found, we cannot be parsing a message. + if (javadoc !== undefined && message.schema.doc === undefined) { + message.schema.doc = javadoc; + } + var oneWay = false; + if ( + message.schema.response === 'void' || + message.schema.response.type === 'void' + ) { + oneWay = !this._ackVoidMessages && !message.schema.errors; + if (message.schema.response === 'void') { + message.schema.response = 'null'; + } else { + message.schema.response.type = 'null'; + } + } + if (oneWay) { + message.schema['one-way'] = true; + } + if (messages[message.name]) { + // We have to do this check here otherwise the duplicate will be + // overwritten (and service instantiation won't be able to catch + // it). + throw new Error(f('duplicate message: %s', message.name)); + } + messages[message.name] = message.schema; + } else { + // This was a standalone type definition. + if (javadoc) { + if (typeof typeSchema == 'string') { + typeSchema = {doc: javadoc, type: typeSchema}; + } else if (typeSchema.doc === undefined) { + typeSchema.doc = javadoc; + } + } + types.push(typeSchema); + // We backtrack until just before the type's type name and swallow an + // eventual semi-colon (to make type declarations more consistent). + tk.pos = pos; + tk.next({val: ';', silent: true}); + } + javadoc = undefined; + } + } + tk.next({id: '(eof)'}); + if (types.length) { + protocolSchema.types = types; + } + if (Object.keys(messages).length) { + protocolSchema.messages = messages; + } + return {protocol: protocolSchema, imports: imports}; +}; + +Reader.prototype._readAnnotations = function (schema) { + var tk = this._tk; + while (tk.next({val: '@', silent: true})) { + // Annotations are allowed to have names which aren't valid Avro names, + // we must advance until we hit the first left parenthesis. + var parts = []; + while (!tk.next({val: '(', silent: true})) { + parts.push(tk.next().val); + } + schema[parts.join('')] = tk.next({id: 'json'}).val; + tk.next({val: ')'}); + } +}; + +Reader.prototype._readMessage = function (responseSchema) { + var tk = this._tk; + var schema = {request: [], response: responseSchema}; + this._readAnnotations(schema); + var name = tk.next().val; + if (tk.next().val !== '(') { + // This isn't a message. + return; + } + if (!tk.next({val: ')', silent: true})) { + do { + schema.request.push(this._readField()); + } while (!tk.next({val: ')', silent: true}) && tk.next({val: ','})); + } + var token = tk.next(); + switch (token.val) { + case 'throws': + // It doesn't seem like the IDL is explicit about which syntax to used + // for multiple errors. We will assume a comma-separated list. + schema.errors = []; + do { + schema.errors.push(this._readType()); + } while (!tk.next({val: ';', silent: true}) && tk.next({val: ','})); + break; + case 'oneway': + schema['one-way'] = true; + tk.next({val: ';'}); + break; + case ';': + break; + default: + throw tk.error('invalid message suffix', token); + } + return {name: name, schema: schema}; +}; + +Reader.prototype._readJavadoc = function () { + var token = this._tk.next({id: 'javadoc', emitJavadoc: true, silent: true}); + if (token) { + return token.val; + } +}; + +Reader.prototype._readField = function () { + var tk = this._tk; + var javadoc = this._readJavadoc(); + var schema = {type: this._readType()}; + if (javadoc !== undefined && schema.doc === undefined) { + schema.doc = javadoc; + } + this._readAnnotations(schema); + schema.name = tk.next({id: 'name'}).val; + if (tk.next({val: '=', silent: true})) { + schema['default'] = tk.next({id: 'json'}).val; + } + return schema; +}; + +Reader.prototype._readType = function (schema) { + schema = schema || {}; + this._readAnnotations(schema); + schema.type = this._tk.next({id: 'name'}).val; + switch (schema.type) { + case 'record': + case 'error': + return this._readRecord(schema); + case 'fixed': + return this._readFixed(schema); + case 'enum': + return this._readEnum(schema); + case 'map': + return this._readMap(schema); + case 'array': + return this._readArray(schema); + case 'union': + if (Object.keys(schema).length > 1) { + throw new Error('union annotations are not supported'); + } + return this._readUnion(); + default: + // Reference. + var ref = this._typeRefs[schema.type]; + if (ref) { + delete schema.type; // Always overwrite the type. + utils.copyOwnProperties(ref, schema); + } + return Object.keys(schema).length > 1 ? schema : schema.type; + } +}; + +Reader.prototype._readFixed = function (schema) { + var tk = this._tk; + if (!tk.next({val: '(', silent: true})) { + schema.name = tk.next({id: 'name'}).val; + tk.next({val: '('}); + } + schema.size = parseInt(tk.next({id: 'number'}).val); + tk.next({val: ')'}); + return schema; +}; + +Reader.prototype._readMap = function (schema) { + var tk = this._tk; + // Brackets are unwieldy when declaring inline types. We allow for them to + // be + // omitted (but we keep the consistency that if the entry bracket is + // present, + // the exit one must be as well). Note that this is non-standard. + var silent = this._implicitTags; + var implicitTags = tk.next({val: '<', silent: silent}) === undefined; + schema.values = this._readType(); + tk.next({val: '>', silent: implicitTags}); + return schema; +}; + +Reader.prototype._readArray = function (schema) { + var tk = this._tk; + var silent = this._implicitTags; + var implicitTags = tk.next({val: '<', silent: silent}) === undefined; + schema.items = this._readType(); + tk.next({val: '>', silent: implicitTags}); + return schema; +}; + +Reader.prototype._readEnum = function (schema) { + var tk = this._tk; + if (!tk.next({val: '{', silent: true})) { + schema.name = tk.next({id: 'name'}).val; + tk.next({val: '{'}); + } + schema.symbols = []; + do { + schema.symbols.push(tk.next().val); + } while (!tk.next({val: '}', silent: true}) && tk.next({val: ','})); + return schema; +}; + +Reader.prototype._readUnion = function () { + var tk = this._tk; + var arr = []; + tk.next({val: '{'}); + do { + arr.push(this._readType()); + } while (!tk.next({val: '}', silent: true}) && tk.next({val: ','})); + return arr; +}; + +Reader.prototype._readRecord = function (schema) { + var tk = this._tk; + if (!tk.next({val: '{', silent: true})) { + schema.name = tk.next({id: 'name'}).val; + tk.next({val: '{'}); + } + schema.fields = []; + while (!tk.next({val: '}', silent: true})) { + schema.fields.push(this._readField()); + tk.next({val: ';'}); + } + return schema; +}; + +Reader.prototype._readImports = function (imports, maybeMessage) { + var tk = this._tk; + var numImports = 0; + var pos = tk.pos; + while (tk.next({val: 'import', silent: true})) { + if (!numImports && maybeMessage && tk.next({val: '(', silent: true})) { + // This will happen if a message is named import. + tk.pos = pos; + return; + } + var kind = tk.next({id: 'name'}).val; + var fname = JSON.parse(tk.next({id: 'string'}).val); + tk.next({val: ';'}); + imports.push({kind: kind, name: fname}); + numImports++; + } + return numImports; +}; + +// Helpers. + +/** + * Simple class to split an input string into tokens. + * + * There are different types of tokens, characterized by their `id`: + * + `number` numbers. + `name` references. + `string` double-quoted. + + * `operator`, anything else, always single character. + `javadoc`, only emitted + * when `next` is called with `emitJavadoc` set. + `json`, only emitted when + * `next` is called with `'json'` as `id` (the tokenizer doesn't have enough + * context to predict these). + */ +function Tokenizer(str) { + this._str = str; + this.pos = 0; +} + +Tokenizer.prototype.next = function (opts) { + var token = {pos: this.pos, id: undefined, val: undefined}; + var javadoc = this._skip(opts && opts.emitJavadoc); + if (javadoc) { + token.id = 'javadoc'; + token.val = javadoc; + } else { + var pos = this.pos; + var str = this._str; + var c = str.charAt(pos); + if (!c) { + token.id = '(eof)'; + } else { + if (opts && opts.id === 'json') { + token.id = 'json'; + this.pos = this._endOfJson(); + } else if (c === '"') { + token.id = 'string'; + this.pos = this._endOfString(); + } else if (/[0-9]/.test(c)) { + token.id = 'number'; + this.pos = this._endOf(/[0-9]/); + } else if (/[`A-Za-z_.]/.test(c)) { + token.id = 'name'; + this.pos = this._endOf(/[`A-Za-z0-9_.]/); + } else { + token.id = 'operator'; + this.pos = pos + 1; + } + token.val = str.slice(pos, this.pos); + if (token.id === 'json') { + // Let's be nice and give a more helpful error message when this occurs + // (JSON parsing errors wouldn't let us find the location otherwise). + try { + token.val = JSON.parse(token.val); + } catch (err) { + throw this.error('invalid JSON', token); + } + } else if (token.id === 'name') { + // Unescape names (our parser doesn't need them). + token.val = token.val.replace(/`/g, ''); + } + } + } + + var err; + if (opts && opts.id && opts.id !== token.id) { + err = this.error(f('expected ID %s', opts.id), token); + } else if (opts && opts.val && opts.val !== token.val) { + err = this.error(f('expected value %s', opts.val), token); + } + if (!err) { + return token; + } else if (opts && opts.silent) { + this.pos = token.pos; // Backtrack to start of token. + return undefined; + } else { + throw err; + } +}; + +Tokenizer.prototype.error = function (reason, context) { + // Context must be either a token or a position. + var isToken = typeof context != 'number'; + var pos = isToken ? context.pos : context; + var str = this._str; + var lineNum = 1; + var lineStart = 0; + var i; + for (i = 0; i < pos; i++) { + if (str.charAt(i) === '\n') { + lineNum++; + lineStart = i; + } + } + var msg = isToken ? f('invalid token %j: %s', context, reason) : reason; + var err = new Error(msg); + err.token = isToken ? context : undefined; + err.lineNum = lineNum; + err.colNum = pos - lineStart; + return err; +}; + +/** Skip whitespace and comments. */ +Tokenizer.prototype._skip = function (emitJavadoc) { + var str = this._str; + var isJavadoc = false; + var pos, c; + + while ((c = str.charAt(this.pos)) && /\s/.test(c)) { + this.pos++; + } + pos = this.pos; + if (c === '/') { + switch (str.charAt(this.pos + 1)) { + case '/': + this.pos += 2; + while ((c = str.charAt(this.pos)) && c !== '\n') { + this.pos++; + } + return this._skip(emitJavadoc); + case '*': + this.pos += 2; + if (str.charAt(this.pos) === '*') { + isJavadoc = true; + } + while ((c = str.charAt(this.pos++))) { + if (c === '*' && str.charAt(this.pos) === '/') { + this.pos++; + if (isJavadoc && emitJavadoc) { + return extractJavadoc(str.slice(pos + 3, this.pos - 2)); + } + return this._skip(emitJavadoc); + } + } + throw this.error('unterminated comment', pos); + } + } +}; + +/** Generic end of method. */ +Tokenizer.prototype._endOf = function (pat) { + var pos = this.pos; + var str = this._str; + while (pat.test(str.charAt(pos))) { + pos++; + } + return pos; +}; + +/** Find end of a string. */ +Tokenizer.prototype._endOfString = function () { + var pos = this.pos + 1; // Skip first double quote. + var str = this._str; + var c; + while ((c = str.charAt(pos))) { + if (c === '"') { + // The spec doesn't explicitly say so, but IDLs likely only + // allow double quotes for strings (C- and Java-style). + return pos + 1; + } + if (c === '\\') { + pos += 2; + } else { + pos++; + } + } + throw this.error('unterminated string', pos - 1); +}; + +/** Find end of JSON object, throwing an error if the end is reached first. */ +Tokenizer.prototype._endOfJson = function () { + var pos = utils.jsonEnd(this._str, this.pos); + if (pos < 0) { + throw this.error('invalid JSON', pos); + } + return pos; +}; + +/** + * Extract Javadoc contents from the comment. + * + * The parsing done is very simple and simply removes the line prefixes and + * leading / trailing empty lines. It's better to be conservative with + * formatting rather than risk losing information. + */ +function extractJavadoc(str) { + var lines = str + .replace(/^[ \t]+|[ \t]+$/g, '') // Trim whitespace. + .split('\n').map(function (line, i) { + return i ? line.replace(/^\s*\*\s?/, '') : line; + }); + while (!lines[0]) { + lines.shift(); + } + while (!lines[lines.length - 1]) { + lines.pop(); + } + return lines.join('\n'); +} + + +module.exports = { + Tokenizer: Tokenizer, + assembleProtocol: assembleProtocol, + read: read, + readProtocol: Reader.readProtocol, + readSchema: Reader.readSchema +}; + +},{"./files":51,"./utils":56,"path":22,"util":47}],55:[function(require,module,exports){ +(function (Buffer){ +/* jshint node: true */ + +// TODO: Make it easier to implement custom types. This will likely require +// exposing the `Tap` object, perhaps under another name. Probably worth a +// major release. +// TODO: Allow configuring when to write the size when writing arrays and maps, +// and customizing their block size. +// TODO: Code-generate `compare` and `clone` record and union methods. + +'use strict'; + +/** + * This module defines all Avro data types and their serialization logic. + * + */ + +var utils = require('./utils'), + buffer = require('buffer'), // For `SlowBuffer`. + util = require('util'); + + +// Convenience imports. +var Tap = utils.Tap; +var debug = util.debuglog('avsc:types'); +var f = util.format; + +// All non-union concrete (i.e. non-logical) Avro types. +var TYPES = { + 'array': ArrayType, + 'boolean': BooleanType, + 'bytes': BytesType, + 'double': DoubleType, + 'enum': EnumType, + 'error': RecordType, + 'fixed': FixedType, + 'float': FloatType, + 'int': IntType, + 'long': LongType, + 'map': MapType, + 'null': NullType, + 'record': RecordType, + 'string': StringType +}; + +// Valid (field, type, and symbol) name regex. +var NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/; + +// Random generator. +var RANDOM = new utils.Lcg(); + +// Encoding tap (shared for performance). +var TAP = new Tap(new buffer.SlowBuffer(1024)); + +// Currently active logical type, used for name redirection. +var LOGICAL_TYPE = null; + +/** + * "Abstract" base Avro type. + * + * This class' constructor will register any named types to support recursive + * schemas. All type values are represented in memory similarly to their JSON + * representation, except for: + * + `bytes` and `fixed` which are represented as `Buffer`s. + `union`s which + * will be "unwrapped" unless the `wrapUnions` option is set. + * + * See individual subclasses for details. + */ +function Type(schema, opts) { + var type = LOGICAL_TYPE || this; + LOGICAL_TYPE = null; + + // Lazily instantiated hash string. It will be generated the first time the + // type's default fingerprint is computed (for example when using `equals`). + // We use a mutable object since types are frozen after instantiation. + this._hash = new Hash(); + this.name = undefined; + this.aliases = undefined; + this.doc = (schema && schema.doc) ? '' + schema.doc : undefined; + + if (schema) { + // This is a complex (i.e. non-primitive) type. + var name = schema.name; + var namespace = schema.namespace === undefined ? + opts && opts.namespace : + schema.namespace; + if (name !== undefined) { + // This isn't an anonymous type. + name = qualify(name, namespace); + if (isPrimitive(name)) { + // Avro doesn't allow redefining primitive names. + throw new Error(f('cannot rename primitive type: %j', name)); + } + var registry = opts && opts.registry; + if (registry) { + if (registry[name] !== undefined) { + throw new Error(f('duplicate type name: %s', name)); + } + registry[name] = type; + } + } else if (opts && opts.noAnonymousTypes) { + throw new Error(f('missing name property in schema: %j', schema)); + } + this.name = name; + this.aliases = schema.aliases ? + schema.aliases.map(function (s) { return qualify(s, namespace); }) : + []; + } +} + +Type.forSchema = function (schema, opts) { + opts = opts || {}; + opts.registry = opts.registry || {}; + + var UnionType = (function (wrapUnions) { + if (wrapUnions === true) { + wrapUnions = 'always'; + } else if (wrapUnions === false) { + wrapUnions = 'never'; + } else if (wrapUnions === undefined) { + wrapUnions = 'auto'; + } else if (typeof wrapUnions == 'string') { + wrapUnions = wrapUnions.toLowerCase(); + } + switch (wrapUnions) { + case 'always': + return WrappedUnionType; + case 'never': + return UnwrappedUnionType; + case 'auto': + return undefined; // Determined dynamically later on. + default: + throw new Error(f('invalid wrap unions option: %j', wrapUnions)); + } + })(opts.wrapUnions); + + if (schema === null) { + // Let's be helpful for this common error. + throw new Error('invalid type: null (did you mean "null"?)'); + } + + if (Type.isType(schema)) { + return schema; + } + + var type; + if (opts.typeHook && (type = opts.typeHook(schema, opts))) { + if (!Type.isType(type)) { + throw new Error(f('invalid typehook return value: %j', type)); + } + return type; + } + + if (typeof schema == 'string') { // Type reference. + schema = qualify(schema, opts.namespace); + type = opts.registry[schema]; + if (type) { + // Type was already defined, return it. + return type; + } + if (isPrimitive(schema)) { + // Reference to a primitive type. These are also defined names by + // default + // so we create the appropriate type and it to the registry for future + // reference. + return opts.registry[schema] = Type.forSchema({type: schema}, opts); + } + throw new Error(f('undefined type name: %s', schema)); + } + + if (schema.logicalType && opts.logicalTypes && !LOGICAL_TYPE) { + var DerivedType = opts.logicalTypes[schema.logicalType]; + if (DerivedType) { + var namespace = opts.namespace; + var registry = {}; + Object.keys(opts.registry).forEach(function (key) { + registry[key] = opts.registry[key]; + }); + try { + debug('instantiating logical type for %s', schema.logicalType); + return new DerivedType(schema, opts); + } catch (err) { + debug('failed to instantiate logical type for %s', schema.logicalType); + if (opts.assertLogicalTypes) { + // The spec mandates that we fall through to the underlying type if + // the logical type is invalid. We provide this option to ease + // debugging. + throw err; + } + LOGICAL_TYPE = null; + opts.namespace = namespace; + opts.registry = registry; + } + } + } + + if (Array.isArray(schema)) { // Union. + var types = schema.map(function (obj) { + return Type.forSchema(obj, opts); + }); + if (!UnionType) { + UnionType = isAmbiguous(types) ? WrappedUnionType : UnwrappedUnionType; + } + type = new UnionType(types, opts); + } else { // New type definition. + type = (function (typeName) { + var Type = TYPES[typeName]; + if (Type === undefined) { + throw new Error(f('unknown type: %j', typeName)); + } + return new Type(schema, opts); + })(schema.type); + } + return type; +}; + +Type.forValue = function (val, opts) { + opts = opts || {}; + + // Sentinel used when inferring the types of empty arrays. + opts.emptyArrayType = opts.emptyArrayType || Type.forSchema({ + type: 'array', items: 'null' + }); + + // Optional custom inference hook. + if (opts.valueHook) { + var type = opts.valueHook(val, opts); + if (type !== undefined) { + if (!Type.isType(type)) { + throw new Error(f('invalid value hook return value: %j', type)); + } + return type; + } + } + + // Default inference logic. + switch (typeof val) { + case 'string': + return Type.forSchema('string', opts); + case 'boolean': + return Type.forSchema('boolean', opts); + case 'number': + if ((val | 0) === val) { + return Type.forSchema('int', opts); + } else if (Math.abs(val) < 9007199254740991) { + return Type.forSchema('float', opts); + } + return Type.forSchema('double', opts); + case 'object': + if (val === null) { + return Type.forSchema('null', opts); + } else if (Array.isArray(val)) { + if (!val.length) { + return opts.emptyArrayType; + } + return Type.forSchema({ + type: 'array', + items: Type.forTypes( + val.map(function (v) { return Type.forValue(v, opts); }) + ) + }, opts); + } else if (Buffer.isBuffer(val)) { + return Type.forSchema('bytes', opts); + } + var fieldNames = Object.keys(val); + if (fieldNames.some(function (s) { return !isValidName(s); })) { + // We have to fall back to a map. + return Type.forSchema({ + type: 'map', + values: Type.forTypes(fieldNames.map(function (s) { + return Type.forValue(val[s], opts); + }), opts) + }, opts); + } + return Type.forSchema({ + type: 'record', + fields: fieldNames.map(function (s) { + return {name: s, type: Type.forValue(val[s], opts)}; + }) + }, opts); + default: + throw new Error(f('cannot infer type from: %j', val)); + } +}; + +Type.forTypes = function (types, opts) { + if (!types.length) { + throw new Error('no types to combine'); + } + if (types.length === 1) { + return types[0]; // Nothing to do. + } + opts = opts || {}; + + // Extract any union types, with special care for wrapped unions (see + // below). + var expanded = []; + var numWrappedUnions = 0; + var isValidWrappedUnion = true; + types.forEach(function (type) { + switch (type.typeName) { + case 'union:unwrapped': + isValidWrappedUnion = false; + expanded = expanded.concat(type.types); + break; + case 'union:wrapped': + numWrappedUnions++; + expanded = expanded.concat(type.types); + break; + case 'null': + expanded.push(type); + break; + default: + isValidWrappedUnion = false; + expanded.push(type); + } + }); + if (numWrappedUnions) { + if (!isValidWrappedUnion) { + // It is only valid to combine wrapped unions when no other type is + // present other than wrapped unions and nulls (otherwise the values of + // others wouldn't be valid in the resulting union). + throw new Error('cannot combine wrapped union'); + } + var branchTypes = {}; + expanded.forEach(function (type) { + var name = type.branchName; + var branchType = branchTypes[name]; + if (!branchType) { + branchTypes[name] = type; + } else if (!type.equals(branchType)) { + throw new Error('inconsistent branch type'); + } + }); + var wrapUnions = opts.wrapUnions; + var unionType; + opts.wrapUnions = true; + try { + unionType = Type.forSchema(Object.keys(branchTypes).map(function (name) { + return branchTypes[name]; + }), opts); + } catch (err) { + opts.wrapUnions = wrapUnions; + throw err; + } + opts.wrapUnions = wrapUnions; + return unionType; + } + + // Group types by category, similar to the logic for unwrapped unions. + var bucketized = {}; + expanded.forEach(function (type) { + var bucket = getTypeBucket(type); + var bucketTypes = bucketized[bucket]; + if (!bucketTypes) { + bucketized[bucket] = bucketTypes = []; + } + bucketTypes.push(type); + }); + + // Generate the "augmented" type for each group. + var buckets = Object.keys(bucketized); + var augmented = buckets.map(function (bucket) { + var bucketTypes = bucketized[bucket]; + if (bucketTypes.length === 1) { + return bucketTypes[0]; + } else { + switch (bucket) { + case 'null': + case 'boolean': + return bucketTypes[0]; + case 'number': + return combineNumbers(bucketTypes); + case 'string': + return combineStrings(bucketTypes, opts); + case 'buffer': + return combineBuffers(bucketTypes, opts); + case 'array': + // Remove any sentinel arrays (used when inferring from empty + // arrays) + // to avoid making things nullable when they shouldn't be. + bucketTypes = bucketTypes.filter(function (t) { + return t !== opts.emptyArrayType; + }); + if (!bucketTypes.length) { + // We still don't have a real type, just return the sentinel. + return opts.emptyArrayType; + } + return Type.forSchema({ + type: 'array', + items: Type.forTypes(bucketTypes.map(function (t) { + return t.itemsType; + })) + }, opts); + default: + return combineObjects(bucketTypes, opts); + } + } + }); + + if (augmented.length === 1) { + return augmented[0]; + } else { + // We return an (unwrapped) union of all augmented types. + return Type.forSchema(augmented, opts); + } +}; + +Type.isType = function (/* any, [prefix] ... */) { + var l = arguments.length; + if (!l) { + return false; + } + + var any = arguments[0]; + if ( + !any || + typeof any._update != 'function' || + typeof any.fingerprint != 'function' + ) { + // Not fool-proof, but most likely good enough. + return false; + } + + if (l === 1) { + // No type names specified, we are done. + return true; + } + + // We check if at least one of the prefixes matches. + var typeName = any.typeName; + var i; + for (i = 1; i < l; i++) { + if (typeName.indexOf(arguments[i]) === 0) { + return true; + } + } + return false; +}; + +Type.__reset = function (size) { + debug('resetting type buffer to %d', size); + TAP.buf = new buffer.SlowBuffer(size); +}; + +Object.defineProperty(Type.prototype, 'branchName', { + enumerable: true, + get: function () { + if (this.name) { + return this.name; + } + var type = Type.isType(this, 'logical') ? this.underlyingType : this; + return Type.isType(type, 'union') ? undefined : type.typeName; + } +}); + +Type.prototype.clone = function (val, opts) { + if (opts) { + opts = { + coerce: !!opts.coerceBuffers | 0, // Coerce JSON to Buffer. + fieldHook: opts.fieldHook, + qualifyNames: !!opts.qualifyNames, + skip: !!opts.skipMissingFields, + wrap: !!opts.wrapUnions | 0 // Wrap first match into union. + }; + return this._copy(val, opts); + } else { + // If no modifications are required, we can get by with a serialization + // roundtrip (generally much faster than a standard deep copy). + return this.fromBuffer(this.toBuffer(val)); + } +}; + +Type.prototype.compare = utils.abstractFunction; + +Type.prototype.compareBuffers = function (buf1, buf2) { + return this._match(new Tap(buf1), new Tap(buf2)); +}; + +Type.prototype.createResolver = function (type, opts) { + if (!Type.isType(type)) { + // More explicit error message than the "incompatible type" thrown + // otherwise (especially because of the overridden `toJSON` method). + throw new Error(f('not a type: %j', type)); + } + + if (!Type.isType(this, 'logical') && Type.isType(type, 'logical')) { + // Trying to read a logical type as a built-in: unwrap the logical type. + return this.createResolver(type.underlyingType, opts); + } + + opts = opts || {}; + opts.registry = opts.registry || {}; + + var resolver, key; + if ( + Type.isType(this, 'record', 'error') && + Type.isType(type, 'record', 'error') + ) { + // We allow conversions between records and errors. + key = this.name + ':' + type.name; // ':' is illegal in Avro type names. + resolver = opts.registry[key]; + if (resolver) { + return resolver; + } + } + + resolver = new Resolver(this); + if (key) { // Register resolver early for recursive schemas. + opts.registry[key] = resolver; + } + + if (Type.isType(type, 'union')) { + var resolvers = type.types.map(function (t) { + return this.createResolver(t, opts); + }, this); + resolver._read = function (tap) { + var index = tap.readLong(); + var resolver = resolvers[index]; + if (resolver === undefined) { + throw new Error(f('invalid union index: %s', index)); + } + return resolvers[index]._read(tap); + }; + } else { + this._update(resolver, type, opts); + } + + if (!resolver._read) { + throw new Error(f('cannot read %s as %s', type, this)); + } + return Object.freeze(resolver); +}; + +Type.prototype.decode = function (buf, pos, resolver) { + var tap = new Tap(buf, pos); + var val = readValue(this, tap, resolver); + if (!tap.isValid()) { + return {value: undefined, offset: -1}; + } + return {value: val, offset: tap.pos}; +}; + +Type.prototype.encode = function (val, buf, pos) { + var tap = new Tap(buf, pos); + this._write(tap, val); + if (!tap.isValid()) { + // Don't throw as there is no way to predict this. We also return the + // number of missing bytes to ease resizing. + return buf.length - tap.pos; + } + return tap.pos; +}; + +Type.prototype.equals = function (type) { + return ( + Type.isType(type) && + this.fingerprint().equals(type.fingerprint()) + ); +}; + +Type.prototype.fingerprint = function (algorithm) { + if (!algorithm) { + if (!this._hash.str) { + var schemaStr = JSON.stringify(this.schema()); + this._hash.str = utils.getHash(schemaStr).toString('binary'); + } + return new Buffer(this._hash.str, 'binary'); + } else { + return utils.getHash(JSON.stringify(this.schema()), algorithm); + } +}; + +Type.prototype.fromBuffer = function (buf, resolver, noCheck) { + var tap = new Tap(buf); + var val = readValue(this, tap, resolver, noCheck); + if (!tap.isValid()) { + throw new Error('truncated buffer'); + } + if (!noCheck && tap.pos < buf.length) { + throw new Error('trailing data'); + } + return val; +}; + +Type.prototype.fromString = function (str) { + return this._copy(JSON.parse(str), {coerce: 2}); +}; + +Type.prototype.inspect = function () { + var typeName = this.typeName; + var className = getClassName(typeName); + if (isPrimitive(typeName)) { + // The class name is sufficient to identify the type. + return f('<%s>', className); + } else { + // We add a little metadata for convenience. + var obj = this.schema({exportAttrs: true, noDeref: true}); + if (typeof obj == 'object' && !Type.isType(this, 'logical')) { + obj.type = undefined; // Would be redundant with constructor name. + } + return f('<%s %j>', className, obj); + } +}; + +Type.prototype.isValid = function (val, opts) { + // We only have a single flag for now, so no need to complicate things. + var flags = (opts && opts.noUndeclaredFields) | 0; + var errorHook = opts && opts.errorHook; + var hook, path; + if (errorHook) { + path = []; + hook = function (any, type) { + errorHook.call(this, path.slice(), any, type, val); + }; + } + return this._check(val, flags, hook, path); +}; + +Type.prototype.random = utils.abstractFunction; + +Type.prototype.schema = function (opts) { + // Copy the options to avoid mutating the original options object when we + // add + // the registry of dereferenced types. + return this._attrs({ + exportAttrs: !!(opts && opts.exportAttrs), + noDeref: !!(opts && opts.noDeref) + }); +}; + +Type.prototype.toBuffer = function (val) { + TAP.pos = 0; + this._write(TAP, val); + var buf = new Buffer(TAP.pos); + if (TAP.isValid()) { + TAP.buf.copy(buf, 0, 0, TAP.pos); + } else { + this._write(new Tap(buf), val); + } + return buf; +}; + +Type.prototype.toJSON = function () { + // Convenience to allow using `JSON.stringify(type)` to get a type's schema. + return this.schema({exportAttrs: true}); +}; + +Type.prototype.toString = function (val) { + if (val === undefined) { + // Consistent behavior with standard `toString` expectations. + return JSON.stringify(this.schema({noDeref: true})); + } + return JSON.stringify(this._copy(val, {coerce: 3})); +}; + +Type.prototype.wrap = function (val) { + var Branch = this._branchConstructor; + return Branch === null ? null : new Branch(val); +}; + +Type.prototype._attrs = function (opts) { + // This function handles a lot of the common logic to schema generation + // across types, for example keeping track of which types have already been + // de-referenced (i.e. derefed). + opts.derefed = opts.derefed || {}; + var name = this.name; + if (name !== undefined) { + if (opts.noDeref || opts.derefed[name]) { + return name; + } + opts.derefed[name] = true; + } + var schema = {}; + // The order in which we add fields to the `schema` object matters here. + // Since JS objects are unordered, this implementation (unfortunately) + // relies + // on engines returning properties in the same order that they are inserted + // in. This is not in the JS spec, but can be "somewhat" safely assumed (see + // http://stackoverflow.com/q/5525795/1062617). + if (this.name !== undefined) { + schema.name = name; + } + schema.type = this.typeName; + var derefedSchema = this._deref(schema, opts); + if (derefedSchema !== undefined) { + // We allow the original schema to be overridden (this will happen for + // primitive types and logical types). + schema = derefedSchema; + } + if (opts.exportAttrs) { + if (this.aliases && this.aliases.length) { + schema.aliases = this.aliases; + } + if (this.doc !== undefined) { + schema.doc = this.doc; + } + } + return schema; +}; + +Type.prototype._createBranchConstructor = function () { + // jshint -W054 + var name = this.branchName; + if (name === 'null') { + return null; + } + var attr = ~name.indexOf('.') ? 'this[\'' + name + '\']' : 'this.' + name; + var body = 'return function Branch$(val) { ' + attr + ' = val; };'; + var Branch = (new Function(body))(); + Branch.type = this; + Branch.prototype.unwrap = new Function('return ' + attr + ';'); + Branch.prototype.unwrapped = Branch.prototype.unwrap; // Deprecated. + return Branch; +}; + +Type.prototype._peek = function (tap) { + var pos = tap.pos; + var val = this._read(tap); + tap.pos = pos; + return val; +}; + +Type.prototype._check = utils.abstractFunction; +Type.prototype._copy = utils.abstractFunction; +Type.prototype._deref = utils.abstractFunction; +Type.prototype._match = utils.abstractFunction; +Type.prototype._read = utils.abstractFunction; +Type.prototype._skip = utils.abstractFunction; +Type.prototype._update = utils.abstractFunction; +Type.prototype._write = utils.abstractFunction; + +// "Deprecated" getters (will be explicitly deprecated in 5.1). + +Type.prototype.getAliases = function () { return this.aliases; }; + +Type.prototype.getFingerprint = Type.prototype.fingerprint; + +Type.prototype.getName = function (asBranch) { + return (this.name || !asBranch) ? this.name : this.branchName; +}; + +Type.prototype.getSchema = Type.prototype.schema; + +Type.prototype.getTypeName = function () { return this.typeName; }; + +// Implementations. + +/** + * Base primitive Avro type. + * + * Most of the primitive types share the same cloning and resolution mechanisms, + * provided by this class. This class also lets us conveniently check whether a + * type is a primitive using `instanceof`. + */ +function PrimitiveType(noFreeze) { + Type.call(this); + this._branchConstructor = this._createBranchConstructor(); + if (!noFreeze) { + // Abstract long types can't be frozen at this stage. + Object.freeze(this); + } +} +util.inherits(PrimitiveType, Type); + +PrimitiveType.prototype._update = function (resolver, type) { + if (type.constructor === this.constructor) { + resolver._read = this._read; + } +}; + +PrimitiveType.prototype._copy = function (val) { + this._check(val, undefined, throwInvalidError); + return val; +}; + +PrimitiveType.prototype._deref = function () { return this.typeName; }; + +PrimitiveType.prototype.compare = utils.compare; + +/** Nulls. */ +function NullType() { PrimitiveType.call(this); } +util.inherits(NullType, PrimitiveType); + +NullType.prototype._check = function (val, flags, hook) { + var b = val === null; + if (!b && hook) { + hook(val, this); + } + return b; +}; + +NullType.prototype._read = function () { return null; }; + +NullType.prototype._skip = function () {}; + +NullType.prototype._write = function (tap, val) { + if (val !== null) { + throwInvalidError(val, this); + } +}; + +NullType.prototype._match = function () { return 0; }; + +NullType.prototype.compare = NullType.prototype._match; + +NullType.prototype.typeName = 'null'; + +NullType.prototype.random = NullType.prototype._read; + +/** Booleans. */ +function BooleanType() { PrimitiveType.call(this); } +util.inherits(BooleanType, PrimitiveType); + +BooleanType.prototype._check = function (val, flags, hook) { + var b = typeof val == 'boolean'; + if (!b && hook) { + hook(val, this); + } + return b; +}; + +BooleanType.prototype._read = function (tap) { return tap.readBoolean(); }; + +BooleanType.prototype._skip = function (tap) { tap.skipBoolean(); }; + +BooleanType.prototype._write = function (tap, val) { + if (typeof val != 'boolean') { + throwInvalidError(val, this); + } + tap.writeBoolean(val); +}; + +BooleanType.prototype._match = function (tap1, tap2) { + return tap1.matchBoolean(tap2); +}; + +BooleanType.prototype.typeName = 'boolean'; + +BooleanType.prototype.random = function () { return RANDOM.nextBoolean(); }; + +/** Integers. */ +function IntType() { PrimitiveType.call(this); } +util.inherits(IntType, PrimitiveType); + +IntType.prototype._check = function (val, flags, hook) { + var b = val === (val | 0); + if (!b && hook) { + hook(val, this); + } + return b; +}; + +IntType.prototype._read = function (tap) { return tap.readInt(); }; + +IntType.prototype._skip = function (tap) { tap.skipInt(); }; + +IntType.prototype._write = function (tap, val) { + if (val !== (val | 0)) { + throwInvalidError(val, this); + } + tap.writeInt(val); +}; + +IntType.prototype._match = function (tap1, tap2) { + return tap1.matchInt(tap2); +}; + +IntType.prototype.typeName = 'int'; + +IntType.prototype.random = function () { return RANDOM.nextInt(1000) | 0; }; + +/** + * Longs. + * + * We can't capture all the range unfortunately since JavaScript represents all + * numbers internally as `double`s, so the default implementation plays safe and + * throws rather than potentially silently change the data. See `__with` or + * `AbstractLongType` below for a way to implement a custom long type. + */ +function LongType() { PrimitiveType.call(this); } +util.inherits(LongType, PrimitiveType); + +LongType.prototype._check = function (val, flags, hook) { + var b = typeof val == 'number' && val % 1 === 0 && isSafeLong(val); + if (!b && hook) { + hook(val, this); + } + return b; +}; + +LongType.prototype._read = function (tap) { + var n = tap.readLong(); + if (!isSafeLong(n)) { + throw new Error('potential precision loss'); + } + return n; +}; + +LongType.prototype._skip = function (tap) { tap.skipLong(); }; + +LongType.prototype._write = function (tap, val) { + if (typeof val != 'number' || val % 1 || !isSafeLong(val)) { + throwInvalidError(val, this); + } + tap.writeLong(val); +}; + +LongType.prototype._match = function (tap1, tap2) { + return tap1.matchLong(tap2); +}; + +LongType.prototype._update = function (resolver, type) { + switch (type.typeName) { + case 'int': + case 'long': + resolver._read = type._read; + } +}; + +LongType.prototype.typeName = 'long'; + +LongType.prototype.random = function () { return RANDOM.nextInt(); }; + +LongType.__with = function (methods, noUnpack) { + methods = methods || {}; // Will give a more helpful error message. + // We map some of the methods to a different name to be able to intercept + // their input and output (otherwise we wouldn't be able to perform any + // unpacking logic, and the type wouldn't work when nested). + var mapping = { + toBuffer: '_toBuffer', + fromBuffer: '_fromBuffer', + fromJSON: '_fromJSON', + toJSON: '_toJSON', + isValid: '_isValid', + compare: 'compare' + }; + var type = new AbstractLongType(noUnpack); + Object.keys(mapping).forEach(function (name) { + if (methods[name] === undefined) { + throw new Error(f('missing method implementation: %s', name)); + } + type[mapping[name]] = methods[name]; + }); + return Object.freeze(type); +}; + +/** Floats. */ +function FloatType() { PrimitiveType.call(this); } +util.inherits(FloatType, PrimitiveType); + +FloatType.prototype._check = function (val, flags, hook) { + var b = typeof val == 'number'; + if (!b && hook) { + hook(val, this); + } + return b; +}; + +FloatType.prototype._read = function (tap) { return tap.readFloat(); }; + +FloatType.prototype._skip = function (tap) { tap.skipFloat(); }; + +FloatType.prototype._write = function (tap, val) { + if (typeof val != 'number') { + throwInvalidError(val, this); + } + tap.writeFloat(val); +}; + +FloatType.prototype._match = function (tap1, tap2) { + return tap1.matchFloat(tap2); +}; + +FloatType.prototype._update = function (resolver, type) { + switch (type.typeName) { + case 'float': + case 'int': + case 'long': + resolver._read = type._read; + } +}; + +FloatType.prototype.typeName = 'float'; + +FloatType.prototype.random = function () { return RANDOM.nextFloat(1e3); }; + +/** Doubles. */ +function DoubleType() { PrimitiveType.call(this); } +util.inherits(DoubleType, PrimitiveType); + +DoubleType.prototype._check = function (val, flags, hook) { + var b = typeof val == 'number'; + if (!b && hook) { + hook(val, this); + } + return b; +}; + +DoubleType.prototype._read = function (tap) { return tap.readDouble(); }; + +DoubleType.prototype._skip = function (tap) { tap.skipDouble(); }; + +DoubleType.prototype._write = function (tap, val) { + if (typeof val != 'number') { + throwInvalidError(val, this); + } + tap.writeDouble(val); +}; + +DoubleType.prototype._match = function (tap1, tap2) { + return tap1.matchDouble(tap2); +}; + +DoubleType.prototype._update = function (resolver, type) { + switch (type.typeName) { + case 'double': + case 'float': + case 'int': + case 'long': + resolver._read = type._read; + } +}; + +DoubleType.prototype.typeName = 'double'; + +DoubleType.prototype.random = function () { return RANDOM.nextFloat(); }; + +/** Strings. */ +function StringType() { PrimitiveType.call(this); } +util.inherits(StringType, PrimitiveType); + +StringType.prototype._check = function (val, flags, hook) { + var b = typeof val == 'string'; + if (!b && hook) { + hook(val, this); + } + return b; +}; + +StringType.prototype._read = function (tap) { return tap.readString(); }; + +StringType.prototype._skip = function (tap) { tap.skipString(); }; + +StringType.prototype._write = function (tap, val) { + if (typeof val != 'string') { + throwInvalidError(val, this); + } + tap.writeString(val); +}; + +StringType.prototype._match = function (tap1, tap2) { + return tap1.matchString(tap2); +}; + +StringType.prototype._update = function (resolver, type) { + switch (type.typeName) { + case 'bytes': + case 'string': + resolver._read = this._read; + } +}; + +StringType.prototype.typeName = 'string'; + +StringType.prototype.random = function () { + return RANDOM.nextString(RANDOM.nextInt(32)); +}; + +/** + * Bytes. + * + * These are represented in memory as `Buffer`s rather than binary-encoded + * strings. This is more efficient (when decoding/encoding from bytes, the + * common use-case), idiomatic, and convenient. + * + * Note the coercion in `_copy`. + */ +function BytesType() { PrimitiveType.call(this); } +util.inherits(BytesType, PrimitiveType); + +BytesType.prototype._check = function (val, flags, hook) { + var b = Buffer.isBuffer(val); + if (!b && hook) { + hook(val, this); + } + return b; +}; + +BytesType.prototype._read = function (tap) { return tap.readBytes(); }; + +BytesType.prototype._skip = function (tap) { tap.skipBytes(); }; + +BytesType.prototype._write = function (tap, val) { + if (!Buffer.isBuffer(val)) { + throwInvalidError(val, this); + } + tap.writeBytes(val); +}; + +BytesType.prototype._match = function (tap1, tap2) { + return tap1.matchBytes(tap2); +}; + +BytesType.prototype._update = StringType.prototype._update; + +BytesType.prototype._copy = function (obj, opts) { + var buf; + switch ((opts && opts.coerce) | 0) { + case 3: // Coerce buffers to strings. + this._check(obj, undefined, throwInvalidError); + return obj.toString('binary'); + case 2: // Coerce strings to buffers. + if (typeof obj != 'string') { + throw new Error(f('cannot coerce to buffer: %j', obj)); + } + buf = new Buffer(obj, 'binary'); + this._check(buf, undefined, throwInvalidError); + return buf; + case 1: // Coerce buffer JSON representation to buffers. + if (!isJsonBuffer(obj)) { + throw new Error(f('cannot coerce to buffer: %j', obj)); + } + buf = new Buffer(obj.data); + this._check(buf, undefined, throwInvalidError); + return buf; + default: // Copy buffer. + this._check(obj, undefined, throwInvalidError); + return new Buffer(obj); + } +}; + +BytesType.prototype.compare = Buffer.compare; + +BytesType.prototype.typeName = 'bytes'; + +BytesType.prototype.random = function () { + return RANDOM.nextBuffer(RANDOM.nextInt(32)); +}; + +/** Base "abstract" Avro union type. */ +function UnionType(schema, opts) { + Type.call(this); + + if (!Array.isArray(schema)) { + throw new Error(f('non-array union schema: %j', schema)); + } + if (!schema.length) { + throw new Error('empty union'); + } + this.types = Object.freeze(schema.map(function (obj) { + return Type.forSchema(obj, opts); + })); + + this._branchIndices = {}; + this.types.forEach(function (type, i) { + if (Type.isType(type, 'union')) { + throw new Error('unions cannot be directly nested'); + } + var branch = type.branchName; + if (this._branchIndices[branch] !== undefined) { + throw new Error(f('duplicate union branch name: %j', branch)); + } + this._branchIndices[branch] = i; + }, this); +} +util.inherits(UnionType, Type); + +UnionType.prototype._branchConstructor = function () { + throw new Error('unions cannot be directly wrapped'); +}; + +UnionType.prototype._skip = function (tap) { + this.types[tap.readLong()]._skip(tap); +}; + +UnionType.prototype._match = function (tap1, tap2) { + var n1 = tap1.readLong(); + var n2 = tap2.readLong(); + if (n1 === n2) { + return this.types[n1]._match(tap1, tap2); + } else { + return n1 < n2 ? -1 : 1; + } +}; + +UnionType.prototype._deref = function (schema, opts) { + return this.types.map(function (t) { return t._attrs(opts); }); +}; + +UnionType.prototype.getTypes = function () { return this.types; }; + +/** + * "Natural" union type. + * + * This representation doesn't require a wrapping object and is therefore + * simpler and generally closer to what users expect. However it cannot be used + * to represent all Avro unions since some lead to ambiguities (e.g. if two + * number types are in the union). + * + * Currently, this union supports at most one type in each of the categories + * below: + * + `null` + `boolean` + `int`, `long`, `float`, `double` + `string`, `enum` + + * `bytes`, `fixed` + `array` + `map`, `record` + */ +function UnwrappedUnionType(schema, opts) { + UnionType.call(this, schema, opts); + + this._logicalBranches = null; + this._bucketIndices = {}; + this.types.forEach(function (type, index) { + if (Type.isType(type, 'logical')) { + if (!this._logicalBranches) { + this._logicalBranches = []; + } + this._logicalBranches.push({index: index, type: type}); + } else { + var bucket = getTypeBucket(type); + if (this._bucketIndices[bucket] !== undefined) { + throw new Error(f('ambiguous unwrapped union: %j', this)); + } + this._bucketIndices[bucket] = index; + } + }, this); + + Object.freeze(this); +} +util.inherits(UnwrappedUnionType, UnionType); + +UnwrappedUnionType.prototype._getIndex = function (val) { + var index = this._bucketIndices[getValueBucket(val)]; + if (this._logicalBranches) { + // Slower path, we must run the value through all logical types. + index = this._getLogicalIndex(val, index); + } + return index; +}; + +UnwrappedUnionType.prototype._getLogicalIndex = function (any, index) { + var logicalBranches = this._logicalBranches; + var i, l, branch; + for (i = 0, l = logicalBranches.length; i < l; i++) { + branch = logicalBranches[i]; + if (branch.type._check(any)) { + if (index === undefined) { + index = branch.index; + } else { + // More than one branch matches the value so we aren't guaranteed to + // infer the correct type. We throw rather than corrupt data. This can + // be fixed by "tightening" the logical types. + throw new Error('ambiguous conversion'); + } + } + } + return index; +}; + +UnwrappedUnionType.prototype._check = function (val, flags, hook, path) { + var index = this._getIndex(val); + var b = index !== undefined; + if (b) { + return this.types[index]._check(val, flags, hook, path); + } + if (hook) { + hook(val, this); + } + return b; +}; + +UnwrappedUnionType.prototype._read = function (tap) { + var index = tap.readLong(); + var branchType = this.types[index]; + if (branchType) { + return branchType._read(tap); + } else { + throw new Error(f('invalid union index: %s', index)); + } +}; + +UnwrappedUnionType.prototype._write = function (tap, val) { + var index = this._getIndex(val); + if (index === undefined) { + throwInvalidError(val, this); + } + tap.writeLong(index); + if (val !== null) { + this.types[index]._write(tap, val); + } +}; + +UnwrappedUnionType.prototype._update = function (resolver, type, opts) { + // jshint -W083 + // (The loop exits after the first function is created.) + var i, l, typeResolver; + for (i = 0, l = this.types.length; i < l; i++) { + try { + typeResolver = this.types[i].createResolver(type, opts); + } catch (err) { + continue; + } + resolver._read = function (tap) { return typeResolver._read(tap); }; + return; + } +}; + +UnwrappedUnionType.prototype._copy = function (val, opts) { + var coerce = opts && opts.coerce | 0; + var wrap = opts && opts.wrap | 0; + var index; + if (wrap === 2) { + // We are parsing a default, so always use the first branch's type. + index = 0; + } else { + switch (coerce) { + case 1: + // Using the `coerceBuffers` option can cause corruption and erroneous + // failures with unwrapped unions (in rare cases when the union also + // contains a record which matches a buffer's JSON representation). + if (isJsonBuffer(val) && this._bucketIndices.buffer !== undefined) { + index = this._bucketIndices.buffer; + } else { + index = this._getIndex(val); + } + break; + case 2: + // Decoding from JSON, we must unwrap the value. + if (val === null) { + index = this._bucketIndices['null']; + } else if (typeof val === 'object') { + var keys = Object.keys(val); + if (keys.length === 1) { + index = this._branchIndices[keys[0]]; + val = val[keys[0]]; + } + } + break; + default: + index = this._getIndex(val); + } + if (index === undefined) { + throwInvalidError(val, this); + } + } + var type = this.types[index]; + if (val === null || wrap === 3) { + return type._copy(val, opts); + } else { + switch (coerce) { + case 3: + // Encoding to JSON, we wrap the value. + var obj = {}; + obj[type.branchName] = type._copy(val, opts); + return obj; + default: + return type._copy(val, opts); + } + } +}; + +UnwrappedUnionType.prototype.compare = function (val1, val2) { + var index1 = this._getIndex(val1); + var index2 = this._getIndex(val2); + if (index1 === undefined) { + throwInvalidError(val1, this); + } else if (index2 === undefined) { + throwInvalidError(val2, this); + } else if (index1 === index2) { + return this.types[index1].compare(val1, val2); + } else { + return utils.compare(index1, index2); + } +}; + +UnwrappedUnionType.prototype.typeName = 'union:unwrapped'; + +UnwrappedUnionType.prototype.random = function () { + var index = RANDOM.nextInt(this.types.length); + return this.types[index].random(); +}; + +/** + * Compatible union type. + * + * Values of this type are represented in memory similarly to their JSON + * representation (i.e. inside an object with single key the name of the + * contained type). + * + * This is not ideal, but is the most efficient way to unambiguously support all + * unions. Here are a few reasons why the wrapping object is necessary: + * + Unions with multiple number types would have undefined behavior, unless + * numbers are wrapped (either everywhere, leading to large performance and + * convenience costs; or only when necessary inside unions, making it hard to + * understand when numbers are wrapped or not). + Fixed types would have to be + * wrapped to be distinguished from bytes. + Using record's constructor names + * would work (after a slight change to use the fully qualified name), but would + * mean that generic objects could no longer be valid records (making it + * inconvenient to do simple things like creating new records). + */ +function WrappedUnionType(schema, opts) { + UnionType.call(this, schema, opts); + Object.freeze(this); +} +util.inherits(WrappedUnionType, UnionType); + +WrappedUnionType.prototype._check = function (val, flags, hook, path) { + var b = false; + if (val === null) { + // Shortcut type lookup in this case. + b = this._branchIndices['null'] !== undefined; + } else if (typeof val == 'object') { + var keys = Object.keys(val); + if (keys.length === 1) { + // We require a single key here to ensure that writes are correct and + // efficient as soon as a record passes this check. + var name = keys[0]; + var index = this._branchIndices[name]; + if (index !== undefined) { + if (hook) { + // Slow path. + path.push(name); + b = this.types[index]._check(val[name], flags, hook, path); + path.pop(); + return b; + } else { + return this.types[index]._check(val[name], flags); + } + } + } + } + if (!b && hook) { + hook(val, this); + } + return b; +}; + +WrappedUnionType.prototype._read = function (tap) { + var type = this.types[tap.readLong()]; + if (!type) { + throw new Error(f('invalid union index')); + } + var Branch = type._branchConstructor; + if (Branch === null) { + return null; + } else { + return new Branch(type._read(tap)); + } +}; + +WrappedUnionType.prototype._write = function (tap, val) { + var index, keys, name; + if (val === null) { + index = this._branchIndices['null']; + if (index === undefined) { + throwInvalidError(val, this); + } + tap.writeLong(index); + } else { + keys = Object.keys(val); + if (keys.length === 1) { + name = keys[0]; + index = this._branchIndices[name]; + } + if (index === undefined) { + throwInvalidError(val, this); + } + tap.writeLong(index); + this.types[index]._write(tap, val[name]); + } +}; + +WrappedUnionType.prototype._update = function (resolver, type, opts) { + // jshint -W083 + // (The loop exits after the first function is created.) + var i, l, typeResolver, Branch; + for (i = 0, l = this.types.length; i < l; i++) { + try { + typeResolver = this.types[i].createResolver(type, opts); + } catch (err) { + continue; + } + Branch = this.types[i]._branchConstructor; + if (Branch) { + resolver._read = function (tap) { + return new Branch(typeResolver._read(tap)); + }; + } else { + resolver._read = function () { return null; }; + } + return; + } +}; + +WrappedUnionType.prototype._copy = function (val, opts) { + var wrap = opts && opts.wrap | 0; + if (wrap === 2) { + var firstType = this.types[0]; + // Promote into first type (used for schema defaults). + if (val === null && firstType.typeName === 'null') { + return null; + } + return new firstType._branchConstructor(firstType._copy(val, opts)); + } + if (val === null && this._branchIndices['null'] !== undefined) { + return null; + } + + var i, l, obj; + if (typeof val == 'object') { + var keys = Object.keys(val); + if (keys.length === 1) { + var name = keys[0]; + i = this._branchIndices[name]; + if (i === undefined && opts.qualifyNames) { + // We are a bit more flexible than in `_check` here since we have + // to deal with other serializers being less strict, so we fall + // back to looking up unqualified names. + var j, type; + for (j = 0, l = this.types.length; j < l; j++) { + type = this.types[j]; + if (type.name && name === unqualify(type.name)) { + i = j; + break; + } + } + } + if (i !== undefined) { + obj = this.types[i]._copy(val[name], opts); + } + } + } + if (wrap === 1 && obj === undefined) { + // Try promoting into first match (convenience, slow). + i = 0; + l = this.types.length; + while (i < l && obj === undefined) { + try { + obj = this.types[i]._copy(val, opts); + } catch (err) { + i++; + } + } + } + if (obj !== undefined) { + return wrap === 3 ? obj : new this.types[i]._branchConstructor(obj); + } + throwInvalidError(val, this); +}; + +WrappedUnionType.prototype.compare = function (val1, val2) { + var name1 = val1 === null ? 'null' : Object.keys(val1)[0]; + var name2 = val2 === null ? 'null' : Object.keys(val2)[0]; + var index = this._branchIndices[name1]; + if (name1 === name2) { + return name1 === 'null' ? + 0 : + this.types[index].compare(val1[name1], val2[name1]); + } else { + return utils.compare(index, this._branchIndices[name2]); + } +}; + +WrappedUnionType.prototype.typeName = 'union:wrapped'; + +WrappedUnionType.prototype.random = function () { + var index = RANDOM.nextInt(this.types.length); + var type = this.types[index]; + var Branch = type._branchConstructor; + if (!Branch) { + return null; + } + return new Branch(type.random()); +}; + +/** + * Avro enum type. + * + * Represented as strings (with allowed values from the set of symbols). Using + * integers would be a reasonable option, but the performance boost is arguably + * offset by the legibility cost and the extra deviation from the JSON encoding + * convention. + * + * An integer representation can still be used (e.g. for compatibility with + * TypeScript `enum`s) by overriding the `EnumType` with a `LongType` (e.g. via + * `parse`'s registry). + */ +function EnumType(schema, opts) { + Type.call(this, schema, opts); + if (!Array.isArray(schema.symbols) || !schema.symbols.length) { + throw new Error(f('invalid enum symbols: %j', schema.symbols)); + } + this.symbols = Object.freeze(schema.symbols.slice()); + this._indices = {}; + this.symbols.forEach(function (symbol, i) { + if (!isValidName(symbol)) { + throw new Error(f('invalid %s symbol: %j', this, symbol)); + } + if (this._indices[symbol] !== undefined) { + throw new Error(f('duplicate %s symbol: %j', this, symbol)); + } + this._indices[symbol] = i; + }, this); + this._branchConstructor = this._createBranchConstructor(); + Object.freeze(this); +} +util.inherits(EnumType, Type); + +EnumType.prototype._check = function (val, flags, hook) { + var b = this._indices[val] !== undefined; + if (!b && hook) { + hook(val, this); + } + return b; +}; + +EnumType.prototype._read = function (tap) { + var index = tap.readLong(); + var symbol = this.symbols[index]; + if (symbol === undefined) { + throw new Error(f('invalid %s enum index: %s', this.name, index)); + } + return symbol; +}; + +EnumType.prototype._skip = function (tap) { tap.skipLong(); }; + +EnumType.prototype._write = function (tap, val) { + var index = this._indices[val]; + if (index === undefined) { + throwInvalidError(val, this); + } + tap.writeLong(index); +}; + +EnumType.prototype._match = function (tap1, tap2) { + return tap1.matchLong(tap2); +}; + +EnumType.prototype.compare = function (val1, val2) { + return utils.compare(this._indices[val1], this._indices[val2]); +}; + +EnumType.prototype._update = function (resolver, type) { + var symbols = this.symbols; + if ( + type.typeName === 'enum' && + (!type.name || ~getAliases(this).indexOf(type.name)) && + type.symbols.every(function (s) { return ~symbols.indexOf(s); }) + ) { + resolver.symbols = type.symbols; + resolver._read = type._read; + } +}; + +EnumType.prototype._copy = function (val) { + this._check(val, undefined, throwInvalidError); + return val; +}; + +EnumType.prototype._deref = function (schema) { + schema.symbols = this.symbols; +}; + +EnumType.prototype.getSymbols = function () { return this.symbols; }; + +EnumType.prototype.typeName = 'enum'; + +EnumType.prototype.random = function () { + return RANDOM.choice(this.symbols); +}; + +/** Avro fixed type. Represented simply as a `Buffer`. */ +function FixedType(schema, opts) { + Type.call(this, schema, opts); + if (schema.size !== (schema.size | 0) || schema.size < 1) { + throw new Error(f('invalid %s size', this.branchName)); + } + this.size = schema.size | 0; + this._branchConstructor = this._createBranchConstructor(); + Object.freeze(this); +} +util.inherits(FixedType, Type); + +FixedType.prototype._check = function (val, flags, hook) { + var b = Buffer.isBuffer(val) && val.length === this.size; + if (!b && hook) { + hook(val, this); + } + return b; +}; + +FixedType.prototype._read = function (tap) { + return tap.readFixed(this.size); +}; + +FixedType.prototype._skip = function (tap) { + tap.skipFixed(this.size); +}; + +FixedType.prototype._write = function (tap, val) { + if (!Buffer.isBuffer(val) || val.length !== this.size) { + throwInvalidError(val, this); + } + tap.writeFixed(val, this.size); +}; + +FixedType.prototype._match = function (tap1, tap2) { + return tap1.matchFixed(tap2, this.size); +}; + +FixedType.prototype.compare = Buffer.compare; + +FixedType.prototype._update = function (resolver, type) { + if ( + type.typeName === 'fixed' && + this.size === type.size && + (!type.name || ~getAliases(this).indexOf(type.name)) + ) { + resolver.size = this.size; + resolver._read = this._read; + } +}; + +FixedType.prototype._copy = BytesType.prototype._copy; + +FixedType.prototype._deref = function (schema) { schema.size = this.size; }; + +FixedType.prototype.getSize = function () { return this.size; }; + +FixedType.prototype.typeName = 'fixed'; + +FixedType.prototype.random = function () { + return RANDOM.nextBuffer(this.size); +}; + +/** Avro map. Represented as vanilla objects. */ +function MapType(schema, opts) { + Type.call(this); + if (!schema.values) { + throw new Error(f('missing map values: %j', schema)); + } + this.valuesType = Type.forSchema(schema.values, opts); + this._branchConstructor = this._createBranchConstructor(); + Object.freeze(this); +} +util.inherits(MapType, Type); + +MapType.prototype._check = function (val, flags, hook, path) { + if (!val || typeof val != 'object' || Array.isArray(val)) { + if (hook) { + hook(val, this); + } + return false; + } + + var keys = Object.keys(val); + var b = true; + var i, l, j, key; + if (hook) { + // Slow path. + j = path.length; + path.push(''); + for (i = 0, l = keys.length; i < l; i++) { + key = path[j] = keys[i]; + if (!this.valuesType._check(val[key], flags, hook, path)) { + b = false; + } + } + path.pop(); + } else { + for (i = 0, l = keys.length; i < l; i++) { + if (!this.valuesType._check(val[keys[i]], flags)) { + return false; + } + } + } + return b; +}; + +MapType.prototype._read = function (tap) { + var values = this.valuesType; + var val = {}; + var n; + while ((n = readArraySize(tap))) { + while (n--) { + var key = tap.readString(); + val[key] = values._read(tap); + } + } + return val; +}; + +MapType.prototype._skip = function (tap) { + var values = this.valuesType; + var len, n; + while ((n = tap.readLong())) { + if (n < 0) { + len = tap.readLong(); + tap.pos += len; + } else { + while (n--) { + tap.skipString(); + values._skip(tap); + } + } + } +}; + +MapType.prototype._write = function (tap, val) { + if (!val || typeof val != 'object' || Array.isArray(val)) { + throwInvalidError(val, this); + } + + var values = this.valuesType; + var keys = Object.keys(val); + var n = keys.length; + var i, key; + if (n) { + tap.writeLong(n); + for (i = 0; i < n; i++) { + key = keys[i]; + tap.writeString(key); + values._write(tap, val[key]); + } + } + tap.writeLong(0); +}; + +MapType.prototype._match = function () { + throw new Error('maps cannot be compared'); +}; + +MapType.prototype._update = function (rsv, type, opts) { + if (type.typeName === 'map') { + rsv.valuesType = this.valuesType.createResolver(type.valuesType, opts); + rsv._read = this._read; + } +}; + +MapType.prototype._copy = function (val, opts) { + if (val && typeof val == 'object' && !Array.isArray(val)) { + var values = this.valuesType; + var keys = Object.keys(val); + var i, l, key; + var copy = {}; + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i]; + copy[key] = values._copy(val[key], opts); + } + return copy; + } + throwInvalidError(val, this); +}; + +MapType.prototype.compare = MapType.prototype._match; + +MapType.prototype.typeName = 'map'; + +MapType.prototype.getValuesType = function () { return this.valuesType; }; + +MapType.prototype.random = function () { + var val = {}; + var i, l; + for (i = 0, l = RANDOM.nextInt(10); i < l; i++) { + val[RANDOM.nextString(RANDOM.nextInt(20))] = this.valuesType.random(); + } + return val; +}; + +MapType.prototype._deref = function (schema, opts) { + schema.values = this.valuesType._attrs(opts); +}; + +/** Avro array. Represented as vanilla arrays. */ +function ArrayType(schema, opts) { + Type.call(this); + if (!schema.items) { + throw new Error(f('missing array items: %j', schema)); + } + this.itemsType = Type.forSchema(schema.items, opts); + this._branchConstructor = this._createBranchConstructor(); + Object.freeze(this); +} +util.inherits(ArrayType, Type); + +ArrayType.prototype._check = function (val, flags, hook, path) { + if (!Array.isArray(val)) { + if (hook) { + hook(val, this); + } + return false; + } + + var b = true; + var i, l, j; + if (hook) { + // Slow path. + j = path.length; + path.push(''); + for (i = 0, l = val.length; i < l; i++) { + path[j] = '' + i; + if (!this.itemsType._check(val[i], flags, hook, path)) { + b = false; + } + } + path.pop(); + } else { + for (i = 0, l = val.length; i < l; i++) { + if (!this.itemsType._check(val[i], flags)) { + return false; + } + } + } + return b; +}; + +ArrayType.prototype._read = function (tap) { + var items = this.itemsType; + var val = []; + var i, n; + while ((n = tap.readLong())) { + if (n < 0) { + n = -n; + tap.skipLong(); // Skip size. + } + for (i = 0; i < n; i++) { + val[i] = items._read(tap); + } + } + return val; +}; + +ArrayType.prototype._skip = function (tap) { + var len, n; + while ((n = tap.readLong())) { + if (n < 0) { + len = tap.readLong(); + tap.pos += len; + } else { + while (n--) { + this.itemsType._skip(tap); + } + } + } +}; + +ArrayType.prototype._write = function (tap, val) { + if (!Array.isArray(val)) { + throwInvalidError(val, this); + } + + var n = val.length; + var i; + if (n) { + tap.writeLong(n); + for (i = 0; i < n; i++) { + this.itemsType._write(tap, val[i]); + } + } + tap.writeLong(0); +}; + +ArrayType.prototype._match = function (tap1, tap2) { + var n1 = tap1.readLong(); + var n2 = tap2.readLong(); + var f; + while (n1 && n2) { + f = this.itemsType._match(tap1, tap2); + if (f) { + return f; + } + if (!--n1) { + n1 = readArraySize(tap1); + } + if (!--n2) { + n2 = readArraySize(tap2); + } + } + return utils.compare(n1, n2); +}; + +ArrayType.prototype._update = function (resolver, type, opts) { + if (type.typeName === 'array') { + resolver.itemsType = this.itemsType.createResolver(type.itemsType, opts); + resolver._read = this._read; + } +}; + +ArrayType.prototype._copy = function (val, opts) { + if (!Array.isArray(val)) { + throwInvalidError(val, this); + } + var items = new Array(val.length); + var i, l; + for (i = 0, l = val.length; i < l; i++) { + items[i] = this.itemsType._copy(val[i], opts); + } + return items; +}; + +ArrayType.prototype._deref = function (schema, opts) { + schema.items = this.itemsType._attrs(opts); +}; + +ArrayType.prototype.compare = function (val1, val2) { + var n1 = val1.length; + var n2 = val2.length; + var i, l, f; + for (i = 0, l = Math.min(n1, n2); i < l; i++) { + if ((f = this.itemsType.compare(val1[i], val2[i]))) { + return f; + } + } + return utils.compare(n1, n2); +}; + +ArrayType.prototype.getItemsType = function () { return this.itemsType; }; + +ArrayType.prototype.typeName = 'array'; + +ArrayType.prototype.random = function () { + var arr = []; + var i, l; + for (i = 0, l = RANDOM.nextInt(10); i < l; i++) { + arr.push(this.itemsType.random()); + } + return arr; +}; + +/** + * Avro record. + * + * Values are represented as instances of a programmatically generated + * constructor (similar to a "specific record"), available via the + * `getRecordConstructor` method. This "specific record class" gives significant + * speedups over using generics objects. + * + * Note that vanilla objects are still accepted as valid as long as their fields + * match (this makes it much more convenient to do simple things like update + * nested records). + * + * This type is also used for errors (similar, except for the extra `Error` + * constructor call) and for messages (see comment below). + */ +function RecordType(schema, opts) { + // Force creation of the options object in case we need to register this + // record's name. + opts = opts || {}; + + // Save the namespace to restore it as we leave this record's scope. + var namespace = opts.namespace; + if (schema.namespace !== undefined) { + opts.namespace = schema.namespace; + } else if (schema.name) { + // Fully qualified names' namespaces are used when no explicit namespace + // attribute was specified. + var match = /^(.*)\.[^.]+$/.exec(schema.name); + if (match) { + opts.namespace = match[1]; + } + } + Type.call(this, schema, opts); + + if (!Array.isArray(schema.fields)) { + throw new Error(f('non-array record fields: %j', schema.fields)); + } + if (utils.hasDuplicates(schema.fields, function (f) { return f.name; })) { + throw new Error(f('duplicate field name: %j', schema.fields)); + } + this._fieldsByName = {}; + this.fields = Object.freeze(schema.fields.map(function (f) { + var field = new Field(f, opts); + this._fieldsByName[field.name] = field; + return field; + }, this)); + this._branchConstructor = this._createBranchConstructor(); + this._isError = schema.type === 'error'; + this.recordConstructor = this._createConstructor(opts.errorStackTraces); + this._read = this._createReader(); + this._skip = this._createSkipper(); + this._write = this._createWriter(); + this._check = this._createChecker(); + + opts.namespace = namespace; + Object.freeze(this); +} +util.inherits(RecordType, Type); + +RecordType.prototype._getConstructorName = function () { + return this.name ? + unqualify(this.name) : + this._isError ? 'Error$' : 'Record$'; +}; + +RecordType.prototype._createConstructor = function (errorStackTraces) { + // jshint -W054 + var outerArgs = []; + var innerArgs = []; + var ds = []; // Defaults. + var innerBody = ''; + var i, l, field, name, defaultValue, hasDefault, stackField; + for (i = 0, l = this.fields.length; i < l; i++) { + field = this.fields[i]; + defaultValue = field.defaultValue; + hasDefault = defaultValue() !== undefined; + name = field.name; + if ( + errorStackTraces && this._isError && name === 'stack' && + Type.isType(field.type, 'string') && !hasDefault + ) { + // We keep track of whether we've encountered a valid stack field (in + // particular, without a default) to populate a stack trace below. + stackField = field; + } + innerArgs.push('v' + i); + innerBody += ' '; + if (!hasDefault) { + innerBody += 'this.' + name + ' = v' + i + ';\n'; + } else { + innerBody += 'if (v' + i + ' === undefined) { '; + innerBody += 'this.' + name + ' = d' + ds.length + '(); '; + innerBody += '} else { this.' + name + ' = v' + i + '; }\n'; + outerArgs.push('d' + ds.length); + ds.push(defaultValue); + } + } + if (stackField) { + // We should populate a stack trace. + innerBody += ' if (this.stack === undefined) { '; + /* istanbul ignore else */ + if (typeof Error.captureStackTrace == 'function') { + // v8 runtimes, the easy case. + innerBody += 'Error.captureStackTrace(this, this.constructor);'; + } else { + // A few other runtimes (e.g. SpiderMonkey), might not work everywhere. + innerBody += 'this.stack = Error().stack;'; + } + innerBody += ' }\n'; + } + var outerBody = 'return function ' + this._getConstructorName() + '('; + outerBody += innerArgs.join() + ') {\n' + innerBody + '};'; + var Record = new Function(outerArgs.join(), outerBody).apply(undefined, ds); + + var self = this; + Record.getType = function () { return self; }; + Record.type = self; + if (this._isError) { + util.inherits(Record, Error); + Record.prototype.name = this._getConstructorName(); + } + Record.prototype.clone = function (o) { return self.clone(this, o); }; + Record.prototype.compare = function (v) { return self.compare(this, v); }; + Record.prototype.isValid = function (o) { return self.isValid(this, o); }; + Record.prototype.toBuffer = function () { return self.toBuffer(this); }; + Record.prototype.toString = function () { return self.toString(this); }; + Record.prototype.wrap = function () { return self.wrap(this); }; + Record.prototype.wrapped = Record.prototype.wrap; // Deprecated. + return Record; +}; + +RecordType.prototype._createChecker = function () { + // jshint -W054 + var names = []; + var values = []; + var name = this._getConstructorName(); + var body = 'return function check' + name + '(v, f, h, p) {\n'; + body += ' if (\n'; + body += ' v === null ||\n'; + body += ' typeof v != \'object\' ||\n'; + body += ' (f && !this._checkFields(v))\n'; + body += ' ) {\n'; + body += ' if (h) { h(v, this); }\n'; + body += ' return false;\n'; + body += ' }\n'; + if (!this.fields.length) { + // Special case, empty record. We handle this directly. + body += ' return true;\n'; + } else { + for (i = 0, l = this.fields.length; i < l; i++) { + field = this.fields[i]; + names.push('t' + i); + values.push(field.type); + if (field.defaultValue() !== undefined) { + body += ' var v' + i + ' = v.' + field.name + ';\n'; + } + } + body += ' if (h) {\n'; + body += ' var b = 1;\n'; + body += ' var j = p.length;\n'; + body += ' p.push(\'\');\n'; + var i, l, field; + for (i = 0, l = this.fields.length; i < l; i++) { + field = this.fields[i]; + body += ' p[j] = \'' + field.name + '\';\n'; + body += ' b &= '; + if (field.defaultValue() === undefined) { + body += 't' + i + '._check(v.' + field.name + ', f, h, p);\n'; + } else { + body += 'v' + i + ' === undefined || '; + body += 't' + i + '._check(v' + i + ', f, h, p);\n'; + } + } + body += ' p.pop();\n'; + body += ' return !!b;\n'; + body += ' } else {\n return (\n '; + body += this.fields.map(function (field, i) { + return field.defaultValue() === undefined ? + 't' + i + '._check(v.' + field.name + ', f)' : + '(v' + i + ' === undefined || t' + i + '._check(v' + i + ', f))'; + }).join(' &&\n '); + body += '\n );\n }\n'; + } + body += '};'; + return new Function(names.join(), body).apply(undefined, values); +}; + +RecordType.prototype._createReader = function () { + // jshint -W054 + var names = []; + var values = [this.recordConstructor]; + var i, l; + for (i = 0, l = this.fields.length; i < l; i++) { + names.push('t' + i); + values.push(this.fields[i].type); + } + var name = this._getConstructorName(); + var body = 'return function read' + name + '(t) {\n'; + body += ' return new ' + name + '(\n '; + body += names.map(function (s) { return s + '._read(t)'; }).join(',\n '); + body += '\n );\n};'; + names.unshift(name); + // We can do this since the JS spec guarantees that function arguments are + // evaluated from left to right. + return new Function(names.join(), body).apply(undefined, values); +}; + +RecordType.prototype._createSkipper = function () { + // jshint -W054 + var args = []; + var body = 'return function skip' + this._getConstructorName() + '(t) {\n'; + var values = []; + var i, l; + for (i = 0, l = this.fields.length; i < l; i++) { + args.push('t' + i); + values.push(this.fields[i].type); + body += ' t' + i + '._skip(t);\n'; + } + body += '}'; + return new Function(args.join(), body).apply(undefined, values); +}; + +RecordType.prototype._createWriter = function () { + // jshint -W054 + // We still do default handling here, in case a normal JS object is passed. + var args = []; + var name = this._getConstructorName(); + var body = 'return function write' + name + '(t, v) {\n'; + var values = []; + var i, l, field, value; + for (i = 0, l = this.fields.length; i < l; i++) { + field = this.fields[i]; + args.push('t' + i); + values.push(field.type); + body += ' '; + if (field.defaultValue() === undefined) { + body += 't' + i + '._write(t, v.' + field.name + ');\n'; + } else { + value = field.type.toBuffer(field.defaultValue()).toString('binary'); + // Convert the default value to a binary string ahead of time. We aren't + // converting it to a buffer to avoid retaining too much memory. If we + // had our own buffer pool, this could be an idea in the future. + args.push('d' + i); + values.push(value); + body += 'var v' + i + ' = v.' + field.name + ';\n'; + body += 'if (v' + i + ' === undefined) {\n'; + body += ' t.writeBinary(d' + i + ', ' + value.length + ');\n'; + body += ' } else {\n t' + i + '._write(t, v' + i + ');\n }\n'; + } + } + body += '}'; + return new Function(args.join(), body).apply(undefined, values); +}; + +RecordType.prototype._update = function (resolver, type, opts) { + // jshint -W054 + if (type.name && !~getAliases(this).indexOf(type.name)) { + throw new Error(f('no alias found for %s', type.name)); + } + + var rFields = this.fields; + var wFields = type.fields; + var wFieldsMap = utils.toMap(wFields, function (f) { return f.name; }); + + var innerArgs = []; // Arguments for reader constructor. + var resolvers = {}; // Resolvers keyed by writer field name. + var i, j, field, name, names, matches, fieldResolver; + for (i = 0; i < rFields.length; i++) { + field = rFields[i]; + names = getAliases(field); + matches = []; + for (j = 0; j < names.length; j++) { + name = names[j]; + if (wFieldsMap[name]) { + matches.push(name); + } + } + if (matches.length > 1) { + throw new Error( + f('ambiguous aliasing for %s.%s (%s)', type.name, field.name, matches) + ); + } + if (!matches.length) { + if (field.defaultValue() === undefined) { + throw new Error( + f('no matching field for default-less %s.%s', type.name, field.name) + ); + } + innerArgs.push('undefined'); + } else { + name = matches[0]; + fieldResolver = { + resolver: field.type.createResolver(wFieldsMap[name].type, opts), + name: field.name, // Reader field name. + }; + if (!resolvers[name]) { + resolvers[name] = [fieldResolver]; + } else { + resolvers[name].push(fieldResolver); + } + innerArgs.push(field.name); + } + } + + // See if we can add a bypass for unused fields at the end of the record. + var lazyIndex = -1; + i = wFields.length; + while (i && resolvers[wFields[--i].name] === undefined) { + lazyIndex = i; + } + + var uname = this._getConstructorName(); + var args = [uname]; + var values = [this.recordConstructor]; + var body = ' return function read' + uname + '(t, b) {\n'; + for (i = 0; i < wFields.length; i++) { + if (i === lazyIndex) { + body += ' if (!b) {\n'; + } + field = type.fields[i]; + name = field.name; + if (resolvers[name] === undefined) { + body += (~lazyIndex && i >= lazyIndex) ? ' ' : ' '; + args.push('r' + i); + values.push(field.type); + body += 'r' + i + '._skip(t);\n'; + } else { + j = resolvers[name].length; + while (j--) { + body += (~lazyIndex && i >= lazyIndex) ? ' ' : ' '; + args.push('r' + i + 'f' + j); + fieldResolver = resolvers[name][j]; + values.push(fieldResolver.resolver); + body += 'var ' + fieldResolver.name + ' = '; + body += 'r' + i + 'f' + j + '._' + (j ? 'peek' : 'read') + '(t);\n'; + } + } + } + if (~lazyIndex) { + body += ' }\n'; + } + body += ' return new ' + uname + '(' + innerArgs.join() + ');\n};'; + + resolver._read = new Function(args.join(), body).apply(undefined, values); +}; + +RecordType.prototype._match = function (tap1, tap2) { + var fields = this.fields; + var i, l, field, order, type; + for (i = 0, l = fields.length; i < l; i++) { + field = fields[i]; + order = field._order; + type = field.type; + if (order) { + order *= type._match(tap1, tap2); + if (order) { + return order; + } + } else { + type._skip(tap1); + type._skip(tap2); + } + } + return 0; +}; + +RecordType.prototype._checkFields = function (obj) { + var keys = Object.keys(obj); + var i, l; + for (i = 0, l = keys.length; i < l; i++) { + if (!this._fieldsByName[keys[i]]) { + return false; + } + } + return true; +}; + +RecordType.prototype._copy = function (val, opts) { + // jshint -W058 + var hook = opts && opts.fieldHook; + var values = [undefined]; + var i, l, field, value; + for (i = 0, l = this.fields.length; i < l; i++) { + field = this.fields[i]; + value = val[field.name]; + if (value === undefined && field.hasOwnProperty('defaultValue')) { + value = field.defaultValue(); + } else if ((opts && !opts.skip) || value !== undefined) { + value = field.type._copy(value, opts); + } + if (hook) { + value = hook(field, value, this); + } + values.push(value); + } + var Record = this.recordConstructor; + return new (Record.bind.apply(Record, values))(); +}; + +RecordType.prototype._deref = function (schema, opts) { + schema.fields = this.fields.map(function (field) { + var fieldType = field.type; + var fieldSchema = { + name: field.name, + type: fieldType._attrs(opts) + }; + if (opts.exportAttrs) { + var val = field.defaultValue(); + if (val !== undefined) { + // We must both unwrap all unions and coerce buffers to strings. + fieldSchema['default'] = fieldType._copy(val, {coerce: 3, wrap: 3}); + } + var fieldOrder = field.order; + if (fieldOrder !== 'ascending') { + fieldSchema.order = fieldOrder; + } + var fieldAliases = field.aliases; + if (fieldAliases.length) { + fieldSchema.aliases = fieldAliases; + } + var fieldDoc = field.doc; + if (fieldDoc !== undefined) { + fieldSchema.doc = fieldDoc; + } + } + return fieldSchema; + }); +}; + +RecordType.prototype.compare = function (val1, val2) { + var fields = this.fields; + var i, l, field, name, order, type; + for (i = 0, l = fields.length; i < l; i++) { + field = fields[i]; + name = field.name; + order = field._order; + type = field.type; + if (order) { + order *= type.compare(val1[name], val2[name]); + if (order) { + return order; + } + } + } + return 0; +}; + +RecordType.prototype.random = function () { + // jshint -W058 + var fields = this.fields.map(function (f) { return f.type.random(); }); + fields.unshift(undefined); + var Record = this.recordConstructor; + return new (Record.bind.apply(Record, fields))(); +}; + +RecordType.prototype.field = function (name) { + return this._fieldsByName[name]; +}; + +RecordType.prototype.getField = RecordType.prototype.field; + +RecordType.prototype.getFields = function () { return this.fields; }; + +RecordType.prototype.getRecordConstructor = function () { + return this.recordConstructor; +}; + +Object.defineProperty(RecordType.prototype, 'typeName', { + enumerable: true, + get: function () { return this._isError ? 'error' : 'record'; } +}); + +/** Derived type abstract class. */ +function LogicalType(schema, opts) { + this._logicalTypeName = schema.logicalType; + Type.call(this); + LOGICAL_TYPE = this; + this.underlyingType = Type.forSchema(schema, opts); + // We create a separate branch constructor for logical types to keep them + // monomorphic. + if (Type.isType(this.underlyingType, 'union')) { + this._branchConstructor = this.underlyingType._branchConstructor; + } else { + this._branchConstructor = this.underlyingType._createBranchConstructor(); + } + // We don't freeze derived types to allow arbitrary properties. Implementors + // can still do so in the subclass' constructor at their convenience. +} +util.inherits(LogicalType, Type); + +Object.defineProperty(LogicalType.prototype, 'typeName', { + enumerable: true, + get: function () { return 'logical:' + this._logicalTypeName; } +}); + +LogicalType.prototype.getUnderlyingType = function () { + return this.underlyingType; +}; + +LogicalType.prototype._read = function (tap) { + return this._fromValue(this.underlyingType._read(tap)); +}; + +LogicalType.prototype._write = function (tap, any) { + this.underlyingType._write(tap, this._toValue(any)); +}; + +LogicalType.prototype._check = function (any, flags, hook, path) { + try { + var val = this._toValue(any); + } catch (err) { + // Handled below. + } + if (val === undefined) { + if (hook) { + hook(any, this); + } + return false; + } + return this.underlyingType._check(val, flags, hook, path); +}; + +LogicalType.prototype._copy = function (any, opts) { + var type = this.underlyingType; + switch (opts && opts.coerce) { + case 3: // To string. + return type._copy(this._toValue(any), opts); + case 2: // From string. + return this._fromValue(type._copy(any, opts)); + default: // Normal copy. + return this._fromValue(type._copy(this._toValue(any), opts)); + } +}; + +LogicalType.prototype._update = function (resolver, type, opts) { + var _fromValue = this._resolve(type, opts); + if (_fromValue) { + resolver._read = function (tap) { return _fromValue(type._read(tap)); }; + } +}; + +LogicalType.prototype.compare = function (obj1, obj2) { + var val1 = this._toValue(obj1); + var val2 = this._toValue(obj2); + return this.underlyingType.compare(val1, val2); +}; + +LogicalType.prototype.random = function () { + return this._fromValue(this.underlyingType.random()); +}; + +LogicalType.prototype._deref = function (schema, opts) { + var type = this.underlyingType; + var isVisited = type.name !== undefined && opts.derefed[type.name]; + schema = type._attrs(opts); + if (!isVisited && opts.exportAttrs) { + if (typeof schema == 'string') { + schema = {type: schema}; + } + schema.logicalType = this._logicalTypeName; + this._export(schema); + } + return schema; +}; + +// Unlike the other methods below, `_export` has a reasonable default which we +// can provide (not exporting anything). +LogicalType.prototype._export = function (/* schema */) {}; + +// Methods to be implemented. +LogicalType.prototype._fromValue = utils.abstractFunction; +LogicalType.prototype._toValue = utils.abstractFunction; +LogicalType.prototype._resolve = utils.abstractFunction; + + +// General helpers. + +/** + * Customizable long. + * + * This allows support of arbitrarily large long (e.g. larger than + * `Number.MAX_SAFE_INTEGER`). See `LongType.__with` method above. Note that we + * can't use a logical type because we need a "lower-level" hook here: passing + * through through the standard long would cause a loss of precision. + */ +function AbstractLongType(noUnpack) { + PrimitiveType.call(this, true); + // Note that this type "inherits" `LongType` (i.e. gain its prototype + // methods) but only "subclasses" `PrimitiveType` to avoid being prematurely + // frozen. + this._noUnpack = !!noUnpack; +} +util.inherits(AbstractLongType, LongType); + +AbstractLongType.prototype._check = function (val, flags, hook) { + var b = this._isValid(val); + if (!b && hook) { + hook(val, this); + } + return b; +}; + +AbstractLongType.prototype._read = function (tap) { + var buf, pos; + if (this._noUnpack) { + pos = tap.pos; + tap.skipLong(); + buf = tap.buf.slice(pos, tap.pos); + } else { + buf = tap.unpackLongBytes(tap); + } + if (tap.isValid()) { + return this._fromBuffer(buf); + } +}; + +AbstractLongType.prototype._write = function (tap, val) { + if (!this._isValid(val)) { + throwInvalidError(val, this); + } + var buf = this._toBuffer(val); + if (this._noUnpack) { + tap.writeFixed(buf); + } else { + tap.packLongBytes(buf); + } +}; + +AbstractLongType.prototype._copy = function (val, opts) { + switch (opts && opts.coerce) { + case 3: // To string. + return this._toJSON(val); + case 2: // From string. + return this._fromJSON(val); + default: // Normal copy. + // Slow but guarantees most consistent results. Faster alternatives + // would + // require assumptions on the long class used (e.g. immutability). + return this._fromJSON(JSON.parse(JSON.stringify(this._toJSON(val)))); + } +}; + +AbstractLongType.prototype.random = function () { + return this._fromJSON(LongType.prototype.random()); +}; + +// Methods to be implemented by the user. +AbstractLongType.prototype._fromBuffer = utils.abstractFunction; +AbstractLongType.prototype._toBuffer = utils.abstractFunction; +AbstractLongType.prototype._fromJSON = utils.abstractFunction; +AbstractLongType.prototype._toJSON = utils.abstractFunction; +AbstractLongType.prototype._isValid = utils.abstractFunction; +AbstractLongType.prototype.compare = utils.abstractFunction; + +/** A record field. */ +function Field(schema, opts) { + var name = schema.name; + if (typeof name != 'string' || !isValidName(name)) { + throw new Error(f('invalid field name: %s', name)); + } + + this.name = name; + this.type = Type.forSchema(schema.type, opts); + this.aliases = schema.aliases || []; + this.doc = schema.doc !== undefined ? '' + schema.doc : undefined; + + this._order = (function (order) { + switch (order) { + case 'ascending': + return 1; + case 'descending': + return -1; + case 'ignore': + return 0; + default: + throw new Error(f('invalid order: %j', order)); + } + })(schema.order === undefined ? 'ascending' : schema.order); + + var value = schema['default']; + if (value !== undefined) { + // We need to convert defaults back to a valid format (unions are + // disallowed in default definitions, only the first type of each union is + // allowed instead). + // http://apache-avro.679487.n3.nabble.com/field-union-default-in-Java-td1175327.html + var type = this.type; + var val = type._copy(value, {coerce: 2, wrap: 2}); + // The clone call above will throw an error if the default is invalid. + if (isPrimitive(type.typeName) && type.typeName !== 'bytes') { + // These are immutable. + this.defaultValue = function () { return val; }; + } else { + this.defaultValue = function () { return type._copy(val); }; + } + } + + Object.freeze(this); +} + +Field.prototype.defaultValue = function () {}; // Undefined default. + +Object.defineProperty(Field.prototype, 'order', { + enumerable: true, + get: function () { + return ['descending', 'ignore', 'ascending'][this._order + 1]; + } +}); + +Field.prototype.getAliases = function () { return this.aliases; }; + +Field.prototype.getDefault = Field.prototype.defaultValue; + +Field.prototype.getName = function () { return this.name; }; + +Field.prototype.getOrder = function () { return this.order; }; + +Field.prototype.getType = function () { return this.type; }; + +/** + * Resolver to read a writer's schema as a new schema. + * + * @param readerType + * {Type} The type to convert to. + */ +function Resolver(readerType) { + // Add all fields here so that all resolvers share the same hidden class. + this._readerType = readerType; + this._read = null; + this.itemsType = null; + this.size = 0; + this.symbols = null; + this.valuesType = null; +} + +Resolver.prototype._peek = Type.prototype._peek; + +Resolver.prototype.inspect = function () { return '<Resolver>'; }; + +/** Mutable hash container. */ +function Hash() { + this.str = undefined; +} + +/** + * Read a value from a tap. + * + * @param type + * {Type} The type to decode. + * @param tap + * {Tap} The tap to read from. No checks are performed here. + * @param resolver + * {Resolver} Optional resolver. It must match the input type. + * @param lazy + * {Boolean} Skip trailing fields when using a resolver. + */ +function readValue(type, tap, resolver, lazy) { + if (resolver) { + if (resolver._readerType !== type) { + throw new Error('invalid resolver'); + } + return resolver._read(tap, lazy); + } else { + return type._read(tap); + } +} + +/** + * Remove namespace from a name. + * + * @param name + * {String} Full or short name. + */ +function unqualify(name) { + var parts = name.split('.'); + return parts[parts.length - 1]; +} + +/** + * Verify and return fully qualified name. + * + * @param name + * {String} Full or short name. It can be prefixed with a dot to + * force global namespace. + * @param namespace + * {String} Optional namespace. + */ +function qualify(name, namespace) { + if (~name.indexOf('.')) { + name = name.replace(/^\./, ''); // Allow absolute referencing. + } else if (namespace) { + name = namespace + '.' + name; + } + name.split('.').forEach(function (part) { + if (!isValidName(part)) { + throw new Error(f('invalid name: %j', name)); + } + }); + var tail = unqualify(name); + // Primitives are always in the global namespace. + return isPrimitive(tail) ? tail : name; +} + +/** + * Get all aliases for a type (including its name). + * + * @param obj + * {Type|Object} Typically a type or a field. Its aliases property + * must exist and be an array. + */ +function getAliases(obj) { + var names = {}; + if (obj.name) { + names[obj.name] = true; + } + var aliases = obj.aliases; + var i, l; + for (i = 0, l = aliases.length; i < l; i++) { + names[aliases[i]] = true; + } + return Object.keys(names); +} + +/** + * Check whether a type's name is a primitive. + * + * @param name + * {String} Type name (e.g. `'string'`, `'array'`). + */ +function isPrimitive(typeName) { + // Since we use this module's own `TYPES` object, we can use `instanceof`. + var type = TYPES[typeName]; + return type && type.prototype instanceof PrimitiveType; +} + +/** + * Return a type's class name from its Avro type name. + * + * We can't simply use `constructor.name` since it isn't supported in all + * browsers. + * + * @param typeName + * {String} Type name. + */ +function getClassName(typeName) { + if (typeName === 'error') { + typeName = 'record'; + } else { + var match = /^([^:]+):(.*)$/.exec(typeName); + if (match) { + if (match[1] === 'union') { + typeName = match[2] + 'Union'; + } else { + // Logical type. + typeName = match[1]; + } + } + } + return utils.capitalize(typeName) + 'Type'; +} + +/** + * Get the number of elements in an array block. + * + * @param tap + * {Tap} A tap positioned at the beginning of an array block. + */ +function readArraySize(tap) { + var n = tap.readLong(); + if (n < 0) { + n = -n; + tap.skipLong(); // Skip size. + } + return n; +} + +/** + * Check whether a long can be represented without precision loss. + * + * @param n + * {Number} The number. + * + * Two things to note: + * + We are not using the `Number` constants for compatibility with older + * browsers. + We must remove one from each bound because of rounding errors. + */ +function isSafeLong(n) { + return n >= -9007199254740990 && n <= 9007199254740990; +} + +/** + * Check whether an object is the JSON representation of a buffer. + */ +function isJsonBuffer(obj) { + return obj && obj.type === 'Buffer' && Array.isArray(obj.data); +} + +/** + * Check whether a string is a valid Avro identifier. + */ +function isValidName(str) { return NAME_PATTERN.test(str); } + +/** + * Throw a somewhat helpful error on invalid object. + * + * @param path + * {Array} Passed from hook, but unused (because empty where this + * function is used, since we aren't keeping track of it for + * effiency). + * @param val + * {...} The object to reject. + * @param type + * {Type} The type to check against. + * + * This method is mostly used from `_write` to signal an invalid object for a + * given type. Note that this provides less information than calling `isValid` + * with a hook since the path is not propagated (for efficiency reasons). + */ +function throwInvalidError(val, type) { + throw new Error(f('invalid %s: %j', type, val)); +} + +/** + * Get a type's bucket when included inside an unwrapped union. + * + * @param type + * {Type} Any type. + */ +function getTypeBucket(type) { + var typeName = type.typeName; + switch (typeName) { + case 'double': + case 'float': + case 'int': + case 'long': + return 'number'; + case 'bytes': + case 'fixed': + return 'buffer'; + case 'enum': + return 'string'; + case 'map': + case 'error': + case 'record': + return 'object'; + default: + return typeName; + } +} + +/** + * Infer a value's bucket (see unwrapped unions for more details). + * + * @param val + * {...} Any value. + */ +function getValueBucket(val) { + if (val === null) { + return 'null'; + } + var bucket = typeof val; + if (bucket === 'object') { + // Could be bytes, fixed, array, map, or record. + if (Array.isArray(val)) { + return 'array'; + } else if (Buffer.isBuffer(val)) { + return 'buffer'; + } + } + return bucket; +} + +/** + * Check whether a collection of types leads to an ambiguous union. + * + * @param types + * {Array} Array of types. + */ +function isAmbiguous(types) { + var buckets = {}; + var i, l, bucket, type; + for (i = 0, l = types.length; i < l; i++) { + type = types[i]; + if (!Type.isType(type, 'logical')) { + bucket = getTypeBucket(type); + if (buckets[bucket]) { + return true; + } + buckets[bucket] = true; + } + } + return false; +} + +/** + * Combine number types. + * + * Note that never have to create a new type here, we are guaranteed to be able + * to reuse one of the input types as super-type. + */ +function combineNumbers(types) { + var typeNames = ['int', 'long', 'float', 'double']; + var superIndex = -1; + var superType = null; + var i, l, type, index; + for (i = 0, l = types.length; i < l; i++) { + type = types[i]; + index = typeNames.indexOf(type.typeName); + if (index > superIndex) { + superIndex = index; + superType = type; + } + } + return superType; +} + +/** + * Combine enums and strings. + * + * The order of the returned symbols is undefined and the returned enum is + * + */ +function combineStrings(types, opts) { + var symbols = {}; + var i, l, type, typeSymbols; + for (i = 0, l = types.length; i < l; i++) { + type = types[i]; + if (type.typeName === 'string') { + // If at least one of the types is a string, it will be the supertype. + return type; + } + typeSymbols = type.symbols; + var j, m; + for (j = 0, m = typeSymbols.length; j < m; j++) { + symbols[typeSymbols[j]] = true; + } + } + return Type.forSchema({type: 'enum', symbols: Object.keys(symbols)}, opts); +} + +/** + * Combine bytes and fixed. + * + * This function is optimized to avoid creating new types when possible: in case + * of a size mismatch between fixed types, it will continue looking through the + * array to find an existing bytes type (rather than exit early by creating one + * eagerly). + */ +function combineBuffers(types, opts) { + var size = -1; + var i, l, type; + for (i = 0, l = types.length; i < l; i++) { + type = types[i]; + if (type.typeName === 'bytes') { + return type; + } + if (size === -1) { + size = type.size; + } else if (type.size !== size) { + // Don't create a bytes type right away, we might be able to reuse one + // later on in the types array. Just mark this for now. + size = -2; + } + } + return size < 0 ? Type.forSchema('bytes', opts) : types[0]; +} + +/** + * Combine maps and records. + * + * Field defaults are kept when possible (i.e. when no coercion to a map + * happens), with later definitions overriding previous ones. + */ +function combineObjects(types, opts) { + var allTypes = []; // Field and value types. + var fieldTypes = {}; // Record field types grouped by field name. + var fieldDefaults = {}; + var isValidRecord = true; + + // Check whether the final type will be a map or a record. + var i, l, type, fields; + for (i = 0, l = types.length; i < l; i++) { + type = types[i]; + if (type.typeName === 'map') { + isValidRecord = false; + allTypes.push(type.valuesType); + } else { + fields = type.fields; + var j, m, field, fieldDefault, fieldName, fieldType; + for (j = 0, m = fields.length; j < m; j++) { + field = fields[j]; + fieldName = field.name; + fieldType = field.type; + allTypes.push(fieldType); + if (isValidRecord) { + if (!fieldTypes[fieldName]) { + fieldTypes[fieldName] = []; + } + fieldTypes[fieldName].push(fieldType); + fieldDefault = field.defaultValue(); + if (fieldDefault !== undefined) { + // Later defaults will override any previous ones. + fieldDefaults[fieldName] = fieldDefault; + } + } + } + } + } + + if (isValidRecord) { + // Check that no fields are missing and that we have the approriate + // defaults for those which are. + var fieldNames = Object.keys(fieldTypes); + for (i = 0, l = fieldNames.length; i < l; i++) { + fieldName = fieldNames[i]; + if ( + fieldTypes[fieldName].length < types.length && + fieldDefaults[fieldName] === undefined + ) { + // At least one of the records is missing a field with no default. + if (opts && opts.strictDefaults) { + isValidRecord = false; + } else { + fieldTypes[fieldName].unshift(Type.forSchema('null', opts)); + fieldDefaults[fieldName] = null; + } + } + } + } + + var schema; + if (isValidRecord) { + schema = { + type: 'record', + fields: fieldNames.map(function (s) { + var fieldType = Type.forTypes(fieldTypes[s], opts); + var fieldDefault = fieldDefaults[s]; + if ( + fieldDefault !== undefined && + ~fieldType.typeName.indexOf('union') + ) { + // Ensure that the default's corresponding type is first. + var unionTypes = fieldType.types.slice(); + var i, l; + for (i = 0, l = unionTypes.length; i < l; i++) { + if (unionTypes[i].isValid(fieldDefault)) { + break; + } + } + if (i > 0) { + var unionType = unionTypes[0]; + unionTypes[0] = unionTypes[i]; + unionTypes[i] = unionType; + fieldType = Type.forSchema(unionTypes, opts); + } + } + return { + name: s, + type: fieldType, + 'default': fieldDefaults[s] + }; + }) + }; + } else { + schema = { + type: 'map', + values: Type.forTypes(allTypes, opts) + }; + } + return Type.forSchema(schema, opts); +} + + +module.exports = { + Type: Type, + getTypeBucket: getTypeBucket, + getValueBucket: getValueBucket, + isPrimitive: isPrimitive, + isValidName: isValidName, + qualify: qualify, + builtins: (function () { + var types = { + LogicalType: LogicalType, + UnwrappedUnionType: UnwrappedUnionType, + WrappedUnionType: WrappedUnionType + }; + var typeNames = Object.keys(TYPES); + var i, l, typeName; + for (i = 0, l = typeNames.length; i < l; i++) { + typeName = typeNames[i]; + types[getClassName(typeName)] = TYPES[typeName]; + } + return types; + })() +}; + +}).call(this,require("buffer").Buffer) +},{"./utils":56,"buffer":16,"util":47}],56:[function(require,module,exports){ +(function (Buffer){ +/* jshint node: true */ + +// TODO: Make long comparison impervious to precision loss. +// TODO: Optimize binary comparison methods. + +'use strict'; + +/** Various utilities used across this library. */ + +var crypto = require('crypto'); +var util = require('util'); + +// Shared buffer pool for all taps. +var POOL = new BufferPool(4096); + + +/** + * Uppercase the first letter of a string. + * + * @param s + * {String} The string. + */ +function capitalize(s) { return s.charAt(0).toUpperCase() + s.slice(1); } + +/** + * Compare two numbers. + * + * @param n1 + * {Number} The first one. + * @param n2 + * {Number} The second one. + */ +function compare(n1, n2) { return n1 === n2 ? 0 : (n1 < n2 ? -1 : 1); } + +/** + * Get option or default if undefined. + * + * @param opts + * {Object} Options. + * @param key + * {String} Name of the option. + * @param def + * {...} Default value. + * + * This is useful mostly for true-ish defaults and false-ish values (where the + * usual `||` idiom breaks down). + */ +function getOption(opts, key, def) { + var value = opts[key]; + return value === undefined ? def : value; +} + +/** + * Compute a string's hash. + * + * @param str + * {String} The string to hash. + * @param algorithm + * {String} The algorithm used. Defaults to MD5. + */ +function getHash(str, algorithm) { + algorithm = algorithm || 'md5'; + var hash = crypto.createHash(algorithm); + hash.end(str); + return hash.read(); +} + +/** + * Find index of value in array. + * + * @param arr + * {Array} Can also be a false-ish value. + * @param v + * {Object} Value to find. + * + * Returns -1 if not found, -2 if found multiple times. + */ +function singleIndexOf(arr, v) { + var pos = -1; + var i, l; + if (!arr) { + return -1; + } + for (i = 0, l = arr.length; i < l; i++) { + if (arr[i] === v) { + if (pos >= 0) { + return -2; + } + pos = i; + } + } + return pos; +} + +/** + * Convert array to map. + * + * @param arr + * {Array} Elements. + * @param fn + * {Function} Function returning an element's key. + */ +function toMap(arr, fn) { + var obj = {}; + var i, elem; + for (i = 0; i < arr.length; i++) { + elem = arr[i]; + obj[fn(elem)] = elem; + } + return obj; +} + +/** + * Convert map to array of values (polyfill for `Object.values`). + * + * @param obj + * {Object} Map. + */ +function objectValues(obj) { + return Object.keys(obj).map(function (key) { return obj[key]; }); +} + +/** + * Check whether an array has duplicates. + * + * @param arr + * {Array} The array. + * @param fn + * {Function} Optional function to apply to each element. + */ +function hasDuplicates(arr, fn) { + var obj = {}; + var i, l, elem; + for (i = 0, l = arr.length; i < l; i++) { + elem = arr[i]; + if (fn) { + elem = fn(elem); + } + if (obj[elem]) { + return true; + } + obj[elem] = true; + } + return false; +} + +/** + * Copy properties from one object to another. + * + * @param src + * {Object} The source object. + * @param dst + * {Object} The destination object. + * @param overwrite + * {Boolean} Whether to overwrite existing destination properties. + * Defaults to false. + */ +function copyOwnProperties(src, dst, overwrite) { + var names = Object.getOwnPropertyNames(src); + var i, l, name; + for (i = 0, l = names.length; i < l; i++) { + name = names[i]; + if (!dst.hasOwnProperty(name) || overwrite) { + var descriptor = Object.getOwnPropertyDescriptor(src, name); + Object.defineProperty(dst, name, descriptor); + } + } + return dst; +} + +/** + * Returns offset in the string of the end of JSON object (-1 if past the end). + * + * To keep the implementation simple, this function isn't a JSON validator. It + * will gladly return a result for invalid JSON (which is OK since that will be + * promptly rejected by the JSON parser). What matters is that it is guaranteed + * to return the correct end when presented with valid JSON. + * + * @param str + * {String} Input string containing serialized JSON.. + * @param pos + * {Number} Starting position. + */ +function jsonEnd(str, pos) { + pos = pos | 0; + + // Handle the case of a simple literal separately. + var c = str.charAt(pos++); + if (/[\d-]/.test(c)) { + while (/[eE\d.+-]/.test(str.charAt(pos))) { + pos++; + } + return pos; + } else if (/true|null/.test(str.slice(pos - 1, pos + 3))) { + return pos + 3; + } else if (/false/.test(str.slice(pos - 1, pos + 4))) { + return pos + 4; + } + + // String, object, or array. + var depth = 0; + var literal = false; + do { + switch (c) { + case '{': + case '[': + if (!literal) { depth++; } + break; + case '}': + case ']': + if (!literal && !--depth) { + return pos; + } + break; + case '"': + literal = !literal; + if (!depth && !literal) { + return pos; + } + break; + case '\\': + pos++; // Skip the next character. + } + } while ((c = str.charAt(pos++))); + + return -1; +} + +/** "Abstract" function to help with "subclassing". */ +function abstractFunction() { throw new Error('abstract'); } + +/** Batch-deprecate "getters" from an object's prototype. */ +function addDeprecatedGetters(obj, props) { + var proto = obj.prototype; + var i, l, prop, getter; + for (i = 0, l = props.length; i < l; i++) { + prop = props[i]; + getter = 'get' + capitalize(prop); + proto[getter] = util.deprecate( + createGetter(prop), + 'use `.' + prop + '` instead of `.' + getter + '()`' + ); + } + + function createGetter(prop) { + return function () { + var delegate = this[prop]; + return typeof delegate == 'function' ? + delegate.apply(this, arguments) : + delegate; + }; + } +} + +/** + * Simple buffer pool to avoid allocating many small buffers. + * + * This provides significant speedups in recent versions of node (6+). + */ +function BufferPool(len) { + this._len = len | 0; + this._pos = 0; + this._slab = new Buffer(this._len); +} + +BufferPool.prototype.alloc = function (len) { + var maxLen = this._len; + if (len > maxLen) { + return new Buffer(len); + } + if (this._pos + len > maxLen) { + this._slab = new Buffer(maxLen); + this._pos = 0; + } + return this._slab.slice(this._pos, this._pos += len); +}; + +/** + * Generator of random things. + * + * Inspired by: http://stackoverflow.com/a/424445/1062617 + */ +function Lcg(seed) { + var a = 1103515245; + var c = 12345; + var m = Math.pow(2, 31); + var state = Math.floor(seed || Math.random() * (m - 1)); + + this._max = m; + this._nextInt = function () { return state = (a * state + c) % m; }; +} + +Lcg.prototype.nextBoolean = function () { + // jshint -W018 + return !!(this._nextInt() % 2); +}; + +Lcg.prototype.nextInt = function (start, end) { + if (end === undefined) { + end = start; + start = 0; + } + end = end === undefined ? this._max : end; + return start + Math.floor(this.nextFloat() * (end - start)); +}; + +Lcg.prototype.nextFloat = function (start, end) { + if (end === undefined) { + end = start; + start = 0; + } + end = end === undefined ? 1 : end; + return start + (end - start) * this._nextInt() / this._max; +}; + +Lcg.prototype.nextString = function(len, flags) { + len |= 0; + flags = flags || 'aA'; + var mask = ''; + if (flags.indexOf('a') > -1) { + mask += 'abcdefghijklmnopqrstuvwxyz'; + } + if (flags.indexOf('A') > -1) { + mask += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; + } + if (flags.indexOf('#') > -1) { + mask += '0123456789'; + } + if (flags.indexOf('!') > -1) { + mask += '~`!@#$%^&*()_+-={}[]:";\'<>?,./|\\'; + } + var result = []; + for (var i = 0; i < len; i++) { + result.push(this.choice(mask)); + } + return result.join(''); +}; + +Lcg.prototype.nextBuffer = function (len) { + var arr = []; + var i; + for (i = 0; i < len; i++) { + arr.push(this.nextInt(256)); + } + return new Buffer(arr); +}; + +Lcg.prototype.choice = function (arr) { + var len = arr.length; + if (!len) { + throw new Error('choosing from empty array'); + } + return arr[this.nextInt(len)]; +}; + +/** + * Ordered queue which returns items consecutively. + * + * This is actually a heap by index, with the added requirements that elements + * can only be retrieved consecutively. + */ +function OrderedQueue() { + this._index = 0; + this._items = []; +} + +OrderedQueue.prototype.push = function (item) { + var items = this._items; + var i = items.length | 0; + var j; + items.push(item); + while (i > 0 && items[i].index < items[j = ((i - 1) >> 1)].index) { + item = items[i]; + items[i] = items[j]; + items[j] = item; + i = j; + } +}; + +OrderedQueue.prototype.pop = function () { + var items = this._items; + var len = (items.length - 1) | 0; + var first = items[0]; + if (!first || first.index > this._index) { + return null; + } + this._index++; + if (!len) { + items.pop(); + return first; + } + items[0] = items.pop(); + var mid = len >> 1; + var i = 0; + var i1, i2, j, item, c, c1, c2; + while (i < mid) { + item = items[i]; + i1 = (i << 1) + 1; + i2 = (i + 1) << 1; + c1 = items[i1]; + c2 = items[i2]; + if (!c2 || c1.index <= c2.index) { + c = c1; + j = i1; + } else { + c = c2; + j = i2; + } + if (c.index >= item.index) { + break; + } + items[j] = item; + items[i] = c; + i = j; + } + return first; +}; + +/** + * A tap is a buffer which remembers what has been already read. + * + * It is optimized for performance, at the cost of failing silently when + * overflowing the buffer. This is a purposeful trade-off given the expected + * rarity of this case and the large performance hit necessary to enforce + * validity. See `isValid` below for more information. + */ +function Tap(buf, pos) { + this.buf = buf; + this.pos = pos | 0; + if (this.pos < 0) { + throw new Error('negative offset'); + } +} + +/** + * Check that the tap is in a valid state. + * + * For efficiency reasons, none of the methods below will fail if an overflow + * occurs (either read, skip, or write). For this reason, it is up to the caller + * to always check that the read, skip, or write was valid by calling this + * method. + */ +Tap.prototype.isValid = function () { return this.pos <= this.buf.length; }; + +// Read, skip, write methods. +// +// These should fail silently when the buffer overflows. Note this is only +// required to be true when the functions are decoding valid objects. For +// example errors will still be thrown if a bad count is read, leading to a +// negative position offset (which will typically cause a failure in +// `readFixed`). + +Tap.prototype.readBoolean = function () { return !!this.buf[this.pos++]; }; + +Tap.prototype.skipBoolean = function () { this.pos++; }; + +Tap.prototype.writeBoolean = function (b) { this.buf[this.pos++] = !!b; }; + +Tap.prototype.readInt = Tap.prototype.readLong = function () { + var n = 0; + var k = 0; + var buf = this.buf; + var b, h, f, fk; + + do { + b = buf[this.pos++]; + h = b & 0x80; + n |= (b & 0x7f) << k; + k += 7; + } while (h && k < 28); + + if (h) { + // Switch to float arithmetic, otherwise we might overflow. + f = n; + fk = 268435456; // 2 ** 28. + do { + b = buf[this.pos++]; + f += (b & 0x7f) * fk; + fk *= 128; + } while (b & 0x80); + return (f % 2 ? -(f + 1) : f) / 2; + } + + return (n >> 1) ^ -(n & 1); +}; + +Tap.prototype.skipInt = Tap.prototype.skipLong = function () { + var buf = this.buf; + while (buf[this.pos++] & 0x80) {} +}; + +Tap.prototype.writeInt = Tap.prototype.writeLong = function (n) { + var buf = this.buf; + var f, m; + + if (n >= -1073741824 && n < 1073741824) { + // Won't overflow, we can use integer arithmetic. + m = n >= 0 ? n << 1 : (~n << 1) | 1; + do { + buf[this.pos] = m & 0x7f; + m >>= 7; + } while (m && (buf[this.pos++] |= 0x80)); + } else { + // We have to use slower floating arithmetic. + f = n >= 0 ? n * 2 : (-n * 2) - 1; + do { + buf[this.pos] = f & 0x7f; + f /= 128; + } while (f >= 1 && (buf[this.pos++] |= 0x80)); + } + this.pos++; +}; + +Tap.prototype.readFloat = function () { + var buf = this.buf; + var pos = this.pos; + this.pos += 4; + if (this.pos > buf.length) { + return; + } + return this.buf.readFloatLE(pos); +}; + +Tap.prototype.skipFloat = function () { this.pos += 4; }; + +Tap.prototype.writeFloat = function (f) { + var buf = this.buf; + var pos = this.pos; + this.pos += 4; + if (this.pos > buf.length) { + return; + } + return this.buf.writeFloatLE(f, pos); +}; + +Tap.prototype.readDouble = function () { + var buf = this.buf; + var pos = this.pos; + this.pos += 8; + if (this.pos > buf.length) { + return; + } + return this.buf.readDoubleLE(pos); +}; + +Tap.prototype.skipDouble = function () { this.pos += 8; }; + +Tap.prototype.writeDouble = function (d) { + var buf = this.buf; + var pos = this.pos; + this.pos += 8; + if (this.pos > buf.length) { + return; + } + return this.buf.writeDoubleLE(d, pos); +}; + +Tap.prototype.readFixed = function (len) { + var pos = this.pos; + this.pos += len; + if (this.pos > this.buf.length) { + return; + } + var fixed = POOL.alloc(len); + this.buf.copy(fixed, 0, pos, pos + len); + return fixed; +}; + +Tap.prototype.skipFixed = function (len) { this.pos += len; }; + +Tap.prototype.writeFixed = function (buf, len) { + len = len || buf.length; + var pos = this.pos; + this.pos += len; + if (this.pos > this.buf.length) { + return; + } + buf.copy(this.buf, pos, 0, len); +}; + +Tap.prototype.readBytes = function () { + return this.readFixed(this.readLong()); +}; + +Tap.prototype.skipBytes = function () { + var len = this.readLong(); + this.pos += len; +}; + +Tap.prototype.writeBytes = function (buf) { + var len = buf.length; + this.writeLong(len); + this.writeFixed(buf, len); +}; + +/* istanbul ignore else */ +if (typeof Buffer.prototype.utf8Slice == 'function') { + // Use this optimized function when available. + Tap.prototype.readString = function () { + var len = this.readLong(); + var pos = this.pos; + var buf = this.buf; + this.pos += len; + if (this.pos > buf.length) { + return; + } + return this.buf.utf8Slice(pos, pos + len); + }; +} else { + Tap.prototype.readString = function () { + var len = this.readLong(); + var pos = this.pos; + var buf = this.buf; + this.pos += len; + if (this.pos > buf.length) { + return; + } + return this.buf.slice(pos, pos + len).toString(); + }; +} + +Tap.prototype.skipString = function () { + var len = this.readLong(); + this.pos += len; +}; + +Tap.prototype.writeString = function (s) { + var len = Buffer.byteLength(s); + var buf = this.buf; + this.writeLong(len); + var pos = this.pos; + this.pos += len; + if (this.pos > buf.length) { + return; + } + if (len > 64) { + this._writeUtf8(s, len); + } else { + var i, l, c1, c2; + for (i = 0, l = len; i < l; i++) { + c1 = s.charCodeAt(i); + if (c1 < 0x80) { + buf[pos++] = c1; + } else if (c1 < 0x800) { + buf[pos++] = c1 >> 6 | 0xc0; + buf[pos++] = c1 & 0x3f | 0x80; + } else if ( + (c1 & 0xfc00) === 0xd800 && + ((c2 = s.charCodeAt(i + 1)) & 0xfc00) === 0xdc00 + ) { + c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff); + i++; + buf[pos++] = c1 >> 18 | 0xf0; + buf[pos++] = c1 >> 12 & 0x3f | 0x80; + buf[pos++] = c1 >> 6 & 0x3f | 0x80; + buf[pos++] = c1 & 0x3f | 0x80; + } else { + buf[pos++] = c1 >> 12 | 0xe0; + buf[pos++] = c1 >> 6 & 0x3f | 0x80; + buf[pos++] = c1 & 0x3f | 0x80; + } + } + } +}; + +/* istanbul ignore else */ +if (typeof Buffer.prototype.utf8Write == 'function') { + Tap.prototype._writeUtf8 = function (str, len) { + this.buf.utf8Write(str, this.pos - len, len); + }; +} else { + // `utf8Write` isn't available in the browser. + Tap.prototype._writeUtf8 = function (str, len) { + this.buf.write(str, this.pos - len, len, 'utf8'); + }; +} + +/* istanbul ignore else */ +if (typeof Buffer.prototype.latin1Write == 'function') { + // `binaryWrite` has been renamed to `latin1Write` in Node v6.4.0, see + // https://github.com/nodejs/node/pull/7111. Note that the `'binary'` + // encoding argument still works however. + Tap.prototype.writeBinary = function (str, len) { + var pos = this.pos; + this.pos += len; + if (this.pos > this.buf.length) { + return; + } + this.buf.latin1Write(str, pos, len); + }; +} else if (typeof Buffer.prototype.binaryWrite == 'function') { + Tap.prototype.writeBinary = function (str, len) { + var pos = this.pos; + this.pos += len; + if (this.pos > this.buf.length) { + return; + } + this.buf.binaryWrite(str, pos, len); + }; +} else { + // Slowest implementation. + Tap.prototype.writeBinary = function (s, len) { + var pos = this.pos; + this.pos += len; + if (this.pos > this.buf.length) { + return; + } + this.buf.write(s, pos, len, 'binary'); + }; +} + +// Binary comparison methods. +// +// These are not guaranteed to consume the objects they are comparing when +// returning a non-zero result (allowing for performance benefits), so no other +// operations should be done on either tap after a compare returns a non-zero +// value. Also, these methods do not have the same silent failure requirement +// as read, skip, and write since they are assumed to be called on valid +// buffers. + +Tap.prototype.matchBoolean = function (tap) { + return this.buf[this.pos++] - tap.buf[tap.pos++]; +}; + +Tap.prototype.matchInt = Tap.prototype.matchLong = function (tap) { + var n1 = this.readLong(); + var n2 = tap.readLong(); + return n1 === n2 ? 0 : (n1 < n2 ? -1 : 1); +}; + +Tap.prototype.matchFloat = function (tap) { + var n1 = this.readFloat(); + var n2 = tap.readFloat(); + return n1 === n2 ? 0 : (n1 < n2 ? -1 : 1); +}; + +Tap.prototype.matchDouble = function (tap) { + var n1 = this.readDouble(); + var n2 = tap.readDouble(); + return n1 === n2 ? 0 : (n1 < n2 ? -1 : 1); +}; + +Tap.prototype.matchFixed = function (tap, len) { + return this.readFixed(len).compare(tap.readFixed(len)); +}; + +Tap.prototype.matchBytes = Tap.prototype.matchString = function (tap) { + var l1 = this.readLong(); + var p1 = this.pos; + this.pos += l1; + var l2 = tap.readLong(); + var p2 = tap.pos; + tap.pos += l2; + var b1 = this.buf.slice(p1, this.pos); + var b2 = tap.buf.slice(p2, tap.pos); + return b1.compare(b2); +}; + +// Functions for supporting custom long classes. +// +// The two following methods allow the long implementations to not have to +// worry about Avro's zigzag encoding, we directly expose longs as unpacked. + +Tap.prototype.unpackLongBytes = function () { + var res = new Buffer(8); + var n = 0; + var i = 0; // Byte index in target buffer. + var j = 6; // Bit offset in current target buffer byte. + var buf = this.buf; + var b, neg; + + b = buf[this.pos++]; + neg = b & 1; + res.fill(0); + + n |= (b & 0x7f) >> 1; + while (b & 0x80) { + b = buf[this.pos++]; + n |= (b & 0x7f) << j; + j += 7; + if (j >= 8) { + // Flush byte. + j -= 8; + res[i++] = n; + n >>= 8; + } + } + res[i] = n; + + if (neg) { + invert(res, 8); + } + + return res; +}; + +Tap.prototype.packLongBytes = function (buf) { + var neg = (buf[7] & 0x80) >> 7; + var res = this.buf; + var j = 1; + var k = 0; + var m = 3; + var n; + + if (neg) { + invert(buf, 8); + n = 1; + } else { + n = 0; + } + + var parts = [ + buf.readUIntLE(0, 3), + buf.readUIntLE(3, 3), + buf.readUIntLE(6, 2) + ]; + // Not reading more than 24 bits because we need to be able to combine the + // "carry" bits from the previous part and JavaScript only supports bitwise + // operations on 32 bit integers. + while (m && !parts[--m]) {} // Skip trailing 0s. + + // Leading parts (if any), we never bail early here since we need the + // continuation bit to be set. + while (k < m) { + n |= parts[k++] << j; + j += 24; + while (j > 7) { + res[this.pos++] = (n & 0x7f) | 0x80; + n >>= 7; + j -= 7; + } + } + + // Final part, similar to normal packing aside from the initial offset. + n |= parts[m] << j; + do { + res[this.pos] = n & 0x7f; + n >>= 7; + } while (n && (res[this.pos++] |= 0x80)); + this.pos++; + + // Restore original buffer (could make this optional?). + if (neg) { + invert(buf, 8); + } +}; + +// Helpers. + +/** + * Invert all bits in a buffer. + * + * @param buf + * {Buffer} Non-empty buffer to invert. + * @param len + * {Number} Buffer length (must be positive). + */ +function invert(buf, len) { + while (len--) { + buf[len] = ~buf[len]; + } +} + + +module.exports = { + abstractFunction: abstractFunction, + addDeprecatedGetters: addDeprecatedGetters, + capitalize: capitalize, + copyOwnProperties: copyOwnProperties, + getHash: getHash, + compare: compare, + getOption: getOption, + jsonEnd: jsonEnd, + objectValues: objectValues, + toMap: toMap, + singleIndexOf: singleIndexOf, + hasDuplicates: hasDuplicates, + Lcg: Lcg, + OrderedQueue: OrderedQueue, + Tap: Tap +}; + +}).call(this,require("buffer").Buffer) +},{"buffer":16,"crypto":50,"util":47}],"avsc":[function(require,module,exports){ +(function (Buffer){ +/* jshint browser: true, node: true */ + +'use strict'; + +/** + * Main browserify entry point. + * + * This version of the entry point adds a couple browser-specific utilities to + * read and write blobs. + */ + +var avroServices = require('./avsc-services'), + containers = require('../../lib/containers'), + utils = require('../../lib/utils'), + stream = require('stream'), + util = require('util'); + + +/** Transform stream which lazily reads a blob's contents. */ +function BlobReader(blob, opts) { + stream.Readable.call(this); + opts = opts || {}; + + this._batchSize = opts.batchSize || 65536; + this._blob = blob; + this._pos = 0; +} +util.inherits(BlobReader, stream.Readable); + +BlobReader.prototype._read = function () { + var pos = this._pos; + if (pos >= this._blob.size) { + this.push(null); + return; + } + + this._pos += this._batchSize; + var blob = this._blob.slice(pos, this._pos, this._blob.type); + var reader = new FileReader(); + var self = this; + reader.addEventListener('loadend', function cb(evt) { + reader.removeEventListener('loadend', cb, false); + if (evt.error) { + self.emit('error', evt.error); + } else { + self.push(new Buffer(reader.result)); + } + }, false); + reader.readAsArrayBuffer(blob); +}; + +/** Transform stream which builds a blob from all data written to it. */ +function BlobWriter() { + stream.Transform.call(this, {readableObjectMode: true}); + this._bufs = []; +} +util.inherits(BlobWriter, stream.Transform); + +BlobWriter.prototype._transform = function (buf, encoding, cb) { + this._bufs.push(buf); + cb(); +}; + +BlobWriter.prototype._flush = function (cb) { + this.push(new Blob(this._bufs, {type: 'application/octet-binary'})); + cb(); +}; + +/** Read an Avro-container stored as a blob. */ +function createBlobDecoder(blob, opts) { + return new BlobReader(blob).pipe(new containers.streams.BlockDecoder(opts)); +} + +/** + * Store Avro values into an Avro-container blob. + * + * The returned stream will emit a single value, the blob, when ended. + */ +function createBlobEncoder(schema, opts) { + var encoder = new containers.streams.BlockEncoder(schema, opts); + var builder = new BlobWriter(); + encoder.pipe(builder); + return new stream.Duplex({ + objectMode: true, + read: function () { + // Not the fastest implementation, but it will only be called at most + // once (since the builder only ever emits a single value) so it'll do. + // It's also likely impractical to create very large blobs. + var val = builder.read(); + if (val) { + done(val); + } else { + builder.once('readable', done); + } + var self = this; + function done(val) { + self.push(val || builder.read()); + self.push(null); + } + }, + write: function (val, encoding, cb) { + return encoder.write(val, encoding, cb); + } + }).on('finish', function () { encoder.end(); }); +} + + +module.exports = { + createBlobDecoder: createBlobDecoder, + createBlobEncoder: createBlobEncoder, + streams: containers.streams +}; + +utils.copyOwnProperties(avroServices, module.exports); + +}).call(this,require("buffer").Buffer) +},{"../../lib/containers":52,"../../lib/utils":56,"./avsc-services":48,"buffer":16,"stream":42,"util":47}]},{},[]); |