@blockchain-lab-um/masca
Version:
Snap for managing VCs and VPs in MetaMask
1,353 lines (1,349 loc) • 13.3 MB
JavaScript
var Worker = {};
var self = window;
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __typeError = msg => {
throw TypeError(msg);
};
var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, {
enumerable: true,
configurable: true,
writable: true,
value
}) : obj[key2] = value;
var __esm = (fn2, res) => function __init() {
return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
};
var __commonJS = (cb, mod6) => function __require() {
return mod6 || (0, cb[__getOwnPropNames(cb)[0]])((mod6 = {
exports: {}
}).exports, mod6), mod6.exports;
};
var __export = (target, all) => {
for (var name10 in all) __defProp(target, name10, {
get: all[name10],
enumerable: true
});
};
var __copyProps = (to2, from11, except, desc) => {
if (from11 && typeof from11 === "object" || typeof from11 === "function") {
for (let key2 of __getOwnPropNames(from11)) if (!__hasOwnProp.call(to2, key2) && key2 !== except) __defProp(to2, key2, {
get: () => from11[key2],
enumerable: !(desc = __getOwnPropDesc(from11, key2)) || desc.enumerable
});
}
return to2;
};
var __toESM = (mod6, isNodeMode, target) => (target = mod6 != null ? __create(__getProtoOf(mod6)) : {}, __copyProps(isNodeMode || !mod6 || !mod6.__esModule ? __defProp(target, "default", {
value: mod6,
enumerable: true
}) : target, mod6));
var __toCommonJS = mod6 => __copyProps(__defProp({}, "__esModule", {
value: true
}), mod6);
var __publicField = (obj, key2, value) => __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
var __privateWrapper = (obj, member, setter, getter) => ({
set _(value) {
__privateSet(obj, member, value, setter);
},
get _() {
return __privateGet(obj, member, getter);
}
});
var require_base64_js = __commonJS({
"../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
"use strict";
init_shim();
exports.byteLength = byteLength2;
exports.toByteArray = toByteArray;
exports.fromByteArray = fromByteArray;
var lookup = [];
var revLookup = [];
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
var code12 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
for (i5 = 0, len = code12.length; i5 < len; ++i5) {
lookup[i5] = code12[i5];
revLookup[code12.charCodeAt(i5)] = i5;
}
var i5;
var len;
revLookup["-".charCodeAt(0)] = 62;
revLookup["_".charCodeAt(0)] = 63;
function getLens(b64) {
var len2 = b64.length;
if (len2 % 4 > 0) {
throw new Error("Invalid string. Length must be a multiple of 4");
}
var validLen = b64.indexOf("=");
if (validLen === -1) validLen = len2;
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
return [validLen, placeHoldersLen];
}
function byteLength2(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;
var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
var i6;
for (i6 = 0; i6 < len2; i6 += 4) {
tmp = revLookup[b64.charCodeAt(i6)] << 18 | revLookup[b64.charCodeAt(i6 + 1)] << 12 | revLookup[b64.charCodeAt(i6 + 2)] << 6 | revLookup[b64.charCodeAt(i6 + 3)];
arr[curByte++] = tmp >> 16 & 255;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 2) {
tmp = revLookup[b64.charCodeAt(i6)] << 2 | revLookup[b64.charCodeAt(i6 + 1)] >> 4;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 1) {
tmp = revLookup[b64.charCodeAt(i6)] << 10 | revLookup[b64.charCodeAt(i6 + 1)] << 4 | revLookup[b64.charCodeAt(i6 + 2)] >> 2;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
return arr;
}
function tripletToBase64(num) {
return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
}
function encodeChunk(uint8, start, end) {
var tmp;
var output8 = [];
for (var i6 = start; i6 < end; i6 += 3) {
tmp = (uint8[i6] << 16 & 16711680) + (uint8[i6 + 1] << 8 & 65280) + (uint8[i6 + 2] & 255);
output8.push(tripletToBase64(tmp));
}
return output8.join("");
}
function fromByteArray(uint8) {
var tmp;
var len2 = uint8.length;
var extraBytes = len2 % 3;
var parts = [];
var maxChunkLength = 16383;
for (var i6 = 0, len22 = len2 - extraBytes; i6 < len22; i6 += maxChunkLength) {
parts.push(encodeChunk(uint8, i6, i6 + maxChunkLength > len22 ? len22 : i6 + maxChunkLength));
}
if (extraBytes === 1) {
tmp = uint8[len2 - 1];
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
} else if (extraBytes === 2) {
tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
}
return parts.join("");
}
}
});
var require_ieee754 = __commonJS({
"../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js"(exports) {
"use strict";
init_shim();
exports.read = function (buffer4, offset, isLE8, mLen, nBytes) {
var e8, m6;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var nBits = -7;
var i5 = isLE8 ? nBytes - 1 : 0;
var d5 = isLE8 ? -1 : 1;
var s5 = buffer4[offset + i5];
i5 += d5;
e8 = s5 & (1 << -nBits) - 1;
s5 >>= -nBits;
nBits += eLen;
for (; nBits > 0; e8 = e8 * 256 + buffer4[offset + i5], i5 += d5, nBits -= 8) {}
m6 = e8 & (1 << -nBits) - 1;
e8 >>= -nBits;
nBits += mLen;
for (; nBits > 0; m6 = m6 * 256 + buffer4[offset + i5], i5 += d5, nBits -= 8) {}
if (e8 === 0) {
e8 = 1 - eBias;
} else if (e8 === eMax) {
return m6 ? NaN : (s5 ? -1 : 1) * Infinity;
} else {
m6 = m6 + Math.pow(2, mLen);
e8 = e8 - eBias;
}
return (s5 ? -1 : 1) * m6 * Math.pow(2, e8 - mLen);
};
exports.write = function (buffer4, value, offset, isLE8, mLen, nBytes) {
var e8, m6, c4;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var rt3 = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
var i5 = isLE8 ? 0 : nBytes - 1;
var d5 = isLE8 ? 1 : -1;
var s5 = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m6 = isNaN(value) ? 1 : 0;
e8 = eMax;
} else {
e8 = Math.floor(Math.log(value) / Math.LN2);
if (value * (c4 = Math.pow(2, -e8)) < 1) {
e8--;
c4 *= 2;
}
if (e8 + eBias >= 1) {
value += rt3 / c4;
} else {
value += rt3 * Math.pow(2, 1 - eBias);
}
if (value * c4 >= 2) {
e8++;
c4 /= 2;
}
if (e8 + eBias >= eMax) {
m6 = 0;
e8 = eMax;
} else if (e8 + eBias >= 1) {
m6 = (value * c4 - 1) * Math.pow(2, mLen);
e8 = e8 + eBias;
} else {
m6 = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e8 = 0;
}
}
for (; mLen >= 8; buffer4[offset + i5] = m6 & 255, i5 += d5, m6 /= 256, mLen -= 8) {}
e8 = e8 << mLen | m6;
eLen += mLen;
for (; eLen > 0; buffer4[offset + i5] = e8 & 255, i5 += d5, e8 /= 256, eLen -= 8) {}
buffer4[offset + i5 - d5] |= s5 * 128;
};
}
});
var require_buffer = __commonJS({
"../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js"(exports) {
"use strict";
init_shim();
var base647 = require_base64_js();
var ieee754 = require_ieee754();
var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
exports.Buffer = Buffer3;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
var K_MAX_LENGTH = 2147483647;
exports.kMaxLength = K_MAX_LENGTH;
Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
if (!Buffer3.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() {
try {
var arr = new Uint8Array(1);
var proto = {
foo: function () {
return 42;
}
};
Object.setPrototypeOf(proto, Uint8Array.prototype);
Object.setPrototypeOf(arr, proto);
return arr.foo() === 42;
} catch (e8) {
return false;
}
}
Object.defineProperty(Buffer3.prototype, "parent", {
enumerable: true,
get: function () {
if (!Buffer3.isBuffer(this)) return void 0;
return this.buffer;
}
});
Object.defineProperty(Buffer3.prototype, "offset", {
enumerable: true,
get: function () {
if (!Buffer3.isBuffer(this)) return void 0;
return this.byteOffset;
}
});
function createBuffer(length8) {
if (length8 > K_MAX_LENGTH) {
throw new RangeError('The value "' + length8 + '" is invalid for option "size"');
}
var buf3 = new Uint8Array(length8);
Object.setPrototypeOf(buf3, Buffer3.prototype);
return buf3;
}
function Buffer3(arg, encodingOrOffset, length8) {
if (typeof arg === "number") {
if (typeof encodingOrOffset === "string") {
throw new TypeError('The "string" argument must be of type string. Received type number');
}
return allocUnsafe5(arg);
}
return from11(arg, encodingOrOffset, length8);
}
Buffer3.poolSize = 8192;
function from11(value, encodingOrOffset, length8) {
if (typeof value === "string") {
return fromString16(value, encodingOrOffset);
}
if (ArrayBuffer.isView(value)) {
return fromArrayView(value);
}
if (value == null) {
throw new 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, length8);
}
if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
return fromArrayBuffer(value, encodingOrOffset, length8);
}
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 Buffer3.from(valueOf, encodingOrOffset, length8);
}
var b8 = fromObject(value);
if (b8) return b8;
if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length8);
}
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
}
Buffer3.from = function (value, encodingOrOffset, length8) {
return from11(value, encodingOrOffset, length8);
};
Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
Object.setPrototypeOf(Buffer3, Uint8Array);
function assertSize2(size3) {
if (typeof size3 !== "number") {
throw new TypeError('"size" argument must be of type number');
} else if (size3 < 0) {
throw new RangeError('The value "' + size3 + '" is invalid for option "size"');
}
}
function alloc4(size3, fill, encoding) {
assertSize2(size3);
if (size3 <= 0) {
return createBuffer(size3);
}
if (fill !== void 0) {
return typeof encoding === "string" ? createBuffer(size3).fill(fill, encoding) : createBuffer(size3).fill(fill);
}
return createBuffer(size3);
}
Buffer3.alloc = function (size3, fill, encoding) {
return alloc4(size3, fill, encoding);
};
function allocUnsafe5(size3) {
assertSize2(size3);
return createBuffer(size3 < 0 ? 0 : checked(size3) | 0);
}
Buffer3.allocUnsafe = function (size3) {
return allocUnsafe5(size3);
};
Buffer3.allocUnsafeSlow = function (size3) {
return allocUnsafe5(size3);
};
function fromString16(string8, encoding) {
if (typeof encoding !== "string" || encoding === "") {
encoding = "utf8";
}
if (!Buffer3.isEncoding(encoding)) {
throw new TypeError("Unknown encoding: " + encoding);
}
var length8 = byteLength2(string8, encoding) | 0;
var buf3 = createBuffer(length8);
var actual = buf3.write(string8, encoding);
if (actual !== length8) {
buf3 = buf3.slice(0, actual);
}
return buf3;
}
function fromArrayLike2(array2) {
var length8 = array2.length < 0 ? 0 : checked(array2.length) | 0;
var buf3 = createBuffer(length8);
for (var i5 = 0; i5 < length8; i5 += 1) {
buf3[i5] = array2[i5] & 255;
}
return buf3;
}
function fromArrayView(arrayView) {
if (isInstance(arrayView, Uint8Array)) {
var copy5 = new Uint8Array(arrayView);
return fromArrayBuffer(copy5.buffer, copy5.byteOffset, copy5.byteLength);
}
return fromArrayLike2(arrayView);
}
function fromArrayBuffer(array2, byteOffset, length8) {
if (byteOffset < 0 || array2.byteLength < byteOffset) {
throw new RangeError('"offset" is outside of buffer bounds');
}
if (array2.byteLength < byteOffset + (length8 || 0)) {
throw new RangeError('"length" is outside of buffer bounds');
}
var buf3;
if (byteOffset === void 0 && length8 === void 0) {
buf3 = new Uint8Array(array2);
} else if (length8 === void 0) {
buf3 = new Uint8Array(array2, byteOffset);
} else {
buf3 = new Uint8Array(array2, byteOffset, length8);
}
Object.setPrototypeOf(buf3, Buffer3.prototype);
return buf3;
}
function fromObject(obj) {
if (Buffer3.isBuffer(obj)) {
var len = checked(obj.length) | 0;
var buf3 = createBuffer(len);
if (buf3.length === 0) {
return buf3;
}
obj.copy(buf3, 0, 0, len);
return buf3;
}
if (obj.length !== void 0) {
if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
return createBuffer(0);
}
return fromArrayLike2(obj);
}
if (obj.type === "Buffer" && Array.isArray(obj.data)) {
return fromArrayLike2(obj.data);
}
}
function checked(length8) {
if (length8 >= K_MAX_LENGTH) {
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
}
return length8 | 0;
}
function SlowBuffer(length8) {
if (+length8 != length8) {
length8 = 0;
}
return Buffer3.alloc(+length8);
}
Buffer3.isBuffer = function isBuffer5(b8) {
return b8 != null && b8._isBuffer === true && b8 !== Buffer3.prototype;
};
Buffer3.compare = function compare7(a5, b8) {
if (isInstance(a5, Uint8Array)) a5 = Buffer3.from(a5, a5.offset, a5.byteLength);
if (isInstance(b8, Uint8Array)) b8 = Buffer3.from(b8, b8.offset, b8.byteLength);
if (!Buffer3.isBuffer(a5) || !Buffer3.isBuffer(b8)) {
throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
}
if (a5 === b8) return 0;
var x6 = a5.length;
var y6 = b8.length;
for (var i5 = 0, len = Math.min(x6, y6); i5 < len; ++i5) {
if (a5[i5] !== b8[i5]) {
x6 = a5[i5];
y6 = b8[i5];
break;
}
}
if (x6 < y6) return -1;
if (y6 < x6) return 1;
return 0;
};
Buffer3.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;
}
};
Buffer3.concat = function concat12(list, length8) {
if (!Array.isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers');
}
if (list.length === 0) {
return Buffer3.alloc(0);
}
var i5;
if (length8 === void 0) {
length8 = 0;
for (i5 = 0; i5 < list.length; ++i5) {
length8 += list[i5].length;
}
}
var buffer4 = Buffer3.allocUnsafe(length8);
var pos = 0;
for (i5 = 0; i5 < list.length; ++i5) {
var buf3 = list[i5];
if (isInstance(buf3, Uint8Array)) {
if (pos + buf3.length > buffer4.length) {
Buffer3.from(buf3).copy(buffer4, pos);
} else {
Uint8Array.prototype.set.call(buffer4, buf3, pos);
}
} else if (!Buffer3.isBuffer(buf3)) {
throw new TypeError('"list" argument must be an Array of Buffers');
} else {
buf3.copy(buffer4, pos);
}
pos += buf3.length;
}
return buffer4;
};
function byteLength2(string8, encoding) {
if (Buffer3.isBuffer(string8)) {
return string8.length;
}
if (ArrayBuffer.isView(string8) || isInstance(string8, ArrayBuffer)) {
return string8.byteLength;
}
if (typeof string8 !== "string") {
throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string8);
}
var len = string8.length;
var mustMatch = arguments.length > 2 && arguments[2] === true;
if (!mustMatch && len === 0) return 0;
var loweredCase = false;
for (;;) {
switch (encoding) {
case "ascii":
case "latin1":
case "binary":
return len;
case "utf8":
case "utf-8":
return utf8ToBytes13(string8).length;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return len * 2;
case "hex":
return len >>> 1;
case "base64":
return base64ToBytes6(string8).length;
default:
if (loweredCase) {
return mustMatch ? -1 : utf8ToBytes13(string8).length;
}
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
}
}
Buffer3.byteLength = byteLength2;
function slowToString(encoding, start, end) {
var loweredCase = false;
if (start === void 0 || start < 0) {
start = 0;
}
if (start > this.length) {
return "";
}
if (end === void 0 || end > this.length) {
end = this.length;
}
if (end <= 0) {
return "";
}
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 utf8Slice3(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;
}
}
}
Buffer3.prototype._isBuffer = true;
function swap(b8, n6, m6) {
var i5 = b8[n6];
b8[n6] = b8[m6];
b8[m6] = i5;
}
Buffer3.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 i5 = 0; i5 < len; i5 += 2) {
swap(this, i5, i5 + 1);
}
return this;
};
Buffer3.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 i5 = 0; i5 < len; i5 += 4) {
swap(this, i5, i5 + 3);
swap(this, i5 + 1, i5 + 2);
}
return this;
};
Buffer3.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 i5 = 0; i5 < len; i5 += 8) {
swap(this, i5, i5 + 7);
swap(this, i5 + 1, i5 + 6);
swap(this, i5 + 2, i5 + 5);
swap(this, i5 + 3, i5 + 4);
}
return this;
};
Buffer3.prototype.toString = function toString17() {
var length8 = this.length;
if (length8 === 0) return "";
if (arguments.length === 0) return utf8Slice3(this, 0, length8);
return slowToString.apply(this, arguments);
};
Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
Buffer3.prototype.equals = function equals12(b8) {
if (!Buffer3.isBuffer(b8)) throw new TypeError("Argument must be a Buffer");
if (this === b8) return true;
return Buffer3.compare(this, b8) === 0;
};
Buffer3.prototype.inspect = function inspect4() {
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 + ">";
};
if (customInspectSymbol) {
Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
}
Buffer3.prototype.compare = function compare7(target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array)) {
target = Buffer3.from(target, target.offset, target.byteLength);
}
if (!Buffer3.isBuffer(target)) {
throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
}
if (start === void 0) {
start = 0;
}
if (end === void 0) {
end = target ? target.length : 0;
}
if (thisStart === void 0) {
thisStart = 0;
}
if (thisEnd === void 0) {
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 x6 = thisEnd - thisStart;
var y6 = end - start;
var len = Math.min(x6, y6);
var thisCopy = this.slice(thisStart, thisEnd);
var targetCopy = target.slice(start, end);
for (var i5 = 0; i5 < len; ++i5) {
if (thisCopy[i5] !== targetCopy[i5]) {
x6 = thisCopy[i5];
y6 = targetCopy[i5];
break;
}
}
if (x6 < y6) return -1;
if (y6 < x6) return 1;
return 0;
};
function bidirectionalIndexOf(buffer4, val, byteOffset, encoding, dir) {
if (buffer4.length === 0) return -1;
if (typeof byteOffset === "string") {
encoding = byteOffset;
byteOffset = 0;
} else if (byteOffset > 2147483647) {
byteOffset = 2147483647;
} else if (byteOffset < -2147483648) {
byteOffset = -2147483648;
}
byteOffset = +byteOffset;
if (numberIsNaN(byteOffset)) {
byteOffset = dir ? 0 : buffer4.length - 1;
}
if (byteOffset < 0) byteOffset = buffer4.length + byteOffset;
if (byteOffset >= buffer4.length) {
if (dir) return -1;else byteOffset = buffer4.length - 1;
} else if (byteOffset < 0) {
if (dir) byteOffset = 0;else return -1;
}
if (typeof val === "string") {
val = Buffer3.from(val, encoding);
}
if (Buffer3.isBuffer(val)) {
if (val.length === 0) {
return -1;
}
return arrayIndexOf(buffer4, val, byteOffset, encoding, dir);
} else if (typeof val === "number") {
val = val & 255;
if (typeof Uint8Array.prototype.indexOf === "function") {
if (dir) {
return Uint8Array.prototype.indexOf.call(buffer4, val, byteOffset);
} else {
return Uint8Array.prototype.lastIndexOf.call(buffer4, val, byteOffset);
}
}
return arrayIndexOf(buffer4, [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 !== void 0) {
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 read7(buf3, i6) {
if (indexSize === 1) {
return buf3[i6];
} else {
return buf3.readUInt16BE(i6 * indexSize);
}
}
var i5;
if (dir) {
var foundIndex = -1;
for (i5 = byteOffset; i5 < arrLength; i5++) {
if (read7(arr, i5) === read7(val, foundIndex === -1 ? 0 : i5 - foundIndex)) {
if (foundIndex === -1) foundIndex = i5;
if (i5 - foundIndex + 1 === valLength) return foundIndex * indexSize;
} else {
if (foundIndex !== -1) i5 -= i5 - foundIndex;
foundIndex = -1;
}
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
for (i5 = byteOffset; i5 >= 0; i5--) {
var found = true;
for (var j5 = 0; j5 < valLength; j5++) {
if (read7(arr, i5 + j5) !== read7(val, j5)) {
found = false;
break;
}
}
if (found) return i5;
}
}
return -1;
}
Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
};
Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
};
Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
};
function hexWrite(buf3, string8, offset, length8) {
offset = Number(offset) || 0;
var remaining = buf3.length - offset;
if (!length8) {
length8 = remaining;
} else {
length8 = Number(length8);
if (length8 > remaining) {
length8 = remaining;
}
}
var strLen = string8.length;
if (length8 > strLen / 2) {
length8 = strLen / 2;
}
for (var i5 = 0; i5 < length8; ++i5) {
var parsed = parseInt(string8.substr(i5 * 2, 2), 16);
if (numberIsNaN(parsed)) return i5;
buf3[offset + i5] = parsed;
}
return i5;
}
function utf8Write(buf3, string8, offset, length8) {
return blitBuffer(utf8ToBytes13(string8, buf3.length - offset), buf3, offset, length8);
}
function asciiWrite(buf3, string8, offset, length8) {
return blitBuffer(asciiToBytes(string8), buf3, offset, length8);
}
function base64Write(buf3, string8, offset, length8) {
return blitBuffer(base64ToBytes6(string8), buf3, offset, length8);
}
function ucs2Write(buf3, string8, offset, length8) {
return blitBuffer(utf16leToBytes(string8, buf3.length - offset), buf3, offset, length8);
}
Buffer3.prototype.write = function write2(string8, offset, length8, encoding) {
if (offset === void 0) {
encoding = "utf8";
length8 = this.length;
offset = 0;
} else if (length8 === void 0 && typeof offset === "string") {
encoding = offset;
length8 = this.length;
offset = 0;
} else if (isFinite(offset)) {
offset = offset >>> 0;
if (isFinite(length8)) {
length8 = length8 >>> 0;
if (encoding === void 0) encoding = "utf8";
} else {
encoding = length8;
length8 = void 0;
}
} else {
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
}
var remaining = this.length - offset;
if (length8 === void 0 || length8 > remaining) length8 = remaining;
if (string8.length > 0 && (length8 < 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, string8, offset, length8);
case "utf8":
case "utf-8":
return utf8Write(this, string8, offset, length8);
case "ascii":
case "latin1":
case "binary":
return asciiWrite(this, string8, offset, length8);
case "base64":
return base64Write(this, string8, offset, length8);
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return ucs2Write(this, string8, offset, length8);
default:
if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
}
};
Buffer3.prototype.toJSON = function toJSON2() {
return {
type: "Buffer",
data: Array.prototype.slice.call(this._arr || this, 0)
};
};
function base64Slice(buf3, start, end) {
if (start === 0 && end === buf3.length) {
return base647.fromByteArray(buf3);
} else {
return base647.fromByteArray(buf3.slice(start, end));
}
}
function utf8Slice3(buf3, start, end) {
end = Math.min(buf3.length, end);
var res = [];
var i5 = start;
while (i5 < end) {
var firstByte = buf3[i5];
var codePoint = null;
var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i5 + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 128) {
codePoint = firstByte;
}
break;
case 2:
secondByte = buf3[i5 + 1];
if ((secondByte & 192) === 128) {
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
if (tempCodePoint > 127) {
codePoint = tempCodePoint;
}
}
break;
case 3:
secondByte = buf3[i5 + 1];
thirdByte = buf3[i5 + 2];
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
codePoint = tempCodePoint;
}
}
break;
case 4:
secondByte = buf3[i5 + 1];
thirdByte = buf3[i5 + 2];
fourthByte = buf3[i5 + 3];
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
codePoint = tempCodePoint;
}
}
}
}
if (codePoint === null) {
codePoint = 65533;
bytesPerSequence = 1;
} else if (codePoint > 65535) {
codePoint -= 65536;
res.push(codePoint >>> 10 & 1023 | 55296);
codePoint = 56320 | codePoint & 1023;
}
res.push(codePoint);
i5 += bytesPerSequence;
}
return decodeCodePointsArray3(res);
}
var MAX_ARGUMENTS_LENGTH3 = 4096;
function decodeCodePointsArray3(codePoints) {
var len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH3) {
return String.fromCharCode.apply(String, codePoints);
}
var res = "";
var i5 = 0;
while (i5 < len) {
res += String.fromCharCode.apply(String, codePoints.slice(i5, i5 += MAX_ARGUMENTS_LENGTH3));
}
return res;
}
function asciiSlice(buf3, start, end) {
var ret2 = "";
end = Math.min(buf3.length, end);
for (var i5 = start; i5 < end; ++i5) {
ret2 += String.fromCharCode(buf3[i5] & 127);
}
return ret2;
}
function latin1Slice(buf3, start, end) {
var ret2 = "";
end = Math.min(buf3.length, end);
for (var i5 = start; i5 < end; ++i5) {
ret2 += String.fromCharCode(buf3[i5]);
}
return ret2;
}
function hexSlice(buf3, start, end) {
var len = buf3.length;
if (!start || start < 0) start = 0;
if (!end || end < 0 || end > len) end = len;
var out = "";
for (var i5 = start; i5 < end; ++i5) {
out += hexSliceLookupTable[buf3[i5]];
}
return out;
}
function utf16leSlice(buf3, start, end) {
var bytes8 = buf3.slice(start, end);
var res = "";
for (var i5 = 0; i5 < bytes8.length - 1; i5 += 2) {
res += String.fromCharCode(bytes8[i5] + bytes8[i5 + 1] * 256);
}
return res;
}
Buffer3.prototype.slice = function slice4(start, end) {
var len = this.length;
start = ~~start;
end = end === void 0 ? 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);
Object.setPrototypeOf(newBuf, Buffer3.prototype);
return newBuf;
};
function checkOffset(offset, ext, length8) {
if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
if (offset + ext > length8) throw new RangeError("Trying to access beyond buffer length");
}
Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) checkOffset(offset, byteLength3, this.length);
var val = this[offset];
var mul4 = 1;
var i5 = 0;
while (++i5 < byteLength3 && (mul4 *= 256)) {
val += this[offset + i5] * mul4;
}
return val;
};
Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
checkOffset(offset, byteLength3, this.length);
}
var val = this[offset + --byteLength3];
var mul4 = 1;
while (byteLength3 > 0 && (mul4 *= 256)) {
val += this[offset + --byteLength3] * mul4;
}
return val;
};
Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
return this[offset];
};
Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] | this[offset + 1] << 8;
};
Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] << 8 | this[offset + 1];
};
Buffer3.prototype.readUint32LE = Buffer3.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] * 16777216;
};
Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
};
Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) checkOffset(offset, byteLength3, this.length);
var val = this[offset];
var mul4 = 1;
var i5 = 0;
while (++i5 < byteLength3 && (mul4 *= 256)) {
val += this[offset + i5] * mul4;
}
mul4 *= 128;
if (val >= mul4) val -= Math.pow(2, 8 * byteLength3);
return val;
};
Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) checkOffset(offset, byteLength3, this.length);
var i5 = byteLength3;
var mul4 = 1;
var val = this[offset + --i5];
while (i5 > 0 && (mul4 *= 256)) {
val += this[offset + --i5] * mul4;
}
mul4 *= 128;
if (val >= mul4) val -= Math.pow(2, 8 * byteLength3);
return val;
};
Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
if (!(this[offset] & 128)) return this[offset];
return (255 - this[offset] + 1) * -1;
};
Buffer3.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 & 32768 ? val | 4294901760 : val;
};
Buffer3.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 & 32768 ? val | 4294901760 : val;
};
Buffer3.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;
};
Buffer3.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];
};
Buffer3.prototype.readFloatLE = function readFloatLE2(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return ieee754.read(this, offset, true, 23, 4);
};
Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return ieee754.read(this, offset, false, 23, 4);
};
Buffer3.prototype.readDoubleLE = function readDoubleLE2(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 8, this.length);
return ieee754.read(this, offset, true, 52, 8);
};
Buffer3.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(buf3, value, offset, ext, max, min) {
if (!Buffer3.isBuffer(buf3)) 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 > buf3.length) throw new RangeError("Index out of range");
}
Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
checkInt(this, value, offset, byteLength3, maxBytes, 0);
}
var mul4 = 1;
var i5 = 0;
this[offset] = value & 255;
while (++i5 < byteLength3 && (mul4 *= 256)) {
this[offset + i5] = value / mul4 & 255;
}
return offset + byteLength3;
};
Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
checkInt(this, value, offset, byteLength3, maxBytes, 0);
}
var i5 = byteLength3 - 1;
var mul4 = 1;
this[offset + i5] = value & 255;
while (--i5 >= 0 && (mul4 *= 256)) {
this[offset + i5] = value / mul4 & 255;
}
return offset + byteLength3;
};
Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
this[offset] = value & 255;
return offset + 1;
};
Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset + 3] = value >>> 24;
this[offset + 2] = value >>> 16;
this[offset + 1] = value >>> 8;
this[offset] = value & 255;
return offset + 4;
};
Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE2(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit2 = Math.pow(2, 8 * byteLength3 - 1);
checkInt(this, value, offset, byteLength3, limit2 - 1, -limit2);
}
var i5 = 0;
var mul4 = 1;
var sub2 = 0;
this[offset] = value & 255;
while (++i5 < byteLength3 && (mul4 *= 256)) {
if (value < 0 && sub2 === 0 && this[offset + i5 - 1] !== 0) {
sub2 = 1;
}
this[offset + i5] = (value / mul4 >> 0) - sub2 & 255;
}
return offset + byteLength3;
};
Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit2 = Math.pow(2, 8 * byteLength3 - 1);
checkInt(this, value, offset, byteLength3, limit2 - 1, -limit2);
}
var i5 = byteLength3 - 1;
var mul4 = 1;
var sub2 = 0;
this[offset + i5] = value & 255;
while (--i5 >= 0 && (mul4 *= 256)) {
if (value < 0 && sub2 === 0 && this[offset + i5 + 1] !== 0) {
sub2 = 1;
}
this[offset + i5] = (value / mul4 >> 0) - sub2 & 255;
}
return offset + byteLength3;
};
Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
if (value < 0) value = 255 + value + 1;
this[offset] = value & 255;
return offset + 1;
};
Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
this[offset + 2] = value >>> 16;
this[offset + 3] = value >>> 24;
return offset + 4;
};
Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
if (value < 0) value = 4294967295 + value + 1;
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
function checkIEEE754(buf3, value, offset, ext, max, min) {
if (offset + ext > buf3.length) throw new RangeError("Index out of range");
if (offset < 0) throw new RangeError("Index out of range");
}
function writeFloat(buf3, value, offset, littleEndian, noAssert) {
value = +value;
offset = offs