|
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
|
|
|
module.exports.get = require('./lib/get'); |
|
module.exports.search = require('./lib/search'); |
|
},{"./lib/get":2,"./lib/search":3}],2:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
/** |
|
* Module dependencies. |
|
*/ |
|
|
|
var http = require('json-http'); |
|
var validator = require('./validator'); |
|
|
|
/** |
|
* Validate the parameters for the get request. |
|
* |
|
* @param {Object} params |
|
* @return {Object} validation state |
|
* @api private |
|
*/ |
|
var _validateParams = function(params) { |
|
|
|
if (!params) { |
|
return { |
|
error: 'params cannot be null.' |
|
}; |
|
} |
|
|
|
// title and id are optional, but one must be present |
|
if (!params.hasOwnProperty('id') && !params.hasOwnProperty('title')) { |
|
return { |
|
error: 'id or title param required.' |
|
}; |
|
} |
|
|
|
if (params.hasOwnProperty('title') && !validator.isString(params.title)) { |
|
return { |
|
error: 'title must be a string.' |
|
}; |
|
} |
|
|
|
if (params.hasOwnProperty('id') && !validator.isString(params.id)) { |
|
return { |
|
error: 'id must be a string.' |
|
}; |
|
} |
|
|
|
if (!validator.isValidType(params)) { |
|
return { |
|
error: 'type must be: movie, series, episode.' |
|
}; |
|
} |
|
|
|
if (params.hasOwnProperty('year') && !validator.isNumber(params.year)) { |
|
return { |
|
error: 'year must be a valid number' |
|
}; |
|
} |
|
|
|
if (!validator.isValidPlotType(params)) { |
|
return { |
|
error: 'plot must be: short, full.' |
|
}; |
|
} |
|
|
|
if (params.hasOwnProperty('incTomatoes') && |
|
!validator.isBoolean(params.incTomatoes)) { |
|
return { |
|
error: 'incTomatoes must be a boolean.' |
|
}; |
|
} |
|
|
|
}; |
|
|
|
/** |
|
* Build the url string from the parameters. |
|
* |
|
* @param {Object} params |
|
* @return {String} url to call omdbapi.com |
|
* @api private |
|
*/ |
|
var _createUrl = function(params) { |
|
|
|
var baseUrl = 'http://www.omdbapi.com/'; |
|
var query = '?'; |
|
|
|
if (params.id) { |
|
query += 'i='.concat(params.id); |
|
} |
|
|
|
if (params.title) { |
|
|
|
if (params.id) { |
|
query += '&t='; |
|
} else { |
|
query += 't='; |
|
} |
|
|
|
query += encodeURIComponent(params.title); |
|
} |
|
|
|
if (params.year) { |
|
query += '&y='.concat(params.year); |
|
} |
|
|
|
if (params.incTomatoes) { |
|
query += '&tomatoes='.concat(params.incTomatoes); |
|
} |
|
|
|
if (params.type) { |
|
query += '&type='.concat(params.type); |
|
} |
|
|
|
if (params.plot) { |
|
query += '&plot='.concat(params.plot); |
|
} |
|
|
|
return baseUrl.concat(query, '&r=json&v=1'); |
|
}; |
|
|
|
/** |
|
* Get film content from the imdb http service. |
|
* |
|
* @param {Object} params |
|
* @param {Function} callback |
|
* @api public |
|
*/ |
|
module.exports = function(params, callback) { |
|
|
|
var validate = _validateParams(params); |
|
var timeout = (params) ? params.timeout || 10000 : 10000; |
|
|
|
if (validate) { |
|
callback(validate.error, null); |
|
return; |
|
} |
|
|
|
http.getJson(_createUrl(params), timeout, function handleResponse(err, data) { |
|
|
|
if (err) { |
|
callback(err, null); |
|
return; |
|
} |
|
|
|
if (data.Error) { |
|
callback(data.Error, null); |
|
} else { |
|
callback(null, data); |
|
} |
|
|
|
}); |
|
}; |
|
|
|
},{"./validator":4,"json-http":5}],3:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
/** |
|
* Module dependencies. |
|
*/ |
|
|
|
var http = require('json-http'); |
|
var validator = require('./validator'); |
|
|
|
/** |
|
* Validate the parameters for the search request. |
|
* |
|
* @param {Object} params |
|
* @return {Object} validation state |
|
* @api private |
|
*/ |
|
var _validateParams = function(params) { |
|
|
|
if (!params) { |
|
return { |
|
error: 'params cannot be null.' |
|
}; |
|
} |
|
|
|
// query is mandatory |
|
if (!params.hasOwnProperty('query')) { |
|
return { |
|
error: 'query param required.' |
|
}; |
|
} |
|
|
|
if (!validator.isString(params.query)) { |
|
return { |
|
error: 'query must be a string.' |
|
}; |
|
} |
|
|
|
if (!validator.isValidType(params)) { |
|
return { |
|
error: 'type must be: movie, series, episode.' |
|
}; |
|
} |
|
|
|
if (params.hasOwnProperty('year') && !validator.isNumber(params.year)) { |
|
return { |
|
error: 'year must be a valid number' |
|
}; |
|
} |
|
|
|
}; |
|
|
|
/** |
|
* Build the url string from the parameters. |
|
* |
|
* @param {Object} params |
|
* @return {String} url to call omdbapi.com |
|
* @api private |
|
*/ |
|
var _createUrl = function(params) { |
|
|
|
var baseUrl = 'http://www.omdbapi.com/'; |
|
var query = '?'; |
|
|
|
// mandatory |
|
query += 's='.concat(encodeURIComponent(params.query)); |
|
|
|
if (params.year) { |
|
query += '&y='.concat(params.year); |
|
} |
|
|
|
if (params.type) { |
|
query += '&type='.concat(params.type); |
|
} |
|
|
|
return baseUrl.concat(query, '&r=json&v=1'); |
|
}; |
|
|
|
/** |
|
* Search film content from the imdb http service. |
|
* |
|
* @param {Object} params |
|
* @param {Function} callback |
|
* @api public |
|
*/ |
|
module.exports = function(params, callback) { |
|
|
|
var validate = _validateParams(params); |
|
var timeout = (params) ? params.timeout || 10000 : 10000; |
|
|
|
if (validate) { |
|
callback(validate.error, null); |
|
return; |
|
} |
|
|
|
http.getJson(_createUrl(params), timeout, function handleResponse(err, data) { |
|
|
|
if (err) { |
|
callback(err, null); |
|
return; |
|
} |
|
|
|
if (data.Error) { |
|
callback(data.Error, null); |
|
} else { |
|
callback(null, data); |
|
} |
|
|
|
}); |
|
|
|
}; |
|
|
|
},{"./validator":4,"json-http":5}],4:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
/** |
|
* Validate a data type for a given object's property. |
|
* |
|
* @param {String} value |
|
* @param {String} expected data type |
|
* @return {Boolean} whether the property is valid |
|
* @api private |
|
*/ |
|
var _isDataType = function(value, type) { |
|
return typeof(value) === type; |
|
}; |
|
|
|
/** |
|
* Validate string. |
|
* |
|
* @param {String} value |
|
* @return {Boolean} whether the property is valid |
|
* @api public |
|
*/ |
|
module.exports.isString = function(value) { |
|
return _isDataType(value, 'string'); |
|
}; |
|
|
|
/** |
|
* Validate number. |
|
* |
|
* @param {Number} value |
|
* @return {Boolean} whether the property is valid |
|
* @api public |
|
*/ |
|
module.exports.isNumber = function(value) { |
|
return _isDataType(value, 'number'); |
|
}; |
|
|
|
/** |
|
* Validate boolean. |
|
* |
|
* @param {Boolean} value |
|
* @return {Boolean} whether the property is valid |
|
* @api public |
|
*/ |
|
module.exports.isBoolean = function(value) { |
|
return _isDataType(value, 'boolean'); |
|
}; |
|
|
|
/** |
|
* Validate result type - optional and (movie|series|episode) |
|
* |
|
* @param {Object} params |
|
* @return {Boolean} whether the property is valid |
|
* @api public |
|
*/ |
|
module.exports.isValidType = function(params) { |
|
if (params.hasOwnProperty('type')) { |
|
return params.type.match('movie|series|episode') !== null; |
|
} |
|
|
|
return true; |
|
}; |
|
|
|
/** |
|
* Validate plot type - optional and (short|full). |
|
* |
|
* @param {Object} params |
|
* @return {Boolean} whether the property is valid |
|
* @api public |
|
*/ |
|
module.exports.isValidPlotType = function(params) { |
|
if (params.hasOwnProperty('plot')) { |
|
return params.plot.match('short|full') !== null; |
|
} |
|
|
|
return true; |
|
}; |
|
|
|
},{}],5:[function(require,module,exports){ |
|
|
|
module.exports.getJson = require('./lib/get-json'); |
|
},{"./lib/get-json":6}],6:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
/** |
|
* Module dependencies. |
|
*/ |
|
|
|
var http = require('http'); |
|
|
|
/** |
|
* Simple wrapper for JSON HTTP get request. |
|
* |
|
* @param {string} The url to call |
|
* @param {number} an (optional) http timeout value |
|
* @param {function} the callback function |
|
* @api public |
|
*/ |
|
module.exports = function() { |
|
|
|
var url = arguments[0]; |
|
var timeoutInMs = 10000; |
|
var callback; |
|
|
|
if (typeof(arguments[1]) === 'function') { |
|
callback = arguments[1]; |
|
} |
|
|
|
if (typeof(arguments[1]) === 'number') { |
|
timeoutInMs = arguments[1]; |
|
callback = arguments[2]; |
|
} |
|
|
|
var request = http.get(url, function handleResponse(res) { |
|
|
|
var body = ''; |
|
res.setEncoding('utf8'); |
|
|
|
res.on('data', function(chunk) { |
|
body += chunk; |
|
}); |
|
|
|
res.on('end', function() { |
|
var response = JSON.parse(body); |
|
callback(null, response); |
|
}); |
|
|
|
}).on('error', function(e) { |
|
callback(e, null); |
|
}); |
|
|
|
// if the request takes longer than 1 second, exit |
|
request.setTimeout(timeoutInMs, function handleTimeout() { |
|
callback('timeout exceeded', null); |
|
}); |
|
|
|
}; |
|
},{"http":13}],7:[function(require,module,exports){ |
|
|
|
},{}],8:[function(require,module,exports){ |
|
/*! |
|
* The buffer module from node.js, for the browser. |
|
* |
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> |
|
* @license MIT |
|
*/ |
|
|
|
var base64 = require('base64-js') |
|
var ieee754 = require('ieee754') |
|
var isArray = require('is-array') |
|
|
|
exports.Buffer = Buffer |
|
exports.SlowBuffer = SlowBuffer |
|
exports.INSPECT_MAX_BYTES = 50 |
|
Buffer.poolSize = 8192 // not used by this implementation |
|
|
|
var kMaxLength = 0x3fffffff |
|
var rootParent = {} |
|
|
|
/** |
|
* If `Buffer.TYPED_ARRAY_SUPPORT`: |
|
* === true Use Uint8Array implementation (fastest) |
|
* === false Use 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+. |
|
* |
|
* Note: |
|
* |
|
* - Implementation must support adding new properties to `Uint8Array` instances. |
|
* Firefox 4-29 lacked support, fixed in Firefox 30+. |
|
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. |
|
* |
|
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. |
|
* |
|
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of |
|
* incorrect length in some situations. |
|
* |
|
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will |
|
* get the Object implementation, which is slower but will work correctly. |
|
*/ |
|
Buffer.TYPED_ARRAY_SUPPORT = (function () { |
|
try { |
|
var buf = new ArrayBuffer(0) |
|
var arr = new Uint8Array(buf) |
|
arr.foo = function () { return 42 } |
|
return arr.foo() === 42 && // typed array instances can be augmented |
|
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` |
|
new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` |
|
} catch (e) { |
|
return false |
|
} |
|
})() |
|
|
|
/** |
|
* Class: Buffer |
|
* ============= |
|
* |
|
* The Buffer constructor returns instances of `Uint8Array` that are augmented |
|
* with function properties for all the node `Buffer` API functions. We use |
|
* `Uint8Array` so that square bracket notation works as expected -- it returns |
|
* a single octet. |
|
* |
|
* By augmenting the instances, we can avoid modifying the `Uint8Array` |
|
* prototype. |
|
*/ |
|
function Buffer (subject, encoding) { |
|
var self = this |
|
if (!(self instanceof Buffer)) return new Buffer(subject, encoding) |
|
|
|
var type = typeof subject |
|
var length |
|
|
|
if (type === 'number') { |
|
length = +subject |
|
} else if (type === 'string') { |
|
length = Buffer.byteLength(subject, encoding) |
|
} else if (type === 'object' && subject !== null) { |
|
// assume object is array-like |
|
if (subject.type === 'Buffer' && isArray(subject.data)) subject = subject.data |
|
length = +subject.length |
|
} else { |
|
throw new TypeError('must start with number, buffer, array or string') |
|
} |
|
|
|
if (length > kMaxLength) { |
|
throw new RangeError('Attempt to allocate Buffer larger than maximum size: 0x' + |
|
kMaxLength.toString(16) + ' bytes') |
|
} |
|
|
|
if (length < 0) length = 0 |
|
else length >>>= 0 // coerce to uint32 |
|
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
// Preferred: Return an augmented `Uint8Array` instance for best performance |
|
self = Buffer._augment(new Uint8Array(length)) // eslint-disable-line consistent-this |
|
} else { |
|
// Fallback: Return THIS instance of Buffer (created by `new`) |
|
self.length = length |
|
self._isBuffer = true |
|
} |
|
|
|
var i |
|
if (Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') { |
|
// Speed optimization -- use set if we're copying from a typed array |
|
self._set(subject) |
|
} else if (isArrayish(subject)) { |
|
// Treat array-ish objects as a byte array |
|
if (Buffer.isBuffer(subject)) { |
|
for (i = 0; i < length; i++) { |
|
self[i] = subject.readUInt8(i) |
|
} |
|
} else { |
|
for (i = 0; i < length; i++) { |
|
self[i] = ((subject[i] % 256) + 256) % 256 |
|
} |
|
} |
|
} else if (type === 'string') { |
|
self.write(subject, 0, encoding) |
|
} else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT) { |
|
for (i = 0; i < length; i++) { |
|
self[i] = 0 |
|
} |
|
} |
|
|
|
if (length > 0 && length <= Buffer.poolSize) self.parent = rootParent |
|
|
|
return self |
|
} |
|
|
|
function SlowBuffer (subject, encoding) { |
|
if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding) |
|
|
|
var buf = new Buffer(subject, encoding) |
|
delete buf.parent |
|
return buf |
|
} |
|
|
|
Buffer.isBuffer = function isBuffer (b) { |
|
return !!(b != null && b._isBuffer) |
|
} |
|
|
|
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 && a[i] === b[i]; i++) {} |
|
if (i !== len) { |
|
x = a[i] |
|
y = b[i] |
|
} |
|
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 'binary': |
|
case 'base64': |
|
case 'raw': |
|
case 'ucs2': |
|
case 'ucs-2': |
|
case 'utf16le': |
|
case 'utf-16le': |
|
return true |
|
default: |
|
return false |
|
} |
|
} |
|
|
|
Buffer.concat = function concat (list, totalLength) { |
|
if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.') |
|
|
|
if (list.length === 0) { |
|
return new Buffer(0) |
|
} else if (list.length === 1) { |
|
return list[0] |
|
} |
|
|
|
var i |
|
if (totalLength === undefined) { |
|
totalLength = 0 |
|
for (i = 0; i < list.length; i++) { |
|
totalLength += list[i].length |
|
} |
|
} |
|
|
|
var buf = new Buffer(totalLength) |
|
var pos = 0 |
|
for (i = 0; i < list.length; i++) { |
|
var item = list[i] |
|
item.copy(buf, pos) |
|
pos += item.length |
|
} |
|
return buf |
|
} |
|
|
|
Buffer.byteLength = function byteLength (str, encoding) { |
|
var ret |
|
str = str + '' |
|
switch (encoding || 'utf8') { |
|
case 'ascii': |
|
case 'binary': |
|
case 'raw': |
|
ret = str.length |
|
break |
|
case 'ucs2': |
|
case 'ucs-2': |
|
case 'utf16le': |
|
case 'utf-16le': |
|
ret = str.length * 2 |
|
break |
|
case 'hex': |
|
ret = str.length >>> 1 |
|
break |
|
case 'utf8': |
|
case 'utf-8': |
|
ret = utf8ToBytes(str).length |
|
break |
|
case 'base64': |
|
ret = base64ToBytes(str).length |
|
break |
|
default: |
|
ret = str.length |
|
} |
|
return ret |
|
} |
|
|
|
// pre-set for values that may exist in the future |
|
Buffer.prototype.length = undefined |
|
Buffer.prototype.parent = undefined |
|
|
|
// toString(encoding, start=0, end=buffer.length) |
|
Buffer.prototype.toString = function toString (encoding, start, end) { |
|
var loweredCase = false |
|
|
|
start = start >>> 0 |
|
end = end === undefined || end === Infinity ? this.length : end >>> 0 |
|
|
|
if (!encoding) encoding = 'utf8' |
|
if (start < 0) start = 0 |
|
if (end > this.length) end = this.length |
|
if (end <= start) return '' |
|
|
|
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 'binary': |
|
return binarySlice(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 |
|
} |
|
} |
|
} |
|
|
|
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 (b) { |
|
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') |
|
if (this === b) return 0 |
|
return Buffer.compare(this, b) |
|
} |
|
|
|
Buffer.prototype.indexOf = function indexOf (val, byteOffset) { |
|
if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff |
|
else if (byteOffset < -0x80000000) byteOffset = -0x80000000 |
|
byteOffset >>= 0 |
|
|
|
if (this.length === 0) return -1 |
|
if (byteOffset >= this.length) return -1 |
|
|
|
// Negative offsets start from the end of the buffer |
|
if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0) |
|
|
|
if (typeof val === 'string') { |
|
if (val.length === 0) return -1 // special case: looking for empty string always fails |
|
return String.prototype.indexOf.call(this, val, byteOffset) |
|
} |
|
if (Buffer.isBuffer(val)) { |
|
return arrayIndexOf(this, val, byteOffset) |
|
} |
|
if (typeof val === 'number') { |
|
if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') { |
|
return Uint8Array.prototype.indexOf.call(this, val, byteOffset) |
|
} |
|
return arrayIndexOf(this, [ val ], byteOffset) |
|
} |
|
|
|
function arrayIndexOf (arr, val, byteOffset) { |
|
var foundIndex = -1 |
|
for (var i = 0; byteOffset + i < arr.length; i++) { |
|
if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) { |
|
if (foundIndex === -1) foundIndex = i |
|
if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex |
|
} else { |
|
foundIndex = -1 |
|
} |
|
} |
|
return -1 |
|
} |
|
|
|
throw new TypeError('val must be string, number or Buffer') |
|
} |
|
|
|
// `get` will be removed in Node 0.13+ |
|
Buffer.prototype.get = function get (offset) { |
|
console.log('.get() is deprecated. Access using array indexes instead.') |
|
return this.readUInt8(offset) |
|
} |
|
|
|
// `set` will be removed in Node 0.13+ |
|
Buffer.prototype.set = function set (v, offset) { |
|
console.log('.set() is deprecated. Access using array indexes instead.') |
|
return this.writeUInt8(v, offset) |
|
} |
|
|
|
function hexWrite (buf, string, offset, length) { |
|
offset = Number(offset) || 0 |
|
var remaining = buf.length - offset |
|
if (!length) { |
|
length = remaining |
|
} else { |
|
length = Number(length) |
|
if (length > remaining) { |
|
length = remaining |
|
} |
|
} |
|
|
|
// must be an even number of digits |
|
var strLen = string.length |
|
if (strLen % 2 !== 0) throw new Error('Invalid hex string') |
|
|
|
if (length > strLen / 2) { |
|
length = strLen / 2 |
|
} |
|
for (var i = 0; i < length; i++) { |
|
var parsed = parseInt(string.substr(i * 2, 2), 16) |
|
if (isNaN(parsed)) throw new Error('Invalid hex string') |
|
buf[offset + i] = parsed |
|
} |
|
return i |
|
} |
|
|
|
function utf8Write (buf, string, offset, length) { |
|
var charsWritten = blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) |
|
return charsWritten |
|
} |
|
|
|
function asciiWrite (buf, string, offset, length) { |
|
var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length) |
|
return charsWritten |
|
} |
|
|
|
function binaryWrite (buf, string, offset, length) { |
|
return asciiWrite(buf, string, offset, length) |
|
} |
|
|
|
function base64Write (buf, string, offset, length) { |
|
var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length) |
|
return charsWritten |
|
} |
|
|
|
function utf16leWrite (buf, string, offset, length) { |
|
var charsWritten = blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) |
|
return charsWritten |
|
} |
|
|
|
Buffer.prototype.write = function write (string, offset, length, encoding) { |
|
// Support both (string, offset, length, encoding) |
|
// and the legacy (string, encoding, offset, length) |
|
if (isFinite(offset)) { |
|
if (!isFinite(length)) { |
|
encoding = length |
|
length = undefined |
|
} |
|
} else { // legacy |
|
var swap = encoding |
|
encoding = offset |
|
offset = length |
|
length = swap |
|
} |
|
|
|
offset = Number(offset) || 0 |
|
|
|
if (length < 0 || offset < 0 || offset > this.length) { |
|
throw new RangeError('attempt to write outside buffer bounds') |
|
} |
|
|
|
var remaining = this.length - offset |
|
if (!length) { |
|
length = remaining |
|
} else { |
|
length = Number(length) |
|
if (length > remaining) { |
|
length = remaining |
|
} |
|
} |
|
encoding = String(encoding || 'utf8').toLowerCase() |
|
|
|
var ret |
|
switch (encoding) { |
|
case 'hex': |
|
ret = hexWrite(this, string, offset, length) |
|
break |
|
case 'utf8': |
|
case 'utf-8': |
|
ret = utf8Write(this, string, offset, length) |
|
break |
|
case 'ascii': |
|
ret = asciiWrite(this, string, offset, length) |
|
break |
|
case 'binary': |
|
ret = binaryWrite(this, string, offset, length) |
|
break |
|
case 'base64': |
|
ret = base64Write(this, string, offset, length) |
|
break |
|
case 'ucs2': |
|
case 'ucs-2': |
|
case 'utf16le': |
|
case 'utf-16le': |
|
ret = utf16leWrite(this, string, offset, length) |
|
break |
|
default: |
|
throw new TypeError('Unknown encoding: ' + encoding) |
|
} |
|
return ret |
|
} |
|
|
|
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) { |
|
var res = '' |
|
var tmp = '' |
|
end = Math.min(buf.length, end) |
|
|
|
for (var i = start; i < end; i++) { |
|
if (buf[i] <= 0x7F) { |
|
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i]) |
|
tmp = '' |
|
} else { |
|
tmp += '%' + buf[i].toString(16) |
|
} |
|
} |
|
|
|
return res + decodeUtf8Char(tmp) |
|
} |
|
|
|
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 binarySlice (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 |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
newBuf = Buffer._augment(this.subarray(start, end)) |
|
} else { |
|
var sliceLen = end - start |
|
newBuf = new Buffer(sliceLen, undefined) |
|
for (var i = 0; i < sliceLen; i++) { |
|
newBuf[i] = this[i + start] |
|
} |
|
} |
|
|
|
if (newBuf.length) newBuf.parent = this.parent || this |
|
|
|
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) { |
|
if (!noAssert) checkOffset(offset, 1, this.length) |
|
return this[offset] |
|
} |
|
|
|
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { |
|
if (!noAssert) checkOffset(offset, 2, this.length) |
|
return this[offset] | (this[offset + 1] << 8) |
|
} |
|
|
|
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { |
|
if (!noAssert) checkOffset(offset, 2, this.length) |
|
return (this[offset] << 8) | this[offset + 1] |
|
} |
|
|
|
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { |
|
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) { |
|
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) { |
|
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) { |
|
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) { |
|
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) { |
|
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) { |
|
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) { |
|
if (!noAssert) checkOffset(offset, 4, this.length) |
|
return ieee754.read(this, offset, true, 23, 4) |
|
} |
|
|
|
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { |
|
if (!noAssert) checkOffset(offset, 4, this.length) |
|
return ieee754.read(this, offset, false, 23, 4) |
|
} |
|
|
|
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { |
|
if (!noAssert) checkOffset(offset, 8, this.length) |
|
return ieee754.read(this, offset, true, 52, 8) |
|
} |
|
|
|
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { |
|
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 must be a Buffer instance') |
|
if (value > max || value < min) throw new RangeError('value 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) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) |
|
|
|
var mul = 1 |
|
var i = 0 |
|
this[offset] = value & 0xFF |
|
while (++i < byteLength && (mul *= 0x100)) { |
|
this[offset + i] = (value / mul) >>> 0 & 0xFF |
|
} |
|
|
|
return offset + byteLength |
|
} |
|
|
|
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { |
|
value = +value |
|
offset = offset >>> 0 |
|
byteLength = byteLength >>> 0 |
|
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) |
|
|
|
var i = byteLength - 1 |
|
var mul = 1 |
|
this[offset + i] = value & 0xFF |
|
while (--i >= 0 && (mul *= 0x100)) { |
|
this[offset + i] = (value / mul) >>> 0 & 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) |
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) |
|
this[offset] = value |
|
return offset + 1 |
|
} |
|
|
|
function objectWriteUInt16 (buf, value, offset, littleEndian) { |
|
if (value < 0) value = 0xffff + value + 1 |
|
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { |
|
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> |
|
(littleEndian ? i : 1 - i) * 8 |
|
} |
|
} |
|
|
|
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { |
|
value = +value |
|
offset = offset >>> 0 |
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset] = value |
|
this[offset + 1] = (value >>> 8) |
|
} else { |
|
objectWriteUInt16(this, value, offset, true) |
|
} |
|
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) |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset] = (value >>> 8) |
|
this[offset + 1] = value |
|
} else { |
|
objectWriteUInt16(this, value, offset, false) |
|
} |
|
return offset + 2 |
|
} |
|
|
|
function objectWriteUInt32 (buf, value, offset, littleEndian) { |
|
if (value < 0) value = 0xffffffff + value + 1 |
|
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) { |
|
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff |
|
} |
|
} |
|
|
|
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { |
|
value = +value |
|
offset = offset >>> 0 |
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset + 3] = (value >>> 24) |
|
this[offset + 2] = (value >>> 16) |
|
this[offset + 1] = (value >>> 8) |
|
this[offset] = value |
|
} else { |
|
objectWriteUInt32(this, value, offset, true) |
|
} |
|
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) |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset] = (value >>> 24) |
|
this[offset + 1] = (value >>> 16) |
|
this[offset + 2] = (value >>> 8) |
|
this[offset + 3] = value |
|
} else { |
|
objectWriteUInt32(this, value, offset, false) |
|
} |
|
return offset + 4 |
|
} |
|
|
|
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { |
|
value = +value |
|
offset = offset >>> 0 |
|
if (!noAssert) { |
|
checkInt( |
|
this, value, offset, byteLength, |
|
Math.pow(2, 8 * byteLength - 1) - 1, |
|
-Math.pow(2, 8 * byteLength - 1) |
|
) |
|
} |
|
|
|
var i = 0 |
|
var mul = 1 |
|
var sub = value < 0 ? 1 : 0 |
|
this[offset] = value & 0xFF |
|
while (++i < byteLength && (mul *= 0x100)) { |
|
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) { |
|
checkInt( |
|
this, value, offset, byteLength, |
|
Math.pow(2, 8 * byteLength - 1) - 1, |
|
-Math.pow(2, 8 * byteLength - 1) |
|
) |
|
} |
|
|
|
var i = byteLength - 1 |
|
var mul = 1 |
|
var sub = value < 0 ? 1 : 0 |
|
this[offset + i] = value & 0xFF |
|
while (--i >= 0 && (mul *= 0x100)) { |
|
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 (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) |
|
if (value < 0) value = 0xff + value + 1 |
|
this[offset] = value |
|
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) |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset] = value |
|
this[offset + 1] = (value >>> 8) |
|
} else { |
|
objectWriteUInt16(this, value, offset, true) |
|
} |
|
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) |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset] = (value >>> 8) |
|
this[offset + 1] = value |
|
} else { |
|
objectWriteUInt16(this, value, offset, false) |
|
} |
|
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) |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset] = value |
|
this[offset + 1] = (value >>> 8) |
|
this[offset + 2] = (value >>> 16) |
|
this[offset + 3] = (value >>> 24) |
|
} else { |
|
objectWriteUInt32(this, value, offset, true) |
|
} |
|
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 |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
this[offset] = (value >>> 24) |
|
this[offset + 1] = (value >>> 16) |
|
this[offset + 2] = (value >>> 8) |
|
this[offset + 3] = value |
|
} else { |
|
objectWriteUInt32(this, value, offset, false) |
|
} |
|
return offset + 4 |
|
} |
|
|
|
function checkIEEE754 (buf, value, offset, ext, max, min) { |
|
if (value > max || value < min) throw new RangeError('value is out of bounds') |
|
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) { |
|
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) { |
|
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, target_start, start, end) { |
|
if (!start) start = 0 |
|
if (!end && end !== 0) end = this.length |
|
if (target_start >= target.length) target_start = target.length |
|
if (!target_start) target_start = 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 (target_start < 0) { |
|
throw new RangeError('targetStart out of bounds') |
|
} |
|
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') |
|
if (end < 0) throw new RangeError('sourceEnd out of bounds') |
|
|
|
// Are we oob? |
|
if (end > this.length) end = this.length |
|
if (target.length - target_start < end - start) { |
|
end = target.length - target_start + start |
|
} |
|
|
|
var len = end - start |
|
|
|
if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { |
|
for (var i = 0; i < len; i++) { |
|
target[i + target_start] = this[i + start] |
|
} |
|
} else { |
|
target._set(this.subarray(start, start + len), target_start) |
|
} |
|
|
|
return len |
|
} |
|
|
|
// fill(value, start=0, end=buffer.length) |
|
Buffer.prototype.fill = function fill (value, start, end) { |
|
if (!value) value = 0 |
|
if (!start) start = 0 |
|
if (!end) end = this.length |
|
|
|
if (end < start) throw new RangeError('end < start') |
|
|
|
// Fill 0 bytes; we're done |
|
if (end === start) return |
|
if (this.length === 0) return |
|
|
|
if (start < 0 || start >= this.length) throw new RangeError('start out of bounds') |
|
if (end < 0 || end > this.length) throw new RangeError('end out of bounds') |
|
|
|
var i |
|
if (typeof value === 'number') { |
|
for (i = start; i < end; i++) { |
|
this[i] = value |
|
} |
|
} else { |
|
var bytes = utf8ToBytes(value.toString()) |
|
var len = bytes.length |
|
for (i = start; i < end; i++) { |
|
this[i] = bytes[i % len] |
|
} |
|
} |
|
|
|
return this |
|
} |
|
|
|
/** |
|
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance. |
|
* Added in Node 0.12. Only available in browsers that support ArrayBuffer. |
|
*/ |
|
Buffer.prototype.toArrayBuffer = function toArrayBuffer () { |
|
if (typeof Uint8Array !== 'undefined') { |
|
if (Buffer.TYPED_ARRAY_SUPPORT) { |
|
return (new Buffer(this)).buffer |
|
} else { |
|
var buf = new Uint8Array(this.length) |
|
for (var i = 0, len = buf.length; i < len; i += 1) { |
|
buf[i] = this[i] |
|
} |
|
return buf.buffer |
|
} |
|
} else { |
|
throw new TypeError('Buffer.toArrayBuffer not supported in this browser') |
|
} |
|
} |
|
|
|
// HELPER FUNCTIONS |
|
// ================ |
|
|
|
var BP = Buffer.prototype |
|
|
|
/** |
|
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods |
|
*/ |
|
Buffer._augment = function _augment (arr) { |
|
arr.constructor = Buffer |
|
arr._isBuffer = true |
|
|
|
// save reference to original Uint8Array set method before overwriting |
|
arr._set = arr.set |
|
|
|
// deprecated, will be removed in node 0.13+ |
|
arr.get = BP.get |
|
arr.set = BP.set |
|
|
|
arr.write = BP.write |
|
arr.toString = BP.toString |
|
arr.toLocaleString = BP.toString |
|
arr.toJSON = BP.toJSON |
|
arr.equals = BP.equals |
|
arr.compare = BP.compare |
|
arr.indexOf = BP.indexOf |
|
arr.copy = BP.copy |
|
arr.slice = BP.slice |
|
arr.readUIntLE = BP.readUIntLE |
|
arr.readUIntBE = BP.readUIntBE |
|
arr.readUInt8 = BP.readUInt8 |
|
arr.readUInt16LE = BP.readUInt16LE |
|
arr.readUInt16BE = BP.readUInt16BE |
|
arr.readUInt32LE = BP.readUInt32LE |
|
arr.readUInt32BE = BP.readUInt32BE |
|
arr.readIntLE = BP.readIntLE |
|
arr.readIntBE = BP.readIntBE |
|
arr.readInt8 = BP.readInt8 |
|
arr.readInt16LE = BP.readInt16LE |
|
arr.readInt16BE = BP.readInt16BE |
|
arr.readInt32LE = BP.readInt32LE |
|
arr.readInt32BE = BP.readInt32BE |
|
arr.readFloatLE = BP.readFloatLE |
|
arr.readFloatBE = BP.readFloatBE |
|
arr.readDoubleLE = BP.readDoubleLE |
|
arr.readDoubleBE = BP.readDoubleBE |
|
arr.writeUInt8 = BP.writeUInt8 |
|
arr.writeUIntLE = BP.writeUIntLE |
|
arr.writeUIntBE = BP.writeUIntBE |
|
arr.writeUInt16LE = BP.writeUInt16LE |
|
arr.writeUInt16BE = BP.writeUInt16BE |
|
arr.writeUInt32LE = BP.writeUInt32LE |
|
arr.writeUInt32BE = BP.writeUInt32BE |
|
arr.writeIntLE = BP.writeIntLE |
|
arr.writeIntBE = BP.writeIntBE |
|
arr.writeInt8 = BP.writeInt8 |
|
arr.writeInt16LE = BP.writeInt16LE |
|
arr.writeInt16BE = BP.writeInt16BE |
|
arr.writeInt32LE = BP.writeInt32LE |
|
arr.writeInt32BE = BP.writeInt32BE |
|
arr.writeFloatLE = BP.writeFloatLE |
|
arr.writeFloatBE = BP.writeFloatBE |
|
arr.writeDoubleLE = BP.writeDoubleLE |
|
arr.writeDoubleBE = BP.writeDoubleBE |
|
arr.fill = BP.fill |
|
arr.inspect = BP.inspect |
|
arr.toArrayBuffer = BP.toArrayBuffer |
|
|
|
return arr |
|
} |
|
|
|
var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g |
|
|
|
function base64clean (str) { |
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not |
|
str = stringtrim(str).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 stringtrim (str) { |
|
if (str.trim) return str.trim() |
|
return str.replace(/^\s+|\s+$/g, '') |
|
} |
|
|
|
function isArrayish (subject) { |
|
return isArray(subject) || Buffer.isBuffer(subject) || |
|
subject && typeof subject === 'object' && |
|
typeof subject.length === 'number' |
|
} |
|
|
|
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 = [] |
|
var i = 0 |
|
|
|
for (; i < length; i++) { |
|
codePoint = string.charCodeAt(i) |
|
|
|
// is surrogate component |
|
if (codePoint > 0xD7FF && codePoint < 0xE000) { |
|
// last char was a lead |
|
if (leadSurrogate) { |
|
// 2 leads in a row |
|
if (codePoint < 0xDC00) { |
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) |
|
leadSurrogate = codePoint |
|
continue |
|
} else { |
|
// valid surrogate pair |
|
codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000 |
|
leadSurrogate = null |
|
} |
|
} else { |
|
// 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 |
|
} else { |
|
// valid lead |
|
leadSurrogate = codePoint |
|
continue |
|
} |
|
} |
|
} 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 < 0x200000) { |
|
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 |
|
} |
|
|
|
function decodeUtf8Char (str) { |
|
try { |
|
return decodeURIComponent(str) |
|
} catch (err) { |
|
return String.fromCharCode(0xFFFD) // UTF 8 invalid char |
|
} |
|
} |
|
|
|
},{"base64-js":9,"ieee754":10,"is-array":11}],9:[function(require,module,exports){ |
|
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; |
|
|
|
;(function (exports) { |
|
'use strict'; |
|
|
|
var Arr = (typeof Uint8Array !== 'undefined') |
|
? Uint8Array |
|
: Array |
|
|
|
var PLUS = '+'.charCodeAt(0) |
|
var SLASH = '/'.charCodeAt(0) |
|
var NUMBER = '0'.charCodeAt(0) |
|
var LOWER = 'a'.charCodeAt(0) |
|
var UPPER = 'A'.charCodeAt(0) |
|
var PLUS_URL_SAFE = '-'.charCodeAt(0) |
|
var SLASH_URL_SAFE = '_'.charCodeAt(0) |
|
|
|
function decode (elt) { |
|
var code = elt.charCodeAt(0) |
|
if (code === PLUS || |
|
code === PLUS_URL_SAFE) |
|
return 62 // '+' |
|
if (code === SLASH || |
|
code === SLASH_URL_SAFE) |
|
return 63 // '/' |
|
if (code < NUMBER) |
|
return -1 //no match |
|
if (code < NUMBER + 10) |
|
return code - NUMBER + 26 + 26 |
|
if (code < UPPER + 26) |
|
return code - UPPER |
|
if (code < LOWER + 26) |
|
return code - LOWER + 26 |
|
} |
|
|
|
function b64ToByteArray (b64) { |
|
var i, j, l, tmp, placeHolders, arr |
|
|
|
if (b64.length % 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 |
|
var len = b64.length |
|
placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0 |
|
|
|
// base64 is 4/3 + up to two characters of the original data |
|
arr = new Arr(b64.length * 3 / 4 - placeHolders) |
|
|
|
// if there are placeholders, only get up to the last complete 4 chars |
|
l = placeHolders > 0 ? b64.length - 4 : b64.length |
|
|
|
var L = 0 |
|
|
|
function push (v) { |
|
arr[L++] = v |
|
} |
|
|
|
for (i = 0, j = 0; i < l; i += 4, j += 3) { |
|
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) |
|
push((tmp & 0xFF0000) >> 16) |
|
push((tmp & 0xFF00) >> 8) |
|
push(tmp & 0xFF) |
|
} |
|
|
|
if (placeHolders === 2) { |
|
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) |
|
push(tmp & 0xFF) |
|
} else if (placeHolders === 1) { |
|
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) |
|
push((tmp >> 8) & 0xFF) |
|
push(tmp & 0xFF) |
|
} |
|
|
|
return arr |
|
} |
|
|
|
function uint8ToBase64 (uint8) { |
|
var i, |
|
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes |
|
output = "", |
|
temp, length |
|
|
|
function encode (num) { |
|
return lookup.charAt(num) |
|
} |
|
|
|
function tripletToBase64 (num) { |
|
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) |
|
} |
|
|
|
// go through the array every three bytes, we'll deal with trailing stuff later |
|
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { |
|
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) |
|
output += tripletToBase64(temp) |
|
} |
|
|
|
// pad the end with zeros, but make sure to not forget the extra bytes |
|
switch (extraBytes) { |
|
case 1: |
|
temp = uint8[uint8.length - 1] |
|
output += encode(temp >> 2) |
|
output += encode((temp << 4) & 0x3F) |
|
output += '==' |
|
break |
|
case 2: |
|
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) |
|
output += encode(temp >> 10) |
|
output += encode((temp >> 4) & 0x3F) |
|
output += encode((temp << 2) & 0x3F) |
|
output += '=' |
|
break |
|
} |
|
|
|
return output |
|
} |
|
|
|
exports.toByteArray = b64ToByteArray |
|
exports.fromByteArray = uint8ToBase64 |
|
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) |
|
|
|
},{}],10:[function(require,module,exports){ |
|
exports.read = function(buffer, offset, isLE, mLen, nBytes) { |
|
var e, m, |
|
eLen = nBytes * 8 - mLen - 1, |
|
eMax = (1 << eLen) - 1, |
|
eBias = eMax >> 1, |
|
nBits = -7, |
|
i = isLE ? (nBytes - 1) : 0, |
|
d = isLE ? -1 : 1, |
|
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, |
|
eLen = nBytes * 8 - mLen - 1, |
|
eMax = (1 << eLen) - 1, |
|
eBias = eMax >> 1, |
|
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0), |
|
i = isLE ? 0 : (nBytes - 1), |
|
d = isLE ? 1 : -1, |
|
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; |
|
}; |
|
|
|
},{}],11:[function(require,module,exports){ |
|
|
|
/** |
|
* isArray |
|
*/ |
|
|
|
var isArray = Array.isArray; |
|
|
|
/** |
|
* toString |
|
*/ |
|
|
|
var str = Object.prototype.toString; |
|
|
|
/** |
|
* Whether or not the given `val` |
|
* is an array. |
|
* |
|
* example: |
|
* |
|
* isArray([]); |
|
* // > true |
|
* isArray(arguments); |
|
* // > false |
|
* isArray(''); |
|
* // > false |
|
* |
|
* @param {mixed} val |
|
* @return {bool} |
|
*/ |
|
|
|
module.exports = isArray || function (val) { |
|
return !! val && '[object Array]' == str.call(val); |
|
}; |
|
|
|
},{}],12:[function(require,module,exports){ |
|
// Copyright Joyent, Inc. and other Node contributors. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a |
|
// copy of this software and associated documentation files (the |
|
// "Software"), to deal in the Software without restriction, including |
|
// without limitation the rights to use, copy, modify, merge, publish, |
|
// distribute, sublicense, and/or sell copies of the Software, and to permit |
|
// persons to whom the Software is furnished to do so, subject to the |
|
// following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included |
|
// in all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
|
// USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
|
|
function EventEmitter() { |
|
this._events = this._events || {}; |
|
this._maxListeners = this._maxListeners || undefined; |
|
} |
|
module.exports = EventEmitter; |
|
|
|
// Backwards-compat with node 0.10.x |
|
EventEmitter.EventEmitter = EventEmitter; |
|
|
|
EventEmitter.prototype._events = undefined; |
|
EventEmitter.prototype._maxListeners = undefined; |
|
|
|
// By default EventEmitters will print a warning if more than 10 listeners are |
|
// added to it. This is a useful default which helps finding memory leaks. |
|
EventEmitter.defaultMaxListeners = 10; |
|
|
|
// Obviously not all Emitters should be limited to 10. This function allows |
|
// that to be increased. Set to zero for unlimited. |
|
EventEmitter.prototype.setMaxListeners = function(n) { |
|
if (!isNumber(n) || n < 0 || isNaN(n)) |
|
throw TypeError('n must be a positive number'); |
|
this._maxListeners = n; |
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.emit = function(type) { |
|
var er, handler, len, args, i, listeners; |
|
|
|
if (!this._events) |
|
this._events = {}; |
|
|
|
// If there is no 'error' event listener then throw. |
|
if (type === 'error') { |
|
if (!this._events.error || |
|
(isObject(this._events.error) && !this._events.error.length)) { |
|
er = arguments[1]; |
|
if (er instanceof Error) { |
|
throw er; // Unhandled 'error' event |
|
} |
|
throw TypeError('Uncaught, unspecified "error" event.'); |
|
} |
|
} |
|
|
|
handler = this._events[type]; |
|
|
|
if (isUndefined(handler)) |
|
return false; |
|
|
|
if (isFunction(handler)) { |
|
switch (arguments.length) { |
|
// fast cases |
|
case 1: |
|
handler.call(this); |
|
break; |
|
case 2: |
|
handler.call(this, arguments[1]); |
|
break; |
|
case 3: |
|
handler.call(this, arguments[1], arguments[2]); |
|
break; |
|
// slower |
|
default: |
|
len = arguments.length; |
|
args = new Array(len - 1); |
|
for (i = 1; i < len; i++) |
|
args[i - 1] = arguments[i]; |
|
handler.apply(this, args); |
|
} |
|
} else if (isObject(handler)) { |
|
len = arguments.length; |
|
args = new Array(len - 1); |
|
for (i = 1; i < len; i++) |
|
args[i - 1] = arguments[i]; |
|
|
|
listeners = handler.slice(); |
|
len = listeners.length; |
|
for (i = 0; i < len; i++) |
|
listeners[i].apply(this, args); |
|
} |
|
|
|
return true; |
|
}; |
|
|
|
EventEmitter.prototype.addListener = function(type, listener) { |
|
var m; |
|
|
|
if (!isFunction(listener)) |
|
throw TypeError('listener must be a function'); |
|
|
|
if (!this._events) |
|
this._events = {}; |
|
|
|
// To avoid recursion in the case that type === "newListener"! Before |
|
// adding it to the listeners, first emit "newListener". |
|
if (this._events.newListener) |
|
this.emit('newListener', type, |
|
isFunction(listener.listener) ? |
|
listener.listener : listener); |
|
|
|
if (!this._events[type]) |
|
// Optimize the case of one listener. Don't need the extra array object. |
|
this._events[type] = listener; |
|
else if (isObject(this._events[type])) |
|
// If we've already got an array, just append. |
|
this._events[type].push(listener); |
|
else |
|
// Adding the second element, need to change to array. |
|
this._events[type] = [this._events[type], listener]; |
|
|
|
// Check for listener leak |
|
if (isObject(this._events[type]) && !this._events[type].warned) { |
|
var m; |
|
if (!isUndefined(this._maxListeners)) { |
|
m = this._maxListeners; |
|
} else { |
|
m = EventEmitter.defaultMaxListeners; |
|
} |
|
|
|
if (m && m > 0 && this._events[type].length > m) { |
|
this._events[type].warned = true; |
|
console.error('(node) warning: possible EventEmitter memory ' + |
|
'leak detected. %d listeners added. ' + |
|
'Use emitter.setMaxListeners() to increase limit.', |
|
this._events[type].length); |
|
if (typeof console.trace === 'function') { |
|
// not supported in IE 10 |
|
console.trace(); |
|
} |
|
} |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener; |
|
|
|
EventEmitter.prototype.once = function(type, listener) { |
|
if (!isFunction(listener)) |
|
throw TypeError('listener must be a function'); |
|
|
|
var fired = false; |
|
|
|
function g() { |
|
this.removeListener(type, g); |
|
|
|
if (!fired) { |
|
fired = true; |
|
listener.apply(this, arguments); |
|
} |
|
} |
|
|
|
g.listener = listener; |
|
this.on(type, g); |
|
|
|
return this; |
|
}; |
|
|
|
// emits a 'removeListener' event iff the listener was removed |
|
EventEmitter.prototype.removeListener = function(type, listener) { |
|
var list, position, length, i; |
|
|
|
if (!isFunction(listener)) |
|
throw TypeError('listener must be a function'); |
|
|
|
if (!this._events || !this._events[type]) |
|
return this; |
|
|
|
list = this._events[type]; |
|
length = list.length; |
|
position = -1; |
|
|
|
if (list === listener || |
|
(isFunction(list.listener) && list.listener === listener)) { |
|
delete this._events[type]; |
|
if (this._events.removeListener) |
|
this.emit('removeListener', type, listener); |
|
|
|
} else if (isObject(list)) { |
|
for (i = length; i-- > 0;) { |
|
if (list[i] === listener || |
|
(list[i].listener && list[i].listener === listener)) { |
|
position = i; |
|
break; |
|
} |
|
} |
|
|
|
if (position < 0) |
|
return this; |
|
|
|
if (list.length === 1) { |
|
list.length = 0; |
|
delete this._events[type]; |
|
} else { |
|
list.splice(position, 1); |
|
} |
|
|
|
if (this._events.removeListener) |
|
this.emit('removeListener', type, listener); |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.removeAllListeners = function(type) { |
|
var key, listeners; |
|
|
|
if (!this._events) |
|
return this; |
|
|
|
// not listening for removeListener, no need to emit |
|
if (!this._events.removeListener) { |
|
if (arguments.length === 0) |
|
this._events = {}; |
|
else if (this._events[type]) |
|
delete this._events[type]; |
|
return this; |
|
} |
|
|
|
// emit removeListener for all listeners on all events |
|
if (arguments.length === 0) { |
|
for (key in this._events) { |
|
if (key === 'removeListener') continue; |
|
this.removeAllListeners(key); |
|
} |
|
this.removeAllListeners('removeListener'); |
|
this._events = {}; |
|
return this; |
|
} |
|
|
|
listeners = this._events[type]; |
|
|
|
if (isFunction(listeners)) { |
|
this.removeListener(type, listeners); |
|
} else { |
|
// LIFO order |
|
while (listeners.length) |
|
this.removeListener(type, listeners[listeners.length - 1]); |
|
} |
|
delete this._events[type]; |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.listeners = function(type) { |
|
var ret; |
|
if (!this._events || !this._events[type]) |
|
ret = []; |
|
else if (isFunction(this._events[type])) |
|
ret = [this._events[type]]; |
|
else |
|
ret = this._events[type].slice(); |
|
return ret; |
|
}; |
|
|
|
EventEmitter.listenerCount = function(emitter, type) { |
|
var ret; |
|
if (!emitter._events || !emitter._events[type]) |
|
ret = 0; |
|
else if (isFunction(emitter._events[type])) |
|
ret = 1; |
|
else |
|
ret = emitter._events[type].length; |
|
return ret; |
|
}; |
|
|
|
function isFunction(arg) { |
|
return typeof arg === 'function'; |
|
} |
|
|
|
function isNumber(arg) { |
|
return typeof arg === 'number'; |
|
} |
|
|
|
function isObject(arg) { |
|
return typeof arg === 'object' && arg !== null; |
|
} |
|
|
|
function isUndefined(arg) { |
|
return arg === void 0; |
|
} |
|
|
|
},{}],13:[function(require,module,exports){ |
|
var http = module.exports; |
|
var EventEmitter = require('events').EventEmitter; |
|
var Request = require('./lib/request'); |
|
var url = require('url') |
|
|
|
http.request = function (params, cb) { |
|
if (typeof params === 'string') { |
|
params = url.parse(params) |
|
} |
|
if (!params) params = {}; |
|
if (!params.host && !params.port) { |
|
params.port = parseInt(window.location.port, 10); |
|
} |
|
if (!params.host && params.hostname) { |
|
params.host = params.hostname; |
|
} |
|
|
|
if (!params.protocol) { |
|
if (params.scheme) { |
|
params.protocol = params.scheme + ':'; |
|
} else { |
|
params.protocol = window.location.protocol; |
|
} |
|
} |
|
|
|
if (!params.host) { |
|
params.host = window.location.hostname || window.location.host; |
|
} |
|
if (/:/.test(params.host)) { |
|
if (!params.port) { |
|
params.port = params.host.split(':')[1]; |
|
} |
|
params.host = params.host.split(':')[0]; |
|
} |
|
if (!params.port) params.port = params.protocol == 'https:' ? 443 : 80; |
|
|
|
var req = new Request(new xhrHttp, params); |
|
if (cb) req.on('response', cb); |
|
return req; |
|
}; |
|
|
|
http.get = function (params, cb) { |
|
params.method = 'GET'; |
|
var req = http.request(params, cb); |
|
req.end(); |
|
return req; |
|
}; |
|
|
|
http.Agent = function () {}; |
|
http.Agent.defaultMaxSockets = 4; |
|
|
|
var xhrHttp = (function () { |
|
if (typeof window === 'undefined') { |
|
throw new Error('no window object present'); |
|
} |
|
else if (window.XMLHttpRequest) { |
|
return window.XMLHttpRequest; |
|
} |
|
else if (window.ActiveXObject) { |
|
var axs = [ |
|
'Msxml2.XMLHTTP.6.0', |
|
'Msxml2.XMLHTTP.3.0', |
|
'Microsoft.XMLHTTP' |
|
]; |
|
for (var i = 0; i < axs.length; i++) { |
|
try { |
|
var ax = new(window.ActiveXObject)(axs[i]); |
|
return function () { |
|
if (ax) { |
|
var ax_ = ax; |
|
ax = null; |
|
return ax_; |
|
} |
|
else { |
|
return new(window.ActiveXObject)(axs[i]); |
|
} |
|
}; |
|
} |
|
catch (e) {} |
|
} |
|
throw new Error('ajax not supported in this browser') |
|
} |
|
else { |
|
throw new Error('ajax not supported in this browser'); |
|
} |
|
})(); |
|
|
|
http.STATUS_CODES = { |
|
100 : 'Continue', |
|
101 : 'Switching Protocols', |
|
102 : 'Processing', // RFC 2518, obsoleted by RFC 4918 |
|
200 : 'OK', |
|
201 : 'Created', |
|
202 : 'Accepted', |
|
203 : 'Non-Authoritative Information', |
|
204 : 'No Content', |
|
205 : 'Reset Content', |
|
206 : 'Partial Content', |
|
207 : 'Multi-Status', // RFC 4918 |
|
300 : 'Multiple Choices', |
|
301 : 'Moved Permanently', |
|
302 : 'Moved Temporarily', |
|
303 : 'See Other', |
|
304 : 'Not Modified', |
|
305 : 'Use Proxy', |
|
307 : 'Temporary Redirect', |
|
400 : 'Bad Request', |
|
401 : 'Unauthorized', |
|
402 : 'Payment Required', |
|
403 : 'Forbidden', |
|
404 : 'Not Found', |
|
405 : 'Method Not Allowed', |
|
406 : 'Not Acceptable', |
|
407 : 'Proxy Authentication Required', |
|
408 : 'Request Time-out', |
|
409 : 'Conflict', |
|
410 : 'Gone', |
|
411 : 'Length Required', |
|
412 : 'Precondition Failed', |
|
413 : 'Request Entity Too Large', |
|
414 : 'Request-URI Too Large', |
|
415 : 'Unsupported Media Type', |
|
416 : 'Requested Range Not Satisfiable', |
|
417 : 'Expectation Failed', |
|
418 : 'I\'m a teapot', // RFC 2324 |
|
422 : 'Unprocessable Entity', // RFC 4918 |
|
423 : 'Locked', // RFC 4918 |
|
424 : 'Failed Dependency', // RFC 4918 |
|
425 : 'Unordered Collection', // RFC 4918 |
|
426 : 'Upgrade Required', // RFC 2817 |
|
428 : 'Precondition Required', // RFC 6585 |
|
429 : 'Too Many Requests', // RFC 6585 |
|
431 : 'Request Header Fields Too Large',// RFC 6585 |
|
500 : 'Internal Server Error', |
|
501 : 'Not Implemented', |
|
502 : 'Bad Gateway', |
|
503 : 'Service Unavailable', |
|
504 : 'Gateway Time-out', |
|
505 : 'HTTP Version Not Supported', |
|
506 : 'Variant Also Negotiates', // RFC 2295 |
|
507 : 'Insufficient Storage', // RFC 4918 |
|
509 : 'Bandwidth Limit Exceeded', |
|
510 : 'Not Extended', // RFC 2774 |
|
511 : 'Network Authentication Required' // RFC 6585 |
|
}; |
|
},{"./lib/request":14,"events":12,"url":37}],14:[function(require,module,exports){ |
|
var Stream = require('stream'); |
|
var Response = require('./response'); |
|
var Base64 = require('Base64'); |
|
var inherits = require('inherits'); |
|
|
|
var Request = module.exports = function (xhr, params) { |
|
var self = this; |
|
self.writable = true; |
|
self.xhr = xhr; |
|
self.body = []; |
|
|
|
self.uri = (params.protocol || 'http:') + '//' |
|
+ params.host |
|
+ (params.port ? ':' + params.port : '') |
|
+ (params.path || '/') |
|
; |
|
|
|
if (typeof params.withCredentials === 'undefined') { |
|
params.withCredentials = true; |
|
} |
|
|
|
try { xhr.withCredentials = params.withCredentials } |
|
catch (e) {} |
|
|
|
if (params.responseType) try { xhr.responseType = params.responseType } |
|
catch (e) {} |
|
|
|
xhr.open( |
|
params.method || 'GET', |
|
self.uri, |
|
true |
|
); |
|
|
|
xhr.onerror = function(event) { |
|
self.emit('error', new Error('Network error')); |
|
}; |
|
|
|
self._headers = {}; |
|
|
|
if (params.headers) { |
|
var keys = objectKeys(params.headers); |
|
for (var i = 0; i < keys.length; i++) { |
|
var key = keys[i]; |
|
if (!self.isSafeRequestHeader(key)) continue; |
|
var value = params.headers[key]; |
|
self.setHeader(key, value); |
|
} |
|
} |
|
|
|
if (params.auth) { |
|
//basic auth |
|
this.setHeader('Authorization', 'Basic ' + Base64.btoa(params.auth)); |
|
} |
|
|
|
var res = new Response; |
|
res.on('close', function () { |
|
self.emit('close'); |
|
}); |
|
|
|
res.on('ready', function () { |
|
self.emit('response', res); |
|
}); |
|
|
|
res.on('error', function (err) { |
|
self.emit('error', err); |
|
}); |
|
|
|
xhr.onreadystatechange = function () { |
|
// Fix for IE9 bug |
|
// SCRIPT575: Could not complete the operation due to error c00c023f |
|
// It happens when a request is aborted, calling the success callback anyway with readyState === 4 |
|
if (xhr.__aborted) return; |
|
res.handle(xhr); |
|
}; |
|
}; |
|
|
|
inherits(Request, Stream); |
|
|
|
Request.prototype.setHeader = function (key, value) { |
|
this._headers[key.toLowerCase()] = value |
|
}; |
|
|
|
Request.prototype.getHeader = function (key) { |
|
return this._headers[key.toLowerCase()] |
|
}; |
|
|
|
Request.prototype.removeHeader = function (key) { |
|
delete this._headers[key.toLowerCase()] |
|
}; |
|
|
|
Request.prototype.write = function (s) { |
|
this.body.push(s); |
|
}; |
|
|
|
Request.prototype.destroy = function (s) { |
|
this.xhr.__aborted = true; |
|
this.xhr.abort(); |
|
this.emit('close'); |
|
}; |
|
|
|
Request.prototype.end = function (s) { |
|
if (s !== undefined) this.body.push(s); |
|
|
|
var keys = objectKeys(this._headers); |
|
for (var i = 0; i < keys.length; i++) { |
|
var key = keys[i]; |
|
var value = this._headers[key]; |
|
if (isArray(value)) { |
|
for (var j = 0; j < value.length; j++) { |
|
this.xhr.setRequestHeader(key, value[j]); |
|
} |
|
} |
|
else this.xhr.setRequestHeader(key, value) |
|
} |
|
|
|
if (this.body.length === 0) { |
|
this.xhr.send(''); |
|
} |
|
else if (typeof this.body[0] === 'string') { |
|
this.xhr.send(this.body.join('')); |
|
} |
|
else if (isArray(this.body[0])) { |
|
var body = []; |
|
for (var i = 0; i < this.body.length; i++) { |
|
body.push.apply(body, this.body[i]); |
|
} |
|
|