Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

How to use SNMP + Node JS at client browser as javascript? #1148

Closed
mj-mrityunjay opened this issue Mar 9, 2018 · 8 comments
Closed

How to use SNMP + Node JS at client browser as javascript? #1148

mj-mrityunjay opened this issue Mar 9, 2018 · 8 comments

Comments

@mj-mrityunjay
Copy link

  • Node.js Version: 9.7.1
  • OS: Windows 10
  • Scope (install, code, runtime, meta, other?): runtime
  • Module (and version) (if relevant): SNMP and DGRAM
@gireeshpunathil
Copy link
Member

please clarify / elaborate on your requirement. What are you trying to achieve?

@mj-mrityunjay
Copy link
Author

mj-mrityunjay commented Mar 11, 2018 via email

@gireeshpunathil
Copy link
Member

can you please the code here? I wrote a sample program with snmp module, and it works fine.

@mj-mrityunjay
Copy link
Author

I have attached my sample code

test_2.js
and browserified code as

independent_code.js
and also taken command screenshot for the same.

broserify issues

@mj-mrityunjay
Copy link
Author

test_2.js

`var snmp = require ("net-snmp");
// Default options
var options = {
port: 161,
retries: 1,
timeout: 5000,
transport: "udp4",
trapPort: 162,
version: snmp.Version1,
idBitsSize: 16
};
var session = snmp.createSession ("192.168.10.146", "public",options);

var oids = ["1.3.6.1.2.1.1.1.0", "1.3.6.1.2.1.1.5.0"];

session.get (oids, function (error, varbinds) {
if (error) {
console.error (error);
} else {
for (var i = 0; i < varbinds.length; i++)
if (snmp.isVarbindError (varbinds[i]))
console.error (snmp.varbindError (varbinds[i]))
else
console.log (varbinds[i].oid + " = " + varbinds[i].value);
}

// If done, close the session
session.close ();

});

session.trap (snmp.TrapType.LinkDown, function (error) {
if (error)
console.error (error);
});
//};`

@mj-mrityunjay
Copy link
Author

mj-mrityunjay commented Mar 16, 2018 •
edited
Loading

`(function(){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}return e})()({1:[function(require,module,exports){

},{}],2:[function(require,module,exports){
(function (global){
'use strict';

// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
// original notice:

/*!

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 = /\sfunction\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/":10}],3:[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
}

// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
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) & 0xFF0000) + ((uint8[i + 1] << 8) & 0xFF00) + (uint8[i + 2] & 0xFF)
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('')
}

},{}],4:[function(require,module,exports){
/*!

'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
}
}

Object.defineProperty(Buffer.prototype, 'parent', {
get: function () {
if (!(this instanceof Buffer)) {
return undefined
}
return this.buffer
}
})

Object.defineProperty(Buffer.prototype, 'offset', {
get: function () {
if (!(this instanceof Buffer)) {
return undefined
}
return this.byteOffset
}
})

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: feross/buffer#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 (isArrayBuffer(value) || (value && isArrayBuffer(value.buffer))) {
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:
// feross/buffer#148
Buffer.prototype.proto = Uint8Array.prototype
Buffer.proto = Uint8Array

function assertSize (size) {
if (typeof size !== 'number') {
throw new TypeError('"size" argument must be of type 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('Unknown encoding: ' + 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 outside of buffer bounds')
}

if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('"length" is outside of buffer 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 (ArrayBuffer.isView(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('The first argument must be one of type 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 (ArrayBuffer.isView(buf)) {
buf = Buffer.from(buf)
}
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 (ArrayBuffer.isView(string) || isArrayBuffer(string)) {
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: feross/buffer#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.toLocaleString = Buffer.prototype.toString

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
}
}

var strLen = string.length

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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
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('Index out of range')
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

if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
// Use built-in when available, missing from IE11
this.copyWithin(targetStart, start, end)
} else if (this === target && start < targetStart && targetStart < end) {
// descending copy from end
for (var i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start]
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, end),
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 (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)
}
if (val.length === 1) {
var code = val.charCodeAt(0)
if ((encoding === 'utf8' && code < 128) ||
encoding === 'latin1') {
// Fast path: If val fits into a single byte, use that numeric value.
val = code
}
}
} 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
if (len === 0) {
throw new TypeError('The value "' + val +
'" is invalid for argument "value"')
}
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 takes equal signs as end of the Base64 encoding
str = str.split('=')[0]
// 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
}

// ArrayBuffers from another context (i.e. an iframe) do not pass the instanceof check
// but they should be treated as valid. See: feross/buffer#166
function isArrayBuffer (obj) {
return obj instanceof ArrayBuffer ||
(obj != null && obj.constructor != null && obj.constructor.name === 'ArrayBuffer' &&
typeof obj.byteLength === 'number')
}

function numberIsNaN (obj) {
return obj !== obj // eslint-disable-line no-self-compare
}

},{"base64-js":3,"ieee754":6}],5:[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.

var objectCreate = Object.create || objectCreatePolyfill
var objectKeys = Object.keys || objectKeysPolyfill
var bind = Function.prototype.bind || functionBindPolyfill

function EventEmitter() {
if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
this._events = objectCreate(null);
this._eventsCount = 0;
}

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.
var defaultMaxListeners = 10;

var hasDefineProperty;
try {
var o = {};
if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
hasDefineProperty = o.x === 0;
} catch (err) { hasDefineProperty = false }
if (hasDefineProperty) {
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
// check whether the input is a positive number (whose value is zero or
// greater and not a NaN).
if (typeof arg !== 'number' || arg < 0 || arg !== arg)
throw new TypeError('"defaultMaxListeners" must be a positive number');
defaultMaxListeners = arg;
}
});
} else {
EventEmitter.defaultMaxListeners = defaultMaxListeners;
}

// 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 setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || isNaN(n))
throw new TypeError('"n" argument must be a positive number');
this._maxListeners = n;
return this;
};

function $getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}

EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return $getMaxListeners(this);
};

// These standalone emit* functions are used to optimize calling of event
// handlers for fast cases because emit() itself often has a variable number of
// arguments and can be deoptimized because of that. These functions always have
// the same number of arguments and thus do not get deoptimized, so the code
// inside them can execute faster.
function emitNone(handler, isFn, self) {
if (isFn)
handler.call(self);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self);
}
}
function emitOne(handler, isFn, self, arg1) {
if (isFn)
handler.call(self, arg1);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1);
}
}
function emitTwo(handler, isFn, self, arg1, arg2) {
if (isFn)
handler.call(self, arg1, arg2);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1, arg2);
}
}
function emitThree(handler, isFn, self, arg1, arg2, arg3) {
if (isFn)
handler.call(self, arg1, arg2, arg3);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1, arg2, arg3);
}
}

function emitMany(handler, isFn, self, args) {
if (isFn)
handler.apply(self, args);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].apply(self, args);
}
}

EventEmitter.prototype.emit = function emit(type) {
var er, handler, len, args, i, events;
var doError = (type === 'error');

events = this._events;
if (events)
doError = (doError && events.error == null);
else if (!doError)
return false;

// If there is no 'error' event listener then throw.
if (doError) {
if (arguments.length > 1)
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('Unhandled "error" event. (' + er + ')');
err.context = er;
throw err;
}
return false;
}

handler = events[type];

if (!handler)
return false;

var isFn = typeof handler === 'function';
len = arguments.length;
switch (len) {
// fast cases
case 1:
emitNone(handler, isFn, this);
break;
case 2:
emitOne(handler, isFn, this, arguments[1]);
break;
case 3:
emitTwo(handler, isFn, this, arguments[1], arguments[2]);
break;
case 4:
emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
break;
// slower
default:
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
emitMany(handler, isFn, this, args);
}

return true;
};

function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;

if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');

events = target._events;
if (!events) {
events = target._events = objectCreate(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);

  // Re-assign `events` because a newListener handler could have caused the
  // this._events to be assigned to a new object
  events = target._events;
}
existing = events[type];

}

if (!existing) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
} else {
// If we've already got an array, just append.
if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
}

// Check for listener leak
if (!existing.warned) {
  m = $getMaxListeners(target);
  if (m && m > 0 && existing.length > m) {
    existing.warned = true;
    var w = new Error('Possible EventEmitter memory leak detected. ' +
        existing.length + ' "' + String(type) + '" listeners ' +
        'added. Use emitter.setMaxListeners() to ' +
        'increase limit.');
    w.name = 'MaxListenersExceededWarning';
    w.emitter = target;
    w.type = type;
    w.count = existing.length;
    if (typeof console === 'object' && console.warn) {
      console.warn('%s: %s', w.name, w.message);
    }
  }
}

}

return target;
}

EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};

function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
switch (arguments.length) {
case 0:
return this.listener.call(this.target);
case 1:
return this.listener.call(this.target, arguments[0]);
case 2:
return this.listener.call(this.target, arguments[0], arguments[1]);
case 3:
return this.listener.call(this.target, arguments[0], arguments[1],
arguments[2]);
default:
var args = new Array(arguments.length);
for (var i = 0; i < args.length; ++i)
args[i] = arguments[i];
this.listener.apply(this.target, args);
}
}
}

function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = bind.call(onceWrapper, state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}

EventEmitter.prototype.once = function once(type, listener) {
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
this.on(type, _onceWrap(this, type, listener));
return this;
};

EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};

// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;

  if (typeof listener !== 'function')
    throw new TypeError('"listener" argument must be a function');

  events = this._events;
  if (!events)
    return this;

  list = events[type];
  if (!list)
    return this;

  if (list === listener || list.listener === listener) {
    if (--this._eventsCount === 0)
      this._events = objectCreate(null);
    else {
      delete events[type];
      if (events.removeListener)
        this.emit('removeListener', type, list.listener || listener);
    }
  } else if (typeof list !== 'function') {
    position = -1;

    for (i = list.length - 1; i >= 0; i--) {
      if (list[i] === listener || list[i].listener === listener) {
        originalListener = list[i].listener;
        position = i;
        break;
      }
    }

    if (position < 0)
      return this;

    if (position === 0)
      list.shift();
    else
      spliceOne(list, position);

    if (list.length === 1)
      events[type] = list[0];

    if (events.removeListener)
      this.emit('removeListener', type, originalListener || listener);
  }

  return this;
};

EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;

  events = this._events;
  if (!events)
    return this;

  // not listening for removeListener, no need to emit
  if (!events.removeListener) {
    if (arguments.length === 0) {
      this._events = objectCreate(null);
      this._eventsCount = 0;
    } else if (events[type]) {
      if (--this._eventsCount === 0)
        this._events = objectCreate(null);
      else
        delete events[type];
    }
    return this;
  }

  // emit removeListener for all listeners on all events
  if (arguments.length === 0) {
    var keys = objectKeys(events);
    var key;
    for (i = 0; i < keys.length; ++i) {
      key = keys[i];
      if (key === 'removeListener') continue;
      this.removeAllListeners(key);
    }
    this.removeAllListeners('removeListener');
    this._events = objectCreate(null);
    this._eventsCount = 0;
    return this;
  }

  listeners = events[type];

  if (typeof listeners === 'function') {
    this.removeListener(type, listeners);
  } else if (listeners) {
    // LIFO order
    for (i = listeners.length - 1; i >= 0; i--) {
      this.removeListener(type, listeners[i]);
    }
  }

  return this;
};

EventEmitter.prototype.listeners = function listeners(type) {
var evlistener;
var ret;
var events = this._events;

if (!events)
ret = [];
else {
evlistener = events[type];
if (!evlistener)
ret = [];
else if (typeof evlistener === 'function')
ret = [evlistener.listener || evlistener];
else
ret = unwrapListeners(evlistener);
}

return ret;
};

EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};

EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;

if (events) {
var evlistener = events[type];

if (typeof evlistener === 'function') {
  return 1;
} else if (evlistener) {
  return evlistener.length;
}

}

return 0;
}

EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
};

// About 1.5x faster than the two-arg version of Array#splice().
function spliceOne(list, index) {
for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
list[i] = list[k];
list.pop();
}

function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}

function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}

function objectCreatePolyfill(proto) {
var F = function() {};
F.prototype = proto;
return new F;
}
function objectKeysPolyfill(obj) {
var keys = [];
for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
keys.push(k);
}
return k;
}
function functionBindPolyfill(context) {
var fn = this;
return function () {
return fn.apply(context, arguments);
};
}

},{}],6:[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
}

},{}],7:[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; };

},{}],8:[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
}
}

},{}],9:[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';
}
},{}],10:[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":9,"_process":7,"inherits":8}],11:[function(require,module,exports){
var snmp = require ("net-snmp");

var session = snmp.createSession ("13.61.10.146", "public");

var oid = "1.3.6.1.2.1.2.2";

function doneCb (error) {
if (error)
console.error (error.toString ());
}

function feedCb (varbinds) {
for (var i = 0; i < varbinds.length; i++) {
if (snmp.isVarbindError (varbinds[i]))
console.error (snmp.varbindError (varbinds[i]));
else
console.log (varbinds[i].oid + "|" + varbinds[i].value);
}
}

var maxRepetitions = 20;

// The maxRepetitions argument is optional, and will be ignored unless using
// SNMP verison 2c
session.walk (oid, maxRepetitions, feedCb, doneCb);
},{"net-snmp":18}],12:[function(require,module,exports){

var Ber = require('./lib/ber/index')

exports.Ber = Ber
exports.BerReader = Ber.Reader
exports.BerWriter = Ber.Writer

},{"./lib/ber/index":14}],13:[function(require,module,exports){

module.exports = {
InvalidAsn1Error: function(msg) {
var e = new Error()
e.name = 'InvalidAsn1Error'
e.message = msg || ''
return e
}
}

},{}],14:[function(require,module,exports){

var errors = require('./errors')
var types = require('./types')

var Reader = require('./reader')
var Writer = require('./writer')

for (var t in types)
if (types.hasOwnProperty(t))
exports[t] = types[t]

for (var e in errors)
if (errors.hasOwnProperty(e))
exports[e] = errors[e]

exports.Reader = Reader
exports.Writer = Writer

},{"./errors":13,"./reader":15,"./types":16,"./writer":17}],15:[function(require,module,exports){
(function (Buffer){

var assert = require('assert');

var ASN1 = require('./types');
var errors = require('./errors');

///--- Globals

var InvalidAsn1Error = errors.InvalidAsn1Error;

///--- API

function Reader(data) {
if (!data || !Buffer.isBuffer(data))
throw new TypeError('data must be a node Buffer');

    this._buf = data;
    this._size = data.length;

    // These hold the "current" state
    this._len = 0;
    this._offset = 0;

}

Object.defineProperty(Reader.prototype, 'length', {
enumerable: true,
get: function () { return (this._len); }
});

Object.defineProperty(Reader.prototype, 'offset', {
enumerable: true,
get: function () { return (this._offset); }
});

Object.defineProperty(Reader.prototype, 'remain', {
get: function () { return (this._size - this._offset); }
});

Object.defineProperty(Reader.prototype, 'buffer', {
get: function () { return (this._buf.slice(this._offset)); }
});

/**

  • Reads a single byte and advances offset; you can pass in true to make this

  • a "peek" operation (i.e., get the byte, but don't advance the offset).

  • @param {Boolean} peek true means don't move offset.

  • @return {Number} the next byte, null if not enough data.
    */
    Reader.prototype.readByte = function(peek) {
    if (this._size - this._offset < 1)
    return null;

     var b = this._buf[this._offset] & 0xff;

 if (!peek)
         this._offset += 1;

 return b;

};

Reader.prototype.peek = function() {
return this.readByte(true);
};

/**

  • Reads a (potentially) variable length off the BER buffer. This call is

  • not really meant to be called directly, as callers have to manipulate

  • the internal buffer afterwards.

  • As a result of this call, you can call Reader.length, until the

  • next thing called that does a readLength.

  • @return {Number} the amount of offset to advance the buffer.

  • @throws {InvalidAsn1Error} on bad ASN.1
    */
    Reader.prototype.readLength = function(offset) {
    if (offset === undefined)
    offset = this._offset;

     if (offset >= this._size)
         return null;

 var lenB = this._buf[offset++] & 0xff;
 if (lenB === null)
         return null;

 if ((lenB & 0x80) == 0x80) {
         lenB &= 0x7f;

         if (lenB == 0)
                 throw InvalidAsn1Error('Indefinite length not supported');

         if (lenB > 4)
                 throw InvalidAsn1Error('encoding too long');

         if (this._size - offset < lenB)
                 return null;

         this._len = 0;
         for (var i = 0; i < lenB; i++)
                 this._len = (this._len << 8) + (this._buf[offset++] & 0xff);

 } else {
         // Wasn't a variable length
         this._len = lenB;
 }

 return offset;

};

/**

  • Parses the next sequence in this BER buffer.

  • To get the length of the sequence, call Reader.length.

  • @return {Number} the sequence's tag.
    */
    Reader.prototype.readSequence = function(tag) {
    var seq = this.peek();
    if (seq === null)
    return null;
    if (tag !== undefined && tag !== seq)
    throw InvalidAsn1Error('Expected 0x' + tag.toString(16) +
    ': got 0x' + seq.toString(16));

     var o = this.readLength(this._offset + 1); // stored in `length`
 if (o === null)
         return null;

 this._offset = o;
 return seq;

};

Reader.prototype.readInt = function(tag) {
if (typeof(tag) !== 'number')
tag = ASN1.Integer;

    return this._readTag(tag);

};

Reader.prototype.readBoolean = function(tag) {
if (typeof(tag) !== 'number')
tag = ASN1.Boolean;

    return (this._readTag(tag) === 0 ? false : true);

};

Reader.prototype.readEnumeration = function(tag) {
if (typeof(tag) !== 'number')
tag = ASN1.Enumeration;

    return this._readTag(tag);

};

Reader.prototype.readString = function(tag, retbuf) {
if (!tag)
tag = ASN1.OctetString;

    var b = this.peek();
    if (b === null)
            return null;

    if (b !== tag)
            throw InvalidAsn1Error('Expected 0x' + tag.toString(16) +
                                                                                                                    ': got 0x' + b.toString(16));

    var o = this.readLength(this._offset + 1); // stored in `length`

    if (o === null)
            return null;

    if (this.length > this._size - o)
            return null;

    this._offset = o;

    if (this.length === 0)
            return retbuf ? new Buffer(0) : '';

    var str = this._buf.slice(this._offset, this._offset + this.length);
    this._offset += this.length;

    return retbuf ? str : str.toString('utf8');

};

Reader.prototype.readOID = function(tag) {
if (!tag)
tag = ASN1.OID;

    var b = this.readString(tag, true);
    if (b === null)
            return null;

    var values = [];
    var value = 0;

    for (var i = 0; i < b.length; i++) {
            var byte = b[i] & 0xff;

            value <<= 7;
            value += byte & 0x7f;
            if ((byte & 0x80) == 0) {
                    values.push(value >>> 0);
                    value = 0;
            }
    }

    value = values.shift();
    values.unshift(value % 40);
    values.unshift((value / 40) >> 0);

    return values.join('.');

};

Reader.prototype._readTag = function(tag) {
assert.ok(tag !== undefined);

    var b = this.peek();

    if (b === null)
            return null;

    if (b !== tag)
            throw InvalidAsn1Error('Expected 0x' + tag.toString(16) +
                                                                                                                    ': got 0x' + b.toString(16));

    var o = this.readLength(this._offset + 1); // stored in `length`
    if (o === null)
            return null;

    if (this.length > 4)
            throw InvalidAsn1Error('Integer too long: ' + this.length);

    if (this.length > this._size - o)
            return null;
    this._offset = o;

    var fb = this._buf[this._offset];
    var value = 0;

    for (var i = 0; i < this.length; i++) {
            value <<= 8;
            value |= (this._buf[this._offset++] & 0xff);
    }

    if ((fb & 0x80) == 0x80 && i !== 4)
            value -= (1 << (i * 8));

    return value >> 0;

};

///--- Exported API

module.exports = Reader;

}).call(this,require("buffer").Buffer)
},{"./errors":13,"./types":16,"assert":2,"buffer":4}],16:[function(require,module,exports){

module.exports = {
EOC: 0,
Boolean: 1,
Integer: 2,
BitString: 3,
OctetString: 4,
Null: 5,
OID: 6,
ObjectDescriptor: 7,
External: 8,
Real: 9,
Enumeration: 10,
PDV: 11,
Utf8String: 12,
RelativeOID: 13,
Sequence: 16,
Set: 17,
NumericString: 18,
PrintableString: 19,
T61String: 20,
VideotexString: 21,
IA5String: 22,
UTCTime: 23,
GeneralizedTime: 24,
GraphicString: 25,
VisibleString: 26,
GeneralString: 28,
UniversalString: 29,
CharacterString: 30,
BMPString: 31,
Constructor: 32,
Context: 128
}

},{}],17:[function(require,module,exports){
(function (Buffer){

var assert = require('assert');
var ASN1 = require('./types');
var errors = require('./errors');

///--- Globals

var InvalidAsn1Error = errors.InvalidAsn1Error;

var DEFAULT_OPTS = {
size: 1024,
growthFactor: 8
};

///--- Helpers

function merge(from, to) {
assert.ok(from);
assert.equal(typeof(from), 'object');
assert.ok(to);
assert.equal(typeof(to), 'object');

    var keys = Object.getOwnPropertyNames(from);
    keys.forEach(function(key) {
            if (to[key])
                    return;

            var value = Object.getOwnPropertyDescriptor(from, key);
            Object.defineProperty(to, key, value);
    });

    return to;

}

///--- API

function Writer(options) {
options = merge(DEFAULT_OPTS, options || {});

    this._buf = new Buffer(options.size || 1024);
    this._size = this._buf.length;
    this._offset = 0;
    this._options = options;

    // A list of offsets in the buffer where we need to insert
    // sequence tag/len pairs.
    this._seq = [];

}

Object.defineProperty(Writer.prototype, 'buffer', {
get: function () {
if (this._seq.length)
throw new InvalidAsn1Error(this._seq.length + ' unended sequence(s)');

            return (this._buf.slice(0, this._offset));
    }

});

Writer.prototype.writeByte = function(b) {
if (typeof(b) !== 'number')
throw new TypeError('argument must be a Number');

    this._ensure(1);
    this._buf[this._offset++] = b;

};

Writer.prototype.writeInt = function(i, tag) {
if (typeof(i) !== 'number')
throw new TypeError('argument must be a Number');
if (typeof(tag) !== 'number')
tag = ASN1.Integer;

    var sz = 4;

    while ((((i & 0xff800000) === 0) || ((i & 0xff800000) === 0xff800000 >> 0)) &&
                             (sz > 1)) {
            sz--;
            i <<= 8;
    }

    if (sz > 4)
            throw new InvalidAsn1Error('BER ints cannot be > 0xffffffff');

    this._ensure(2 + sz);
    this._buf[this._offset++] = tag;
    this._buf[this._offset++] = sz;

    while (sz-- > 0) {
            this._buf[this._offset++] = ((i & 0xff000000) >>> 24);
            i <<= 8;
    }

};

Writer.prototype.writeNull = function() {
this.writeByte(ASN1.Null);
this.writeByte(0x00);
};

Writer.prototype.writeEnumeration = function(i, tag) {
if (typeof(i) !== 'number')
throw new TypeError('argument must be a Number');
if (typeof(tag) !== 'number')
tag = ASN1.Enumeration;

    return this.writeInt(i, tag);

};

Writer.prototype.writeBoolean = function(b, tag) {
if (typeof(b) !== 'boolean')
throw new TypeError('argument must be a Boolean');
if (typeof(tag) !== 'number')
tag = ASN1.Boolean;

    this._ensure(3);
    this._buf[this._offset++] = tag;
    this._buf[this._offset++] = 0x01;
    this._buf[this._offset++] = b ? 0xff : 0x00;

};

Writer.prototype.writeString = function(s, tag) {
if (typeof(s) !== 'string')
throw new TypeError('argument must be a string (was: ' + typeof(s) + ')');
if (typeof(tag) !== 'number')
tag = ASN1.OctetString;

    var len = Buffer.byteLength(s);
    this.writeByte(tag);
    this.writeLength(len);
    if (len) {
            this._ensure(len);
            this._buf.write(s, this._offset);
            this._offset += len;
    }

};

Writer.prototype.writeBuffer = function(buf, tag) {
if (!Buffer.isBuffer(buf))
throw new TypeError('argument must be a buffer');

    // If no tag is specified we will assume `buf` already contains tag and length
    if (typeof(tag) === 'number') {
            this.writeByte(tag);
            this.writeLength(buf.length);
    }

    this._ensure(buf.length);
    buf.copy(this._buf, this._offset, 0, buf.length);
    this._offset += buf.length;

};

Writer.prototype.writeStringArray = function(strings, tag) {
if (! (strings instanceof Array))
throw new TypeError('argument must be an Array[String]');

    var self = this;
    strings.forEach(function(s) {
            self.writeString(s, tag);
    });

};

// This is really to solve DER cases, but whatever for now
Writer.prototype.writeOID = function(s, tag) {
if (typeof(s) !== 'string')
throw new TypeError('argument must be a string');
if (typeof(tag) !== 'number')
tag = ASN1.OID;

    if (!/^([0-9]+\.){3,}[0-9]+$/.test(s))
            throw new Error('argument is not a valid OID string');

    function encodeOctet(bytes, octet) {
            if (octet < 128) {
                            bytes.push(octet);
            } else if (octet < 16384) {
                            bytes.push((octet >>> 7) | 0x80);
                            bytes.push(octet & 0x7F);
            } else if (octet < 2097152) {
                    bytes.push((octet >>> 14) | 0x80);
                    bytes.push(((octet >>> 7) | 0x80) & 0xFF);
                    bytes.push(octet & 0x7F);
            } else if (octet < 268435456) {
                    bytes.push((octet >>> 21) | 0x80);
                    bytes.push(((octet >>> 14) | 0x80) & 0xFF);
                    bytes.push(((octet >>> 7) | 0x80) & 0xFF);
                    bytes.push(octet & 0x7F);
            } else {
                    bytes.push(((octet >>> 28) | 0x80) & 0xFF);
                    bytes.push(((octet >>> 21) | 0x80) & 0xFF);
                    bytes.push(((octet >>> 14) | 0x80) & 0xFF);
                    bytes.push(((octet >>> 7) | 0x80) & 0xFF);
                    bytes.push(octet & 0x7F);
            }
    }

    var tmp = s.split('.');
    var bytes = [];
    bytes.push(parseInt(tmp[0], 10) * 40 + parseInt(tmp[1], 10));
    tmp.slice(2).forEach(function(b) {
            encodeOctet(bytes, parseInt(b, 10));
    });

    var self = this;
    this._ensure(2 + bytes.length);
    this.writeByte(tag);
    this.writeLength(bytes.length);
    bytes.forEach(function(b) {
            self.writeByte(b);
    });

};

Writer.prototype.writeLength = function(len) {
if (typeof(len) !== 'number')
throw new TypeError('argument must be a Number');

    this._ensure(4);

    if (len <= 0x7f) {
            this._buf[this._offset++] = len;
    } else if (len <= 0xff) {
            this._buf[this._offset++] = 0x81;
            this._buf[this._offset++] = len;
    } else if (len <= 0xffff) {
            this._buf[this._offset++] = 0x82;
            this._buf[this._offset++] = len >> 8;
            this._buf[this._offset++] = len;
    } else if (len <= 0xffffff) {
            this._buf[this._offset++] = 0x83;
            this._buf[this._offset++] = len >> 16;
            this._buf[this._offset++] = len >> 8;
            this._buf[this._offset++] = len;
    } else {
            throw new InvalidAsn1Error('Length too long (> 4 bytes)');
    }

};

Writer.prototype.startSequence = function(tag) {
if (typeof(tag) !== 'number')
tag = ASN1.Sequence | ASN1.Constructor;

    this.writeByte(tag);
    this._seq.push(this._offset);
    this._ensure(3);
    this._offset += 3;

};

Writer.prototype.endSequence = function() {
var seq = this._seq.pop();
var start = seq + 3;
var len = this._offset - start;

    if (len <= 0x7f) {
            this._shift(start, len, -2);
            this._buf[seq] = len;
    } else if (len <= 0xff) {
            this._shift(start, len, -1);
            this._buf[seq] = 0x81;
            this._buf[seq + 1] = len;
    } else if (len <= 0xffff) {
            this._buf[seq] = 0x82;
            this._buf[seq + 1] = len >> 8;
            this._buf[seq + 2] = len;
    } else if (len <= 0xffffff) {
            this._shift(start, len, 1);
            this._buf[seq] = 0x83;
            this._buf[seq + 1] = len >> 16;
            this._buf[seq + 2] = len >> 8;
            this._buf[seq + 3] = len;
    } else {
            throw new InvalidAsn1Error('Sequence too long');
    }

};

Writer.prototype._shift = function(start, len, shift) {
assert.ok(start !== undefined);
assert.ok(len !== undefined);
assert.ok(shift);

    this._buf.copy(this._buf, start + shift, start, start + len);
    this._offset += shift;

};

Writer.prototype._ensure = function(len) {
assert.ok(len);

    if (this._size - this._offset < len) {
            var sz = this._size * this._options.growthFactor;
            if (sz - this._offset < len)
                    sz += len;

            var buf = new Buffer(sz);

            this._buf.copy(buf, 0, 0, this._offset);
            this._buf = buf;
            this._size = sz;
    }

};

///--- Exported API

module.exports = Writer;

}).call(this,require("buffer").Buffer)
},{"./errors":13,"./types":16,"assert":2,"buffer":4}],18:[function(require,module,exports){
(function (process,Buffer){

// Copyright 2013 Stephen Vickers stephen.vickers.sv@gmail.com

var ber = require ("asn1-ber").Ber;
var dgram = require ("dgram");
var events = require ("events");
var util = require ("util");

/*****************************************************************************
** Constants
**/

function _expandConstantObject (object) {
var keys = [];
for (var key in object)
keys.push (key);
for (var i = 0; i < keys.length; i++)
object[object[keys[i]]] = parseInt (keys[i]);
}

var ErrorStatus = {
0: "NoError",
1: "TooBig",
2: "NoSuchName",
3: "BadValue",
4: "ReadOnly",
5: "GeneralError",
6: "NoAccess",
7: "WrongType",
8: "WrongLength",
9: "WrongEncoding",
10: "WrongValue",
11: "NoCreation",
12: "InconsistentValue",
13: "ResourceUnavailable",
14: "CommitFailed",
15: "UndoFailed",
16: "AuthorizationError",
17: "NotWritable",
18: "InconsistentName"
};

_expandConstantObject (ErrorStatus);

var ObjectType = {
1: "Boolean",
2: "Integer",
4: "OctetString",
5: "Null",
6: "OID",
64: "IpAddress",
65: "Counter",
66: "Gauge",
67: "TimeTicks",
68: "Opaque",
70: "Counter64",
128: "NoSuchObject",
129: "NoSuchInstance",
130: "EndOfMibView"
};

_expandConstantObject (ObjectType);

ObjectType.Integer32 = ObjectType.Integer;
ObjectType.Counter32 = ObjectType.Counter;
ObjectType.Gauge32 = ObjectType.Gauge;
ObjectType.Unsigned32 = ObjectType.Gauge32;

var PduType = {
160: "GetRequest",
161: "GetNextRequest",
162: "GetResponse",
163: "SetRequest",
164: "Trap",
165: "GetBulkRequest",
166: "InformRequest",
167: "TrapV2",
168: "Report"
};

_expandConstantObject (PduType);

var TrapType = {
0: "ColdStart",
1: "WarmStart",
2: "LinkDown",
3: "LinkUp",
4: "AuthenticationFailure",
5: "EgpNeighborLoss",
6: "EnterpriseSpecific"
};

_expandConstantObject (TrapType);

var Version1 = 0;
var Version2c = 1;

/*****************************************************************************
** Exception class definitions
**/

function ResponseInvalidError (message) {
this.name = "ResponseInvalidError";
this.message = message;
Error.captureStackTrace(this, ResponseInvalidError);
}
util.inherits (ResponseInvalidError, Error);

function RequestInvalidError (message) {
this.name = "RequestInvalidError";
this.message = message;
Error.captureStackTrace(this, RequestInvalidError);
}
util.inherits (RequestInvalidError, Error);

function RequestFailedError (message, status) {
this.name = "RequestFailedError";
this.message = message;
this.status = status;
Error.captureStackTrace(this, RequestFailedError);
}
util.inherits (RequestFailedError, Error);

function RequestTimedOutError (message) {
this.name = "RequestTimedOutError";
this.message = message;
Error.captureStackTrace(this, RequestTimedOutError);
}
util.inherits (RequestTimedOutError, Error);

/*****************************************************************************
** OID and varbind helper functions
**/

function isVarbindError (varbind) {
return !!(varbind.type == ObjectType.NoSuchObject
|| varbind.type == ObjectType.NoSuchInstance
|| varbind.type == ObjectType.EndOfMibView);
}

function varbindError (varbind) {
return (ObjectType[varbind.type] || "NotAnError") + ": " + varbind.oid;
}

function oidFollowsOid (oidString, nextString) {
var oid = {str: oidString, len: oidString.length, idx: 0};
var next = {str: nextString, len: nextString.length, idx: 0};
var dotCharCode = ".".charCodeAt (0);

    function getNumber (item) {
            var n = 0;
            if (item.idx >= item.len)
                    return null;
            while (item.idx < item.len) {
                    var charCode = item.str.charCodeAt (item.idx++);
                    if (charCode == dotCharCode)
                            return n;
                    n = (n ? (n * 10) : n) + (charCode - 48);
            }
            return n;
    }

    while (1) {
            var oidNumber = getNumber (oid);
            var nextNumber = getNumber (next);

            if (oidNumber !== null) {
                    if (nextNumber !== null) {
                            if (nextNumber > oidNumber) {
                                    return true;
                            } else if (nextNumber < oidNumber) {
                                    return false;
                            }
                    } else {
                            return true;
                    }
            } else {
                    return true;
            }
    }

}

function oidInSubtree (oidString, nextString) {
var oid = oidString.split (".");
var next = nextString.split (".");

    if (oid.length > next.length)
            return false;

    for (var i = 0; i < oid.length; i++) {
            if (next[i] != oid[i])
                    return false;
    }

    return true;

}

/**
** Some SNMP agents produce integers on the wire such as 00 ff ff ff ff.
** The ASN.1 BER parser we use throws an error when parsing this, which we
** believe is correct. So, we decided not to bother the "asn1" developer(s)
** with this, instead opting to work around it here.
**
** If an integer is 5 bytes in length we check if the first byte is 0, and if so
** simply drop it and parse it like it was a 4 byte integer, otherwise throw
** an error since the integer is too large.
**/

function readInt (buffer) {
return readUint (buffer, true);
}

function readUint (buffer, isSigned) {
buffer.readByte ();
var length = buffer.readByte ();
var value = 0;
var signedBitSet = false;

    if (length > 5) {
             throw new RangeError ("Integer too long '" + length + "'");
    } else if (length == 5) {
            if (buffer.readByte () !== 0)
                    throw new RangeError ("Integer too long '" + length + "'");
            length = 4;
    }

    for (var i = 0; i < length; i++) {
            value *= 256;
            value += buffer.readByte ();

            if (isSigned && i <= 0) {
                    if ((value & 0x80) == 0x80)
                            signedBitSet = true;
            }
    }

    if (signedBitSet)
            value -= (1 << (i * 8));

    return value;

}

function readUint64 (buffer) {
var value = buffer.readString (ObjectType.Counter64, true);

    return value;

}

function readVarbinds (buffer, varbinds) {
buffer.readSequence ();

    while (1) {
            buffer.readSequence ();
            var oid = buffer.readOID ();
            var type = buffer.peek ();

            if (type == null)
                    break;

            var value;

            if (type == ObjectType.Boolean) {
                    value = buffer.readBoolean ();
            } else if (type == ObjectType.Integer) {
                    value = readInt (buffer);
            } else if (type == ObjectType.OctetString) {
                    value = buffer.readString (null, true);
            } else if (type == ObjectType.Null) {
                    buffer.readByte ();
                    buffer.readByte ();
                    value = null;
            } else if (type == ObjectType.OID) {
                    value = buffer.readOID ();
            } else if (type == ObjectType.IpAddress) {
                    var bytes = buffer.readString (ObjectType.IpAddress, true);
                    if (bytes.length != 4)
                            throw new ResponseInvalidError ("Length '" + bytes.length
                                            + "' of IP address '" + bytes.toString ("hex")
                                            + "' is not 4");
                    value = bytes[0] + "." + bytes[1] + "." + bytes[2] + "." + bytes[3];
            } else if (type == ObjectType.Counter) {
                    value = readUint (buffer);
            } else if (type == ObjectType.Gauge) {
                    value = readUint (buffer);
            } else if (type == ObjectType.TimeTicks) {
                    value = readUint (buffer);
            } else if (type == ObjectType.Opaque) {
                    value = buffer.readString (ObjectType.Opaque, true);
            } else if (type == ObjectType.Counter64) {
                    value = readUint64 (buffer);
            } else if (type == ObjectType.NoSuchObject) {
                    buffer.readByte ();
                    buffer.readByte ();
                    value = null;
            } else if (type == ObjectType.NoSuchInstance) {
                    buffer.readByte ();
                    buffer.readByte ();
                    value = null;
            } else if (type == ObjectType.EndOfMibView) {
                    buffer.readByte ();
                    buffer.readByte ();
                    value = null;
            } else {
                    throw new ResponseInvalidError ("Unknown type '" + type
                                    + "' in response");
            }

            varbinds.push ({
                    oid: oid,
                    type: type,
                    value: value
            });
    }

}

function writeUint (buffer, type, value) {
var b = new Buffer (4);
b.writeUInt32BE (value, 0);
buffer.writeBuffer (b, type);
}

function writeUint64 (buffer, value) {
buffer.writeBuffer (value, ObjectType.Counter64);
}

function writeVarbinds (buffer, varbinds) {
buffer.startSequence ();
for (var i = 0; i < varbinds.length; i++) {
buffer.startSequence ();
buffer.writeOID (varbinds[i].oid);

            if (varbinds[i].type && varbinds[i].hasOwnProperty("value")) {
                    var type = varbinds[i].type;
                    var value = varbinds[i].value;

                    if (type == ObjectType.Boolean) {
                            buffer.writeBoolean (value ? true : false);
                    } else if (type == ObjectType.Integer) { // also Integer32
                            buffer.writeInt (value);
                    } else if (type == ObjectType.OctetString) {
                            if (typeof value == "string")
                                    buffer.writeString (value);
                            else
                                    buffer.writeBuffer (value, ObjectType.OctetString);
                    } else if (type == ObjectType.Null) {
                            buffer.writeNull ();
                    } else if (type == ObjectType.OID) {
                            buffer.writeOID (value);
                    } else if (type == ObjectType.IpAddress) {
                            var bytes = value.split (".");
                            if (bytes.length != 4)
                                    throw new RequestInvalidError ("Invalid IP address '"
                                                    + value + "'");
                            buffer.writeBuffer (new Buffer (bytes), 64);
                    } else if (type == ObjectType.Counter) { // also Counter32
                            writeUint (buffer, ObjectType.Counter, value);
                    } else if (type == ObjectType.Gauge) { // also Gauge32 & Unsigned32
                            writeUint (buffer, ObjectType.Gauge, value);
                    } else if (type == ObjectType.TimeTicks) {
                            writeUint (buffer, ObjectType.TimeTicks, value);
                    } else if (type == ObjectType.Opaque) {
                            buffer.writeBuffer (value, ObjectType.Opaque);
                    } else if (type == ObjectType.Counter64) {
                            writeUint64 (buffer, value);
                    } else {
                            throw new RequestInvalidError ("Unknown type '" + type
                                            + "' in request");
                    }
            } else {
                    buffer.writeNull ();
            }

            buffer.endSequence ();
    }
    buffer.endSequence ();

}

/*****************************************************************************
** PDU class definitions
**/

var SimplePdu = function (id, varbinds, options) {
this.id = id;
this.varbinds = varbinds;
this.options = options || {};
};

SimplePdu.prototype.toBuffer = function (buffer) {
buffer.startSequence (this.type);

    buffer.writeInt (this.id);
    buffer.writeInt ((this.type == PduType.GetBulkRequest)
                    ? (this.options.nonRepeaters || 0)
                    : 0);
    buffer.writeInt ((this.type == PduType.GetBulkRequest)
                    ? (this.options.maxRepetitions || 0)
                    : 0);

    writeVarbinds (buffer, this.varbinds);

    buffer.endSequence ();

};

var GetBulkRequestPdu = function () {
this.type = PduType.GetBulkRequest;
GetBulkRequestPdu.super_.apply (this, arguments);
};

util.inherits (GetBulkRequestPdu, SimplePdu);

var GetNextRequestPdu = function () {
this.type = PduType.GetNextRequest;
GetNextRequestPdu.super_.apply (this, arguments);
};

util.inherits (GetNextRequestPdu, SimplePdu);

var GetResponsePdu = function (buffer) {
this.type = PduType.GetResponse;

    buffer.readSequence (this.type);

    this.id = buffer.readInt ();

    this.errorStatus = buffer.readInt ();
    this.errorIndex = buffer.readInt ();

    this.varbinds = [];

    readVarbinds (buffer, this.varbinds);

};

var GetRequestPdu = function () {
this.type = PduType.GetRequest;
GetRequestPdu.super_.apply (this, arguments);
};

util.inherits (GetRequestPdu, SimplePdu);

var InformRequestPdu = function () {
this.type = PduType.InformRequest;
InformRequestPdu.super_.apply (this, arguments);
};

util.inherits (InformRequestPdu, SimplePdu);

var SetRequestPdu = function () {
this.type = PduType.SetRequest;
SetRequestPdu.super_.apply (this, arguments);
};

util.inherits (SetRequestPdu, SimplePdu);

var TrapPdu = function (typeOrOid, varbinds, options) {
this.type = PduType.Trap;

    this.agentAddr = options.agentAddr || "127.0.0.1";
    this.upTime = options.upTime;

    if (typeof typeOrOid == "string") {
            this.generic = TrapType.EnterpriseSpecific;
            this.specific = parseInt (typeOrOid.match (/\.(\d+)$/)[1]);
            this.enterprise = typeOrOid.replace (/\.(\d+)$/, "");
    } else {
            this.generic = typeOrOid;
            this.specific = 0;
            this.enterprise = "1.3.6.1.4.1";
    }

    this.varbinds = varbinds;

};

TrapPdu.prototype.toBuffer = function (buffer) {
buffer.startSequence (this.type);

    buffer.writeOID (this.enterprise);
    buffer.writeBuffer (new Buffer (this.agentAddr.split (".")),
                    ObjectType.IpAddress);
    buffer.writeInt (this.generic);
    buffer.writeInt (this.specific);
    writeUint (buffer, ObjectType.TimeTicks,
                    this.upTime || Math.floor (process.uptime () * 100));

    writeVarbinds (buffer, this.varbinds);

    buffer.endSequence ();

};

var TrapV2Pdu = function () {
this.type = PduType.TrapV2;
TrapV2Pdu.super_.apply (this, arguments);
};

util.inherits (TrapV2Pdu, SimplePdu);

/*****************************************************************************
** Message class definitions
**/

var RequestMessage = function (version, community, pdu) {
this.version = version;
this.community = community;
this.pdu = pdu;
};

RequestMessage.prototype.toBuffer = function () {
if (this.buffer)
return this.buffer;

    var writer = new ber.Writer ();

    writer.startSequence ();

    writer.writeInt (this.version);
    writer.writeString (this.community);

    this.pdu.toBuffer (writer);

    writer.endSequence ();

    this.buffer = writer.buffer;

    return this.buffer;

};

var ResponseMessage = function (buffer) {
var reader = new ber.Reader (buffer);

    reader.readSequence ();

    this.version = reader.readInt ();
    this.community = reader.readString ();

    var type = reader.peek ();

    if (type == PduType.GetResponse) {
            this.pdu = new GetResponsePdu (reader);
    } else {
            throw new ResponseInvalidError ("Unknown PDU type '" + type
                            + "' in response");
    }

};

/*****************************************************************************
** Session class definition
**/

var Session = function (target, community, options) {
console.log(target);
this.target = target || "127.0.0.1";
this.community = community || "public";

    this.version = (options && options.version)
                    ? options.version
                    : Version1;

    this.transport = (options && options.transport)
                    ? options.transport
                    : "udp4";
    this.port = (options && options.port )
                    ? options.port
                    : 161;
    this.trapPort = (options && options.trapPort )
                    ? options.trapPort
                    : 162;

    this.retries = (options && (options.retries || options.retries == 0))
                    ? options.retries
                    : 1;
    this.timeout = (options && options.timeout)
                    ? options.timeout
                    : 5000;

    this.sourceAddress = (options && options.sourceAddress )
                    ? options.sourceAddress
                    : undefined;
    this.sourcePort = (options && options.sourcePort )
                    ? parseInt(options.sourcePort)
                    : undefined;

    this.idBitsSize = (options && options.idBitsSize)
                    ? parseInt(options.idBitsSize)
                    : 32;

    this.reqs = {};
    this.reqCount = 0;

    this.dgram = dgram.createSocket (this.transport);
    this.dgram.unref();

    var me = this;
    this.dgram.on ("message", me.onMsg.bind (me));
    this.dgram.on ("close", me.onClose.bind (me));
    this.dgram.on ("error", me.onError.bind (me));

    if (this.sourceAddress || this.sourcePort)
            this.dgram.bind (this.sourcePort, this.sourceAddress);

};

util.inherits (Session, events.EventEmitter);

Session.prototype.close = function () {
this.dgram.close ();
return this;
};

Session.prototype.cancelRequests = function (error) {
var id;
for (id in this.reqs) {
var req = this.reqs[id];
this.unregisterRequest (req.id);
req.responseCb (error);
}
};

function _generateId (bitSize) {
if (bitSize === 16) {
return Math.floor(Math.random() * 10000) % 65535;
}
return Math.floor(Math.random() * 100000000) % 4294967295;
}

Session.prototype.get = function (oids, responseCb) {
function feedCb (req, message) {
var pdu = message.pdu;
var varbinds = [];

            if (req.message.pdu.varbinds.length != pdu.varbinds.length) {
                    req.responseCb (new ResponseInvalidError ("Requested OIDs do not "
                                    + "match response OIDs"));
            } else {
                    for (var i = 0; i < req.message.pdu.varbinds.length; i++) {
                            if (req.message.pdu.varbinds[i].oid != pdu.varbinds[i].oid) {
                                    req.responseCb (new ResponseInvalidError ("OID '"
                                                    + req.message.pdu.varbinds[i].oid
                                                    + "' in request at positiion '" + i + "' does not "
                                                    + "match OID '" + pdu.varbinds[i].oid + "' in response "
                                                    + "at position '" + i + "'"));
                                    return;
                            } else {
                                    varbinds.push (pdu.varbinds[i]);
                            }
                    }

                    req.responseCb (null, varbinds);
            }
    }

    var pduVarbinds = [];

    for (var i = 0; i < oids.length; i++) {
            var varbind = {
                    oid: oids[i]
            };
            pduVarbinds.push (varbind);
    }

    this.simpleGet (GetRequestPdu, feedCb, pduVarbinds, responseCb);

    return this;

};

Session.prototype.getBulk = function () {
var oids, nonRepeaters, maxRepetitions, responseCb;

    if (arguments.length >= 4) {
            oids = arguments[0];
            nonRepeaters = arguments[1];
            maxRepetitions = arguments[2];
            responseCb = arguments[3];
    } else if (arguments.length >= 3) {
            oids = arguments[0];
            nonRepeaters = arguments[1];
            maxRepetitions = 10;
            responseCb = arguments[2];
    } else {
            oids = arguments[0];
            nonRepeaters = 0;
            maxRepetitions = 10;
            responseCb = arguments[1];
    }

    function feedCb (req, message) {
            var pdu = message.pdu;
            var varbinds = [];
            var i = 0;

            // first walk through and grab non-repeaters
            if (pdu.varbinds.length < nonRepeaters) {
                    req.responseCb (new ResponseInvalidError ("Varbind count in "
                                    + "response '" + pdu.varbinds.length + "' is less than "
                                    + "non-repeaters '" + nonRepeaters + "' in request"));
            } else {
                    for ( ; i < nonRepeaters; i++) {
                            if (isVarbindError (pdu.varbinds[i])) {
                                    varbinds.push (pdu.varbinds[i]);
                            } else if (! oidFollowsOid (req.message.pdu.varbinds[i].oid,
                                            pdu.varbinds[i].oid)) {
                                    req.responseCb (new ResponseInvalidError ("OID '"
                                                    + req.message.pdu.varbinds[i].oid + "' in request at "
                                                    + "positiion '" + i + "' does not precede "
                                                    + "OID '" + pdu.varbinds[i].oid + "' in response "
                                                    + "at position '" + i + "'"));
                                    return;
                            } else {
                                    varbinds.push (pdu.varbinds[i]);
                            }
                    }
            }

            var repeaters = req.message.pdu.varbinds.length - nonRepeaters;

            // secondly walk through and grab repeaters
            if (pdu.varbinds.length % (repeaters)) {
                    req.responseCb (new ResponseInvalidError ("Varbind count in "
                                    + "response '" + pdu.varbinds.length + "' is not a "
                                    + "multiple of repeaters '" + repeaters
                                    + "' plus non-repeaters '" + nonRepeaters + "' in request"));
            } else {
                    while (i < pdu.varbinds.length) {
                            for (var j = 0; j < repeaters; j++, i++) {
                                    var reqIndex = nonRepeaters + j;
                                    var respIndex = i;

                                    if (isVarbindError (pdu.varbinds[respIndex])) {
                                            if (! varbinds[reqIndex])
                                                    varbinds[reqIndex] = [];
                                            varbinds[reqIndex].push (pdu.varbinds[respIndex]);
                                    } else if (! oidFollowsOid (
                                                    req.message.pdu.varbinds[reqIndex].oid,
                                                    pdu.varbinds[respIndex].oid)) {
                                            req.responseCb (new ResponseInvalidError ("OID '"
                                                            + req.message.pdu.varbinds[reqIndex].oid
                                                            + "' in request at positiion '" + (reqIndex)
                                                            + "' does not precede OID '"
                                                            + pdu.varbinds[respIndex].oid
                                                            + "' in response at position '" + (respIndex) + "'"));
                                            return;
                                    } else {
                                            if (! varbinds[reqIndex])
                                                    varbinds[reqIndex] = [];
                                            varbinds[reqIndex].push (pdu.varbinds[respIndex]);
                                    }
                            }
                    }
            }

            req.responseCb (null, varbinds);
    }

    var pduVarbinds = [];

    for (var i = 0; i < oids.length; i++) {
            var varbind = {
                    oid: oids[i]
            };
            pduVarbinds.push (varbind);
    }

    var options = {
            nonRepeaters: nonRepeaters,
            maxRepetitions: maxRepetitions
    };

    this.simpleGet (GetBulkRequestPdu, feedCb, pduVarbinds, responseCb,
                    options);

    return this;

};

Session.prototype.getNext = function (oids, responseCb) {
function feedCb (req, message) {
var pdu = message.pdu;
var varbinds = [];

            if (req.message.pdu.varbinds.length != pdu.varbinds.length) {
                    req.responseCb (new ResponseInvalidError ("Requested OIDs do not "
                                    + "match response OIDs"));
            } else {
                    for (var i = 0; i < req.message.pdu.varbinds.length; i++) {
                            if (isVarbindError (pdu.varbinds[i])) {
                                    varbinds.push (pdu.varbinds[i]);
                            } else if (! oidFollowsOid (req.message.pdu.varbinds[i].oid,
                                            pdu.varbinds[i].oid)) {
                                    req.responseCb (new ResponseInvalidError ("OID '"
                                                    + req.message.pdu.varbinds[i].oid + "' in request at "
                                                    + "positiion '" + i + "' does not precede "
                                                    + "OID '" + pdu.varbinds[i].oid + "' in response "
                                                    + "at position '" + i + "'"));
                                    return;
                            } else {
                                    varbinds.push (pdu.varbinds[i]);
                            }
                    }

                    req.responseCb (null, varbinds);
            }
    }

    var pduVarbinds = [];

    for (var i = 0; i < oids.length; i++) {
            var varbind = {
                    oid: oids[i]
            };
            pduVarbinds.push (varbind);
    }

    this.simpleGet (GetNextRequestPdu, feedCb, pduVarbinds, responseCb);

    return this;

};

Session.prototype.inform = function () {
var typeOrOid = arguments[0];
var varbinds, options = {}, responseCb;

    /**
     ** Support the following signatures:
     **
     **    typeOrOid, varbinds, options, callback
     **    typeOrOid, varbinds, callback
     **    typeOrOid, options, callback
     **    typeOrOid, callback
     **/
    if (arguments.length >= 4) {
            varbinds = arguments[1];
            options = arguments[2];
            responseCb = arguments[3];
    } else if (arguments.length >= 3) {
            if (arguments[1].constructor != Array) {
                    varbinds = [];
                    options = arguments[1];
                    responseCb = arguments[2];
            } else {
                    varbinds = arguments[1];
                    responseCb = arguments[2];
            }
    } else {
            varbinds = [];
            responseCb = arguments[1];
    }

    function feedCb (req, message) {
            var pdu = message.pdu;
            var varbinds = [];

            if (req.message.pdu.varbinds.length != pdu.varbinds.length) {
                    req.responseCb (new ResponseInvalidError ("Inform OIDs do not "
                                    + "match response OIDs"));
            } else {
                    for (var i = 0; i < req.message.pdu.varbinds.length; i++) {
                            if (req.message.pdu.varbinds[i].oid != pdu.varbinds[i].oid) {
                                    req.responseCb (new ResponseInvalidError ("OID '"
                                                    + req.message.pdu.varbinds[i].oid
                                                    + "' in inform at positiion '" + i + "' does not "
                                                    + "match OID '" + pdu.varbinds[i].oid + "' in response "
                                                    + "at position '" + i + "'"));
                                    return;
                            } else {
                                    varbinds.push (pdu.varbinds[i]);
                            }
                    }

                    req.responseCb (null, varbinds);
            }
    }

    if (typeof typeOrOid != "string")
            typeOrOid = "1.3.6.1.6.3.1.1.5." + (typeOrOid + 1);

    var pduVarbinds = [
            {
                    oid: "1.3.6.1.2.1.1.3.0",
                    type: ObjectType.TimeTicks,
                    value: options.upTime || Math.floor (process.uptime () * 100)
            },
            {
                    oid: "1.3.6.1.6.3.1.1.4.1.0",
                    type: ObjectType.OID,
                    value: typeOrOid
            }
    ];

    for (var i = 0; i < varbinds.length; i++) {
            var varbind = {
                    oid: varbinds[i].oid,
                    type: varbinds[i].type,
                    value: varbinds[i].value
            };
            pduVarbinds.push (varbind);
    }

    options.port = this.trapPort;

    this.simpleGet (InformRequestPdu, feedCb, pduVarbinds, responseCb, options);

    return this;

};

Session.prototype.onClose = function () {
this.cancelRequests (new Error ("Socket forcibly closed"));
this.emit ("close");
};

Session.prototype.onError = function (error) {
this.emit (error);
};

Session.prototype.onMsg = function (buffer, remote) {
try {
var message = new ResponseMessage (buffer);

            var req = this.unregisterRequest (message.pdu.id);
            if (! req)
                    return;

            try {
                    if (message.version != req.message.version) {
                            req.responseCb (new ResponseInvalidError ("Version in request '"
                                            + req.message.version + "' does not match version in "
                                            + "response '" + message.version));
                    } else if (message.community != req.message.community) {
                            req.responseCb (new ResponseInvalidError ("Community '"
                                            + req.message.community + "' in request does not match "
                                            + "community '" + message.community + "' in response"));
                    } else if (message.pdu.type == PduType.GetResponse) {
                            req.onResponse (req, message);
                    } else {
                            req.responseCb (new ResponseInvalidError ("Unknown PDU type '"
                                            + message.pdu.type + "' in response"));
                    }
            } catch (error) {
                    req.responseCb (error);
            }
    } catch (error) {
            this.emit("error", error);
    }

};

Session.prototype.onSimpleGetResponse = function (req, message) {
var pdu = message.pdu;

    if (pdu.errorStatus > 0) {
            var statusString = ErrorStatus[pdu.errorStatus]
                            || ErrorStatus.GeneralError;
            var statusCode = ErrorStatus[statusString]
                            || ErrorStatus[ErrorStatus.GeneralError];

            if (pdu.errorIndex <= 0 || pdu.errorIndex > pdu.varbinds.length) {
                    req.responseCb (new RequestFailedError (statusString, statusCode));
            } else {
                    var oid = pdu.varbinds[pdu.errorIndex - 1].oid;
                    var error = new RequestFailedError (statusString + ": " + oid,
                                    statusCode);
                    req.responseCb (error);
            }
    } else {
            req.feedCb (req, message);
    }

};

Session.prototype.registerRequest = function (req) {
if (! this.reqs[req.id]) {
this.reqs[req.id] = req;
if (this.reqCount <= 0)
this.dgram.ref();
this.reqCount++;
}
var me = this;
req.timer = setTimeout (function () {
if (req.retries-- > 0) {
me.send (req);
} else {
me.unregisterRequest (req.id);
req.responseCb (new RequestTimedOutError (
"Request timed out"));
}
}, req.timeout);
};

Session.prototype.send = function (req, noWait) {
try {
var me = this;

            var buffer = req.message.toBuffer ();

            this.dgram.send (buffer, 0, buffer.length, req.port, this.target,
                            function (error, bytes) {
                    if (error) {
                            req.responseCb (error);
                    } else {
                            if (noWait) {
                                    req.responseCb (null);
                            } else {
                                    me.registerRequest (req);
                            }
                    }
            });
    } catch (error) {
            req.responseCb (error);
    }

    return this;

};

Session.prototype.set = function (varbinds, responseCb) {
function feedCb (req, message) {
var pdu = message.pdu;
var varbinds = [];

            if (req.message.pdu.varbinds.length != pdu.varbinds.length) {
                    req.responseCb (new ResponseInvalidError ("Requested OIDs do not "
                                    + "match response OIDs"));
            } else {
                    for (var i = 0; i < req.message.pdu.varbinds.length; i++) {
                            if (req.message.pdu.varbinds[i].oid != pdu.varbinds[i].oid) {
                                    req.responseCb (new ResponseInvalidError ("OID '"
                                                    + req.message.pdu.varbinds[i].oid
                                                    + "' in request at positiion '" + i + "' does not "
                                                    + "match OID '" + pdu.varbinds[i].oid + "' in response "
                                                    + "at position '" + i + "'"));
                                    return;
                            } else {
                                    varbinds.push (pdu.varbinds[i]);
                            }
                    }

                    req.responseCb (null, varbinds);
            }
    }

    var pduVarbinds = [];

    for (var i = 0; i < varbinds.length; i++) {
            var varbind = {
                    oid: varbinds[i].oid,
                    type: varbinds[i].type,
                    value: varbinds[i].value
            };
            pduVarbinds.push (varbind);
    }

    this.simpleGet (SetRequestPdu, feedCb, pduVarbinds, responseCb);

    return this;

};

Session.prototype.simpleGet = function (pduClass, feedCb, varbinds,
responseCb, options) {
var req = {};

    try {
            var id = _generateId (this.idBitsSize);
            var pdu = new pduClass (id, varbinds, options);
            var message = new RequestMessage (this.version, this.community, pdu);

            req = {
                    id: id,
                    message: message,
                    responseCb: responseCb,
                    retries: this.retries,
                    timeout: this.timeout,
                    onResponse: this.onSimpleGetResponse,
                    feedCb: feedCb,
                    port: (options && options.port) ? options.port : this.port
            };

            this.send (req);
    } catch (error) {
            if (req.responseCb)
                    req.responseCb (error);
    }

};

function subtreeCb (req, varbinds) {
var done = 0;

    for (var i = varbinds.length; i > 0; i--) {
            if (! oidInSubtree (req.baseOid, varbinds[i - 1].oid)) {
                    done = 1;
                    varbinds.pop ();
            }
    }

    if (varbinds.length > 0)
            req.feedCb (varbinds);

    if (done)
            return true;

}

Session.prototype.subtree = function () {
var me = this;
var oid = arguments[0];
var maxRepetitions, feedCb, doneCb;

    if (arguments.length < 4) {
            maxRepetitions = 20;
            feedCb = arguments[1];
            doneCb = arguments[2];
    } else {
            maxRepetitions = arguments[1];
            feedCb = arguments[2];
            doneCb = arguments[3];
    }

    var req = {
            feedCb: feedCb,
            doneCb: doneCb,
            maxRepetitions: maxRepetitions,
            baseOid: oid
    };

    this.walk (oid, maxRepetitions, subtreeCb.bind (me, req), doneCb);

    return this;

};

function tableColumnsResponseCb (req, error) {
if (error) {
req.responseCb (error);
} else if (req.error) {
req.responseCb (req.error);
} else {
if (req.columns.length > 0) {
var column = req.columns.pop ();
var me = this;
this.subtree (req.rowOid + column, req.maxRepetitions,
tableColumnsFeedCb.bind (me, req),
tableColumnsResponseCb.bind (me, req));
} else {
req.responseCb (null, req.table);
}
}
}

function tableColumnsFeedCb (req, varbinds) {
for (var i = 0; i < varbinds.length; i++) {
if (isVarbindError (varbinds[i])) {
req.error = new RequestFailedError (varbindError (varbind[i]));
return true;
}

            var oid = varbinds[i].oid.replace (req.rowOid, "");
            if (oid && oid != varbinds[i].oid) {
                    var match = oid.match (/^(\d+)\.(.+)$/);
                    if (match && match[1] > 0) {
                            if (! req.table[match[2]])
                                    req.table[match[2]] = {};
                            req.table[match[2]][match[1]] = varbinds[i].value;
                    }
            }
    }

}

Session.prototype.tableColumns = function () {
var me = this;

    var oid = arguments[0];
    var columns = arguments[1];
    var maxRepetitions, responseCb;

    if (arguments.length < 4) {
            responseCb = arguments[2];
            maxRepetitions = 20;
    } else {
            maxRepetitions = arguments[2];
            responseCb = arguments[3];
    }

    var req = {
            responseCb: responseCb,
            maxRepetitions: maxRepetitions,
            baseOid: oid,
            rowOid: oid + ".1.",
            columns: columns.slice(0),
            table: {}
    };

    if (req.columns.length > 0) {
            var column = req.columns.pop ();
            this.subtree (req.rowOid + column, maxRepetitions,
                            tableColumnsFeedCb.bind (me, req),
                            tableColumnsResponseCb.bind (me, req));
    }

    return this;

};

function tableResponseCb (req, error) {
if (error)
req.responseCb (error);
else if (req.error)
req.responseCb (req.error);
else
req.responseCb (null, req.table);
}

function tableFeedCb (req, varbinds) {
for (var i = 0; i < varbinds.length; i++) {
if (isVarbindError (varbinds[i])) {
req.error = new RequestFailedError (varbindError (varbind[i]));
return true;
}

            var oid = varbinds[i].oid.replace (req.rowOid, "");
            if (oid && oid != varbinds[i].oid) {
                    var match = oid.match (/^(\d+)\.(.+)$/);
                    if (match && match[1] > 0) {
                            if (! req.table[match[2]])
                                    req.table[match[2]] = {};
                            req.table[match[2]][match[1]] = varbinds[i].value;
                    }
            }
    }

}

Session.prototype.table = function () {
var me = this;

    var oid = arguments[0];
    var maxRepetitions, responseCb;

    if (arguments.length < 3) {
            responseCb = arguments[1];
            maxRepetitions = 20;
    } else {
            maxRepetitions = arguments[1];
            responseCb = arguments[2];
    }

    var req = {
            responseCb: responseCb,
            maxRepetitions: maxRepetitions,
            baseOid: oid,
            rowOid: oid + ".1.",
            table: {}
    };

    this.subtree (oid, maxRepetitions, tableFeedCb.bind (me, req),
                    tableResponseCb.bind (me, req));

    return this;

};

Session.prototype.trap = function () {
var req = {};

    try {
            var typeOrOid = arguments[0];
            var varbinds, options = {}, responseCb;

            /**
             ** Support the following signatures:
             **
             **    typeOrOid, varbinds, options, callback
             **    typeOrOid, varbinds, agentAddr, callback
             **    typeOrOid, varbinds, callback
             **    typeOrOid, agentAddr, callback
             **    typeOrOid, options, callback
             **    typeOrOid, callback
             **/
            if (arguments.length >= 4) {
                    varbinds = arguments[1];
                    if (typeof arguments[2] == "string") {
                            options.agentAddr = arguments[2];
                    } else if (arguments[2].constructor != Array) {
                            options = arguments[2];
                    }
                    responseCb = arguments[3];
            } else if (arguments.length >= 3) {
                    if (typeof arguments[1] == "string") {
                            varbinds = [];
                            options.agentAddr = arguments[1];
                    } else if (arguments[1].constructor != Array) {
                            varbinds = [];
                            options = arguments[1];
                    } else {
                            varbinds = arguments[1];
                            agentAddr = null;
                    }
                    responseCb = arguments[2];
            } else {
                    varbinds = [];
                    responseCb = arguments[1];
            }

            var pdu, pduVarbinds = [];

            for (var i = 0; i < varbinds.length; i++) {
                    var varbind = {
                            oid: varbinds[i].oid,
                            type: varbinds[i].type,
                            value: varbinds[i].value
                    };
                    pduVarbinds.push (varbind);
            }

            var id = _generateId (this.idBitsSize);

            if (this.version == Version2c) {
                    if (typeof typeOrOid != "string")
                            typeOrOid = "1.3.6.1.6.3.1.1.5." + (typeOrOid + 1);

                    pduVarbinds.unshift (
                            {
                                    oid: "1.3.6.1.2.1.1.3.0",
                                    type: ObjectType.TimeTicks,
                                    value: options.upTime || Math.floor (process.uptime () * 100)
                            },
                            {
                                    oid: "1.3.6.1.6.3.1.1.4.1.0",
                                    type: ObjectType.OID,
                                    value: typeOrOid
                            }
                    );

                    pdu = new TrapV2Pdu (id, pduVarbinds, options);
            } else {
                    pdu = new TrapPdu (typeOrOid, pduVarbinds, options);
            }

            var message = new RequestMessage (this.version, this.community, pdu);

            req = {
                    id: id,
                    message: message,
                    responseCb: responseCb,
                    port: this.trapPort
            };

            this.send (req, true);
    } catch (error) {
            if (req.responseCb)
                    req.responseCb (error);
    }

    return this;

};

Session.prototype.unregisterRequest = function (id) {
var req = this.reqs[id];
if (req) {
delete this.reqs[id];
clearTimeout (req.timer);
delete req.timer;
this.reqCount--;
if (this.reqCount <= 0)
this.dgram.unref();
return req;
} else {
return null;
}
};

function walkCb (req, error, varbinds) {
var done = 0;
var oid;

    if (error) {
            if (error instanceof RequestFailedError) {
                    if (error.status != ErrorStatus.NoSuchName) {
                            req.doneCb (error);
                            return;
                    } else {
                            // signal the version 1 walk code below that it should stop
                            done = 1;
                    }
            } else {
                    req.doneCb (error);
                    return;
            }
    }

    if (this.version == Version2c) {
            for (var i = varbinds[0].length; i > 0; i--) {
                    if (varbinds[0][i - 1].type == ObjectType.EndOfMibView) {
                            varbinds[0].pop ();
                            done = 1;
                    }
            }
            if (req.feedCb (varbinds[0]))
                    done = 1;
            if (! done)
                    oid = varbinds[0][varbinds[0].length - 1].oid;
    } else {
            if (! done) {
                    if (req.feedCb (varbinds)) {
                            done = 1;
                    } else {
                            oid = varbinds[0].oid;
                    }
            }
    }

    if (done)
            req.doneCb (null);
    else
            this.walk (oid, req.maxRepetitions, req.feedCb, req.doneCb,
                            req.baseOid);

}

Session.prototype.walk = function () {
var me = this;
var oid = arguments[0];
var maxRepetitions, feedCb, doneCb, baseOid;

    if (arguments.length < 4) {
            maxRepetitions = 20;
            feedCb = arguments[1];
            doneCb = arguments[2];
    } else {
            maxRepetitions = arguments[1];
            feedCb = arguments[2];
            doneCb = arguments[3];
    }

    var req = {
            maxRepetitions: maxRepetitions,
            feedCb: feedCb,
            doneCb: doneCb
    };

    if (this.version == Version2c)
            this.getBulk ([oid], 0, maxRepetitions,
                            walkCb.bind (me, req));
    else
            this.getNext ([oid], walkCb.bind (me, req));

    return this;

};

/*****************************************************************************
** Exports
**/

exports.Session = Session;

exports.createSession = function (target, community, options) {
return new Session (target, community, options);
};

exports.isVarbindError = isVarbindError;
exports.varbindError = varbindError;

exports.Version1 = Version1;
exports.Version2c = Version2c;

exports.ErrorStatus = ErrorStatus;
exports.TrapType = TrapType;
exports.ObjectType = ObjectType;

exports.ResponseInvalidError = ResponseInvalidError;
exports.RequestInvalidError = RequestInvalidError;
exports.RequestFailedError = RequestFailedError;
exports.RequestTimedOutError = RequestTimedOutError;

/**
** We've added this for testing.
**/
exports.ObjectParser = {
readInt: readInt,
readUint: readUint
};
Browserify generated code.

}).call(this,require('_process'),require("buffer").Buffer)
},{"_process":7,"asn1-ber":12,"buffer":4,"dgram":1,"events":5,"util":10}]},{},[11]);
`

@gireeshpunathil
Copy link
Member

Thanks. looks like drgam is not supported by browserify as it is highly platform dependent low level code and not necessarily all the browsers support it nor in a uniform manner.

Please see the open issue under browserify for this:
browserify/browserify#1788

It is possible that there are packages that implement this in pure JS. You may follow in 1788 to get more information.

You can find the supported in-built modules from node in this page.

Hope this helps!
https://www.npmjs.com/package/browserify

@gireeshpunathil
Copy link
Member

closing as answered.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
2 participants
@gireeshpunathil @mj-mrityunjay