Last active
April 10, 2024 19:47
-
-
Save Kreijstal/2691cae140baf5d9e785828e10f7ae58 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ | |
(function (global){(function (){ | |
'use strict'; | |
var possibleNames = require('possible-typed-array-names'); | |
var g = typeof globalThis === 'undefined' ? global : globalThis; | |
/** @type {import('.')} */ | |
module.exports = function availableTypedArrays() { | |
var /** @type {ReturnType<typeof availableTypedArrays>} */ out = []; | |
for (var i = 0; i < possibleNames.length; i++) { | |
if (typeof g[possibleNames[i]] === 'function') { | |
// @ts-expect-error | |
out[out.length] = possibleNames[i]; | |
} | |
} | |
return out; | |
}; | |
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
},{"possible-typed-array-names":32}],2:[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 getLens (b64) { | |
var len = b64.length | |
if (len % 4 > 0) { | |
throw new Error('Invalid string. Length must be a multiple of 4') | |
} | |
// Trim off extra bytes after placeholder bytes are found | |
// See: https://github.com/beatgammit/base64-js/issues/42 | |
var validLen = b64.indexOf('=') | |
if (validLen === -1) validLen = len | |
var placeHoldersLen = validLen === len | |
? 0 | |
: 4 - (validLen % 4) | |
return [validLen, placeHoldersLen] | |
} | |
// base64 is 4/3 + up to two characters of the original data | |
function byteLength (b64) { | |
var lens = getLens(b64) | |
var validLen = lens[0] | |
var placeHoldersLen = lens[1] | |
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen | |
} | |
function _byteLength (b64, validLen, placeHoldersLen) { | |
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen | |
} | |
function toByteArray (b64) { | |
var tmp | |
var lens = getLens(b64) | |
var validLen = lens[0] | |
var placeHoldersLen = lens[1] | |
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) | |
var curByte = 0 | |
// if there are placeholders, only get up to the last complete 4 chars | |
var len = placeHoldersLen > 0 | |
? validLen - 4 | |
: validLen | |
var i | |
for (i = 0; i < len; 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[curByte++] = (tmp >> 16) & 0xFF | |
arr[curByte++] = (tmp >> 8) & 0xFF | |
arr[curByte++] = tmp & 0xFF | |
} | |
if (placeHoldersLen === 2) { | |
tmp = | |
(revLookup[b64.charCodeAt(i)] << 2) | | |
(revLookup[b64.charCodeAt(i + 1)] >> 4) | |
arr[curByte++] = tmp & 0xFF | |
} | |
if (placeHoldersLen === 1) { | |
tmp = | |
(revLookup[b64.charCodeAt(i)] << 10) | | |
(revLookup[b64.charCodeAt(i + 1)] << 4) | | |
(revLookup[b64.charCodeAt(i + 2)] >> 2) | |
arr[curByte++] = (tmp >> 8) & 0xFF | |
arr[curByte++] = 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 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] | |
parts.push( | |
lookup[tmp >> 2] + | |
lookup[(tmp << 4) & 0x3F] + | |
'==' | |
) | |
} else if (extraBytes === 2) { | |
tmp = (uint8[len - 2] << 8) + uint8[len - 1] | |
parts.push( | |
lookup[tmp >> 10] + | |
lookup[(tmp >> 4) & 0x3F] + | |
lookup[(tmp << 2) & 0x3F] + | |
'=' | |
) | |
} | |
return parts.join('') | |
} | |
},{}],3:[function(require,module,exports){ | |
(function (Buffer){(function (){ | |
/*! | |
* The buffer module from node.js, for the browser. | |
* | |
* @author Feross Aboukhadijeh <https://feross.org> | |
* @license MIT | |
*/ | |
/* eslint-disable no-proto */ | |
'use strict' | |
var base64 = require('base64-js') | |
var ieee754 = require('ieee754') | |
exports.Buffer = Buffer | |
exports.SlowBuffer = SlowBuffer | |
exports.INSPECT_MAX_BYTES = 50 | |
var K_MAX_LENGTH = 0x7fffffff | |
exports.kMaxLength = K_MAX_LENGTH | |
/** | |
* If `Buffer.TYPED_ARRAY_SUPPORT`: | |
* === true Use Uint8Array implementation (fastest) | |
* === false Print warning and recommend using `buffer` v4.x which has an Object | |
* implementation (most compatible, even IE6) | |
* | |
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, | |
* Opera 11.6+, iOS 4.2+. | |
* | |
* We report that the browser does not support typed arrays if the are not subclassable | |
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` | |
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support | |
* for __proto__ and has a buggy typed array implementation. | |
*/ | |
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() | |
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && | |
typeof console.error === 'function') { | |
console.error( | |
'This browser lacks typed array (Uint8Array) support which is required by ' + | |
'`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' | |
) | |
} | |
function typedArraySupport () { | |
// Can typed array instances can be augmented? | |
try { | |
var arr = new Uint8Array(1) | |
arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } } | |
return arr.foo() === 42 | |
} catch (e) { | |
return false | |
} | |
} | |
Object.defineProperty(Buffer.prototype, 'parent', { | |
enumerable: true, | |
get: function () { | |
if (!Buffer.isBuffer(this)) return undefined | |
return this.buffer | |
} | |
}) | |
Object.defineProperty(Buffer.prototype, 'offset', { | |
enumerable: true, | |
get: function () { | |
if (!Buffer.isBuffer(this)) return undefined | |
return this.byteOffset | |
} | |
}) | |
function createBuffer (length) { | |
if (length > K_MAX_LENGTH) { | |
throw new RangeError('The value "' + length + '" is invalid for option "size"') | |
} | |
// 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 TypeError( | |
'The "string" argument must be of type string. Received type number' | |
) | |
} | |
return allocUnsafe(arg) | |
} | |
return from(arg, encodingOrOffset, length) | |
} | |
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 | |
if (typeof Symbol !== 'undefined' && Symbol.species != null && | |
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 === 'string') { | |
return fromString(value, encodingOrOffset) | |
} | |
if (ArrayBuffer.isView(value)) { | |
return fromArrayLike(value) | |
} | |
if (value == null) { | |
throw TypeError( | |
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + | |
'or Array-like Object. Received type ' + (typeof value) | |
) | |
} | |
if (isInstance(value, ArrayBuffer) || | |
(value && isInstance(value.buffer, ArrayBuffer))) { | |
return fromArrayBuffer(value, encodingOrOffset, length) | |
} | |
if (typeof value === 'number') { | |
throw new TypeError( | |
'The "value" argument must not be of type number. Received type number' | |
) | |
} | |
var valueOf = value.valueOf && value.valueOf() | |
if (valueOf != null && valueOf !== value) { | |
return Buffer.from(valueOf, encodingOrOffset, length) | |
} | |
var b = fromObject(value) | |
if (b) return b | |
if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null && | |
typeof value[Symbol.toPrimitive] === 'function') { | |
return Buffer.from( | |
value[Symbol.toPrimitive]('string'), encodingOrOffset, length | |
) | |
} | |
throw new TypeError( | |
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + | |
'or Array-like Object. Received type ' + (typeof value) | |
) | |
} | |
/** | |
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError | |
* if value is a number. | |
* Buffer.from(str[, encoding]) | |
* Buffer.from(array) | |
* Buffer.from(buffer) | |
* Buffer.from(arrayBuffer[, byteOffset[, length]]) | |
**/ | |
Buffer.from = function (value, encodingOrOffset, length) { | |
return from(value, encodingOrOffset, length) | |
} | |
// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: | |
// https://github.com/feross/buffer/pull/148 | |
Buffer.prototype.__proto__ = Uint8Array.prototype | |
Buffer.__proto__ = Uint8Array | |
function assertSize (size) { | |
if (typeof size !== 'number') { | |
throw new TypeError('"size" argument must be of type number') | |
} else if (size < 0) { | |
throw new RangeError('The value "' + size + '" is invalid for option "size"') | |
} | |
} | |
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.length !== undefined) { | |
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) | |
} | |
} | |
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 && | |
b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false | |
} | |
Buffer.compare = function compare (a, b) { | |
if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength) | |
if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength) | |
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { | |
throw new TypeError( | |
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' | |
) | |
} | |
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 (isInstance(buf, Uint8Array)) { | |
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) || isInstance(string, ArrayBuffer)) { | |
return string.byteLength | |
} | |
if (typeof string !== 'string') { | |
throw new TypeError( | |
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + | |
'Received type ' + typeof string | |
) | |
} | |
var len = string.length | |
var mustMatch = (arguments.length > 2 && arguments[2] === true) | |
if (!mustMatch && 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': | |
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 mustMatch ? -1 : utf8ToBytes(string).length // assume utf8 | |
} | |
encoding = ('' + encoding).toLowerCase() | |
loweredCase = true | |
} | |
} | |
} | |
Buffer.byteLength = byteLength | |
function slowToString (encoding, start, end) { | |
var loweredCase = false | |
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only | |
// property of a typed array. | |
// This behaves neither like String nor Uint8Array in that we set start/end | |
// to their upper/lower bounds if the value passed is out of range. | |
// undefined is handled specially as per ECMA-262 6th Edition, | |
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. | |
if (start === undefined || start < 0) { | |
start = 0 | |
} | |
// Return early if start > this.length. Done here to prevent potential uint32 | |
// coercion fail below. | |
if (start > this.length) { | |
return '' | |
} | |
if (end === undefined || end > this.length) { | |
end = this.length | |
} | |
if (end <= 0) { | |
return '' | |
} | |
// Force coersion to uint32. This will also coerce falsey/NaN values to 0. | |
end >>>= 0 | |
start >>>= 0 | |
if (end <= start) { | |
return '' | |
} | |
if (!encoding) encoding = 'utf8' | |
while (true) { | |
switch (encoding) { | |
case 'hex': | |
return hexSlice(this, start, end) | |
case 'utf8': | |
case 'utf-8': | |
return utf8Slice(this, start, end) | |
case 'ascii': | |
return asciiSlice(this, start, end) | |
case 'latin1': | |
case 'binary': | |
return latin1Slice(this, start, end) | |
case 'base64': | |
return base64Slice(this, start, end) | |
case 'ucs2': | |
case 'ucs-2': | |
case 'utf16le': | |
case 'utf-16le': | |
return utf16leSlice(this, start, end) | |
default: | |
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) | |
encoding = (encoding + '').toLowerCase() | |
loweredCase = true | |
} | |
} | |
} | |
// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) | |
// to detect a Buffer instance. It's not possible to use `instanceof Buffer` | |
// reliably in a browserify context because there could be multiple different | |
// copies of the 'buffer' package in use. This method works even for Buffer | |
// instances that were created from another copy of the `buffer` package. | |
// See: https://github.com/feross/buffer/issues/154 | |
Buffer.prototype._isBuffer = true | |
function swap (b, n, m) { | |
var i = b[n] | |
b[n] = b[m] | |
b[m] = i | |
} | |
Buffer.prototype.swap16 = function swap16 () { | |
var len = this.length | |
if (len % 2 !== 0) { | |
throw new RangeError('Buffer size must be a multiple of 16-bits') | |
} | |
for (var i = 0; i < len; i += 2) { | |
swap(this, i, i + 1) | |
} | |
return this | |
} | |
Buffer.prototype.swap32 = function swap32 () { | |
var len = this.length | |
if (len % 4 !== 0) { | |
throw new RangeError('Buffer size must be a multiple of 32-bits') | |
} | |
for (var i = 0; i < len; i += 4) { | |
swap(this, i, i + 3) | |
swap(this, i + 1, i + 2) | |
} | |
return this | |
} | |
Buffer.prototype.swap64 = function swap64 () { | |
var len = this.length | |
if (len % 8 !== 0) { | |
throw new RangeError('Buffer size must be a multiple of 64-bits') | |
} | |
for (var i = 0; i < len; i += 8) { | |
swap(this, i, i + 7) | |
swap(this, i + 1, i + 6) | |
swap(this, i + 2, i + 5) | |
swap(this, i + 3, i + 4) | |
} | |
return this | |
} | |
Buffer.prototype.toString = function toString () { | |
var length = this.length | |
if (length === 0) return '' | |
if (arguments.length === 0) return utf8Slice(this, 0, length) | |
return slowToString.apply(this, arguments) | |
} | |
Buffer.prototype.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 | |
str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim() | |
if (this.length > max) str += ' ... ' | |
return '<Buffer ' + str + '>' | |
} | |
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { | |
if (isInstance(target, Uint8Array)) { | |
target = Buffer.from(target, target.offset, target.byteLength) | |
} | |
if (!Buffer.isBuffer(target)) { | |
throw new TypeError( | |
'The "target" argument must be one of type Buffer or Uint8Array. ' + | |
'Received type ' + (typeof target) | |
) | |
} | |
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 | |
: Buffer.from(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 | |
} | |
// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass | |
// the `instanceof` check but they should be treated as of that type. | |
// See: https://github.com/feross/buffer/issues/166 | |
function isInstance (obj, type) { | |
return obj instanceof type || | |
(obj != null && obj.constructor != null && obj.constructor.name != null && | |
obj.constructor.name === type.name) | |
} | |
function numberIsNaN (obj) { | |
// For IE11 support | |
return obj !== obj // eslint-disable-line no-self-compare | |
} | |
}).call(this)}).call(this,require("buffer").Buffer) | |
},{"base64-js":2,"buffer":3,"ieee754":26}],4:[function(require,module,exports){ | |
'use strict'; | |
var GetIntrinsic = require('get-intrinsic'); | |
var callBind = require('./'); | |
var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf')); | |
module.exports = function callBoundIntrinsic(name, allowMissing) { | |
var intrinsic = GetIntrinsic(name, !!allowMissing); | |
if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) { | |
return callBind(intrinsic); | |
} | |
return intrinsic; | |
}; | |
},{"./":5,"get-intrinsic":18}],5:[function(require,module,exports){ | |
'use strict'; | |
var bind = require('function-bind'); | |
var GetIntrinsic = require('get-intrinsic'); | |
var setFunctionLength = require('set-function-length'); | |
var $TypeError = require('es-errors/type'); | |
var $apply = GetIntrinsic('%Function.prototype.apply%'); | |
var $call = GetIntrinsic('%Function.prototype.call%'); | |
var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply); | |
var $defineProperty = require('es-define-property'); | |
var $max = GetIntrinsic('%Math.max%'); | |
module.exports = function callBind(originalFunction) { | |
if (typeof originalFunction !== 'function') { | |
throw new $TypeError('a function is required'); | |
} | |
var func = $reflectApply(bind, $call, arguments); | |
return setFunctionLength( | |
func, | |
1 + $max(0, originalFunction.length - (arguments.length - 1)), | |
true | |
); | |
}; | |
var applyBind = function applyBind() { | |
return $reflectApply(bind, $apply, arguments); | |
}; | |
if ($defineProperty) { | |
$defineProperty(module.exports, 'apply', { value: applyBind }); | |
} else { | |
module.exports.apply = applyBind; | |
} | |
},{"es-define-property":7,"es-errors/type":13,"function-bind":17,"get-intrinsic":18,"set-function-length":34}],6:[function(require,module,exports){ | |
'use strict'; | |
var $defineProperty = require('es-define-property'); | |
var $SyntaxError = require('es-errors/syntax'); | |
var $TypeError = require('es-errors/type'); | |
var gopd = require('gopd'); | |
/** @type {import('.')} */ | |
module.exports = function defineDataProperty( | |
obj, | |
property, | |
value | |
) { | |
if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) { | |
throw new $TypeError('`obj` must be an object or a function`'); | |
} | |
if (typeof property !== 'string' && typeof property !== 'symbol') { | |
throw new $TypeError('`property` must be a string or a symbol`'); | |
} | |
if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) { | |
throw new $TypeError('`nonEnumerable`, if provided, must be a boolean or null'); | |
} | |
if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) { | |
throw new $TypeError('`nonWritable`, if provided, must be a boolean or null'); | |
} | |
if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) { | |
throw new $TypeError('`nonConfigurable`, if provided, must be a boolean or null'); | |
} | |
if (arguments.length > 6 && typeof arguments[6] !== 'boolean') { | |
throw new $TypeError('`loose`, if provided, must be a boolean'); | |
} | |
var nonEnumerable = arguments.length > 3 ? arguments[3] : null; | |
var nonWritable = arguments.length > 4 ? arguments[4] : null; | |
var nonConfigurable = arguments.length > 5 ? arguments[5] : null; | |
var loose = arguments.length > 6 ? arguments[6] : false; | |
/* @type {false | TypedPropertyDescriptor<unknown>} */ | |
var desc = !!gopd && gopd(obj, property); | |
if ($defineProperty) { | |
$defineProperty(obj, property, { | |
configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable, | |
enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable, | |
value: value, | |
writable: nonWritable === null && desc ? desc.writable : !nonWritable | |
}); | |
} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) { | |
// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable | |
obj[property] = value; // eslint-disable-line no-param-reassign | |
} else { | |
throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.'); | |
} | |
}; | |
},{"es-define-property":7,"es-errors/syntax":12,"es-errors/type":13,"gopd":19}],7:[function(require,module,exports){ | |
'use strict'; | |
var GetIntrinsic = require('get-intrinsic'); | |
/** @type {import('.')} */ | |
var $defineProperty = GetIntrinsic('%Object.defineProperty%', true) || false; | |
if ($defineProperty) { | |
try { | |
$defineProperty({}, 'a', { value: 1 }); | |
} catch (e) { | |
// IE 8 has a broken defineProperty | |
$defineProperty = false; | |
} | |
} | |
module.exports = $defineProperty; | |
},{"get-intrinsic":18}],8:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('./eval')} */ | |
module.exports = EvalError; | |
},{}],9:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('.')} */ | |
module.exports = Error; | |
},{}],10:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('./range')} */ | |
module.exports = RangeError; | |
},{}],11:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('./ref')} */ | |
module.exports = ReferenceError; | |
},{}],12:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('./syntax')} */ | |
module.exports = SyntaxError; | |
},{}],13:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('./type')} */ | |
module.exports = TypeError; | |
},{}],14:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('./uri')} */ | |
module.exports = URIError; | |
},{}],15:[function(require,module,exports){ | |
'use strict'; | |
var isCallable = require('is-callable'); | |
var toStr = Object.prototype.toString; | |
var hasOwnProperty = Object.prototype.hasOwnProperty; | |
var forEachArray = function forEachArray(array, iterator, receiver) { | |
for (var i = 0, len = array.length; i < len; i++) { | |
if (hasOwnProperty.call(array, i)) { | |
if (receiver == null) { | |
iterator(array[i], i, array); | |
} else { | |
iterator.call(receiver, array[i], i, array); | |
} | |
} | |
} | |
}; | |
var forEachString = function forEachString(string, iterator, receiver) { | |
for (var i = 0, len = string.length; i < len; i++) { | |
// no such thing as a sparse string. | |
if (receiver == null) { | |
iterator(string.charAt(i), i, string); | |
} else { | |
iterator.call(receiver, string.charAt(i), i, string); | |
} | |
} | |
}; | |
var forEachObject = function forEachObject(object, iterator, receiver) { | |
for (var k in object) { | |
if (hasOwnProperty.call(object, k)) { | |
if (receiver == null) { | |
iterator(object[k], k, object); | |
} else { | |
iterator.call(receiver, object[k], k, object); | |
} | |
} | |
} | |
}; | |
var forEach = function forEach(list, iterator, thisArg) { | |
if (!isCallable(iterator)) { | |
throw new TypeError('iterator must be a function'); | |
} | |
var receiver; | |
if (arguments.length >= 3) { | |
receiver = thisArg; | |
} | |
if (toStr.call(list) === '[object Array]') { | |
forEachArray(list, iterator, receiver); | |
} else if (typeof list === 'string') { | |
forEachString(list, iterator, receiver); | |
} else { | |
forEachObject(list, iterator, receiver); | |
} | |
}; | |
module.exports = forEach; | |
},{"is-callable":29}],16:[function(require,module,exports){ | |
'use strict'; | |
/* eslint no-invalid-this: 1 */ | |
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; | |
var toStr = Object.prototype.toString; | |
var max = Math.max; | |
var funcType = '[object Function]'; | |
var concatty = function concatty(a, b) { | |
var arr = []; | |
for (var i = 0; i < a.length; i += 1) { | |
arr[i] = a[i]; | |
} | |
for (var j = 0; j < b.length; j += 1) { | |
arr[j + a.length] = b[j]; | |
} | |
return arr; | |
}; | |
var slicy = function slicy(arrLike, offset) { | |
var arr = []; | |
for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) { | |
arr[j] = arrLike[i]; | |
} | |
return arr; | |
}; | |
var joiny = function (arr, joiner) { | |
var str = ''; | |
for (var i = 0; i < arr.length; i += 1) { | |
str += arr[i]; | |
if (i + 1 < arr.length) { | |
str += joiner; | |
} | |
} | |
return str; | |
}; | |
module.exports = function bind(that) { | |
var target = this; | |
if (typeof target !== 'function' || toStr.apply(target) !== funcType) { | |
throw new TypeError(ERROR_MESSAGE + target); | |
} | |
var args = slicy(arguments, 1); | |
var bound; | |
var binder = function () { | |
if (this instanceof bound) { | |
var result = target.apply( | |
this, | |
concatty(args, arguments) | |
); | |
if (Object(result) === result) { | |
return result; | |
} | |
return this; | |
} | |
return target.apply( | |
that, | |
concatty(args, arguments) | |
); | |
}; | |
var boundLength = max(0, target.length - args.length); | |
var boundArgs = []; | |
for (var i = 0; i < boundLength; i++) { | |
boundArgs[i] = '$' + i; | |
} | |
bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder); | |
if (target.prototype) { | |
var Empty = function Empty() {}; | |
Empty.prototype = target.prototype; | |
bound.prototype = new Empty(); | |
Empty.prototype = null; | |
} | |
return bound; | |
}; | |
},{}],17:[function(require,module,exports){ | |
'use strict'; | |
var implementation = require('./implementation'); | |
module.exports = Function.prototype.bind || implementation; | |
},{"./implementation":16}],18:[function(require,module,exports){ | |
'use strict'; | |
var undefined; | |
var $Error = require('es-errors'); | |
var $EvalError = require('es-errors/eval'); | |
var $RangeError = require('es-errors/range'); | |
var $ReferenceError = require('es-errors/ref'); | |
var $SyntaxError = require('es-errors/syntax'); | |
var $TypeError = require('es-errors/type'); | |
var $URIError = require('es-errors/uri'); | |
var $Function = Function; | |
// eslint-disable-next-line consistent-return | |
var getEvalledConstructor = function (expressionSyntax) { | |
try { | |
return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')(); | |
} catch (e) {} | |
}; | |
var $gOPD = Object.getOwnPropertyDescriptor; | |
if ($gOPD) { | |
try { | |
$gOPD({}, ''); | |
} catch (e) { | |
$gOPD = null; // this is IE 8, which has a broken gOPD | |
} | |
} | |
var throwTypeError = function () { | |
throw new $TypeError(); | |
}; | |
var ThrowTypeError = $gOPD | |
? (function () { | |
try { | |
// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties | |
arguments.callee; // IE 8 does not throw here | |
return throwTypeError; | |
} catch (calleeThrows) { | |
try { | |
// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '') | |
return $gOPD(arguments, 'callee').get; | |
} catch (gOPDthrows) { | |
return throwTypeError; | |
} | |
} | |
}()) | |
: throwTypeError; | |
var hasSymbols = require('has-symbols')(); | |
var hasProto = require('has-proto')(); | |
var getProto = Object.getPrototypeOf || ( | |
hasProto | |
? function (x) { return x.__proto__; } // eslint-disable-line no-proto | |
: null | |
); | |
var needsEval = {}; | |
var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array); | |
var INTRINSICS = { | |
__proto__: null, | |
'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError, | |
'%Array%': Array, | |
'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, | |
'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined, | |
'%AsyncFromSyncIteratorPrototype%': undefined, | |
'%AsyncFunction%': needsEval, | |
'%AsyncGenerator%': needsEval, | |
'%AsyncGeneratorFunction%': needsEval, | |
'%AsyncIteratorPrototype%': needsEval, | |
'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, | |
'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt, | |
'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array, | |
'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array, | |
'%Boolean%': Boolean, | |
'%DataView%': typeof DataView === 'undefined' ? undefined : DataView, | |
'%Date%': Date, | |
'%decodeURI%': decodeURI, | |
'%decodeURIComponent%': decodeURIComponent, | |
'%encodeURI%': encodeURI, | |
'%encodeURIComponent%': encodeURIComponent, | |
'%Error%': $Error, | |
'%eval%': eval, // eslint-disable-line no-eval | |
'%EvalError%': $EvalError, | |
'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, | |
'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, | |
'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry, | |
'%Function%': $Function, | |
'%GeneratorFunction%': needsEval, | |
'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, | |
'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, | |
'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, | |
'%isFinite%': isFinite, | |
'%isNaN%': isNaN, | |
'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined, | |
'%JSON%': typeof JSON === 'object' ? JSON : undefined, | |
'%Map%': typeof Map === 'undefined' ? undefined : Map, | |
'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()), | |
'%Math%': Math, | |
'%Number%': Number, | |
'%Object%': Object, | |
'%parseFloat%': parseFloat, | |
'%parseInt%': parseInt, | |
'%Promise%': typeof Promise === 'undefined' ? undefined : Promise, | |
'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, | |
'%RangeError%': $RangeError, | |
'%ReferenceError%': $ReferenceError, | |
'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, | |
'%RegExp%': RegExp, | |
'%Set%': typeof Set === 'undefined' ? undefined : Set, | |
'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()), | |
'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, | |
'%String%': String, | |
'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined, | |
'%Symbol%': hasSymbols ? Symbol : undefined, | |
'%SyntaxError%': $SyntaxError, | |
'%ThrowTypeError%': ThrowTypeError, | |
'%TypedArray%': TypedArray, | |
'%TypeError%': $TypeError, | |
'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, | |
'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, | |
'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, | |
'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, | |
'%URIError%': $URIError, | |
'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, | |
'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef, | |
'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet | |
}; | |
if (getProto) { | |
try { | |
null.error; // eslint-disable-line no-unused-expressions | |
} catch (e) { | |
// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229 | |
var errorProto = getProto(getProto(e)); | |
INTRINSICS['%Error.prototype%'] = errorProto; | |
} | |
} | |
var doEval = function doEval(name) { | |
var value; | |
if (name === '%AsyncFunction%') { | |
value = getEvalledConstructor('async function () {}'); | |
} else if (name === '%GeneratorFunction%') { | |
value = getEvalledConstructor('function* () {}'); | |
} else if (name === '%AsyncGeneratorFunction%') { | |
value = getEvalledConstructor('async function* () {}'); | |
} else if (name === '%AsyncGenerator%') { | |
var fn = doEval('%AsyncGeneratorFunction%'); | |
if (fn) { | |
value = fn.prototype; | |
} | |
} else if (name === '%AsyncIteratorPrototype%') { | |
var gen = doEval('%AsyncGenerator%'); | |
if (gen && getProto) { | |
value = getProto(gen.prototype); | |
} | |
} | |
INTRINSICS[name] = value; | |
return value; | |
}; | |
var LEGACY_ALIASES = { | |
__proto__: null, | |
'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'], | |
'%ArrayPrototype%': ['Array', 'prototype'], | |
'%ArrayProto_entries%': ['Array', 'prototype', 'entries'], | |
'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'], | |
'%ArrayProto_keys%': ['Array', 'prototype', 'keys'], | |
'%ArrayProto_values%': ['Array', 'prototype', 'values'], | |
'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'], | |
'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'], | |
'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'], | |
'%BooleanPrototype%': ['Boolean', 'prototype'], | |
'%DataViewPrototype%': ['DataView', 'prototype'], | |
'%DatePrototype%': ['Date', 'prototype'], | |
'%ErrorPrototype%': ['Error', 'prototype'], | |
'%EvalErrorPrototype%': ['EvalError', 'prototype'], | |
'%Float32ArrayPrototype%': ['Float32Array', 'prototype'], | |
'%Float64ArrayPrototype%': ['Float64Array', 'prototype'], | |
'%FunctionPrototype%': ['Function', 'prototype'], | |
'%Generator%': ['GeneratorFunction', 'prototype'], | |
'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'], | |
'%Int8ArrayPrototype%': ['Int8Array', 'prototype'], | |
'%Int16ArrayPrototype%': ['Int16Array', 'prototype'], | |
'%Int32ArrayPrototype%': ['Int32Array', 'prototype'], | |
'%JSONParse%': ['JSON', 'parse'], | |
'%JSONStringify%': ['JSON', 'stringify'], | |
'%MapPrototype%': ['Map', 'prototype'], | |
'%NumberPrototype%': ['Number', 'prototype'], | |
'%ObjectPrototype%': ['Object', 'prototype'], | |
'%ObjProto_toString%': ['Object', 'prototype', 'toString'], | |
'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'], | |
'%PromisePrototype%': ['Promise', 'prototype'], | |
'%PromiseProto_then%': ['Promise', 'prototype', 'then'], | |
'%Promise_all%': ['Promise', 'all'], | |
'%Promise_reject%': ['Promise', 'reject'], | |
'%Promise_resolve%': ['Promise', 'resolve'], | |
'%RangeErrorPrototype%': ['RangeError', 'prototype'], | |
'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'], | |
'%RegExpPrototype%': ['RegExp', 'prototype'], | |
'%SetPrototype%': ['Set', 'prototype'], | |
'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'], | |
'%StringPrototype%': ['String', 'prototype'], | |
'%SymbolPrototype%': ['Symbol', 'prototype'], | |
'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'], | |
'%TypedArrayPrototype%': ['TypedArray', 'prototype'], | |
'%TypeErrorPrototype%': ['TypeError', 'prototype'], | |
'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'], | |
'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'], | |
'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'], | |
'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'], | |
'%URIErrorPrototype%': ['URIError', 'prototype'], | |
'%WeakMapPrototype%': ['WeakMap', 'prototype'], | |
'%WeakSetPrototype%': ['WeakSet', 'prototype'] | |
}; | |
var bind = require('function-bind'); | |
var hasOwn = require('hasown'); | |
var $concat = bind.call(Function.call, Array.prototype.concat); | |
var $spliceApply = bind.call(Function.apply, Array.prototype.splice); | |
var $replace = bind.call(Function.call, String.prototype.replace); | |
var $strSlice = bind.call(Function.call, String.prototype.slice); | |
var $exec = bind.call(Function.call, RegExp.prototype.exec); | |
/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */ | |
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; | |
var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */ | |
var stringToPath = function stringToPath(string) { | |
var first = $strSlice(string, 0, 1); | |
var last = $strSlice(string, -1); | |
if (first === '%' && last !== '%') { | |
throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`'); | |
} else if (last === '%' && first !== '%') { | |
throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`'); | |
} | |
var result = []; | |
$replace(string, rePropName, function (match, number, quote, subString) { | |
result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match; | |
}); | |
return result; | |
}; | |
/* end adaptation */ | |
var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) { | |
var intrinsicName = name; | |
var alias; | |
if (hasOwn(LEGACY_ALIASES, intrinsicName)) { | |
alias = LEGACY_ALIASES[intrinsicName]; | |
intrinsicName = '%' + alias[0] + '%'; | |
} | |
if (hasOwn(INTRINSICS, intrinsicName)) { | |
var value = INTRINSICS[intrinsicName]; | |
if (value === needsEval) { | |
value = doEval(intrinsicName); | |
} | |
if (typeof value === 'undefined' && !allowMissing) { | |
throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); | |
} | |
return { | |
alias: alias, | |
name: intrinsicName, | |
value: value | |
}; | |
} | |
throw new $SyntaxError('intrinsic ' + name + ' does not exist!'); | |
}; | |
module.exports = function GetIntrinsic(name, allowMissing) { | |
if (typeof name !== 'string' || name.length === 0) { | |
throw new $TypeError('intrinsic name must be a non-empty string'); | |
} | |
if (arguments.length > 1 && typeof allowMissing !== 'boolean') { | |
throw new $TypeError('"allowMissing" argument must be a boolean'); | |
} | |
if ($exec(/^%?[^%]*%?$/, name) === null) { | |
throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name'); | |
} | |
var parts = stringToPath(name); | |
var intrinsicBaseName = parts.length > 0 ? parts[0] : ''; | |
var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing); | |
var intrinsicRealName = intrinsic.name; | |
var value = intrinsic.value; | |
var skipFurtherCaching = false; | |
var alias = intrinsic.alias; | |
if (alias) { | |
intrinsicBaseName = alias[0]; | |
$spliceApply(parts, $concat([0, 1], alias)); | |
} | |
for (var i = 1, isOwn = true; i < parts.length; i += 1) { | |
var part = parts[i]; | |
var first = $strSlice(part, 0, 1); | |
var last = $strSlice(part, -1); | |
if ( | |
( | |
(first === '"' || first === "'" || first === '`') | |
|| (last === '"' || last === "'" || last === '`') | |
) | |
&& first !== last | |
) { | |
throw new $SyntaxError('property names with quotes must have matching quotes'); | |
} | |
if (part === 'constructor' || !isOwn) { | |
skipFurtherCaching = true; | |
} | |
intrinsicBaseName += '.' + part; | |
intrinsicRealName = '%' + intrinsicBaseName + '%'; | |
if (hasOwn(INTRINSICS, intrinsicRealName)) { | |
value = INTRINSICS[intrinsicRealName]; | |
} else if (value != null) { | |
if (!(part in value)) { | |
if (!allowMissing) { | |
throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.'); | |
} | |
return void undefined; | |
} | |
if ($gOPD && (i + 1) >= parts.length) { | |
var desc = $gOPD(value, part); | |
isOwn = !!desc; | |
// By convention, when a data property is converted to an accessor | |
// property to emulate a data property that does not suffer from | |
// the override mistake, that accessor's getter is marked with | |
// an `originalValue` property. Here, when we detect this, we | |
// uphold the illusion by pretending to see that original data | |
// property, i.e., returning the value rather than the getter | |
// itself. | |
if (isOwn && 'get' in desc && !('originalValue' in desc.get)) { | |
value = desc.get; | |
} else { | |
value = value[part]; | |
} | |
} else { | |
isOwn = hasOwn(value, part); | |
value = value[part]; | |
} | |
if (isOwn && !skipFurtherCaching) { | |
INTRINSICS[intrinsicRealName] = value; | |
} | |
} | |
} | |
return value; | |
}; | |
},{"es-errors":9,"es-errors/eval":8,"es-errors/range":10,"es-errors/ref":11,"es-errors/syntax":12,"es-errors/type":13,"es-errors/uri":14,"function-bind":17,"has-proto":21,"has-symbols":22,"hasown":25}],19:[function(require,module,exports){ | |
'use strict'; | |
var GetIntrinsic = require('get-intrinsic'); | |
var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true); | |
if ($gOPD) { | |
try { | |
$gOPD([], 'length'); | |
} catch (e) { | |
// IE 8 has a broken gOPD | |
$gOPD = null; | |
} | |
} | |
module.exports = $gOPD; | |
},{"get-intrinsic":18}],20:[function(require,module,exports){ | |
'use strict'; | |
var $defineProperty = require('es-define-property'); | |
var hasPropertyDescriptors = function hasPropertyDescriptors() { | |
return !!$defineProperty; | |
}; | |
hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() { | |
// node v0.6 has a bug where array lengths can be Set but not Defined | |
if (!$defineProperty) { | |
return null; | |
} | |
try { | |
return $defineProperty([], 'length', { value: 1 }).length !== 1; | |
} catch (e) { | |
// In Firefox 4-22, defining length on an array throws an exception. | |
return true; | |
} | |
}; | |
module.exports = hasPropertyDescriptors; | |
},{"es-define-property":7}],21:[function(require,module,exports){ | |
'use strict'; | |
var test = { | |
__proto__: null, | |
foo: {} | |
}; | |
var $Object = Object; | |
/** @type {import('.')} */ | |
module.exports = function hasProto() { | |
// @ts-expect-error: TS errors on an inherited property for some reason | |
return { __proto__: test }.foo === test.foo | |
&& !(test instanceof $Object); | |
}; | |
},{}],22:[function(require,module,exports){ | |
'use strict'; | |
var origSymbol = typeof Symbol !== 'undefined' && Symbol; | |
var hasSymbolSham = require('./shams'); | |
module.exports = function hasNativeSymbols() { | |
if (typeof origSymbol !== 'function') { return false; } | |
if (typeof Symbol !== 'function') { return false; } | |
if (typeof origSymbol('foo') !== 'symbol') { return false; } | |
if (typeof Symbol('bar') !== 'symbol') { return false; } | |
return hasSymbolSham(); | |
}; | |
},{"./shams":23}],23:[function(require,module,exports){ | |
'use strict'; | |
/* eslint complexity: [2, 18], max-statements: [2, 33] */ | |
module.exports = function hasSymbols() { | |
if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; } | |
if (typeof Symbol.iterator === 'symbol') { return true; } | |
var obj = {}; | |
var sym = Symbol('test'); | |
var symObj = Object(sym); | |
if (typeof sym === 'string') { return false; } | |
if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; } | |
if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; } | |
// temp disabled per https://github.com/ljharb/object.assign/issues/17 | |
// if (sym instanceof Symbol) { return false; } | |
// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4 | |
// if (!(symObj instanceof Symbol)) { return false; } | |
// if (typeof Symbol.prototype.toString !== 'function') { return false; } | |
// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; } | |
var symVal = 42; | |
obj[sym] = symVal; | |
for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop | |
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; } | |
if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; } | |
var syms = Object.getOwnPropertySymbols(obj); | |
if (syms.length !== 1 || syms[0] !== sym) { return false; } | |
if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; } | |
if (typeof Object.getOwnPropertyDescriptor === 'function') { | |
var descriptor = Object.getOwnPropertyDescriptor(obj, sym); | |
if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; } | |
} | |
return true; | |
}; | |
},{}],24:[function(require,module,exports){ | |
'use strict'; | |
var hasSymbols = require('has-symbols/shams'); | |
/** @type {import('.')} */ | |
module.exports = function hasToStringTagShams() { | |
return hasSymbols() && !!Symbol.toStringTag; | |
}; | |
},{"has-symbols/shams":23}],25:[function(require,module,exports){ | |
'use strict'; | |
var call = Function.prototype.call; | |
var $hasOwn = Object.prototype.hasOwnProperty; | |
var bind = require('function-bind'); | |
/** @type {import('.')} */ | |
module.exports = bind.call(call, $hasOwn); | |
},{"function-bind":17}],26:[function(require,module,exports){ | |
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */ | |
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 | |
} | |
},{}],27:[function(require,module,exports){ | |
if (typeof Object.create === 'function') { | |
// implementation from standard node.js 'util' module | |
module.exports = function inherits(ctor, superCtor) { | |
if (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) { | |
if (superCtor) { | |
ctor.super_ = superCtor | |
var TempCtor = function () {} | |
TempCtor.prototype = superCtor.prototype | |
ctor.prototype = new TempCtor() | |
ctor.prototype.constructor = ctor | |
} | |
} | |
} | |
},{}],28:[function(require,module,exports){ | |
'use strict'; | |
var hasToStringTag = require('has-tostringtag/shams')(); | |
var callBound = require('call-bind/callBound'); | |
var $toString = callBound('Object.prototype.toString'); | |
var isStandardArguments = function isArguments(value) { | |
if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) { | |
return false; | |
} | |
return $toString(value) === '[object Arguments]'; | |
}; | |
var isLegacyArguments = function isArguments(value) { | |
if (isStandardArguments(value)) { | |
return true; | |
} | |
return value !== null && | |
typeof value === 'object' && | |
typeof value.length === 'number' && | |
value.length >= 0 && | |
$toString(value) !== '[object Array]' && | |
$toString(value.callee) === '[object Function]'; | |
}; | |
var supportsStandardArguments = (function () { | |
return isStandardArguments(arguments); | |
}()); | |
isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests | |
module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments; | |
},{"call-bind/callBound":4,"has-tostringtag/shams":24}],29:[function(require,module,exports){ | |
'use strict'; | |
var fnToStr = Function.prototype.toString; | |
var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply; | |
var badArrayLike; | |
var isCallableMarker; | |
if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') { | |
try { | |
badArrayLike = Object.defineProperty({}, 'length', { | |
get: function () { | |
throw isCallableMarker; | |
} | |
}); | |
isCallableMarker = {}; | |
// eslint-disable-next-line no-throw-literal | |
reflectApply(function () { throw 42; }, null, badArrayLike); | |
} catch (_) { | |
if (_ !== isCallableMarker) { | |
reflectApply = null; | |
} | |
} | |
} else { | |
reflectApply = null; | |
} | |
var constructorRegex = /^\s*class\b/; | |
var isES6ClassFn = function isES6ClassFunction(value) { | |
try { | |
var fnStr = fnToStr.call(value); | |
return constructorRegex.test(fnStr); | |
} catch (e) { | |
return false; // not a function | |
} | |
}; | |
var tryFunctionObject = function tryFunctionToStr(value) { | |
try { | |
if (isES6ClassFn(value)) { return false; } | |
fnToStr.call(value); | |
return true; | |
} catch (e) { | |
return false; | |
} | |
}; | |
var toStr = Object.prototype.toString; | |
var objectClass = '[object Object]'; | |
var fnClass = '[object Function]'; | |
var genClass = '[object GeneratorFunction]'; | |
var ddaClass = '[object HTMLAllCollection]'; // IE 11 | |
var ddaClass2 = '[object HTML document.all class]'; | |
var ddaClass3 = '[object HTMLCollection]'; // IE 9-10 | |
var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag` | |
var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing | |
var isDDA = function isDocumentDotAll() { return false; }; | |
if (typeof document === 'object') { | |
// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly | |
var all = document.all; | |
if (toStr.call(all) === toStr.call(document.all)) { | |
isDDA = function isDocumentDotAll(value) { | |
/* globals document: false */ | |
// in IE 6-8, typeof document.all is "object" and it's truthy | |
if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) { | |
try { | |
var str = toStr.call(value); | |
return ( | |
str === ddaClass | |
|| str === ddaClass2 | |
|| str === ddaClass3 // opera 12.16 | |
|| str === objectClass // IE 6-8 | |
) && value('') == null; // eslint-disable-line eqeqeq | |
} catch (e) { /**/ } | |
} | |
return false; | |
}; | |
} | |
} | |
module.exports = reflectApply | |
? function isCallable(value) { | |
if (isDDA(value)) { return true; } | |
if (!value) { return false; } | |
if (typeof value !== 'function' && typeof value !== 'object') { return false; } | |
try { | |
reflectApply(value, null, badArrayLike); | |
} catch (e) { | |
if (e !== isCallableMarker) { return false; } | |
} | |
return !isES6ClassFn(value) && tryFunctionObject(value); | |
} | |
: function isCallable(value) { | |
if (isDDA(value)) { return true; } | |
if (!value) { return false; } | |
if (typeof value !== 'function' && typeof value !== 'object') { return false; } | |
if (hasToStringTag) { return tryFunctionObject(value); } | |
if (isES6ClassFn(value)) { return false; } | |
var strClass = toStr.call(value); | |
if (strClass !== fnClass && strClass !== genClass && !(/^\[object HTML/).test(strClass)) { return false; } | |
return tryFunctionObject(value); | |
}; | |
},{}],30:[function(require,module,exports){ | |
'use strict'; | |
var toStr = Object.prototype.toString; | |
var fnToStr = Function.prototype.toString; | |
var isFnRegex = /^\s*(?:function)?\*/; | |
var hasToStringTag = require('has-tostringtag/shams')(); | |
var getProto = Object.getPrototypeOf; | |
var getGeneratorFunc = function () { // eslint-disable-line consistent-return | |
if (!hasToStringTag) { | |
return false; | |
} | |
try { | |
return Function('return function*() {}')(); | |
} catch (e) { | |
} | |
}; | |
var GeneratorFunction; | |
module.exports = function isGeneratorFunction(fn) { | |
if (typeof fn !== 'function') { | |
return false; | |
} | |
if (isFnRegex.test(fnToStr.call(fn))) { | |
return true; | |
} | |
if (!hasToStringTag) { | |
var str = toStr.call(fn); | |
return str === '[object GeneratorFunction]'; | |
} | |
if (!getProto) { | |
return false; | |
} | |
if (typeof GeneratorFunction === 'undefined') { | |
var generatorFunc = getGeneratorFunc(); | |
GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false; | |
} | |
return getProto(fn) === GeneratorFunction; | |
}; | |
},{"has-tostringtag/shams":24}],31:[function(require,module,exports){ | |
'use strict'; | |
var whichTypedArray = require('which-typed-array'); | |
/** @type {import('.')} */ | |
module.exports = function isTypedArray(value) { | |
return !!whichTypedArray(value); | |
}; | |
},{"which-typed-array":38}],32:[function(require,module,exports){ | |
'use strict'; | |
/** @type {import('.')} */ | |
module.exports = [ | |
'Float32Array', | |
'Float64Array', | |
'Int8Array', | |
'Int16Array', | |
'Int32Array', | |
'Uint8Array', | |
'Uint8ClampedArray', | |
'Uint16Array', | |
'Uint32Array', | |
'BigInt64Array', | |
'BigUint64Array' | |
]; | |
},{}],33:[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; }; | |
},{}],34:[function(require,module,exports){ | |
'use strict'; | |
var GetIntrinsic = require('get-intrinsic'); | |
var define = require('define-data-property'); | |
var hasDescriptors = require('has-property-descriptors')(); | |
var gOPD = require('gopd'); | |
var $TypeError = require('es-errors/type'); | |
var $floor = GetIntrinsic('%Math.floor%'); | |
/** @type {import('.')} */ | |
module.exports = function setFunctionLength(fn, length) { | |
if (typeof fn !== 'function') { | |
throw new $TypeError('`fn` is not a function'); | |
} | |
if (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) { | |
throw new $TypeError('`length` must be a positive 32-bit integer'); | |
} | |
var loose = arguments.length > 2 && !!arguments[2]; | |
var functionLengthIsConfigurable = true; | |
var functionLengthIsWritable = true; | |
if ('length' in fn && gOPD) { | |
var desc = gOPD(fn, 'length'); | |
if (desc && !desc.configurable) { | |
functionLengthIsConfigurable = false; | |
} | |
if (desc && !desc.writable) { | |
functionLengthIsWritable = false; | |
} | |
} | |
if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) { | |
if (hasDescriptors) { | |
define(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true); | |
} else { | |
define(/** @type {Parameters<define>[0]} */ (fn), 'length', length); | |
} | |
} | |
return fn; | |
}; | |
},{"define-data-property":6,"es-errors/type":13,"get-intrinsic":18,"gopd":19,"has-property-descriptors":20}],35:[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'; | |
} | |
},{}],36:[function(require,module,exports){ | |
// Currently in sync with Node.js lib/internal/util/types.js | |
// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9 | |
'use strict'; | |
var isArgumentsObject = require('is-arguments'); | |
var isGeneratorFunction = require('is-generator-function'); | |
var whichTypedArray = require('which-typed-array'); | |
var isTypedArray = require('is-typed-array'); | |
function uncurryThis(f) { | |
return f.call.bind(f); | |
} | |
var BigIntSupported = typeof BigInt !== 'undefined'; | |
var SymbolSupported = typeof Symbol !== 'undefined'; | |
var ObjectToString = uncurryThis(Object.prototype.toString); | |
var numberValue = uncurryThis(Number.prototype.valueOf); | |
var stringValue = uncurryThis(String.prototype.valueOf); | |
var booleanValue = uncurryThis(Boolean.prototype.valueOf); | |
if (BigIntSupported) { | |
var bigIntValue = uncurryThis(BigInt.prototype.valueOf); | |
} | |
if (SymbolSupported) { | |
var symbolValue = uncurryThis(Symbol.prototype.valueOf); | |
} | |
function checkBoxedPrimitive(value, prototypeValueOf) { | |
if (typeof value !== 'object') { | |
return false; | |
} | |
try { | |
prototypeValueOf(value); | |
return true; | |
} catch(e) { | |
return false; | |
} | |
} | |
exports.isArgumentsObject = isArgumentsObject; | |
exports.isGeneratorFunction = isGeneratorFunction; | |
exports.isTypedArray = isTypedArray; | |
// Taken from here and modified for better browser support | |
// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js | |
function isPromise(input) { | |
return ( | |
( | |
typeof Promise !== 'undefined' && | |
input instanceof Promise | |
) || | |
( | |
input !== null && | |
typeof input === 'object' && | |
typeof input.then === 'function' && | |
typeof input.catch === 'function' | |
) | |
); | |
} | |
exports.isPromise = isPromise; | |
function isArrayBufferView(value) { | |
if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) { | |
return ArrayBuffer.isView(value); | |
} | |
return ( | |
isTypedArray(value) || | |
isDataView(value) | |
); | |
} | |
exports.isArrayBufferView = isArrayBufferView; | |
function isUint8Array(value) { | |
return whichTypedArray(value) === 'Uint8Array'; | |
} | |
exports.isUint8Array = isUint8Array; | |
function isUint8ClampedArray(value) { | |
return whichTypedArray(value) === 'Uint8ClampedArray'; | |
} | |
exports.isUint8ClampedArray = isUint8ClampedArray; | |
function isUint16Array(value) { | |
return whichTypedArray(value) === 'Uint16Array'; | |
} | |
exports.isUint16Array = isUint16Array; | |
function isUint32Array(value) { | |
return whichTypedArray(value) === 'Uint32Array'; | |
} | |
exports.isUint32Array = isUint32Array; | |
function isInt8Array(value) { | |
return whichTypedArray(value) === 'Int8Array'; | |
} | |
exports.isInt8Array = isInt8Array; | |
function isInt16Array(value) { | |
return whichTypedArray(value) === 'Int16Array'; | |
} | |
exports.isInt16Array = isInt16Array; | |
function isInt32Array(value) { | |
return whichTypedArray(value) === 'Int32Array'; | |
} | |
exports.isInt32Array = isInt32Array; | |
function isFloat32Array(value) { | |
return whichTypedArray(value) === 'Float32Array'; | |
} | |
exports.isFloat32Array = isFloat32Array; | |
function isFloat64Array(value) { | |
return whichTypedArray(value) === 'Float64Array'; | |
} | |
exports.isFloat64Array = isFloat64Array; | |
function isBigInt64Array(value) { | |
return whichTypedArray(value) === 'BigInt64Array'; | |
} | |
exports.isBigInt64Array = isBigInt64Array; | |
function isBigUint64Array(value) { | |
return whichTypedArray(value) === 'BigUint64Array'; | |
} | |
exports.isBigUint64Array = isBigUint64Array; | |
function isMapToString(value) { | |
return ObjectToString(value) === '[object Map]'; | |
} | |
isMapToString.working = ( | |
typeof Map !== 'undefined' && | |
isMapToString(new Map()) | |
); | |
function isMap(value) { | |
if (typeof Map === 'undefined') { | |
return false; | |
} | |
return isMapToString.working | |
? isMapToString(value) | |
: value instanceof Map; | |
} | |
exports.isMap = isMap; | |
function isSetToString(value) { | |
return ObjectToString(value) === '[object Set]'; | |
} | |
isSetToString.working = ( | |
typeof Set !== 'undefined' && | |
isSetToString(new Set()) | |
); | |
function isSet(value) { | |
if (typeof Set === 'undefined') { | |
return false; | |
} | |
return isSetToString.working | |
? isSetToString(value) | |
: value instanceof Set; | |
} | |
exports.isSet = isSet; | |
function isWeakMapToString(value) { | |
return ObjectToString(value) === '[object WeakMap]'; | |
} | |
isWeakMapToString.working = ( | |
typeof WeakMap !== 'undefined' && | |
isWeakMapToString(new WeakMap()) | |
); | |
function isWeakMap(value) { | |
if (typeof WeakMap === 'undefined') { | |
return false; | |
} | |
return isWeakMapToString.working | |
? isWeakMapToString(value) | |
: value instanceof WeakMap; | |
} | |
exports.isWeakMap = isWeakMap; | |
function isWeakSetToString(value) { | |
return ObjectToString(value) === '[object WeakSet]'; | |
} | |
isWeakSetToString.working = ( | |
typeof WeakSet !== 'undefined' && | |
isWeakSetToString(new WeakSet()) | |
); | |
function isWeakSet(value) { | |
return isWeakSetToString(value); | |
} | |
exports.isWeakSet = isWeakSet; | |
function isArrayBufferToString(value) { | |
return ObjectToString(value) === '[object ArrayBuffer]'; | |
} | |
isArrayBufferToString.working = ( | |
typeof ArrayBuffer !== 'undefined' && | |
isArrayBufferToString(new ArrayBuffer()) | |
); | |
function isArrayBuffer(value) { | |
if (typeof ArrayBuffer === 'undefined') { | |
return false; | |
} | |
return isArrayBufferToString.working | |
? isArrayBufferToString(value) | |
: value instanceof ArrayBuffer; | |
} | |
exports.isArrayBuffer = isArrayBuffer; | |
function isDataViewToString(value) { | |
return ObjectToString(value) === '[object DataView]'; | |
} | |
isDataViewToString.working = ( | |
typeof ArrayBuffer !== 'undefined' && | |
typeof DataView !== 'undefined' && | |
isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1)) | |
); | |
function isDataView(value) { | |
if (typeof DataView === 'undefined') { | |
return false; | |
} | |
return isDataViewToString.working | |
? isDataViewToString(value) | |
: value instanceof DataView; | |
} | |
exports.isDataView = isDataView; | |
// Store a copy of SharedArrayBuffer in case it's deleted elsewhere | |
var SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined; | |
function isSharedArrayBufferToString(value) { | |
return ObjectToString(value) === '[object SharedArrayBuffer]'; | |
} | |
function isSharedArrayBuffer(value) { | |
if (typeof SharedArrayBufferCopy === 'undefined') { | |
return false; | |
} | |
if (typeof isSharedArrayBufferToString.working === 'undefined') { | |
isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy()); | |
} | |
return isSharedArrayBufferToString.working | |
? isSharedArrayBufferToString(value) | |
: value instanceof SharedArrayBufferCopy; | |
} | |
exports.isSharedArrayBuffer = isSharedArrayBuffer; | |
function isAsyncFunction(value) { | |
return ObjectToString(value) === '[object AsyncFunction]'; | |
} | |
exports.isAsyncFunction = isAsyncFunction; | |
function isMapIterator(value) { | |
return ObjectToString(value) === '[object Map Iterator]'; | |
} | |
exports.isMapIterator = isMapIterator; | |
function isSetIterator(value) { | |
return ObjectToString(value) === '[object Set Iterator]'; | |
} | |
exports.isSetIterator = isSetIterator; | |
function isGeneratorObject(value) { | |
return ObjectToString(value) === '[object Generator]'; | |
} | |
exports.isGeneratorObject = isGeneratorObject; | |
function isWebAssemblyCompiledModule(value) { | |
return ObjectToString(value) === '[object WebAssembly.Module]'; | |
} | |
exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule; | |
function isNumberObject(value) { | |
return checkBoxedPrimitive(value, numberValue); | |
} | |
exports.isNumberObject = isNumberObject; | |
function isStringObject(value) { | |
return checkBoxedPrimitive(value, stringValue); | |
} | |
exports.isStringObject = isStringObject; | |
function isBooleanObject(value) { | |
return checkBoxedPrimitive(value, booleanValue); | |
} | |
exports.isBooleanObject = isBooleanObject; | |
function isBigIntObject(value) { | |
return BigIntSupported && checkBoxedPrimitive(value, bigIntValue); | |
} | |
exports.isBigIntObject = isBigIntObject; | |
function isSymbolObject(value) { | |
return SymbolSupported && checkBoxedPrimitive(value, symbolValue); | |
} | |
exports.isSymbolObject = isSymbolObject; | |
function isBoxedPrimitive(value) { | |
return ( | |
isNumberObject(value) || | |
isStringObject(value) || | |
isBooleanObject(value) || | |
isBigIntObject(value) || | |
isSymbolObject(value) | |
); | |
} | |
exports.isBoxedPrimitive = isBoxedPrimitive; | |
function isAnyArrayBuffer(value) { | |
return typeof Uint8Array !== 'undefined' && ( | |
isArrayBuffer(value) || | |
isSharedArrayBuffer(value) | |
); | |
} | |
exports.isAnyArrayBuffer = isAnyArrayBuffer; | |
['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) { | |
Object.defineProperty(exports, method, { | |
enumerable: false, | |
value: function() { | |
throw new Error(method + ' is not supported in userland'); | |
} | |
}); | |
}); | |
},{"is-arguments":28,"is-generator-function":30,"is-typed-array":31,"which-typed-array":38}],37:[function(require,module,exports){ | |
(function (process){(function (){ | |
// 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 getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || | |
function getOwnPropertyDescriptors(obj) { | |
var keys = Object.keys(obj); | |
var descriptors = {}; | |
for (var i = 0; i < keys.length; i++) { | |
descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]); | |
} | |
return descriptors; | |
}; | |
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) { | |
if (typeof process !== 'undefined' && process.noDeprecation === true) { | |
return fn; | |
} | |
// Allow for deprecating things in the process of starting up. | |
if (typeof process === 'undefined') { | |
return function() { | |
return exports.deprecate(fn, msg).apply(this, arguments); | |
}; | |
} | |
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 debugEnvRegex = /^$/; | |
if (process.env.NODE_DEBUG) { | |
var debugEnv = process.env.NODE_DEBUG; | |
debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&') | |
.replace(/\*/g, '.*') | |
.replace(/,/g, '$|^') | |
.toUpperCase(); | |
debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i'); | |
} | |
exports.debuglog = function(set) { | |
set = set.toUpperCase(); | |
if (!debugs[set]) { | |
if (debugEnvRegex.test(set)) { | |
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').slice(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.slice(1, -1); | |
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()`. | |
exports.types = require('./support/types'); | |
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; | |
exports.types.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; | |
exports.types.isDate = isDate; | |
function isError(e) { | |
return isObject(e) && | |
(objectToString(e) === '[object Error]' || e instanceof Error); | |
} | |
exports.isError = isError; | |
exports.types.isNativeError = 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); | |
} | |
var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined; | |
exports.promisify = function promisify(original) { | |
if (typeof original !== 'function') | |
throw new TypeError('The "original" argument must be of type Function'); | |
if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) { | |
var fn = original[kCustomPromisifiedSymbol]; | |
if (typeof fn !== 'function') { | |
throw new TypeError('The "util.promisify.custom" argument must be of type Function'); | |
} | |
Object.defineProperty(fn, kCustomPromisifiedSymbol, { | |
value: fn, enumerable: false, writable: false, configurable: true | |
}); | |
return fn; | |
} | |
function fn() { | |
var promiseResolve, promiseReject; | |
var promise = new Promise(function (resolve, reject) { | |
promiseResolve = resolve; | |
promiseReject = reject; | |
}); | |
var args = []; | |
for (var i = 0; i < arguments.length; i++) { | |
args.push(arguments[i]); | |
} | |
args.push(function (err, value) { | |
if (err) { | |
promiseReject(err); | |
} else { | |
promiseResolve(value); | |
} | |
}); | |
try { | |
original.apply(this, args); | |
} catch (err) { | |
promiseReject(err); | |
} | |
return promise; | |
} | |
Object.setPrototypeOf(fn, Object.getPrototypeOf(original)); | |
if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, { | |
value: fn, enumerable: false, writable: false, configurable: true | |
}); | |
return Object.defineProperties( | |
fn, | |
getOwnPropertyDescriptors(original) | |
); | |
} | |
exports.promisify.custom = kCustomPromisifiedSymbol | |
function callbackifyOnRejected(reason, cb) { | |
// `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M). | |
// Because `null` is a special error value in callbacks which means "no error | |
// occurred", we error-wrap so the callback consumer can distinguish between | |
// "the promise rejected with null" or "the promise fulfilled with undefined". | |
if (!reason) { | |
var newReason = new Error('Promise was rejected with a falsy value'); | |
newReason.reason = reason; | |
reason = newReason; | |
} | |
return cb(reason); | |
} | |
function callbackify(original) { | |
if (typeof original !== 'function') { | |
throw new TypeError('The "original" argument must be of type Function'); | |
} | |
// We DO NOT return the promise as it gives the user a false sense that | |
// the promise is actually somehow related to the callback's execution | |
// and that the callback throwing will reject the promise. | |
function callbackified() { | |
var args = []; | |
for (var i = 0; i < arguments.length; i++) { | |
args.push(arguments[i]); | |
} | |
var maybeCb = args.pop(); | |
if (typeof maybeCb !== 'function') { | |
throw new TypeError('The last argument must be of type Function'); | |
} | |
var self = this; | |
var cb = function() { | |
return maybeCb.apply(self, arguments); | |
}; | |
// In true node style we process the callback on `nextTick` with all the | |
// implications (stack, `uncaughtException`, `async_hooks`) | |
original.apply(this, args) | |
.then(function(ret) { process.nextTick(cb.bind(null, null, ret)) }, | |
function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) }); | |
} | |
Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original)); | |
Object.defineProperties(callbackified, | |
getOwnPropertyDescriptors(original)); | |
return callbackified; | |
} | |
exports.callbackify = callbackify; | |
}).call(this)}).call(this,require('_process')) | |
},{"./support/isBuffer":35,"./support/types":36,"_process":33,"inherits":27}],38:[function(require,module,exports){ | |
(function (global){(function (){ | |
'use strict'; | |
var forEach = require('for-each'); | |
var availableTypedArrays = require('available-typed-arrays'); | |
var callBind = require('call-bind'); | |
var callBound = require('call-bind/callBound'); | |
var gOPD = require('gopd'); | |
/** @type {(O: object) => string} */ | |
var $toString = callBound('Object.prototype.toString'); | |
var hasToStringTag = require('has-tostringtag/shams')(); | |
var g = typeof globalThis === 'undefined' ? global : globalThis; | |
var typedArrays = availableTypedArrays(); | |
var $slice = callBound('String.prototype.slice'); | |
var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof'); | |
/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */ | |
var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) { | |
for (var i = 0; i < array.length; i += 1) { | |
if (array[i] === value) { | |
return i; | |
} | |
} | |
return -1; | |
}; | |
/** @typedef {(receiver: import('.').TypedArray) => string | typeof Uint8Array.prototype.slice.call | typeof Uint8Array.prototype.set.call} Getter */ | |
/** @type {{ [k in `\$${import('.').TypedArrayName}`]?: Getter } & { __proto__: null }} */ | |
var cache = { __proto__: null }; | |
if (hasToStringTag && gOPD && getPrototypeOf) { | |
forEach(typedArrays, function (typedArray) { | |
var arr = new g[typedArray](); | |
if (Symbol.toStringTag in arr) { | |
var proto = getPrototypeOf(arr); | |
// @ts-expect-error TS won't narrow inside a closure | |
var descriptor = gOPD(proto, Symbol.toStringTag); | |
if (!descriptor) { | |
var superProto = getPrototypeOf(proto); | |
// @ts-expect-error TS won't narrow inside a closure | |
descriptor = gOPD(superProto, Symbol.toStringTag); | |
} | |
// @ts-expect-error TODO: fix | |
cache['$' + typedArray] = callBind(descriptor.get); | |
} | |
}); | |
} else { | |
forEach(typedArrays, function (typedArray) { | |
var arr = new g[typedArray](); | |
var fn = arr.slice || arr.set; | |
if (fn) { | |
// @ts-expect-error TODO: fix | |
cache['$' + typedArray] = callBind(fn); | |
} | |
}); | |
} | |
/** @type {(value: object) => false | import('.').TypedArrayName} */ | |
var tryTypedArrays = function tryAllTypedArrays(value) { | |
/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false; | |
forEach( | |
// eslint-disable-next-line no-extra-parens | |
/** @type {Record<`\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache), | |
/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */ | |
function (getter, typedArray) { | |
if (!found) { | |
try { | |
// @ts-expect-error TODO: fix | |
if ('$' + getter(value) === typedArray) { | |
found = $slice(typedArray, 1); | |
} | |
} catch (e) { /**/ } | |
} | |
} | |
); | |
return found; | |
}; | |
/** @type {(value: object) => false | import('.').TypedArrayName} */ | |
var trySlices = function tryAllSlices(value) { | |
/** @type {ReturnType<typeof tryAllSlices>} */ var found = false; | |
forEach( | |
// eslint-disable-next-line no-extra-parens | |
/** @type {Record<`\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache), | |
/** @type {(getter: typeof cache, name: `\$${import('.').TypedArrayName}`) => void} */ function (getter, name) { | |
if (!found) { | |
try { | |
// @ts-expect-error TODO: fix | |
getter(value); | |
found = $slice(name, 1); | |
} catch (e) { /**/ } | |
} | |
} | |
); | |
return found; | |
}; | |
/** @type {import('.')} */ | |
module.exports = function whichTypedArray(value) { | |
if (!value || typeof value !== 'object') { return false; } | |
if (!hasToStringTag) { | |
/** @type {string} */ | |
var tag = $slice($toString(value), 8, -1); | |
if ($indexOf(typedArrays, tag) > -1) { | |
return tag; | |
} | |
if (tag !== 'Object') { | |
return false; | |
} | |
// node < 0.6 hits here on real Typed Arrays | |
return trySlices(value); | |
} | |
if (!gOPD) { return null; } // unknown engine | |
return tryTypedArrays(value); | |
}; | |
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
},{"available-typed-arrays":1,"call-bind":5,"call-bind/callBound":4,"for-each":15,"gopd":19,"has-tostringtag/shams":24}],39:[function(require,module,exports){ | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.Parser = void 0; | |
const smart_buffer_1 = require("smart-buffer"); | |
class Context { | |
constructor(importPath, useContextVariables) { | |
this.code = ""; | |
this.scopes = [["vars"]]; | |
this.bitFields = []; | |
this.tmpVariableCount = 0; | |
this.references = new Map(); | |
this.imports = []; | |
this.reverseImports = new Map(); | |
this.useContextVariables = false; | |
this.importPath = importPath; | |
this.useContextVariables = useContextVariables; | |
} | |
generateVariable(name) { | |
const scopes = [...this.scopes[this.scopes.length - 1]]; | |
if (name) { | |
scopes.push(name); | |
} | |
return scopes.join("."); | |
} | |
generateOption(val) { | |
switch (typeof val) { | |
case "number": | |
return val.toString(); | |
case "string": | |
return this.generateVariable(val); | |
case "function": | |
return `${this.addImport(val)}.call(${this.generateVariable()}, vars)`; | |
} | |
} | |
generateError(err) { | |
this.pushCode(`throw new Error(${err});`); | |
} | |
generateTmpVariable() { | |
return "$tmp" + this.tmpVariableCount++; | |
} | |
pushCode(code) { | |
this.code += code + "\n"; | |
} | |
pushPath(name) { | |
if (name) { | |
this.scopes[this.scopes.length - 1].push(name); | |
} | |
} | |
popPath(name) { | |
if (name) { | |
this.scopes[this.scopes.length - 1].pop(); | |
} | |
} | |
pushScope(name) { | |
this.scopes.push([name]); | |
} | |
popScope() { | |
this.scopes.pop(); | |
} | |
addImport(im) { | |
if (!this.importPath) | |
return `(${im})`; | |
let id = this.reverseImports.get(im); | |
if (!id) { | |
id = this.imports.push(im) - 1; | |
this.reverseImports.set(im, id); | |
} | |
return `${this.importPath}[${id}]`; | |
} | |
addReference(alias) { | |
if (!this.references.has(alias)) { | |
this.references.set(alias, { resolved: false, requested: false }); | |
} | |
} | |
markResolved(alias) { | |
const reference = this.references.get(alias); | |
if (reference) { | |
reference.resolved = true; | |
} | |
} | |
markRequested(aliasList) { | |
aliasList.forEach((alias) => { | |
const reference = this.references.get(alias); | |
if (reference) { | |
reference.requested = true; | |
} | |
}); | |
} | |
getUnresolvedReferences() { | |
return Array.from(this.references) | |
.filter(([_, reference]) => !reference.resolved && !reference.requested) | |
.map(([alias, _]) => alias); | |
} | |
} | |
const aliasRegistry = new Map(); | |
const FUNCTION_PREFIX = "___parser_"; | |
const FUNCTION_ENCODE_PREFIX = "___encoder_"; | |
const PRIMITIVE_SIZES = { | |
uint8: 1, | |
uint16le: 2, | |
uint16be: 2, | |
uint32le: 4, | |
uint32be: 4, | |
int8: 1, | |
int16le: 2, | |
int16be: 2, | |
int32le: 4, | |
int32be: 4, | |
int64be: 8, | |
int64le: 8, | |
uint64be: 8, | |
uint64le: 8, | |
floatle: 4, | |
floatbe: 4, | |
doublele: 8, | |
doublebe: 8, | |
}; | |
const PRIMITIVE_NAMES = { | |
uint8: "Uint8", | |
uint16le: "Uint16", | |
uint16be: "Uint16", | |
uint32le: "Uint32", | |
uint32be: "Uint32", | |
int8: "Int8", | |
int16le: "Int16", | |
int16be: "Int16", | |
int32le: "Int32", | |
int32be: "Int32", | |
int64be: "BigInt64", | |
int64le: "BigInt64", | |
uint64be: "BigUint64", | |
uint64le: "BigUint64", | |
floatle: "Float32", | |
floatbe: "Float32", | |
doublele: "Float64", | |
doublebe: "Float64", | |
}; | |
const PRIMITIVE_LITTLE_ENDIANS = { | |
uint8: false, | |
uint16le: true, | |
uint16be: false, | |
uint32le: true, | |
uint32be: false, | |
int8: false, | |
int16le: true, | |
int16be: false, | |
int32le: true, | |
int32be: false, | |
int64be: false, | |
int64le: true, | |
uint64be: false, | |
uint64le: true, | |
floatle: true, | |
floatbe: false, | |
doublele: true, | |
doublebe: false, | |
}; | |
const CAPITILIZED_TYPE_NAMES = { | |
uint8: "UInt8", | |
uint16le: "UInt16LE", | |
uint16be: "UInt16BE", | |
uint32le: "UInt32LE", | |
uint32be: "UInt32BE", | |
int8: "Int8", | |
int16le: "Int16LE", | |
int16be: "Int16BE", | |
int32le: "Int32LE", | |
int32be: "Int32BE", | |
int64be: "BigInt64BE", | |
int64le: "BigInt64LE", | |
uint64be: "BigUInt64BE", | |
uint64le: "BigUInt64LE", | |
floatle: "FloatLE", | |
floatbe: "FloatBE", | |
doublele: "DoubleLE", | |
doublebe: "DoubleBE", | |
bit: "Bit", | |
string: "String", | |
buffer: "Buffer", | |
array: "Array", | |
choice: "Choice", | |
nest: "Nest", | |
seek: "Seek", | |
pointer: "Pointer", | |
saveOffset: "SaveOffset", | |
"": "", | |
wrapper: "Wrapper", | |
}; | |
class Parser { | |
constructor(opts) { | |
this.varName = ""; | |
this.type = ""; | |
this.options = {}; | |
this.endian = "be"; | |
this.useContextVariables = false; | |
this.compiledEncode = null; | |
this.smartBufferSize = | |
opts && typeof opts === "object" && opts.smartBufferSize | |
? opts.smartBufferSize | |
: 256; | |
this.encoderOpts = { | |
bitEndianess: false, | |
}; | |
} | |
static start(opts) { | |
return new Parser(opts); | |
} | |
primitiveGenerateN(type, ctx) { | |
const typeName = PRIMITIVE_NAMES[type]; | |
const littleEndian = PRIMITIVE_LITTLE_ENDIANS[type]; | |
ctx.pushCode(`${ctx.generateVariable(this.varName)} = dataView.get${typeName}(offset, ${littleEndian});`); | |
ctx.pushCode(`offset += ${PRIMITIVE_SIZES[type]};`); | |
} | |
primitiveGenerate_encodeN(type, ctx) { | |
const typeName = CAPITILIZED_TYPE_NAMES[type]; | |
ctx.pushCode(`smartBuffer.write${typeName}(${ctx.generateVariable(this.varName)});`); | |
} | |
primitiveN(type, varName, options) { | |
return this.setNextParser(type, varName, options); | |
} | |
useThisEndian(type) { | |
return (type + this.endian.toLowerCase()); | |
} | |
uint8(varName, options = {}) { | |
return this.primitiveN("uint8", varName, options); | |
} | |
uint16(varName, options = {}) { | |
return this.primitiveN(this.useThisEndian("uint16"), varName, options); | |
} | |
uint16le(varName, options = {}) { | |
return this.primitiveN("uint16le", varName, options); | |
} | |
uint16be(varName, options = {}) { | |
return this.primitiveN("uint16be", varName, options); | |
} | |
uint32(varName, options = {}) { | |
return this.primitiveN(this.useThisEndian("uint32"), varName, options); | |
} | |
uint32le(varName, options = {}) { | |
return this.primitiveN("uint32le", varName, options); | |
} | |
uint32be(varName, options = {}) { | |
return this.primitiveN("uint32be", varName, options); | |
} | |
int8(varName, options = {}) { | |
return this.primitiveN("int8", varName, options); | |
} | |
int16(varName, options = {}) { | |
return this.primitiveN(this.useThisEndian("int16"), varName, options); | |
} | |
int16le(varName, options = {}) { | |
return this.primitiveN("int16le", varName, options); | |
} | |
int16be(varName, options = {}) { | |
return this.primitiveN("int16be", varName, options); | |
} | |
int32(varName, options = {}) { | |
return this.primitiveN(this.useThisEndian("int32"), varName, options); | |
} | |
int32le(varName, options = {}) { | |
return this.primitiveN("int32le", varName, options); | |
} | |
int32be(varName, options = {}) { | |
return this.primitiveN("int32be", varName, options); | |
} | |
bigIntVersionCheck() { | |
if (!DataView.prototype.getBigInt64) | |
throw new Error("BigInt64 is unsupported on this runtime"); | |
} | |
int64(varName, options = {}) { | |
this.bigIntVersionCheck(); | |
return this.primitiveN(this.useThisEndian("int64"), varName, options); | |
} | |
int64be(varName, options = {}) { | |
this.bigIntVersionCheck(); | |
return this.primitiveN("int64be", varName, options); | |
} | |
int64le(varName, options = {}) { | |
this.bigIntVersionCheck(); | |
return this.primitiveN("int64le", varName, options); | |
} | |
uint64(varName, options = {}) { | |
this.bigIntVersionCheck(); | |
return this.primitiveN(this.useThisEndian("uint64"), varName, options); | |
} | |
uint64be(varName, options = {}) { | |
this.bigIntVersionCheck(); | |
return this.primitiveN("uint64be", varName, options); | |
} | |
uint64le(varName, options = {}) { | |
this.bigIntVersionCheck(); | |
return this.primitiveN("uint64le", varName, options); | |
} | |
floatle(varName, options = {}) { | |
return this.primitiveN("floatle", varName, options); | |
} | |
floatbe(varName, options = {}) { | |
return this.primitiveN("floatbe", varName, options); | |
} | |
doublele(varName, options = {}) { | |
return this.primitiveN("doublele", varName, options); | |
} | |
doublebe(varName, options = {}) { | |
return this.primitiveN("doublebe", varName, options); | |
} | |
bitN(size, varName, options) { | |
options.length = size; | |
return this.setNextParser("bit", varName, options); | |
} | |
bit1(varName, options = {}) { | |
return this.bitN(1, varName, options); | |
} | |
bit2(varName, options = {}) { | |
return this.bitN(2, varName, options); | |
} | |
bit3(varName, options = {}) { | |
return this.bitN(3, varName, options); | |
} | |
bit4(varName, options = {}) { | |
return this.bitN(4, varName, options); | |
} | |
bit5(varName, options = {}) { | |
return this.bitN(5, varName, options); | |
} | |
bit6(varName, options = {}) { | |
return this.bitN(6, varName, options); | |
} | |
bit7(varName, options = {}) { | |
return this.bitN(7, varName, options); | |
} | |
bit8(varName, options = {}) { | |
return this.bitN(8, varName, options); | |
} | |
bit9(varName, options = {}) { | |
return this.bitN(9, varName, options); | |
} | |
bit10(varName, options = {}) { | |
return this.bitN(10, varName, options); | |
} | |
bit11(varName, options = {}) { | |
return this.bitN(11, varName, options); | |
} | |
bit12(varName, options = {}) { | |
return this.bitN(12, varName, options); | |
} | |
bit13(varName, options = {}) { | |
return this.bitN(13, varName, options); | |
} | |
bit14(varName, options = {}) { | |
return this.bitN(14, varName, options); | |
} | |
bit15(varName, options = {}) { | |
return this.bitN(15, varName, options); | |
} | |
bit16(varName, options = {}) { | |
return this.bitN(16, varName, options); | |
} | |
bit17(varName, options = {}) { | |
return this.bitN(17, varName, options); | |
} | |
bit18(varName, options = {}) { | |
return this.bitN(18, varName, options); | |
} | |
bit19(varName, options = {}) { | |
return this.bitN(19, varName, options); | |
} | |
bit20(varName, options = {}) { | |
return this.bitN(20, varName, options); | |
} | |
bit21(varName, options = {}) { | |
return this.bitN(21, varName, options); | |
} | |
bit22(varName, options = {}) { | |
return this.bitN(22, varName, options); | |
} | |
bit23(varName, options = {}) { | |
return this.bitN(23, varName, options); | |
} | |
bit24(varName, options = {}) { | |
return this.bitN(24, varName, options); | |
} | |
bit25(varName, options = {}) { | |
return this.bitN(25, varName, options); | |
} | |
bit26(varName, options = {}) { | |
return this.bitN(26, varName, options); | |
} | |
bit27(varName, options = {}) { | |
return this.bitN(27, varName, options); | |
} | |
bit28(varName, options = {}) { | |
return this.bitN(28, varName, options); | |
} | |
bit29(varName, options = {}) { | |
return this.bitN(29, varName, options); | |
} | |
bit30(varName, options = {}) { | |
return this.bitN(30, varName, options); | |
} | |
bit31(varName, options = {}) { | |
return this.bitN(31, varName, options); | |
} | |
bit32(varName, options = {}) { | |
return this.bitN(32, varName, options); | |
} | |
namely(alias) { | |
aliasRegistry.set(alias, this); | |
this.alias = alias; | |
return this; | |
} | |
skip(length, options = {}) { | |
return this.seek(length, options); | |
} | |
seek(relOffset, options = {}) { | |
if (options.assert) { | |
throw new Error("assert option on seek is not allowed."); | |
} | |
return this.setNextParser("seek", "", { length: relOffset }); | |
} | |
string(varName, options) { | |
if (!options.zeroTerminated && !options.length && !options.greedy) { | |
throw new Error("One of length, zeroTerminated, or greedy must be defined for string."); | |
} | |
if ((options.zeroTerminated || options.length) && options.greedy) { | |
throw new Error("greedy is mutually exclusive with length and zeroTerminated for string."); | |
} | |
if (options.stripNull && !(options.length || options.greedy)) { | |
throw new Error("length or greedy must be defined if stripNull is enabled."); | |
} | |
options.encoding = options.encoding || "utf8"; | |
return this.setNextParser("string", varName, options); | |
} | |
buffer(varName, options) { | |
if (!options.length && !options.readUntil) { | |
throw new Error("length or readUntil must be defined for buffer."); | |
} | |
return this.setNextParser("buffer", varName, options); | |
} | |
wrapped(varName, options) { | |
if (typeof options !== "object" && typeof varName === "object") { | |
options = varName; | |
varName = ""; | |
} | |
if (!options || !options.wrapper || !options.type) { | |
throw new Error("Both wrapper and type must be defined for wrapped."); | |
} | |
if (!options.length && !options.readUntil) { | |
throw new Error("length or readUntil must be defined for wrapped."); | |
} | |
return this.setNextParser("wrapper", varName, options); | |
} | |
array(varName, options) { | |
if (!options.readUntil && !options.length && !options.lengthInBytes) { | |
throw new Error("One of readUntil, length and lengthInBytes must be defined for array."); | |
} | |
if (!options.type) { | |
throw new Error("type is required for array."); | |
} | |
if (typeof options.type === "string" && | |
!aliasRegistry.has(options.type) && | |
!(options.type in PRIMITIVE_SIZES)) { | |
throw new Error(`Array element type "${options.type}" is unknown.`); | |
} | |
return this.setNextParser("array", varName, options); | |
} | |
choice(varName, options) { | |
if (typeof options !== "object" && typeof varName === "object") { | |
options = varName; | |
varName = ""; | |
} | |
if (!options) { | |
throw new Error("tag and choices are are required for choice."); | |
} | |
if (!options.tag) { | |
throw new Error("tag is requird for choice."); | |
} | |
if (!options.choices) { | |
throw new Error("choices is required for choice."); | |
} | |
for (const keyString in options.choices) { | |
const key = parseInt(keyString, 10); | |
const value = options.choices[key]; | |
if (isNaN(key)) { | |
throw new Error(`Choice key "${keyString}" is not a number.`); | |
} | |
if (typeof value === "string" && | |
!aliasRegistry.has(value) && | |
!(value in PRIMITIVE_SIZES)) { | |
throw new Error(`Choice type "${value}" is unknown.`); | |
} | |
} | |
return this.setNextParser("choice", varName, options); | |
} | |
nest(varName, options) { | |
if (typeof options !== "object" && typeof varName === "object") { | |
options = varName; | |
varName = ""; | |
} | |
if (!options || !options.type) { | |
throw new Error("type is required for nest."); | |
} | |
if (!(options.type instanceof Parser) && !aliasRegistry.has(options.type)) { | |
throw new Error("type must be a known parser name or a Parser object."); | |
} | |
if (!(options.type instanceof Parser) && !varName) { | |
throw new Error("type must be a Parser object if the variable name is omitted."); | |
} | |
return this.setNextParser("nest", varName, options); | |
} | |
pointer(varName, options) { | |
if (!options.offset) { | |
throw new Error("offset is required for pointer."); | |
} | |
if (!options.type) { | |
throw new Error("type is required for pointer."); | |
} | |
if (typeof options.type === "string" && | |
!(options.type in PRIMITIVE_SIZES) && | |
!aliasRegistry.has(options.type)) { | |
throw new Error(`Pointer type "${options.type}" is unknown.`); | |
} | |
return this.setNextParser("pointer", varName, options); | |
} | |
saveOffset(varName, options = {}) { | |
return this.setNextParser("saveOffset", varName, options); | |
} | |
endianness(endianness) { | |
switch (endianness.toLowerCase()) { | |
case "little": | |
this.endian = "le"; | |
break; | |
case "big": | |
this.endian = "be"; | |
break; | |
default: | |
throw new Error('endianness must be one of "little" or "big"'); | |
} | |
return this; | |
} | |
encoderSetOptions(opts) { | |
Object.assign(this.encoderOpts, opts); | |
return this; | |
} | |
endianess(endianess) { | |
return this.endianness(endianess); | |
} | |
useContextVars(useContextVariables = true) { | |
this.useContextVariables = useContextVariables; | |
return this; | |
} | |
create(constructorFn) { | |
if (!(constructorFn instanceof Function)) { | |
throw new Error("Constructor must be a Function object."); | |
} | |
this.constructorFn = constructorFn; | |
return this; | |
} | |
getContext(importPath) { | |
const ctx = new Context(importPath, this.useContextVariables); | |
ctx.pushCode("var dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"); | |
if (!this.alias) { | |
this.addRawCode(ctx); | |
} | |
else { | |
this.addAliasedCode(ctx); | |
ctx.pushCode(`return ${FUNCTION_PREFIX + this.alias}(0).result;`); | |
} | |
return ctx; | |
} | |
getCode() { | |
const importPath = "imports"; | |
return this.getContext(importPath).code; | |
} | |
getContextEncode(importPath) { | |
const ctx = new Context(importPath, this.useContextVariables); | |
ctx.pushCode('if (!obj || typeof obj !== "object") {'); | |
ctx.generateError('"argument obj is not an object"'); | |
ctx.pushCode("}"); | |
if (!this.alias) { | |
this.addRawCodeEncode(ctx); | |
} | |
else { | |
this.addAliasedCodeEncode(ctx); | |
ctx.pushCode(`return ${FUNCTION_ENCODE_PREFIX + this.alias}(obj);`); | |
} | |
return ctx; | |
} | |
getCodeEncode() { | |
return this.getContextEncode("").code; // TODO: Not sure "" is a valid input here | |
} | |
addRawCode(ctx) { | |
ctx.pushCode("var offset = 0;"); | |
ctx.pushCode(`var vars = ${this.constructorFn ? "new constructorFn()" : "{}"};`); | |
ctx.pushCode("vars.$parent = null;"); | |
ctx.pushCode("vars.$root = vars;"); | |
this.generate(ctx); | |
this.resolveReferences(ctx); | |
ctx.pushCode("delete vars.$parent;"); | |
ctx.pushCode("delete vars.$root;"); | |
ctx.pushCode("return vars;"); | |
} | |
addRawCodeEncode(ctx) { | |
ctx.pushCode("var vars = obj || {};"); | |
ctx.pushCode("vars.$parent = null;"); | |
ctx.pushCode("vars.$root = vars;"); | |
ctx.pushCode(`var smartBuffer = SmartBuffer.fromOptions({size: ${this.smartBufferSize}, encoding: "utf8"});`); | |
this.generateEncode(ctx); | |
ctx.pushCode("delete vars.$parent;"); | |
ctx.pushCode("delete vars.$root;"); | |
this.resolveReferences(ctx, "encode"); | |
ctx.pushCode("return smartBuffer.toBuffer();"); | |
} | |
addAliasedCode(ctx) { | |
ctx.pushCode(`function ${FUNCTION_PREFIX + this.alias}(offset, context) {`); | |
ctx.pushCode(`var vars = ${this.constructorFn ? "new constructorFn()" : "{}"};`); | |
ctx.pushCode("var ctx = Object.assign({$parent: null, $root: vars}, context || {});"); | |
ctx.pushCode(`vars = Object.assign(vars, ctx);`); | |
this.generate(ctx); | |
ctx.markResolved(this.alias); | |
this.resolveReferences(ctx); | |
ctx.pushCode("Object.keys(ctx).forEach(function (item) { delete vars[item]; });"); | |
ctx.pushCode("return { offset: offset, result: vars };"); | |
ctx.pushCode("}"); | |
return ctx; | |
} | |
addAliasedCodeEncode(ctx) { | |
ctx.pushCode(`function ${FUNCTION_ENCODE_PREFIX + this.alias}(obj, context) {`); | |
ctx.pushCode("var vars = obj || {};"); | |
ctx.pushCode("var ctx = Object.assign({$parent: null, $root: vars}, context || {});"); | |
ctx.pushCode(`vars = Object.assign(vars, ctx);`); | |
ctx.pushCode(`var smartBuffer = SmartBuffer.fromOptions({size: ${this.smartBufferSize}, encoding: "utf8"});`); | |
this.generateEncode(ctx); | |
ctx.markResolved(this.alias); | |
this.resolveReferences(ctx, "encode"); | |
ctx.pushCode("return { result: smartBuffer.toBuffer() };"); | |
ctx.pushCode("}"); | |
return ctx; | |
} | |
resolveReferences(ctx, encode) { | |
const references = ctx.getUnresolvedReferences(); | |
ctx.markRequested(references); | |
references.forEach((alias) => { | |
const parser = aliasRegistry.get(alias); | |
if (encode) { | |
parser === null || parser === void 0 ? void 0 : parser.addAliasedCodeEncode(ctx); | |
} | |
else { | |
parser === null || parser === void 0 ? void 0 : parser.addAliasedCode(ctx); | |
} | |
}); | |
} | |
compile() { | |
const importPath = "imports"; | |
const ctx = this.getContext(importPath); | |
this.compiled = new Function(importPath, "TextDecoder", `return function (buffer, constructorFn) { ${ctx.code} };`)(ctx.imports, TextDecoder); | |
} | |
compileEncode() { | |
const importPath = "imports"; | |
const ctx = this.getContextEncode(importPath); | |
this.compiledEncode = new Function(importPath, "TextDecoder", "SmartBuffer", `return function (obj) { ${ctx.code} };`)(ctx.imports, typeof TextDecoder === "undefined" | |
? require("util").TextDecoder | |
: TextDecoder, typeof smart_buffer_1.SmartBuffer === "undefined" | |
? require("smart-buffer").SmartBuffer | |
: smart_buffer_1.SmartBuffer); | |
} | |
sizeOf() { | |
let size = NaN; | |
if (Object.keys(PRIMITIVE_SIZES).indexOf(this.type) >= 0) { | |
size = PRIMITIVE_SIZES[this.type]; | |
// if this is a fixed length string | |
} | |
else if (this.type === "string" && | |
typeof this.options.length === "number") { | |
size = this.options.length; | |
// if this is a fixed length buffer | |
} | |
else if (this.type === "buffer" && | |
typeof this.options.length === "number") { | |
size = this.options.length; | |
// if this is a fixed length array | |
} | |
else if (this.type === "array" && | |
typeof this.options.length === "number") { | |
let elementSize = NaN; | |
if (typeof this.options.type === "string") { | |
elementSize = PRIMITIVE_SIZES[this.options.type]; | |
} | |
else if (this.options.type instanceof Parser) { | |
elementSize = this.options.type.sizeOf(); | |
} | |
size = this.options.length * elementSize; | |
// if this a skip | |
} | |
else if (this.type === "seek") { | |
size = this.options.length; | |
// if this is a nested parser | |
} | |
else if (this.type === "nest") { | |
size = this.options.type.sizeOf(); | |
} | |
else if (!this.type) { | |
size = 0; | |
} | |
if (this.next) { | |
size += this.next.sizeOf(); | |
} | |
return size; | |
} | |
// Follow the parser chain till the root and start parsing from there | |
parse(buffer) { | |
if (!this.compiled) { | |
this.compile(); | |
} | |
return this.compiled(buffer, this.constructorFn); | |
} | |
// Follow the parser chain till the root and start encoding from there | |
encode(obj) { | |
if (!this.compiledEncode) { | |
this.compileEncode(); | |
} | |
const encoded = this.compiledEncode(obj); | |
if (encoded.result) { | |
return encoded.result; | |
} | |
return encoded; | |
} | |
setNextParser(type, varName, options) { | |
const parser = new Parser(); | |
parser.type = type; | |
parser.varName = varName; | |
parser.options = options; | |
parser.endian = this.endian; | |
parser.encoderOpts = this.encoderOpts; | |
if (this.head) { | |
this.head.next = parser; | |
} | |
else { | |
this.next = parser; | |
} | |
this.head = parser; | |
return this; | |
} | |
// Call code generator for this parser | |
generate(ctx) { | |
if (this.type) { | |
switch (this.type) { | |
case "uint8": | |
case "uint16le": | |
case "uint16be": | |
case "uint32le": | |
case "uint32be": | |
case "int8": | |
case "int16le": | |
case "int16be": | |
case "int32le": | |
case "int32be": | |
case "int64be": | |
case "int64le": | |
case "uint64be": | |
case "uint64le": | |
case "floatle": | |
case "floatbe": | |
case "doublele": | |
case "doublebe": | |
this.primitiveGenerateN(this.type, ctx); | |
break; | |
case "bit": | |
this.generateBit(ctx); | |
break; | |
case "string": | |
this.generateString(ctx); | |
break; | |
case "buffer": | |
this.generateBuffer(ctx); | |
break; | |
case "seek": | |
this.generateSeek(ctx); | |
break; | |
case "nest": | |
this.generateNest(ctx); | |
break; | |
case "array": | |
this.generateArray(ctx); | |
break; | |
case "choice": | |
this.generateChoice(ctx); | |
break; | |
case "pointer": | |
this.generatePointer(ctx); | |
break; | |
case "saveOffset": | |
this.generateSaveOffset(ctx); | |
break; | |
case "wrapper": | |
this.generateWrapper(ctx); | |
break; | |
} | |
if (this.type !== "bit") | |
this.generateAssert(ctx); | |
} | |
const varName = ctx.generateVariable(this.varName); | |
if (this.options.formatter && this.type !== "bit") { | |
this.generateFormatter(ctx, varName, this.options.formatter); | |
} | |
return this.generateNext(ctx); | |
} | |
generateEncode(ctx) { | |
var savVarName = ctx.generateTmpVariable(); | |
const varName = ctx.generateVariable(this.varName); | |
// Transform with the possibly provided encoder before encoding | |
if (this.options.encoder) { | |
ctx.pushCode(`var ${savVarName} = ${varName}`); | |
this.generateEncoder(ctx, varName, this.options.encoder); | |
} | |
if (this.type) { | |
switch (this.type) { | |
case "uint8": | |
case "uint16le": | |
case "uint16be": | |
case "uint32le": | |
case "uint32be": | |
case "int8": | |
case "int16le": | |
case "int16be": | |
case "int32le": | |
case "int32be": | |
case "int64be": | |
case "int64le": | |
case "uint64be": | |
case "uint64le": | |
case "floatle": | |
case "floatbe": | |
case "doublele": | |
case "doublebe": | |
this.primitiveGenerate_encodeN(this.type, ctx); | |
break; | |
case "bit": | |
this.generate_encodeBit(ctx); | |
break; | |
case "string": | |
this.generate_encodeString(ctx); | |
break; | |
case "buffer": | |
this.generate_encodeBuffer(ctx); | |
break; | |
case "seek": | |
this.generate_encodeSeek(ctx); | |
break; | |
case "nest": | |
this.generate_encodeNest(ctx); | |
break; | |
case "array": | |
this.generate_encodeArray(ctx); | |
break; | |
case "choice": | |
this.generate_encodeChoice(ctx); | |
break; | |
case "pointer": | |
this.generate_encodePointer(ctx); | |
break; | |
case "saveOffset": | |
this.generate_encodeSaveOffset(ctx); | |
break; | |
} | |
this.generateAssert(ctx); | |
} | |
if (this.options.encoder) { | |
// Restore varName after encoder transformation so that next parsers will | |
// have access to original field value (but not nested ones) | |
ctx.pushCode(`${varName} = ${savVarName};`); | |
} | |
return this.generateEncodeNext(ctx); | |
} | |
generateAssert(ctx) { | |
if (!this.options.assert) { | |
return; | |
} | |
const varName = ctx.generateVariable(this.varName); | |
switch (typeof this.options.assert) { | |
case "function": | |
{ | |
const func = ctx.addImport(this.options.assert); | |
ctx.pushCode(`if (!${func}.call(vars, ${varName})) {`); | |
} | |
break; | |
case "number": | |
ctx.pushCode(`if (${this.options.assert} !== ${varName}) {`); | |
break; | |
case "string": | |
ctx.pushCode(`if (${JSON.stringify(this.options.assert)} !== ${varName}) {`); | |
break; | |
default: | |
throw new Error("assert option must be a string, number or a function."); | |
} | |
ctx.generateError(`"Assertion error: ${varName} is " + ${JSON.stringify(this.options.assert.toString())}`); | |
ctx.pushCode("}"); | |
} | |
// Recursively call code generators and append results | |
generateNext(ctx) { | |
if (this.next) { | |
ctx = this.next.generate(ctx); | |
} | |
return ctx; | |
} | |
// Recursively call code generators and append results | |
generateEncodeNext(ctx) { | |
if (this.next) { | |
ctx = this.next.generateEncode(ctx); | |
} | |
return ctx; | |
} | |
nextNotBit() { | |
// Used to test if next type is a bitN or not | |
if (this.next) { | |
if (this.next.type === "nest") { | |
// For now consider a nest as a bit | |
if (this.next.options && this.next.options.type instanceof Parser) { | |
// Something in the nest | |
if (this.next.options.type.next) { | |
return this.next.options.type.next.type !== "bit"; | |
} | |
return false; | |
} | |
else { | |
// Nest is empty. For now assume this means bit is not next. However what if something comes after the nest? | |
return true; | |
} | |
} | |
else { | |
return this.next.type !== "bit"; | |
} | |
} | |
else { | |
// Nothing else so next can't be bits | |
return true; | |
} | |
} | |
generateBit(ctx) { | |
// TODO find better method to handle nested bit fields | |
const parser = JSON.parse(JSON.stringify(this)); | |
parser.options = this.options; | |
parser.generateAssert = this.generateAssert.bind(this); | |
parser.generateFormatter = this.generateFormatter.bind(this); | |
parser.varName = ctx.generateVariable(parser.varName); | |
ctx.bitFields.push(parser); | |
if (!this.next || this.nextNotBit()) { | |
const val = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${val} = 0;`); | |
const getMaxBits = (from = 0) => { | |
let sum = 0; | |
for (let i = from; i < ctx.bitFields.length; i++) { | |
const length = ctx.bitFields[i].options.length; | |
if (sum + length > 32) | |
break; | |
sum += length; | |
} | |
return sum; | |
}; | |
const getBytes = (sum) => { | |
if (sum <= 8) { | |
ctx.pushCode(`${val} = dataView.getUint8(offset);`); | |
sum = 8; | |
} | |
else if (sum <= 16) { | |
ctx.pushCode(`${val} = dataView.getUint16(offset);`); | |
sum = 16; | |
} | |
else if (sum <= 24) { | |
ctx.pushCode(`${val} = (dataView.getUint16(offset) << 8) | dataView.getUint8(offset + 2);`); | |
sum = 24; | |
} | |
else { | |
ctx.pushCode(`${val} = dataView.getUint32(offset);`); | |
sum = 32; | |
} | |
ctx.pushCode(`offset += ${sum / 8};`); | |
return sum; | |
}; | |
let bitOffset = 0; | |
const isBigEndian = this.endian === "be"; | |
let sum = 0; | |
let rem = 0; | |
ctx.bitFields.forEach((parser, i) => { | |
let length = parser.options.length; | |
if (length > rem) { | |
if (rem) { | |
const mask = -1 >>> (32 - rem); | |
ctx.pushCode(`${parser.varName} = (${val} & 0x${mask.toString(16)}) << ${length - rem};`); | |
length -= rem; | |
} | |
bitOffset = 0; | |
rem = sum = getBytes(getMaxBits(i) - rem); | |
} | |
const offset = isBigEndian ? sum - bitOffset - length : bitOffset; | |
const mask = -1 >>> (32 - length); | |
ctx.pushCode(`${parser.varName} ${length < parser.options.length ? "|=" : "="} ${val} >> ${offset} & 0x${mask.toString(16)};`); | |
// Ensure value is unsigned | |
if (parser.options.length === 32) { | |
ctx.pushCode(`${parser.varName} >>>= 0`); | |
} | |
if (parser.options.assert) { | |
parser.generateAssert(ctx); | |
} | |
if (parser.options.formatter) { | |
parser.generateFormatter(ctx, parser.varName, parser.options.formatter); | |
} | |
bitOffset += length; | |
rem -= length; | |
}); | |
ctx.bitFields = []; | |
} | |
} | |
generate_encodeBit(ctx) { | |
// TODO find better method to handle nested bit fields | |
const parser = JSON.parse(JSON.stringify(this)); | |
parser.varName = ctx.generateVariable(parser.varName); | |
ctx.bitFields.push(parser); | |
if (!this.next || | |
(this.next && ["bit", "nest"].indexOf(this.next.type) < 0)) { | |
let sum = 0; | |
ctx.bitFields.forEach((parser) => { | |
sum += parser.options.length; | |
}); | |
if (sum <= 8) { | |
sum = 8; | |
} | |
else if (sum <= 16) { | |
sum = 16; | |
} | |
else if (sum <= 24) { | |
sum = 24; | |
} | |
else if (sum <= 32) { | |
sum = 32; | |
} | |
else { | |
throw new Error("Currently, bit field sequences longer than 4-bytes is not supported."); | |
} | |
const isBitLittleEndian = this.endian === "le" && this.encoderOpts.bitEndianess; | |
const tmpVal = ctx.generateTmpVariable(); | |
const boundVal = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tmpVal} = 0;`); | |
ctx.pushCode(`var ${boundVal} = 0;`); | |
let bitOffset = 0; | |
ctx.bitFields.forEach((parser) => { | |
ctx.pushCode(`${boundVal} = (${parser.varName} & ${(1 << parser.options.length) - 1});`); | |
ctx.pushCode(`${tmpVal} |= (${boundVal} << ${isBitLittleEndian | |
? bitOffset | |
: sum - parser.options.length - bitOffset});`); | |
ctx.pushCode(`${tmpVal} = ${tmpVal} >>> 0;`); | |
bitOffset += parser.options.length; | |
}); | |
if (sum == 8) { | |
ctx.pushCode(`smartBuffer.writeUInt8(${tmpVal});`); | |
} | |
else if (sum == 16) { | |
ctx.pushCode(`smartBuffer.writeUInt16BE(${tmpVal});`); | |
} | |
else if (sum == 24) { | |
const val1 = ctx.generateTmpVariable(); | |
const val2 = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${val1} = (${tmpVal} >>> 8);`); | |
ctx.pushCode(`var ${val2} = (${tmpVal} & 0x0ff);`); | |
ctx.pushCode(`smartBuffer.writeUInt16BE(${val1});`); | |
ctx.pushCode(`smartBuffer.writeUInt8(${val2});`); | |
} | |
else if (sum == 32) { | |
ctx.pushCode(`smartBuffer.writeUInt32BE(${tmpVal});`); | |
} | |
ctx.bitFields = []; | |
} | |
} | |
generateSeek(ctx) { | |
const length = ctx.generateOption(this.options.length); | |
ctx.pushCode(`offset += ${length};`); | |
} | |
generate_encodeSeek(ctx) { | |
const length = ctx.generateOption(this.options.length); | |
ctx.pushCode(`smartBuffer.writeBuffer(Buffer.alloc(${length}));`); | |
} | |
generateString(ctx) { | |
const name = ctx.generateVariable(this.varName); | |
const start = ctx.generateTmpVariable(); | |
const encoding = this.options.encoding; | |
const isHex = encoding.toLowerCase() === "hex"; | |
const toHex = 'b => b.toString(16).padStart(2, "0")'; | |
if (this.options.length && this.options.zeroTerminated) { | |
const len = this.options.length; | |
ctx.pushCode(`var ${start} = offset;`); | |
ctx.pushCode(`while(dataView.getUint8(offset++) !== 0 && offset - ${start} < ${len});`); | |
//const end = `offset - ${start} < ${len} ? offset - 1 : offset`; | |
const end = "dataView.getUint8(offset -1) == 0 ? offset - 1 : offset"; | |
ctx.pushCode(isHex | |
? `${name} = Array.from(buffer.subarray(${start}, ${end}), ${toHex}).join('');` | |
: `${name} = new TextDecoder('${encoding}').decode(buffer.subarray(${start}, ${end}));`); | |
} | |
else if (this.options.length) { | |
const len = ctx.generateOption(this.options.length); | |
ctx.pushCode(isHex | |
? `${name} = Array.from(buffer.subarray(offset, offset + ${len}), ${toHex}).join('');` | |
: `${name} = new TextDecoder('${encoding}').decode(buffer.subarray(offset, offset + ${len}));`); | |
ctx.pushCode(`offset += ${len};`); | |
} | |
else if (this.options.zeroTerminated) { | |
ctx.pushCode(`var ${start} = offset;`); | |
ctx.pushCode("while(dataView.getUint8(offset++) !== 0);"); | |
ctx.pushCode(isHex | |
? `${name} = Array.from(buffer.subarray(${start}, offset - 1), ${toHex}).join('');` | |
: `${name} = new TextDecoder('${encoding}').decode(buffer.subarray(${start}, offset - 1));`); | |
} | |
else if (this.options.greedy) { | |
ctx.pushCode(`var ${start} = offset;`); | |
ctx.pushCode("while(buffer.length > offset++);"); | |
ctx.pushCode(isHex | |
? `${name} = Array.from(buffer.subarray(${start}, offset), ${toHex}).join('');` | |
: `${name} = new TextDecoder('${encoding}').decode(buffer.subarray(${start}, offset));`); | |
} | |
if (this.options.stripNull) { | |
ctx.pushCode(`${name} = ${name}.replace(/\\x00+$/g, '')`); | |
} | |
if (this.options.trim) { | |
ctx.pushCode(`${name} = ${name}.trim()`); | |
} | |
} | |
generate_encodeString(ctx) { | |
const name = ctx.generateVariable(this.varName); | |
// Get the length of string to encode | |
if (this.options.length) { | |
const optLength = ctx.generateOption(this.options.length); | |
// Encode the string to a temporary buffer | |
const tmpBuf = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tmpBuf} = Buffer.from(${name}, "${this.options.encoding}");`); | |
// Truncate the buffer to specified (Bytes) length | |
ctx.pushCode(`${tmpBuf} = ${tmpBuf}.slice(0, ${optLength});`); | |
// Compute padding length | |
const padLen = ctx.generateTmpVariable(); | |
ctx.pushCode(`${padLen} = ${optLength} - ${tmpBuf}.length;`); | |
if (this.options.zeroTerminated) { | |
ctx.pushCode(`smartBuffer.writeBuffer(${tmpBuf});`); | |
ctx.pushCode(`if (${padLen} > 0) { smartBuffer.writeUInt8(0x00); }`); | |
} | |
else { | |
const padCharVar = ctx.generateTmpVariable(); | |
let padChar = this.options.stripNull ? "\u0000" : " "; | |
if (this.options.padd && typeof this.options.padd === "string") { | |
const code = this.options.padd.charCodeAt(0); | |
if (code < 0x80) { | |
padChar = String.fromCharCode(code); | |
} | |
} | |
ctx.pushCode(`${padCharVar} = "${padChar}";`); | |
if (this.options.padding === "left") { | |
// Add heading padding spaces | |
ctx.pushCode(`if (${padLen} > 0) {smartBuffer.writeString(${padCharVar}.repeat(${padLen}));}`); | |
} | |
// Copy the temporary string buffer to current smartBuffer | |
ctx.pushCode(`smartBuffer.writeBuffer(${tmpBuf});`); | |
if (this.options.padding !== "left") { | |
// Add trailing padding spaces | |
ctx.pushCode(`if (${padLen} > 0) {smartBuffer.writeString(${padCharVar}.repeat(${padLen}));}`); | |
} | |
} | |
} | |
else { | |
ctx.pushCode(`smartBuffer.writeString(${name}, "${this.options.encoding}");`); | |
if (this.options.zeroTerminated) { | |
ctx.pushCode("smartBuffer.writeUInt8(0x00);"); | |
} | |
} | |
} | |
generateBuffer(ctx) { | |
const varName = ctx.generateVariable(this.varName); | |
if (typeof this.options.readUntil === "function") { | |
const pred = this.options.readUntil; | |
const start = ctx.generateTmpVariable(); | |
const cur = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${start} = offset;`); | |
ctx.pushCode(`var ${cur} = 0;`); | |
ctx.pushCode(`while (offset < buffer.length) {`); | |
ctx.pushCode(`${cur} = dataView.getUint8(offset);`); | |
const func = ctx.addImport(pred); | |
ctx.pushCode(`if (${func}.call(${ctx.generateVariable()}, ${cur}, buffer.subarray(offset))) break;`); | |
ctx.pushCode(`offset += 1;`); | |
ctx.pushCode(`}`); | |
ctx.pushCode(`${varName} = buffer.subarray(${start}, offset);`); | |
} | |
else if (this.options.readUntil === "eof") { | |
ctx.pushCode(`${varName} = buffer.subarray(offset);`); | |
} | |
else { | |
const len = ctx.generateOption(this.options.length); | |
ctx.pushCode(`${varName} = buffer.subarray(offset, offset + ${len});`); | |
ctx.pushCode(`offset += ${len};`); | |
} | |
if (this.options.clone) { | |
ctx.pushCode(`${varName} = buffer.constructor.from(${varName});`); | |
} | |
} | |
generate_encodeBuffer(ctx) { | |
ctx.pushCode(`smartBuffer.writeBuffer(${ctx.generateVariable(this.varName)});`); | |
} | |
generateArray(ctx) { | |
const length = ctx.generateOption(this.options.length); | |
const lengthInBytes = ctx.generateOption(this.options.lengthInBytes); | |
const type = this.options.type; | |
const counter = ctx.generateTmpVariable(); | |
const lhs = ctx.generateVariable(this.varName); | |
const item = ctx.generateTmpVariable(); | |
const key = this.options.key; | |
const isHash = typeof key === "string"; | |
if (isHash) { | |
ctx.pushCode(`${lhs} = {};`); | |
} | |
else { | |
ctx.pushCode(`${lhs} = [];`); | |
} | |
if (typeof this.options.readUntil === "function") { | |
ctx.pushCode("do {"); | |
} | |
else if (this.options.readUntil === "eof") { | |
ctx.pushCode(`for (var ${counter} = 0; offset < buffer.length; ${counter}++) {`); | |
} | |
else if (lengthInBytes !== undefined) { | |
ctx.pushCode(`for (var ${counter} = offset + ${lengthInBytes}; offset < ${counter}; ) {`); | |
} | |
else { | |
ctx.pushCode(`for (var ${counter} = ${length}; ${counter} > 0; ${counter}--) {`); | |
} | |
if (typeof type === "string") { | |
if (!aliasRegistry.get(type)) { | |
const typeName = PRIMITIVE_NAMES[type]; | |
const littleEndian = PRIMITIVE_LITTLE_ENDIANS[type]; | |
ctx.pushCode(`var ${item} = dataView.get${typeName}(offset, ${littleEndian});`); | |
ctx.pushCode(`offset += ${PRIMITIVE_SIZES[type]};`); | |
} | |
else { | |
const tempVar = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tempVar} = ${FUNCTION_PREFIX + type}(offset, {`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`$parent: ${parentVar},`); | |
ctx.pushCode(`$root: ${parentVar}.$root,`); | |
if (!this.options.readUntil && lengthInBytes === undefined) { | |
ctx.pushCode(`$index: ${length} - ${counter},`); | |
} | |
} | |
ctx.pushCode(`});`); | |
ctx.pushCode(`var ${item} = ${tempVar}.result; offset = ${tempVar}.offset;`); | |
if (type !== this.alias) | |
ctx.addReference(type); | |
} | |
} | |
else if (type instanceof Parser) { | |
ctx.pushCode(`var ${item} = {};`); | |
const parentVar = ctx.generateVariable(); | |
ctx.pushScope(item); | |
if (ctx.useContextVariables) { | |
ctx.pushCode(`${item}.$parent = ${parentVar};`); | |
ctx.pushCode(`${item}.$root = ${parentVar}.$root;`); | |
if (!this.options.readUntil && lengthInBytes === undefined) { | |
ctx.pushCode(`${item}.$index = ${length} - ${counter};`); | |
} | |
} | |
type.generate(ctx); | |
if (ctx.useContextVariables) { | |
ctx.pushCode(`delete ${item}.$parent;`); | |
ctx.pushCode(`delete ${item}.$root;`); | |
ctx.pushCode(`delete ${item}.$index;`); | |
} | |
ctx.popScope(); | |
} | |
if (isHash) { | |
ctx.pushCode(`${lhs}[${item}.${key}] = ${item};`); | |
} | |
else { | |
ctx.pushCode(`${lhs}.push(${item});`); | |
} | |
ctx.pushCode("}"); | |
if (typeof this.options.readUntil === "function") { | |
const pred = this.options.readUntil; | |
const func = ctx.addImport(pred); | |
ctx.pushCode(`while (!${func}.call(${ctx.generateVariable()}, ${item}, buffer.subarray(offset)));`); | |
} | |
} | |
generate_encodeArray(ctx) { | |
const length = ctx.generateOption(this.options.length); | |
const lengthInBytes = ctx.generateOption(this.options.lengthInBytes); | |
const type = this.options.type; | |
const name = ctx.generateVariable(this.varName); | |
const item = ctx.generateTmpVariable(); | |
const itemCounter = ctx.generateTmpVariable(); | |
const maxItems = ctx.generateTmpVariable(); | |
const isHash = typeof this.options.key === "string"; | |
if (isHash) { | |
ctx.generateError('"Encoding associative array not supported"'); | |
} | |
ctx.pushCode(`var ${maxItems} = 0;`); | |
// Get default array length (if defined) | |
ctx.pushCode(`if(${name}) {${maxItems} = ${name}.length;}`); | |
// Compute the desired count of array items to encode (min of array size | |
// and length option) | |
if (length !== undefined) { | |
ctx.pushCode(`${maxItems} = ${maxItems} > ${length} ? ${length} : ${maxItems}`); | |
} | |
// Save current encoding smartBuffer and allocate a new one | |
const savSmartBuffer = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${savSmartBuffer} = smartBuffer; ` + | |
`smartBuffer = SmartBuffer.fromOptions({size: ${this.smartBufferSize}, encoding: "utf8"});`); | |
ctx.pushCode(`if(${maxItems} > 0) {`); | |
ctx.pushCode(`var ${itemCounter} = 0;`); | |
if (typeof this.options.encodeUntil === "function" || | |
typeof this.options.readUntil === "function") { | |
ctx.pushCode("do {"); | |
} | |
else { | |
ctx.pushCode(`for ( ; ${itemCounter} < ${maxItems}; ) {`); | |
} | |
ctx.pushCode(`var ${item} = ${name}[${itemCounter}];`); | |
ctx.pushCode(`${itemCounter}++;`); | |
if (typeof type === "string") { | |
if (!aliasRegistry.get(type)) { | |
ctx.pushCode(`smartBuffer.write${CAPITILIZED_TYPE_NAMES[type]}(${item});`); | |
} | |
else { | |
ctx.pushCode(`smartBuffer.writeBuffer(${FUNCTION_ENCODE_PREFIX + type}(${item}).result);`); | |
if (type !== this.alias) { | |
ctx.addReference(type); | |
} | |
} | |
} | |
else if (type instanceof Parser) { | |
ctx.pushScope(item); | |
type.generateEncode(ctx); | |
ctx.popScope(); | |
} | |
ctx.pushCode("}"); // End of 'do {' or 'for (...) {' | |
if (typeof this.options.encodeUntil === "function") { | |
ctx.pushCode(` while (${itemCounter} < ${maxItems} && !(${this.options.encodeUntil}).call(this, ${item}, vars));`); | |
} | |
else if (typeof this.options.readUntil === "function") { | |
ctx.pushCode(` while (${itemCounter} < ${maxItems} && !(${this.options.readUntil}).call(this, ${item}, ${savSmartBuffer}.toBuffer()));`); | |
} | |
ctx.pushCode("}"); // End of 'if(...) {' | |
const tmpBuffer = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tmpBuffer} = smartBuffer.toBuffer()`); | |
if (lengthInBytes !== undefined) { | |
// Truncate the tmpBuffer so that it will respect the lengthInBytes option | |
ctx.pushCode(`${tmpBuffer} = ${tmpBuffer}.slice(0, ${lengthInBytes});`); | |
} | |
// Copy tmp Buffer to saved smartBuffer | |
ctx.pushCode(`${savSmartBuffer}.writeBuffer(${tmpBuffer});`); | |
// Restore current smartBuffer | |
ctx.pushCode(`smartBuffer = ${savSmartBuffer};`); | |
} | |
generateChoiceCase(ctx, varName, type) { | |
if (typeof type === "string") { | |
const varName = ctx.generateVariable(this.varName); | |
if (!aliasRegistry.has(type)) { | |
const typeName = PRIMITIVE_NAMES[type]; | |
const littleEndian = PRIMITIVE_LITTLE_ENDIANS[type]; | |
ctx.pushCode(`${varName} = dataView.get${typeName}(offset, ${littleEndian});`); | |
ctx.pushCode(`offset += ${PRIMITIVE_SIZES[type]}`); | |
} | |
else { | |
const tempVar = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tempVar} = ${FUNCTION_PREFIX + type}(offset, {`); | |
if (ctx.useContextVariables) { | |
ctx.pushCode(`$parent: ${varName}.$parent,`); | |
ctx.pushCode(`$root: ${varName}.$root,`); | |
} | |
ctx.pushCode(`});`); | |
ctx.pushCode(`${varName} = ${tempVar}.result; offset = ${tempVar}.offset;`); | |
if (type !== this.alias) | |
ctx.addReference(type); | |
} | |
} | |
else if (type instanceof Parser) { | |
ctx.pushPath(varName); | |
type.generate(ctx); | |
ctx.popPath(varName); | |
} | |
} | |
generate_encodeChoiceCase(ctx, varName, type) { | |
if (typeof type === "string") { | |
if (!aliasRegistry.has(type)) { | |
ctx.pushCode(`smartBuffer.write${CAPITILIZED_TYPE_NAMES[type]}(${ctx.generateVariable(this.varName)});`); | |
} | |
else { | |
var tempVar = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tempVar} = ${FUNCTION_ENCODE_PREFIX + type}(${ctx.generateVariable(this.varName)}, {`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`$parent: ${parentVar},`); | |
ctx.pushCode(`$root: ${parentVar}.$root,`); | |
} | |
ctx.pushCode(`});`); | |
ctx.pushCode(`smartBuffer.writeBuffer(${tempVar}.result);`); | |
if (type !== this.alias) | |
ctx.addReference(type); | |
} | |
} | |
else if (type instanceof Parser) { | |
ctx.pushPath(varName); | |
type.generateEncode(ctx); | |
ctx.popPath(varName); | |
} | |
} | |
generateChoice(ctx) { | |
const tag = ctx.generateOption(this.options.tag); | |
const nestVar = ctx.generateVariable(this.varName); | |
if (this.varName) { | |
ctx.pushCode(`${nestVar} = {};`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`${nestVar}.$parent = ${parentVar};`); | |
ctx.pushCode(`${nestVar}.$root = ${parentVar}.$root;`); | |
} | |
} | |
ctx.pushCode(`switch(${tag}) {`); | |
for (const tagString in this.options.choices) { | |
const tag = parseInt(tagString, 10); | |
const type = this.options.choices[tag]; | |
ctx.pushCode(`case ${tag}:`); | |
this.generateChoiceCase(ctx, this.varName, type); | |
ctx.pushCode("break;"); | |
} | |
ctx.pushCode("default:"); | |
if (this.options.defaultChoice) { | |
this.generateChoiceCase(ctx, this.varName, this.options.defaultChoice); | |
} | |
else { | |
ctx.generateError(`"Met undefined tag value " + ${tag} + " at choice"`); | |
} | |
ctx.pushCode("}"); | |
if (this.varName && ctx.useContextVariables) { | |
ctx.pushCode(`delete ${nestVar}.$parent;`); | |
ctx.pushCode(`delete ${nestVar}.$root;`); | |
} | |
} | |
generate_encodeChoice(ctx) { | |
const tag = ctx.generateOption(this.options.tag); | |
const nestVar = ctx.generateVariable(this.varName); | |
if (this.varName && ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`${nestVar}.$parent = ${parentVar};`); | |
ctx.pushCode(`${nestVar}.$root = ${parentVar}.$root;`); | |
} | |
ctx.pushCode(`switch(${tag}) {`); | |
for (const tagString in this.options.choices) { | |
const tag = parseInt(tagString, 10); | |
const type = this.options.choices[tag]; | |
ctx.pushCode(`case ${tag}:`); | |
this.generate_encodeChoiceCase(ctx, this.varName, type); | |
ctx.pushCode("break;"); | |
} | |
ctx.pushCode("default:"); | |
if (this.options.defaultChoice) { | |
this.generate_encodeChoiceCase(ctx, this.varName, this.options.defaultChoice); | |
} | |
else { | |
ctx.generateError(`"Met undefined tag value " + ${tag} + " at choice"`); | |
} | |
ctx.pushCode("}"); | |
if (this.varName && ctx.useContextVariables) { | |
ctx.pushCode(`delete ${nestVar}.$parent;`); | |
ctx.pushCode(`delete ${nestVar}.$root;`); | |
} | |
} | |
generateNest(ctx) { | |
const nestVar = ctx.generateVariable(this.varName); | |
if (this.options.type instanceof Parser) { | |
if (this.varName) { | |
ctx.pushCode(`${nestVar} = {};`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`${nestVar}.$parent = ${parentVar};`); | |
ctx.pushCode(`${nestVar}.$root = ${parentVar}.$root;`); | |
} | |
} | |
ctx.pushPath(this.varName); | |
this.options.type.generate(ctx); | |
ctx.popPath(this.varName); | |
if (this.varName && ctx.useContextVariables) { | |
if (ctx.useContextVariables) { | |
ctx.pushCode(`delete ${nestVar}.$parent;`); | |
ctx.pushCode(`delete ${nestVar}.$root;`); | |
} | |
} | |
} | |
else if (aliasRegistry.has(this.options.type)) { | |
const tempVar = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tempVar} = ${FUNCTION_PREFIX + this.options.type}(offset, {`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`$parent: ${parentVar},`); | |
ctx.pushCode(`$root: ${parentVar}.$root,`); | |
} | |
ctx.pushCode(`});`); | |
ctx.pushCode(`${nestVar} = ${tempVar}.result; offset = ${tempVar}.offset;`); | |
if (this.options.type !== this.alias) { | |
ctx.addReference(this.options.type); | |
} | |
} | |
} | |
generate_encodeNest(ctx) { | |
const nestVar = ctx.generateVariable(this.varName); | |
if (this.options.type instanceof Parser) { | |
if (this.varName && ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`${nestVar}.$parent = ${parentVar};`); | |
ctx.pushCode(`${nestVar}.$root = ${parentVar}.$root;`); | |
} | |
ctx.pushPath(this.varName); | |
this.options.type.generateEncode(ctx); | |
ctx.popPath(this.varName); | |
if (this.varName && ctx.useContextVariables) { | |
if (ctx.useContextVariables) { | |
ctx.pushCode(`delete ${nestVar}.$parent;`); | |
ctx.pushCode(`delete ${nestVar}.$root;`); | |
} | |
} | |
} | |
else if (aliasRegistry.has(this.options.type)) { | |
var tempVar = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tempVar} = ${FUNCTION_ENCODE_PREFIX + this.options.type}(${nestVar}, {`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`$parent: ${parentVar},`); | |
ctx.pushCode(`$root: ${parentVar}.$root,`); | |
} | |
ctx.pushCode(`});`); | |
ctx.pushCode(`smartBuffer.writeBuffer(${tempVar}.result);`); | |
if (this.options.type !== this.alias) { | |
ctx.addReference(this.options.type); | |
} | |
} | |
} | |
generateWrapper(ctx) { | |
const wrapperVar = ctx.generateVariable(this.varName); | |
const wrappedBuf = ctx.generateTmpVariable(); | |
if (typeof this.options.readUntil === "function") { | |
const pred = this.options.readUntil; | |
const start = ctx.generateTmpVariable(); | |
const cur = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${start} = offset;`); | |
ctx.pushCode(`var ${cur} = 0;`); | |
ctx.pushCode(`while (offset < buffer.length) {`); | |
ctx.pushCode(`${cur} = dataView.getUint8(offset);`); | |
const func = ctx.addImport(pred); | |
ctx.pushCode(`if (${func}.call(${ctx.generateVariable()}, ${cur}, buffer.subarray(offset))) break;`); | |
ctx.pushCode(`offset += 1;`); | |
ctx.pushCode(`}`); | |
ctx.pushCode(`${wrappedBuf} = buffer.subarray(${start}, offset);`); | |
} | |
else if (this.options.readUntil === "eof") { | |
ctx.pushCode(`${wrappedBuf} = buffer.subarray(offset);`); | |
} | |
else { | |
const len = ctx.generateOption(this.options.length); | |
ctx.pushCode(`${wrappedBuf} = buffer.subarray(offset, offset + ${len});`); | |
ctx.pushCode(`offset += ${len};`); | |
} | |
if (this.options.clone) { | |
ctx.pushCode(`${wrappedBuf} = buffer.constructor.from(${wrappedBuf});`); | |
} | |
const tempBuf = ctx.generateTmpVariable(); | |
const tempOff = ctx.generateTmpVariable(); | |
const tempView = ctx.generateTmpVariable(); | |
const func = ctx.addImport(this.options.wrapper); | |
ctx.pushCode(`${wrappedBuf} = ${func}.call(this, ${wrappedBuf}).subarray(0);`); | |
ctx.pushCode(`var ${tempBuf} = buffer;`); | |
ctx.pushCode(`var ${tempOff} = offset;`); | |
ctx.pushCode(`var ${tempView} = dataView;`); | |
ctx.pushCode(`buffer = ${wrappedBuf};`); | |
ctx.pushCode(`offset = 0;`); | |
ctx.pushCode(`dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);`); | |
if (this.options.type instanceof Parser) { | |
if (this.varName) { | |
ctx.pushCode(`${wrapperVar} = {};`); | |
} | |
ctx.pushPath(this.varName); | |
this.options.type.generate(ctx); | |
ctx.popPath(this.varName); | |
} | |
else if (aliasRegistry.has(this.options.type)) { | |
const tempVar = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tempVar} = ${FUNCTION_PREFIX + this.options.type}(0);`); | |
ctx.pushCode(`${wrapperVar} = ${tempVar}.result;`); | |
if (this.options.type !== this.alias) { | |
ctx.addReference(this.options.type); | |
} | |
} | |
ctx.pushCode(`buffer = ${tempBuf};`); | |
ctx.pushCode(`dataView = ${tempView};`); | |
ctx.pushCode(`offset = ${tempOff};`); | |
} | |
generateFormatter(ctx, varName, formatter) { | |
if (typeof formatter === "function") { | |
const func = ctx.addImport(formatter); | |
ctx.pushCode(`${varName} = ${func}.call(${ctx.generateVariable()}, ${varName});`); | |
} | |
} | |
generateEncoder(ctx, varName, encoder) { | |
if (typeof encoder === "function") { | |
ctx.pushCode(`${varName} = (${encoder}).call(${ctx.generateVariable()}, ${varName}, vars);`); | |
} | |
} | |
generatePointer(ctx) { | |
const type = this.options.type; | |
const offset = ctx.generateOption(this.options.offset); | |
const tempVar = ctx.generateTmpVariable(); | |
const nestVar = ctx.generateVariable(this.varName); | |
// Save current offset | |
ctx.pushCode(`var ${tempVar} = offset;`); | |
// Move offset | |
ctx.pushCode(`offset = ${offset};`); | |
if (this.options.type instanceof Parser) { | |
ctx.pushCode(`${nestVar} = {};`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`${nestVar}.$parent = ${parentVar};`); | |
ctx.pushCode(`${nestVar}.$root = ${parentVar}.$root;`); | |
} | |
ctx.pushPath(this.varName); | |
this.options.type.generate(ctx); | |
ctx.popPath(this.varName); | |
if (ctx.useContextVariables) { | |
ctx.pushCode(`delete ${nestVar}.$parent;`); | |
ctx.pushCode(`delete ${nestVar}.$root;`); | |
} | |
} | |
else if (aliasRegistry.has(this.options.type)) { | |
const tempVar = ctx.generateTmpVariable(); | |
ctx.pushCode(`var ${tempVar} = ${FUNCTION_PREFIX + this.options.type}(offset, {`); | |
if (ctx.useContextVariables) { | |
const parentVar = ctx.generateVariable(); | |
ctx.pushCode(`$parent: ${parentVar},`); | |
ctx.pushCode(`$root: ${parentVar}.$root,`); | |
} | |
ctx.pushCode(`});`); | |
ctx.pushCode(`${nestVar} = ${tempVar}.result; offset = ${tempVar}.offset;`); | |
if (this.options.type !== this.alias) { | |
ctx.addReference(this.options.type); | |
} | |
} | |
else if (Object.keys(PRIMITIVE_SIZES).indexOf(this.options.type) >= 0) { | |
const typeName = PRIMITIVE_NAMES[type]; | |
const littleEndian = PRIMITIVE_LITTLE_ENDIANS[type]; | |
ctx.pushCode(`${nestVar} = dataView.get${typeName}(offset, ${littleEndian});`); | |
ctx.pushCode(`offset += ${PRIMITIVE_SIZES[type]};`); | |
} | |
// Restore offset | |
ctx.pushCode(`offset = ${tempVar};`); | |
} | |
// @ts-ignore TS6133 | |
generate_encodePointer(ctx) { | |
// TODO | |
} | |
generateSaveOffset(ctx) { | |
const varName = ctx.generateVariable(this.varName); | |
ctx.pushCode(`${varName} = offset`); | |
} | |
// @ts-ignore TS6133 | |
generate_encodeSaveOffset(ctx) { | |
// TODO | |
} | |
} | |
exports.Parser = Parser; | |
},{"smart-buffer":40,"util":37}],40:[function(require,module,exports){ | |
(function (Buffer){(function (){ | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
const utils_1 = require("./utils"); | |
// The default Buffer size if one is not provided. | |
const DEFAULT_SMARTBUFFER_SIZE = 4096; | |
// The default string encoding to use for reading/writing strings. | |
const DEFAULT_SMARTBUFFER_ENCODING = 'utf8'; | |
class SmartBuffer { | |
/** | |
* Creates a new SmartBuffer instance. | |
* | |
* @param options { SmartBufferOptions } The SmartBufferOptions to apply to this instance. | |
*/ | |
constructor(options) { | |
this.length = 0; | |
this._encoding = DEFAULT_SMARTBUFFER_ENCODING; | |
this._writeOffset = 0; | |
this._readOffset = 0; | |
if (SmartBuffer.isSmartBufferOptions(options)) { | |
// Checks for encoding | |
if (options.encoding) { | |
utils_1.checkEncoding(options.encoding); | |
this._encoding = options.encoding; | |
} | |
// Checks for initial size length | |
if (options.size) { | |
if (utils_1.isFiniteInteger(options.size) && options.size > 0) { | |
this._buff = Buffer.allocUnsafe(options.size); | |
} | |
else { | |
throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE); | |
} | |
// Check for initial Buffer | |
} | |
else if (options.buff) { | |
if (Buffer.isBuffer(options.buff)) { | |
this._buff = options.buff; | |
this.length = options.buff.length; | |
} | |
else { | |
throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER); | |
} | |
} | |
else { | |
this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); | |
} | |
} | |
else { | |
// If something was passed but it's not a SmartBufferOptions object | |
if (typeof options !== 'undefined') { | |
throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT); | |
} | |
// Otherwise default to sane options | |
this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); | |
} | |
} | |
/** | |
* Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding. | |
* | |
* @param size { Number } The size of the internal Buffer. | |
* @param encoding { String } The BufferEncoding to use for strings. | |
* | |
* @return { SmartBuffer } | |
*/ | |
static fromSize(size, encoding) { | |
return new this({ | |
size: size, | |
encoding: encoding | |
}); | |
} | |
/** | |
* Creates a new SmartBuffer instance with the provided Buffer and optional encoding. | |
* | |
* @param buffer { Buffer } The Buffer to use as the internal Buffer value. | |
* @param encoding { String } The BufferEncoding to use for strings. | |
* | |
* @return { SmartBuffer } | |
*/ | |
static fromBuffer(buff, encoding) { | |
return new this({ | |
buff: buff, | |
encoding: encoding | |
}); | |
} | |
/** | |
* Creates a new SmartBuffer instance with the provided SmartBufferOptions options. | |
* | |
* @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance. | |
*/ | |
static fromOptions(options) { | |
return new this(options); | |
} | |
/** | |
* Type checking function that determines if an object is a SmartBufferOptions object. | |
*/ | |
static isSmartBufferOptions(options) { | |
const castOptions = options; | |
return (castOptions && | |
(castOptions.encoding !== undefined || castOptions.size !== undefined || castOptions.buff !== undefined)); | |
} | |
// Signed integers | |
/** | |
* Reads an Int8 value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readInt8(offset) { | |
return this._readNumberValue(Buffer.prototype.readInt8, 1, offset); | |
} | |
/** | |
* Reads an Int16BE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readInt16BE(offset) { | |
return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset); | |
} | |
/** | |
* Reads an Int16LE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readInt16LE(offset) { | |
return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset); | |
} | |
/** | |
* Reads an Int32BE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readInt32BE(offset) { | |
return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset); | |
} | |
/** | |
* Reads an Int32LE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readInt32LE(offset) { | |
return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset); | |
} | |
/** | |
* Reads a BigInt64BE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { BigInt } | |
*/ | |
readBigInt64BE(offset) { | |
utils_1.bigIntAndBufferInt64Check('readBigInt64BE'); | |
return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset); | |
} | |
/** | |
* Reads a BigInt64LE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { BigInt } | |
*/ | |
readBigInt64LE(offset) { | |
utils_1.bigIntAndBufferInt64Check('readBigInt64LE'); | |
return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset); | |
} | |
/** | |
* Writes an Int8 value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeInt8(value, offset) { | |
this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset); | |
return this; | |
} | |
/** | |
* Inserts an Int8 value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertInt8(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset); | |
} | |
/** | |
* Writes an Int16BE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeInt16BE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset); | |
} | |
/** | |
* Inserts an Int16BE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertInt16BE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset); | |
} | |
/** | |
* Writes an Int16LE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeInt16LE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset); | |
} | |
/** | |
* Inserts an Int16LE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertInt16LE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset); | |
} | |
/** | |
* Writes an Int32BE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeInt32BE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset); | |
} | |
/** | |
* Inserts an Int32BE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertInt32BE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset); | |
} | |
/** | |
* Writes an Int32LE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeInt32LE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset); | |
} | |
/** | |
* Inserts an Int32LE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertInt32LE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset); | |
} | |
/** | |
* Writes a BigInt64BE value to the current write position (or at optional offset). | |
* | |
* @param value { BigInt } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeBigInt64BE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigInt64BE'); | |
return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset); | |
} | |
/** | |
* Inserts a BigInt64BE value at the given offset value. | |
* | |
* @param value { BigInt } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertBigInt64BE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigInt64BE'); | |
return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset); | |
} | |
/** | |
* Writes a BigInt64LE value to the current write position (or at optional offset). | |
* | |
* @param value { BigInt } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeBigInt64LE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigInt64LE'); | |
return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset); | |
} | |
/** | |
* Inserts a Int64LE value at the given offset value. | |
* | |
* @param value { BigInt } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertBigInt64LE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigInt64LE'); | |
return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset); | |
} | |
// Unsigned Integers | |
/** | |
* Reads an UInt8 value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readUInt8(offset) { | |
return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset); | |
} | |
/** | |
* Reads an UInt16BE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readUInt16BE(offset) { | |
return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset); | |
} | |
/** | |
* Reads an UInt16LE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readUInt16LE(offset) { | |
return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset); | |
} | |
/** | |
* Reads an UInt32BE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readUInt32BE(offset) { | |
return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset); | |
} | |
/** | |
* Reads an UInt32LE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readUInt32LE(offset) { | |
return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset); | |
} | |
/** | |
* Reads a BigUInt64BE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { BigInt } | |
*/ | |
readBigUInt64BE(offset) { | |
utils_1.bigIntAndBufferInt64Check('readBigUInt64BE'); | |
return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset); | |
} | |
/** | |
* Reads a BigUInt64LE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { BigInt } | |
*/ | |
readBigUInt64LE(offset) { | |
utils_1.bigIntAndBufferInt64Check('readBigUInt64LE'); | |
return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset); | |
} | |
/** | |
* Writes an UInt8 value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeUInt8(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset); | |
} | |
/** | |
* Inserts an UInt8 value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertUInt8(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset); | |
} | |
/** | |
* Writes an UInt16BE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeUInt16BE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset); | |
} | |
/** | |
* Inserts an UInt16BE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertUInt16BE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset); | |
} | |
/** | |
* Writes an UInt16LE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeUInt16LE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset); | |
} | |
/** | |
* Inserts an UInt16LE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertUInt16LE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset); | |
} | |
/** | |
* Writes an UInt32BE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeUInt32BE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset); | |
} | |
/** | |
* Inserts an UInt32BE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertUInt32BE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset); | |
} | |
/** | |
* Writes an UInt32LE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeUInt32LE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset); | |
} | |
/** | |
* Inserts an UInt32LE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertUInt32LE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset); | |
} | |
/** | |
* Writes a BigUInt64BE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeBigUInt64BE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE'); | |
return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset); | |
} | |
/** | |
* Inserts a BigUInt64BE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertBigUInt64BE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE'); | |
return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset); | |
} | |
/** | |
* Writes a BigUInt64LE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeBigUInt64LE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE'); | |
return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset); | |
} | |
/** | |
* Inserts a BigUInt64LE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertBigUInt64LE(value, offset) { | |
utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE'); | |
return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset); | |
} | |
// Floating Point | |
/** | |
* Reads an FloatBE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readFloatBE(offset) { | |
return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset); | |
} | |
/** | |
* Reads an FloatLE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readFloatLE(offset) { | |
return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset); | |
} | |
/** | |
* Writes a FloatBE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeFloatBE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset); | |
} | |
/** | |
* Inserts a FloatBE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertFloatBE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset); | |
} | |
/** | |
* Writes a FloatLE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeFloatLE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset); | |
} | |
/** | |
* Inserts a FloatLE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertFloatLE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset); | |
} | |
// Double Floating Point | |
/** | |
* Reads an DoublEBE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readDoubleBE(offset) { | |
return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset); | |
} | |
/** | |
* Reads an DoubleLE value from the current read position or an optionally provided offset. | |
* | |
* @param offset { Number } The offset to read data from (optional) | |
* @return { Number } | |
*/ | |
readDoubleLE(offset) { | |
return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset); | |
} | |
/** | |
* Writes a DoubleBE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeDoubleBE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset); | |
} | |
/** | |
* Inserts a DoubleBE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertDoubleBE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset); | |
} | |
/** | |
* Writes a DoubleLE value to the current write position (or at optional offset). | |
* | |
* @param value { Number } The value to write. | |
* @param offset { Number } The offset to write the value at. | |
* | |
* @return this | |
*/ | |
writeDoubleLE(value, offset) { | |
return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset); | |
} | |
/** | |
* Inserts a DoubleLE value at the given offset value. | |
* | |
* @param value { Number } The value to insert. | |
* @param offset { Number } The offset to insert the value at. | |
* | |
* @return this | |
*/ | |
insertDoubleLE(value, offset) { | |
return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset); | |
} | |
// Strings | |
/** | |
* Reads a String from the current read position. | |
* | |
* @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for | |
* the string (Defaults to instance level encoding). | |
* @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). | |
* | |
* @return { String } | |
*/ | |
readString(arg1, encoding) { | |
let lengthVal; | |
// Length provided | |
if (typeof arg1 === 'number') { | |
utils_1.checkLengthValue(arg1); | |
lengthVal = Math.min(arg1, this.length - this._readOffset); | |
} | |
else { | |
encoding = arg1; | |
lengthVal = this.length - this._readOffset; | |
} | |
// Check encoding | |
if (typeof encoding !== 'undefined') { | |
utils_1.checkEncoding(encoding); | |
} | |
const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding); | |
this._readOffset += lengthVal; | |
return value; | |
} | |
/** | |
* Inserts a String | |
* | |
* @param value { String } The String value to insert. | |
* @param offset { Number } The offset to insert the string at. | |
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). | |
* | |
* @return this | |
*/ | |
insertString(value, offset, encoding) { | |
utils_1.checkOffsetValue(offset); | |
return this._handleString(value, true, offset, encoding); | |
} | |
/** | |
* Writes a String | |
* | |
* @param value { String } The String value to write. | |
* @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use. | |
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). | |
* | |
* @return this | |
*/ | |
writeString(value, arg2, encoding) { | |
return this._handleString(value, false, arg2, encoding); | |
} | |
/** | |
* Reads a null-terminated String from the current read position. | |
* | |
* @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). | |
* | |
* @return { String } | |
*/ | |
readStringNT(encoding) { | |
if (typeof encoding !== 'undefined') { | |
utils_1.checkEncoding(encoding); | |
} | |
// Set null character position to the end SmartBuffer instance. | |
let nullPos = this.length; | |
// Find next null character (if one is not found, default from above is used) | |
for (let i = this._readOffset; i < this.length; i++) { | |
if (this._buff[i] === 0x00) { | |
nullPos = i; | |
break; | |
} | |
} | |
// Read string value | |
const value = this._buff.slice(this._readOffset, nullPos); | |
// Increment internal Buffer read offset | |
this._readOffset = nullPos + 1; | |
return value.toString(encoding || this._encoding); | |
} | |
/** | |
* Inserts a null-terminated String. | |
* | |
* @param value { String } The String value to write. | |
* @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. | |
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). | |
* | |
* @return this | |
*/ | |
insertStringNT(value, offset, encoding) { | |
utils_1.checkOffsetValue(offset); | |
// Write Values | |
this.insertString(value, offset, encoding); | |
this.insertUInt8(0x00, offset + value.length); | |
return this; | |
} | |
/** | |
* Writes a null-terminated String. | |
* | |
* @param value { String } The String value to write. | |
* @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. | |
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). | |
* | |
* @return this | |
*/ | |
writeStringNT(value, arg2, encoding) { | |
// Write Values | |
this.writeString(value, arg2, encoding); | |
this.writeUInt8(0x00, typeof arg2 === 'number' ? arg2 + value.length : this.writeOffset); | |
return this; | |
} | |
// Buffers | |
/** | |
* Reads a Buffer from the internal read position. | |
* | |
* @param length { Number } The length of data to read as a Buffer. | |
* | |
* @return { Buffer } | |
*/ | |
readBuffer(length) { | |
if (typeof length !== 'undefined') { | |
utils_1.checkLengthValue(length); | |
} | |
const lengthVal = typeof length === 'number' ? length : this.length; | |
const endPoint = Math.min(this.length, this._readOffset + lengthVal); | |
// Read buffer value | |
const value = this._buff.slice(this._readOffset, endPoint); | |
// Increment internal Buffer read offset | |
this._readOffset = endPoint; | |
return value; | |
} | |
/** | |
* Writes a Buffer to the current write position. | |
* | |
* @param value { Buffer } The Buffer to write. | |
* @param offset { Number } The offset to write the Buffer to. | |
* | |
* @return this | |
*/ | |
insertBuffer(value, offset) { | |
utils_1.checkOffsetValue(offset); | |
return this._handleBuffer(value, true, offset); | |
} | |
/** | |
* Writes a Buffer to the current write position. | |
* | |
* @param value { Buffer } The Buffer to write. | |
* @param offset { Number } The offset to write the Buffer to. | |
* | |
* @return this | |
*/ | |
writeBuffer(value, offset) { | |
return this._handleBuffer(value, false, offset); | |
} | |
/** | |
* Reads a null-terminated Buffer from the current read poisiton. | |
* | |
* @return { Buffer } | |
*/ | |
readBufferNT() { | |
// Set null character position to the end SmartBuffer instance. | |
let nullPos = this.length; | |
// Find next null character (if one is not found, default from above is used) | |
for (let i = this._readOffset; i < this.length; i++) { | |
if (this._buff[i] === 0x00) { | |
nullPos = i; | |
break; | |
} | |
} | |
// Read value | |
const value = this._buff.slice(this._readOffset, nullPos); | |
// Increment internal Buffer read offset | |
this._readOffset = nullPos + 1; | |
return value; | |
} | |
/** | |
* Inserts a null-terminated Buffer. | |
* | |
* @param value { Buffer } The Buffer to write. | |
* @param offset { Number } The offset to write the Buffer to. | |
* | |
* @return this | |
*/ | |
insertBufferNT(value, offset) { | |
utils_1.checkOffsetValue(offset); | |
// Write Values | |
this.insertBuffer(value, offset); | |
this.insertUInt8(0x00, offset + value.length); | |
return this; | |
} | |
/** | |
* Writes a null-terminated Buffer. | |
* | |
* @param value { Buffer } The Buffer to write. | |
* @param offset { Number } The offset to write the Buffer to. | |
* | |
* @return this | |
*/ | |
writeBufferNT(value, offset) { | |
// Checks for valid numberic value; | |
if (typeof offset !== 'undefined') { | |
utils_1.checkOffsetValue(offset); | |
} | |
// Write Values | |
this.writeBuffer(value, offset); | |
this.writeUInt8(0x00, typeof offset === 'number' ? offset + value.length : this._writeOffset); | |
return this; | |
} | |
/** | |
* Clears the SmartBuffer instance to its original empty state. | |
*/ | |
clear() { | |
this._writeOffset = 0; | |
this._readOffset = 0; | |
this.length = 0; | |
return this; | |
} | |
/** | |
* Gets the remaining data left to be read from the SmartBuffer instance. | |
* | |
* @return { Number } | |
*/ | |
remaining() { | |
return this.length - this._readOffset; | |
} | |
/** | |
* Gets the current read offset value of the SmartBuffer instance. | |
* | |
* @return { Number } | |
*/ | |
get readOffset() { | |
return this._readOffset; | |
} | |
/** | |
* Sets the read offset value of the SmartBuffer instance. | |
* | |
* @param offset { Number } - The offset value to set. | |
*/ | |
set readOffset(offset) { | |
utils_1.checkOffsetValue(offset); | |
// Check for bounds. | |
utils_1.checkTargetOffset(offset, this); | |
this._readOffset = offset; | |
} | |
/** | |
* Gets the current write offset value of the SmartBuffer instance. | |
* | |
* @return { Number } | |
*/ | |
get writeOffset() { | |
return this._writeOffset; | |
} | |
/** | |
* Sets the write offset value of the SmartBuffer instance. | |
* | |
* @param offset { Number } - The offset value to set. | |
*/ | |
set writeOffset(offset) { | |
utils_1.checkOffsetValue(offset); | |
// Check for bounds. | |
utils_1.checkTargetOffset(offset, this); | |
this._writeOffset = offset; | |
} | |
/** | |
* Gets the currently set string encoding of the SmartBuffer instance. | |
* | |
* @return { BufferEncoding } The string Buffer encoding currently set. | |
*/ | |
get encoding() { | |
return this._encoding; | |
} | |
/** | |
* Sets the string encoding of the SmartBuffer instance. | |
* | |
* @param encoding { BufferEncoding } The string Buffer encoding to set. | |
*/ | |
set encoding(encoding) { | |
utils_1.checkEncoding(encoding); | |
this._encoding = encoding; | |
} | |
/** | |
* Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer) | |
* | |
* @return { Buffer } The Buffer value. | |
*/ | |
get internalBuffer() { | |
return this._buff; | |
} | |
/** | |
* Gets the value of the internal managed Buffer (Includes managed data only) | |
* | |
* @param { Buffer } | |
*/ | |
toBuffer() { | |
return this._buff.slice(0, this.length); | |
} | |
/** | |
* Gets the String value of the internal managed Buffer | |
* | |
* @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding). | |
*/ | |
toString(encoding) { | |
const encodingVal = typeof encoding === 'string' ? encoding : this._encoding; | |
// Check for invalid encoding. | |
utils_1.checkEncoding(encodingVal); | |
return this._buff.toString(encodingVal, 0, this.length); | |
} | |
/** | |
* Destroys the SmartBuffer instance. | |
*/ | |
destroy() { | |
this.clear(); | |
return this; | |
} | |
/** | |
* Handles inserting and writing strings. | |
* | |
* @param value { String } The String value to insert. | |
* @param isInsert { Boolean } True if inserting a string, false if writing. | |
* @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use. | |
* @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). | |
*/ | |
_handleString(value, isInsert, arg3, encoding) { | |
let offsetVal = this._writeOffset; | |
let encodingVal = this._encoding; | |
// Check for offset | |
if (typeof arg3 === 'number') { | |
offsetVal = arg3; | |
// Check for encoding | |
} | |
else if (typeof arg3 === 'string') { | |
utils_1.checkEncoding(arg3); | |
encodingVal = arg3; | |
} | |
// Check for encoding (third param) | |
if (typeof encoding === 'string') { | |
utils_1.checkEncoding(encoding); | |
encodingVal = encoding; | |
} | |
// Calculate bytelength of string. | |
const byteLength = Buffer.byteLength(value, encodingVal); | |
// Ensure there is enough internal Buffer capacity. | |
if (isInsert) { | |
this.ensureInsertable(byteLength, offsetVal); | |
} | |
else { | |
this._ensureWriteable(byteLength, offsetVal); | |
} | |
// Write value | |
this._buff.write(value, offsetVal, byteLength, encodingVal); | |
// Increment internal Buffer write offset; | |
if (isInsert) { | |
this._writeOffset += byteLength; | |
} | |
else { | |
// If an offset was given, check to see if we wrote beyond the current writeOffset. | |
if (typeof arg3 === 'number') { | |
this._writeOffset = Math.max(this._writeOffset, offsetVal + byteLength); | |
} | |
else { | |
// If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset. | |
this._writeOffset += byteLength; | |
} | |
} | |
return this; | |
} | |
/** | |
* Handles writing or insert of a Buffer. | |
* | |
* @param value { Buffer } The Buffer to write. | |
* @param offset { Number } The offset to write the Buffer to. | |
*/ | |
_handleBuffer(value, isInsert, offset) { | |
const offsetVal = typeof offset === 'number' ? offset : this._writeOffset; | |
// Ensure there is enough internal Buffer capacity. | |
if (isInsert) { | |
this.ensureInsertable(value.length, offsetVal); | |
} | |
else { | |
this._ensureWriteable(value.length, offsetVal); | |
} | |
// Write buffer value | |
value.copy(this._buff, offsetVal); | |
// Increment internal Buffer write offset; | |
if (isInsert) { | |
this._writeOffset += value.length; | |
} | |
else { | |
// If an offset was given, check to see if we wrote beyond the current writeOffset. | |
if (typeof offset === 'number') { | |
this._writeOffset = Math.max(this._writeOffset, offsetVal + value.length); | |
} | |
else { | |
// If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset. | |
this._writeOffset += value.length; | |
} | |
} | |
return this; | |
} | |
/** | |
* Ensures that the internal Buffer is large enough to read data. | |
* | |
* @param length { Number } The length of the data that needs to be read. | |
* @param offset { Number } The offset of the data that needs to be read. | |
*/ | |
ensureReadable(length, offset) { | |
// Offset value defaults to managed read offset. | |
let offsetVal = this._readOffset; | |
// If an offset was provided, use it. | |
if (typeof offset !== 'undefined') { | |
// Checks for valid numberic value; | |
utils_1.checkOffsetValue(offset); | |
// Overide with custom offset. | |
offsetVal = offset; | |
} | |
// Checks if offset is below zero, or the offset+length offset is beyond the total length of the managed data. | |
if (offsetVal < 0 || offsetVal + length > this.length) { | |
throw new Error(utils_1.ERRORS.INVALID_READ_BEYOND_BOUNDS); | |
} | |
} | |
/** | |
* Ensures that the internal Buffer is large enough to insert data. | |
* | |
* @param dataLength { Number } The length of the data that needs to be written. | |
* @param offset { Number } The offset of the data to be written. | |
*/ | |
ensureInsertable(dataLength, offset) { | |
// Checks for valid numberic value; | |
utils_1.checkOffsetValue(offset); | |
// Ensure there is enough internal Buffer capacity. | |
this._ensureCapacity(this.length + dataLength); | |
// If an offset was provided and its not the very end of the buffer, copy data into appropriate location in regards to the offset. | |
if (offset < this.length) { | |
this._buff.copy(this._buff, offset + dataLength, offset, this._buff.length); | |
} | |
// Adjust tracked smart buffer length | |
if (offset + dataLength > this.length) { | |
this.length = offset + dataLength; | |
} | |
else { | |
this.length += dataLength; | |
} | |
} | |
/** | |
* Ensures that the internal Buffer is large enough to write data. | |
* | |
* @param dataLength { Number } The length of the data that needs to be written. | |
* @param offset { Number } The offset of the data to be written (defaults to writeOffset). | |
*/ | |
_ensureWriteable(dataLength, offset) { | |
const offsetVal = typeof offset === 'number' ? offset : this._writeOffset; | |
// Ensure enough capacity to write data. | |
this._ensureCapacity(offsetVal + dataLength); | |
// Adjust SmartBuffer length (if offset + length is larger than managed length, adjust length) | |
if (offsetVal + dataLength > this.length) { | |
this.length = offsetVal + dataLength; | |
} | |
} | |
/** | |
* Ensures that the internal Buffer is large enough to write at least the given amount of data. | |
* | |
* @param minLength { Number } The minimum length of the data needs to be written. | |
*/ | |
_ensureCapacity(minLength) { | |
const oldLength = this._buff.length; | |
if (minLength > oldLength) { | |
let data = this._buff; | |
let newLength = (oldLength * 3) / 2 + 1; | |
if (newLength < minLength) { | |
newLength = minLength; | |
} | |
this._buff = Buffer.allocUnsafe(newLength); | |
data.copy(this._buff, 0, 0, oldLength); | |
} | |
} | |
/** | |
* Reads a numeric number value using the provided function. | |
* | |
* @typeparam T { number | bigint } The type of the value to be read | |
* | |
* @param func { Function(offset: number) => number } The function to read data on the internal Buffer with. | |
* @param byteSize { Number } The number of bytes read. | |
* @param offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead. | |
* | |
* @returns { T } the number value | |
*/ | |
_readNumberValue(func, byteSize, offset) { | |
this.ensureReadable(byteSize, offset); | |
// Call Buffer.readXXXX(); | |
const value = func.call(this._buff, typeof offset === 'number' ? offset : this._readOffset); | |
// Adjust internal read offset if an optional read offset was not provided. | |
if (typeof offset === 'undefined') { | |
this._readOffset += byteSize; | |
} | |
return value; | |
} | |
/** | |
* Inserts a numeric number value based on the given offset and value. | |
* | |
* @typeparam T { number | bigint } The type of the value to be written | |
* | |
* @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. | |
* @param byteSize { Number } The number of bytes written. | |
* @param value { T } The number value to write. | |
* @param offset { Number } the offset to write the number at (REQUIRED). | |
* | |
* @returns SmartBuffer this buffer | |
*/ | |
_insertNumberValue(func, byteSize, value, offset) { | |
// Check for invalid offset values. | |
utils_1.checkOffsetValue(offset); | |
// Ensure there is enough internal Buffer capacity. (raw offset is passed) | |
this.ensureInsertable(byteSize, offset); | |
// Call buffer.writeXXXX(); | |
func.call(this._buff, value, offset); | |
// Adjusts internally managed write offset. | |
this._writeOffset += byteSize; | |
return this; | |
} | |
/** | |
* Writes a numeric number value based on the given offset and value. | |
* | |
* @typeparam T { number | bigint } The type of the value to be written | |
* | |
* @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. | |
* @param byteSize { Number } The number of bytes written. | |
* @param value { T } The number value to write. | |
* @param offset { Number } the offset to write the number at (REQUIRED). | |
* | |
* @returns SmartBuffer this buffer | |
*/ | |
_writeNumberValue(func, byteSize, value, offset) { | |
// If an offset was provided, validate it. | |
if (typeof offset === 'number') { | |
// Check if we're writing beyond the bounds of the managed data. | |
if (offset < 0) { | |
throw new Error(utils_1.ERRORS.INVALID_WRITE_BEYOND_BOUNDS); | |
} | |
utils_1.checkOffsetValue(offset); | |
} | |
// Default to writeOffset if no offset value was given. | |
const offsetVal = typeof offset === 'number' ? offset : this._writeOffset; | |
// Ensure there is enough internal Buffer capacity. (raw offset is passed) | |
this._ensureWriteable(byteSize, offsetVal); | |
func.call(this._buff, value, offsetVal); | |
// If an offset was given, check to see if we wrote beyond the current writeOffset. | |
if (typeof offset === 'number') { | |
this._writeOffset = Math.max(this._writeOffset, offsetVal + byteSize); | |
} | |
else { | |
// If no numeric offset was given, we wrote to the end of the SmartBuffer so increment writeOffset. | |
this._writeOffset += byteSize; | |
} | |
return this; | |
} | |
} | |
exports.SmartBuffer = SmartBuffer; | |
}).call(this)}).call(this,require("buffer").Buffer) | |
},{"./utils":41,"buffer":3}],41:[function(require,module,exports){ | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
const buffer_1 = require("buffer"); | |
/** | |
* Error strings | |
*/ | |
const ERRORS = { | |
INVALID_ENCODING: 'Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.', | |
INVALID_SMARTBUFFER_SIZE: 'Invalid size provided. Size must be a valid integer greater than zero.', | |
INVALID_SMARTBUFFER_BUFFER: 'Invalid Buffer provided in SmartBufferOptions.', | |
INVALID_SMARTBUFFER_OBJECT: 'Invalid SmartBufferOptions object supplied to SmartBuffer constructor or factory methods.', | |
INVALID_OFFSET: 'An invalid offset value was provided.', | |
INVALID_OFFSET_NON_NUMBER: 'An invalid offset value was provided. A numeric value is required.', | |
INVALID_LENGTH: 'An invalid length value was provided.', | |
INVALID_LENGTH_NON_NUMBER: 'An invalid length value was provived. A numeric value is required.', | |
INVALID_TARGET_OFFSET: 'Target offset is beyond the bounds of the internal SmartBuffer data.', | |
INVALID_TARGET_LENGTH: 'Specified length value moves cursor beyong the bounds of the internal SmartBuffer data.', | |
INVALID_READ_BEYOND_BOUNDS: 'Attempted to read beyond the bounds of the managed data.', | |
INVALID_WRITE_BEYOND_BOUNDS: 'Attempted to write beyond the bounds of the managed data.' | |
}; | |
exports.ERRORS = ERRORS; | |
/** | |
* Checks if a given encoding is a valid Buffer encoding. (Throws an exception if check fails) | |
* | |
* @param { String } encoding The encoding string to check. | |
*/ | |
function checkEncoding(encoding) { | |
if (!buffer_1.Buffer.isEncoding(encoding)) { | |
throw new Error(ERRORS.INVALID_ENCODING); | |
} | |
} | |
exports.checkEncoding = checkEncoding; | |
/** | |
* Checks if a given number is a finite integer. (Throws an exception if check fails) | |
* | |
* @param { Number } value The number value to check. | |
*/ | |
function isFiniteInteger(value) { | |
return typeof value === 'number' && isFinite(value) && isInteger(value); | |
} | |
exports.isFiniteInteger = isFiniteInteger; | |
/** | |
* Checks if an offset/length value is valid. (Throws an exception if check fails) | |
* | |
* @param value The value to check. | |
* @param offset True if checking an offset, false if checking a length. | |
*/ | |
function checkOffsetOrLengthValue(value, offset) { | |
if (typeof value === 'number') { | |
// Check for non finite/non integers | |
if (!isFiniteInteger(value) || value < 0) { | |
throw new Error(offset ? ERRORS.INVALID_OFFSET : ERRORS.INVALID_LENGTH); | |
} | |
} | |
else { | |
throw new Error(offset ? ERRORS.INVALID_OFFSET_NON_NUMBER : ERRORS.INVALID_LENGTH_NON_NUMBER); | |
} | |
} | |
/** | |
* Checks if a length value is valid. (Throws an exception if check fails) | |
* | |
* @param { Number } length The value to check. | |
*/ | |
function checkLengthValue(length) { | |
checkOffsetOrLengthValue(length, false); | |
} | |
exports.checkLengthValue = checkLengthValue; | |
/** | |
* Checks if a offset value is valid. (Throws an exception if check fails) | |
* | |
* @param { Number } offset The value to check. | |
*/ | |
function checkOffsetValue(offset) { | |
checkOffsetOrLengthValue(offset, true); | |
} | |
exports.checkOffsetValue = checkOffsetValue; | |
/** | |
* Checks if a target offset value is out of bounds. (Throws an exception if check fails) | |
* | |
* @param { Number } offset The offset value to check. | |
* @param { SmartBuffer } buff The SmartBuffer instance to check against. | |
*/ | |
function checkTargetOffset(offset, buff) { | |
if (offset < 0 || offset > buff.length) { | |
throw new Error(ERRORS.INVALID_TARGET_OFFSET); | |
} | |
} | |
exports.checkTargetOffset = checkTargetOffset; | |
/** | |
* Determines whether a given number is a integer. | |
* @param value The number to check. | |
*/ | |
function isInteger(value) { | |
return typeof value === 'number' && isFinite(value) && Math.floor(value) === value; | |
} | |
/** | |
* Throws if Node.js version is too low to support bigint | |
*/ | |
function bigIntAndBufferInt64Check(bufferMethod) { | |
if (typeof BigInt === 'undefined') { | |
throw new Error('Platform does not support JS BigInt type.'); | |
} | |
if (typeof buffer_1.Buffer.prototype[bufferMethod] === 'undefined') { | |
throw new Error(`Platform does not support Buffer.prototype.${bufferMethod}.`); | |
} | |
} | |
exports.bigIntAndBufferInt64Check = bigIntAndBufferInt64Check; | |
},{"buffer":3}]},{},[39]); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment