Skip to content

Instantly share code, notes, and snippets.

@Kreijstal

Kreijstal/jsbinary.js

Last active April 10, 2024 19:47
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save Kreijstal/2691cae140baf5d9e785828e10f7ae58 to your computer and use it in GitHub Desktop.
Save Kreijstal/2691cae140baf5d9e785828e10f7ae58 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
jsbinary.js
(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