@inditextech/weave-store-standalone 3.9.0 → 3.9.2

package/dist/client.js

@@ -201,13 +201,13 @@ var require_ieee754 = __commonJS({ "../../node_modules/ieee754/index.js"(exports
 //#endregion
 //#region ../../node_modules/buffer/index.js
 var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports) {
-	var base64 = require_base64_js();
-	var ieee754 = require_ieee754();
-	var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+	const base64 = require_base64_js();
+	const ieee754 = require_ieee754();
+	const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
 	exports.Buffer = Buffer$1;
 	exports.SlowBuffer = SlowBuffer;
 	exports.INSPECT_MAX_BYTES = 50;
-	var K_MAX_LENGTH = 2147483647;
+	const K_MAX_LENGTH = 2147483647;
 	exports.kMaxLength = K_MAX_LENGTH;
 	/**
 	* If `Buffer.TYPED_ARRAY_SUPPORT`:
@@ -227,8 +227,8 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	if (!Buffer$1.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() {
+			const arr = new Uint8Array(1);
+			const proto = { foo: function() {
 				return 42;
 			} };
 			Object.setPrototypeOf(proto, Uint8Array.prototype);
@@ -254,7 +254,7 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	});
 	function createBuffer(length) {
 		if (length > K_MAX_LENGTH) throw new RangeError("The value \"" + length + "\" is invalid for option \"size\"");
-		var buf = new Uint8Array(length);
+		const buf = new Uint8Array(length);
 		Object.setPrototypeOf(buf, Buffer$1.prototype);
 		return buf;
 	}
@@ -282,9 +282,9 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) return fromArrayBuffer(value, encodingOrOffset, length);
 		if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) 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();
+		const valueOf = value.valueOf && value.valueOf();
 		if (valueOf != null && valueOf !== value) return Buffer$1.from(valueOf, encodingOrOffset, length);
-		var b = fromObject(value);
+		const b = fromObject(value);
 		if (b) return b;
 		if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") return Buffer$1.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);
@@ -338,21 +338,21 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	function fromString(string, encoding) {
 		if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
 		if (!Buffer$1.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
-		var length = byteLength(string, encoding) | 0;
-		var buf = createBuffer(length);
-		var actual = buf.write(string, encoding);
+		const length = byteLength(string, encoding) | 0;
+		let buf = createBuffer(length);
+		const actual = buf.write(string, encoding);
 		if (actual !== length) 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$1 = 0; i$1 < length; i$1 += 1) buf[i$1] = array[i$1] & 255;
+		const length = array.length < 0 ? 0 : checked(array.length) | 0;
+		const buf = createBuffer(length);
+		for (let i$1 = 0; i$1 < length; i$1 += 1) buf[i$1] = array[i$1] & 255;
 		return buf;
 	}
 	function fromArrayView(arrayView) {
 		if (isInstance(arrayView, Uint8Array)) {
-			var copy = new Uint8Array(arrayView);
+			const copy = new Uint8Array(arrayView);
 			return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
 		}
 		return fromArrayLike(arrayView);
@@ -360,7 +360,7 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	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;
+		let buf;
 		if (byteOffset === void 0 && length === void 0) buf = new Uint8Array(array);
 		else if (length === void 0) buf = new Uint8Array(array, byteOffset);
 		else buf = new Uint8Array(array, byteOffset, length);
@@ -369,8 +369,8 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	}
 	function fromObject(obj) {
 		if (Buffer$1.isBuffer(obj)) {
-			var len$1 = checked(obj.length) | 0;
-			var buf = createBuffer(len$1);
+			const len$1 = checked(obj.length) | 0;
+			const buf = createBuffer(len$1);
 			if (buf.length === 0) return buf;
 			obj.copy(buf, 0, 0, len$1);
 			return buf;
@@ -397,9 +397,9 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		if (isInstance(b, Uint8Array)) b = Buffer$1.from(b, b.offset, b.byteLength);
 		if (!Buffer$1.isBuffer(a) || !Buffer$1.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$1 = 0, len$1 = Math.min(x, y); i$1 < len$1; ++i$1) if (a[i$1] !== b[i$1]) {
+		let x = a.length;
+		let y = b.length;
+		for (let i$1 = 0, len$1 = Math.min(x, y); i$1 < len$1; ++i$1) if (a[i$1] !== b[i$1]) {
 			x = a[i$1];
 			y = b[i$1];
 			break;
@@ -427,17 +427,19 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	Buffer$1.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$1.alloc(0);
-		var i$1;
+		let i$1;
 		if (length === void 0) {
 			length = 0;
 			for (i$1 = 0; i$1 < list.length; ++i$1) length += list[i$1].length;
 		}
-		var buffer = Buffer$1.allocUnsafe(length);
-		var pos = 0;
+		const buffer = Buffer$1.allocUnsafe(length);
+		let pos = 0;
 		for (i$1 = 0; i$1 < list.length; ++i$1) {
-			var buf = list[i$1];
-			if (isInstance(buf, Uint8Array)) if (pos + buf.length > buffer.length) Buffer$1.from(buf).copy(buffer, pos);
-			else Uint8Array.prototype.set.call(buffer, buf, pos);
+			let buf = list[i$1];
+			if (isInstance(buf, Uint8Array)) if (pos + buf.length > buffer.length) {
+				if (!Buffer$1.isBuffer(buf)) buf = Buffer$1.from(buf);
+				buf.copy(buffer, pos);
+			} else Uint8Array.prototype.set.call(buffer, buf, pos);
 			else if (!Buffer$1.isBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
 			else buf.copy(buffer, pos);
 			pos += buf.length;
@@ -448,10 +450,10 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		if (Buffer$1.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$1 = string.length;
-		var mustMatch = arguments.length > 2 && arguments[2] === true;
+		const len$1 = string.length;
+		const mustMatch = arguments.length > 2 && arguments[2] === true;
 		if (!mustMatch && len$1 === 0) return 0;
-		var loweredCase = false;
+		let loweredCase = false;
 		for (;;) switch (encoding) {
 			case "ascii":
 			case "latin1":
@@ -472,7 +474,7 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	}
 	Buffer$1.byteLength = byteLength;
 	function slowToString(encoding, start, end) {
-		var loweredCase = false;
+		let 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;
@@ -501,29 +503,29 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	}
 	Buffer$1.prototype._isBuffer = true;
 	function swap(b, n, m) {
-		var i$1 = b[n];
+		const i$1 = b[n];
 		b[n] = b[m];
 		b[m] = i$1;
 	}
 	Buffer$1.prototype.swap16 = function swap16() {
-		var len$1 = this.length;
+		const len$1 = this.length;
 		if (len$1 % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
-		for (var i$1 = 0; i$1 < len$1; i$1 += 2) swap(this, i$1, i$1 + 1);
+		for (let i$1 = 0; i$1 < len$1; i$1 += 2) swap(this, i$1, i$1 + 1);
 		return this;
 	};
 	Buffer$1.prototype.swap32 = function swap32() {
-		var len$1 = this.length;
+		const len$1 = this.length;
 		if (len$1 % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
-		for (var i$1 = 0; i$1 < len$1; i$1 += 4) {
+		for (let i$1 = 0; i$1 < len$1; i$1 += 4) {
 			swap(this, i$1, i$1 + 3);
 			swap(this, i$1 + 1, i$1 + 2);
 		}
 		return this;
 	};
 	Buffer$1.prototype.swap64 = function swap64() {
-		var len$1 = this.length;
+		const len$1 = this.length;
 		if (len$1 % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
-		for (var i$1 = 0; i$1 < len$1; i$1 += 8) {
+		for (let i$1 = 0; i$1 < len$1; i$1 += 8) {
 			swap(this, i$1, i$1 + 7);
 			swap(this, i$1 + 1, i$1 + 6);
 			swap(this, i$1 + 2, i$1 + 5);
@@ -532,7 +534,7 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		return this;
 	};
 	Buffer$1.prototype.toString = function toString() {
-		var length = this.length;
+		const length = this.length;
 		if (length === 0) return "";
 		if (arguments.length === 0) return utf8Slice(this, 0, length);
 		return slowToString.apply(this, arguments);
@@ -544,8 +546,8 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		return Buffer$1.compare(this, b) === 0;
 	};
 	Buffer$1.prototype.inspect = function inspect() {
-		var str = "";
-		var max = exports.INSPECT_MAX_BYTES;
+		let str = "";
+		const max = exports.INSPECT_MAX_BYTES;
 		str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
 		if (this.length > max) str += " ... ";
 		return "<Buffer " + str + ">";
@@ -567,12 +569,12 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		thisStart >>>= 0;
 		thisEnd >>>= 0;
 		if (this === target) return 0;
-		var x = thisEnd - thisStart;
-		var y = end - start;
-		var len$1 = Math.min(x, y);
-		var thisCopy = this.slice(thisStart, thisEnd);
-		var targetCopy = target.slice(start, end);
-		for (var i$1 = 0; i$1 < len$1; ++i$1) if (thisCopy[i$1] !== targetCopy[i$1]) {
+		let x = thisEnd - thisStart;
+		let y = end - start;
+		const len$1 = Math.min(x, y);
+		const thisCopy = this.slice(thisStart, thisEnd);
+		const targetCopy = target.slice(start, end);
+		for (let i$1 = 0; i$1 < len$1; ++i$1) if (thisCopy[i$1] !== targetCopy[i$1]) {
 			x = thisCopy[i$1];
 			y = targetCopy[i$1];
 			break;
@@ -608,9 +610,9 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		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;
+		let indexSize = 1;
+		let arrLength = arr.length;
+		let valLength = val.length;
 		if (encoding !== void 0) {
 			encoding = String(encoding).toLowerCase();
 			if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
@@ -625,9 +627,9 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 			if (indexSize === 1) return buf[i$2];
 			else return buf.readUInt16BE(i$2 * indexSize);
 		}
-		var i$1;
+		let i$1;
 		if (dir) {
-			var foundIndex = -1;
+			let foundIndex = -1;
 			for (i$1 = byteOffset; i$1 < arrLength; i$1++) if (read(arr, i$1) === read(val, foundIndex === -1 ? 0 : i$1 - foundIndex)) {
 				if (foundIndex === -1) foundIndex = i$1;
 				if (i$1 - foundIndex + 1 === valLength) return foundIndex * indexSize;
@@ -638,8 +640,8 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		} else {
 			if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
 			for (i$1 = byteOffset; i$1 >= 0; i$1--) {
-				var found = true;
-				for (var j = 0; j < valLength; j++) if (read(arr, i$1 + j) !== read(val, j)) {
+				let found = true;
+				for (let j = 0; j < valLength; j++) if (read(arr, i$1 + j) !== read(val, j)) {
 					found = false;
 					break;
 				}
@@ -659,16 +661,17 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	};
 	function hexWrite(buf, string, offset, length) {
 		offset = Number(offset) || 0;
-		var remaining = buf.length - offset;
+		const remaining = buf.length - offset;
 		if (!length) length = remaining;
 		else {
 			length = Number(length);
 			if (length > remaining) length = remaining;
 		}
-		var strLen = string.length;
+		const strLen = string.length;
 		if (length > strLen / 2) length = strLen / 2;
-		for (var i$1 = 0; i$1 < length; ++i$1) {
-			var parsed = parseInt(string.substr(i$1 * 2, 2), 16);
+		let i$1;
+		for (i$1 = 0; i$1 < length; ++i$1) {
+			const parsed = parseInt(string.substr(i$1 * 2, 2), 16);
 			if (numberIsNaN(parsed)) return i$1;
 			buf[offset + i$1] = parsed;
 		}
@@ -705,11 +708,11 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 				length = void 0;
 			}
 		} else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
-		var remaining = this.length - offset;
+		const remaining = this.length - offset;
 		if (length === void 0 || 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;
+		let loweredCase = false;
 		for (;;) switch (encoding) {
 			case "hex": return hexWrite(this, string, offset, length);
 			case "utf8":
@@ -740,14 +743,14 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	}
 	function utf8Slice(buf, start, end) {
 		end = Math.min(buf.length, end);
-		var res = [];
-		var i$1 = start;
+		const res = [];
+		let i$1 = start;
 		while (i$1 < end) {
-			var firstByte = buf[i$1];
-			var codePoint = null;
-			var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+			const firstByte = buf[i$1];
+			let codePoint = null;
+			let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
 			if (i$1 + bytesPerSequence <= end) {
-				var secondByte, thirdByte, fourthByte, tempCodePoint;
+				let secondByte, thirdByte, fourthByte, tempCodePoint;
 				switch (bytesPerSequence) {
 					case 1:
 						if (firstByte < 128) codePoint = firstByte;
@@ -790,43 +793,43 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		}
 		return decodeCodePointsArray(res);
 	}
-	var MAX_ARGUMENTS_LENGTH = 4096;
+	const MAX_ARGUMENTS_LENGTH = 4096;
 	function decodeCodePointsArray(codePoints) {
-		var len$1 = codePoints.length;
+		const len$1 = codePoints.length;
 		if (len$1 <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
-		var res = "";
-		var i$1 = 0;
+		let res = "";
+		let i$1 = 0;
 		while (i$1 < len$1) res += String.fromCharCode.apply(String, codePoints.slice(i$1, i$1 += MAX_ARGUMENTS_LENGTH));
 		return res;
 	}
 	function asciiSlice(buf, start, end) {
-		var ret = "";
+		let ret = "";
 		end = Math.min(buf.length, end);
-		for (var i$1 = start; i$1 < end; ++i$1) ret += String.fromCharCode(buf[i$1] & 127);
+		for (let i$1 = start; i$1 < end; ++i$1) ret += String.fromCharCode(buf[i$1] & 127);
 		return ret;
 	}
 	function latin1Slice(buf, start, end) {
-		var ret = "";
+		let ret = "";
 		end = Math.min(buf.length, end);
-		for (var i$1 = start; i$1 < end; ++i$1) ret += String.fromCharCode(buf[i$1]);
+		for (let i$1 = start; i$1 < end; ++i$1) ret += String.fromCharCode(buf[i$1]);
 		return ret;
 	}
 	function hexSlice(buf, start, end) {
-		var len$1 = buf.length;
+		const len$1 = buf.length;
 		if (!start || start < 0) start = 0;
 		if (!end || end < 0 || end > len$1) end = len$1;
-		var out = "";
-		for (var i$1 = start; i$1 < end; ++i$1) out += hexSliceLookupTable[buf[i$1]];
+		let out = "";
+		for (let i$1 = start; i$1 < end; ++i$1) out += hexSliceLookupTable[buf[i$1]];
 		return out;
 	}
 	function utf16leSlice(buf, start, end) {
-		var bytes = buf.slice(start, end);
-		var res = "";
-		for (var i$1 = 0; i$1 < bytes.length - 1; i$1 += 2) res += String.fromCharCode(bytes[i$1] + bytes[i$1 + 1] * 256);
+		const bytes = buf.slice(start, end);
+		let res = "";
+		for (let i$1 = 0; i$1 < bytes.length - 1; i$1 += 2) res += String.fromCharCode(bytes[i$1] + bytes[i$1 + 1] * 256);
 		return res;
 	}
 	Buffer$1.prototype.slice = function slice(start, end) {
-		var len$1 = this.length;
+		const len$1 = this.length;
 		start = ~~start;
 		end = end === void 0 ? len$1 : ~~end;
 		if (start < 0) {
@@ -838,7 +841,7 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 			if (end < 0) end = 0;
 		} else if (end > len$1) end = len$1;
 		if (end < start) end = start;
-		var newBuf = this.subarray(start, end);
+		const newBuf = this.subarray(start, end);
 		Object.setPrototypeOf(newBuf, Buffer$1.prototype);
 		return newBuf;
 	};
@@ -850,9 +853,9 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		offset = offset >>> 0;
 		byteLength$2 = byteLength$2 >>> 0;
 		if (!noAssert) checkOffset(offset, byteLength$2, this.length);
-		var val = this[offset];
-		var mul = 1;
-		var i$1 = 0;
+		let val = this[offset];
+		let mul = 1;
+		let i$1 = 0;
 		while (++i$1 < byteLength$2 && (mul *= 256)) val += this[offset + i$1] * mul;
 		return val;
 	};
@@ -860,8 +863,8 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		offset = offset >>> 0;
 		byteLength$2 = byteLength$2 >>> 0;
 		if (!noAssert) checkOffset(offset, byteLength$2, this.length);
-		var val = this[offset + --byteLength$2];
-		var mul = 1;
+		let val = this[offset + --byteLength$2];
+		let mul = 1;
 		while (byteLength$2 > 0 && (mul *= 256)) val += this[offset + --byteLength$2] * mul;
 		return val;
 	};
@@ -890,13 +893,33 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		if (!noAssert) checkOffset(offset, 4, this.length);
 		return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
 	};
+	Buffer$1.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+		offset = offset >>> 0;
+		validateNumber(offset, "offset");
+		const first = this[offset];
+		const last = this[offset + 7];
+		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
+		const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+		const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+		return BigInt(lo) + (BigInt(hi) << BigInt(32));
+	});
+	Buffer$1.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+		offset = offset >>> 0;
+		validateNumber(offset, "offset");
+		const first = this[offset];
+		const last = this[offset + 7];
+		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
+		const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+		const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+		return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+	});
 	Buffer$1.prototype.readIntLE = function readIntLE(offset, byteLength$2, noAssert) {
 		offset = offset >>> 0;
 		byteLength$2 = byteLength$2 >>> 0;
 		if (!noAssert) checkOffset(offset, byteLength$2, this.length);
-		var val = this[offset];
-		var mul = 1;
-		var i$1 = 0;
+		let val = this[offset];
+		let mul = 1;
+		let i$1 = 0;
 		while (++i$1 < byteLength$2 && (mul *= 256)) val += this[offset + i$1] * mul;
 		mul *= 128;
 		if (val >= mul) val -= Math.pow(2, 8 * byteLength$2);
@@ -906,9 +929,9 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		offset = offset >>> 0;
 		byteLength$2 = byteLength$2 >>> 0;
 		if (!noAssert) checkOffset(offset, byteLength$2, this.length);
-		var i$1 = byteLength$2;
-		var mul = 1;
-		var val = this[offset + --i$1];
+		let i$1 = byteLength$2;
+		let mul = 1;
+		let val = this[offset + --i$1];
 		while (i$1 > 0 && (mul *= 256)) val += this[offset + --i$1] * mul;
 		mul *= 128;
 		if (val >= mul) val -= Math.pow(2, 8 * byteLength$2);
@@ -923,13 +946,13 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	Buffer$1.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
 		offset = offset >>> 0;
 		if (!noAssert) checkOffset(offset, 2, this.length);
-		var val = this[offset] | this[offset + 1] << 8;
+		const val = this[offset] | this[offset + 1] << 8;
 		return val & 32768 ? val | 4294901760 : val;
 	};
 	Buffer$1.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
 		offset = offset >>> 0;
 		if (!noAssert) checkOffset(offset, 2, this.length);
-		var val = this[offset + 1] | this[offset] << 8;
+		const val = this[offset + 1] | this[offset] << 8;
 		return val & 32768 ? val | 4294901760 : val;
 	};
 	Buffer$1.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
@@ -942,6 +965,24 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		if (!noAssert) checkOffset(offset, 4, this.length);
 		return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
 	};
+	Buffer$1.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+		offset = offset >>> 0;
+		validateNumber(offset, "offset");
+		const first = this[offset];
+		const last = this[offset + 7];
+		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
+		const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+		return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+	});
+	Buffer$1.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+		offset = offset >>> 0;
+		validateNumber(offset, "offset");
+		const first = this[offset];
+		const last = this[offset + 7];
+		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
+		const val = (first << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+		return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+	});
 	Buffer$1.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
 		offset = offset >>> 0;
 		if (!noAssert) checkOffset(offset, 4, this.length);
@@ -972,11 +1013,11 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		offset = offset >>> 0;
 		byteLength$2 = byteLength$2 >>> 0;
 		if (!noAssert) {
-			var maxBytes = Math.pow(2, 8 * byteLength$2) - 1;
+			const maxBytes = Math.pow(2, 8 * byteLength$2) - 1;
 			checkInt(this, value, offset, byteLength$2, maxBytes, 0);
 		}
-		var mul = 1;
-		var i$1 = 0;
+		let mul = 1;
+		let i$1 = 0;
 		this[offset] = value & 255;
 		while (++i$1 < byteLength$2 && (mul *= 256)) this[offset + i$1] = value / mul & 255;
 		return offset + byteLength$2;
@@ -986,11 +1027,11 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		offset = offset >>> 0;
 		byteLength$2 = byteLength$2 >>> 0;
 		if (!noAssert) {
-			var maxBytes = Math.pow(2, 8 * byteLength$2) - 1;
+			const maxBytes = Math.pow(2, 8 * byteLength$2) - 1;
 			checkInt(this, value, offset, byteLength$2, maxBytes, 0);
 		}
-		var i$1 = byteLength$2 - 1;
-		var mul = 1;
+		let i$1 = byteLength$2 - 1;
+		let mul = 1;
 		this[offset + i$1] = value & 255;
 		while (--i$1 >= 0 && (mul *= 256)) this[offset + i$1] = value / mul & 255;
 		return offset + byteLength$2;
@@ -1038,16 +1079,62 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		this[offset + 3] = value & 255;
 		return offset + 4;
 	};
+	function wrtBigUInt64LE(buf, value, offset, min, max) {
+		checkIntBI(value, min, max, buf, offset, 7);
+		let lo = Number(value & BigInt(4294967295));
+		buf[offset++] = lo;
+		lo = lo >> 8;
+		buf[offset++] = lo;
+		lo = lo >> 8;
+		buf[offset++] = lo;
+		lo = lo >> 8;
+		buf[offset++] = lo;
+		let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+		buf[offset++] = hi;
+		hi = hi >> 8;
+		buf[offset++] = hi;
+		hi = hi >> 8;
+		buf[offset++] = hi;
+		hi = hi >> 8;
+		buf[offset++] = hi;
+		return offset;
+	}
+	function wrtBigUInt64BE(buf, value, offset, min, max) {
+		checkIntBI(value, min, max, buf, offset, 7);
+		let lo = Number(value & BigInt(4294967295));
+		buf[offset + 7] = lo;
+		lo = lo >> 8;
+		buf[offset + 6] = lo;
+		lo = lo >> 8;
+		buf[offset + 5] = lo;
+		lo = lo >> 8;
+		buf[offset + 4] = lo;
+		let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+		buf[offset + 3] = hi;
+		hi = hi >> 8;
+		buf[offset + 2] = hi;
+		hi = hi >> 8;
+		buf[offset + 1] = hi;
+		hi = hi >> 8;
+		buf[offset] = hi;
+		return offset + 8;
+	}
+	Buffer$1.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+		return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+	});
+	Buffer$1.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+		return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+	});
 	Buffer$1.prototype.writeIntLE = function writeIntLE(value, offset, byteLength$2, noAssert) {
 		value = +value;
 		offset = offset >>> 0;
 		if (!noAssert) {
-			var limit = Math.pow(2, 8 * byteLength$2 - 1);
+			const limit = Math.pow(2, 8 * byteLength$2 - 1);
 			checkInt(this, value, offset, byteLength$2, limit - 1, -limit);
 		}
-		var i$1 = 0;
-		var mul = 1;
-		var sub = 0;
+		let i$1 = 0;
+		let mul = 1;
+		let sub = 0;
 		this[offset] = value & 255;
 		while (++i$1 < byteLength$2 && (mul *= 256)) {
 			if (value < 0 && sub === 0 && this[offset + i$1 - 1] !== 0) sub = 1;
@@ -1059,12 +1146,12 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		value = +value;
 		offset = offset >>> 0;
 		if (!noAssert) {
-			var limit = Math.pow(2, 8 * byteLength$2 - 1);
+			const limit = Math.pow(2, 8 * byteLength$2 - 1);
 			checkInt(this, value, offset, byteLength$2, limit - 1, -limit);
 		}
-		var i$1 = byteLength$2 - 1;
-		var mul = 1;
-		var sub = 0;
+		let i$1 = byteLength$2 - 1;
+		let mul = 1;
+		let sub = 0;
 		this[offset + i$1] = value & 255;
 		while (--i$1 >= 0 && (mul *= 256)) {
 			if (value < 0 && sub === 0 && this[offset + i$1 + 1] !== 0) sub = 1;
@@ -1117,6 +1204,12 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		this[offset + 3] = value & 255;
 		return offset + 4;
 	};
+	Buffer$1.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+		return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+	});
+	Buffer$1.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+		return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+	});
 	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");
@@ -1161,7 +1254,7 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		if (end < 0) throw new RangeError("sourceEnd out of bounds");
 		if (end > this.length) end = this.length;
 		if (target.length - targetStart < end - start) end = target.length - targetStart + start;
-		var len$1 = end - start;
+		const len$1 = end - start;
 		if (this === target && typeof Uint8Array.prototype.copyWithin === "function") this.copyWithin(targetStart, start, end);
 		else Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
 		return len$1;
@@ -1179,7 +1272,7 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 			if (encoding !== void 0 && typeof encoding !== "string") throw new TypeError("encoding must be a string");
 			if (typeof encoding === "string" && !Buffer$1.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
 			if (val.length === 1) {
-				var code$1 = val.charCodeAt(0);
+				const code$1 = val.charCodeAt(0);
 				if (encoding === "utf8" && code$1 < 128 || encoding === "latin1") val = code$1;
 			}
 		} else if (typeof val === "number") val = val & 255;
@@ -1189,17 +1282,99 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		start = start >>> 0;
 		end = end === void 0 ? this.length : end >>> 0;
 		if (!val) val = 0;
-		var i$1;
+		let i$1;
 		if (typeof val === "number") for (i$1 = start; i$1 < end; ++i$1) this[i$1] = val;
 		else {
-			var bytes = Buffer$1.isBuffer(val) ? val : Buffer$1.from(val, encoding);
-			var len$1 = bytes.length;
+			const bytes = Buffer$1.isBuffer(val) ? val : Buffer$1.from(val, encoding);
+			const len$1 = bytes.length;
 			if (len$1 === 0) throw new TypeError("The value \"" + val + "\" is invalid for argument \"value\"");
 			for (i$1 = 0; i$1 < end - start; ++i$1) this[i$1 + start] = bytes[i$1 % len$1];
 		}
 		return this;
 	};
-	var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+	const errors = {};
+	function E(sym, getMessage, Base) {
+		errors[sym] = class NodeError extends Base {
+			constructor() {
+				super();
+				Object.defineProperty(this, "message", {
+					value: getMessage.apply(this, arguments),
+					writable: true,
+					configurable: true
+				});
+				this.name = `${this.name} [${sym}]`;
+				this.stack;
+				delete this.name;
+			}
+			get code() {
+				return sym;
+			}
+			set code(value) {
+				Object.defineProperty(this, "code", {
+					configurable: true,
+					enumerable: true,
+					value,
+					writable: true
+				});
+			}
+			toString() {
+				return `${this.name} [${sym}]: ${this.message}`;
+			}
+		};
+	}
+	E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
+		if (name) return `${name} is outside of buffer bounds`;
+		return "Attempt to access memory outside buffer bounds";
+	}, RangeError);
+	E("ERR_INVALID_ARG_TYPE", function(name, actual) {
+		return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
+	}, TypeError);
+	E("ERR_OUT_OF_RANGE", function(str, range, input) {
+		let msg = `The value of "${str}" is out of range.`;
+		let received = input;
+		if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) received = addNumericalSeparator(String(input));
+		else if (typeof input === "bigint") {
+			received = String(input);
+			if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) received = addNumericalSeparator(received);
+			received += "n";
+		}
+		msg += ` It must be ${range}. Received ${received}`;
+		return msg;
+	}, RangeError);
+	function addNumericalSeparator(val) {
+		let res = "";
+		let i$1 = val.length;
+		const start = val[0] === "-" ? 1 : 0;
+		for (; i$1 >= start + 4; i$1 -= 3) res = `_${val.slice(i$1 - 3, i$1)}${res}`;
+		return `${val.slice(0, i$1)}${res}`;
+	}
+	function checkBounds(buf, offset, byteLength$2) {
+		validateNumber(offset, "offset");
+		if (buf[offset] === void 0 || buf[offset + byteLength$2] === void 0) boundsError(offset, buf.length - (byteLength$2 + 1));
+	}
+	function checkIntBI(value, min, max, buf, offset, byteLength$2) {
+		if (value > max || value < min) {
+			const n = typeof min === "bigint" ? "n" : "";
+			let range;
+			if (byteLength$2 > 3) if (min === 0 || min === BigInt(0)) range = `>= 0${n} and < 2${n} ** ${(byteLength$2 + 1) * 8}${n}`;
+			else range = `>= -(2${n} ** ${(byteLength$2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength$2 + 1) * 8 - 1}${n}`;
+			else range = `>= ${min}${n} and <= ${max}${n}`;
+			throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+		}
+		checkBounds(buf, offset, byteLength$2);
+	}
+	function validateNumber(value, name) {
+		if (typeof value !== "number") throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
+	}
+	function boundsError(value, length, type) {
+		if (Math.floor(value) !== value) {
+			validateNumber(value, type);
+			throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
+		}
+		if (length < 0) throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+		throw new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
+	}
+	const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
 	function base64clean(str) {
 		str = str.split("=")[0];
 		str = str.trim().replace(INVALID_BASE64_RE, "");
@@ -1209,11 +1384,11 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	}
 	function utf8ToBytes(string, units) {
 		units = units || Infinity;
-		var codePoint;
-		var length = string.length;
-		var leadSurrogate = null;
-		var bytes = [];
-		for (var i$1 = 0; i$1 < length; ++i$1) {
+		let codePoint;
+		const length = string.length;
+		let leadSurrogate = null;
+		const bytes = [];
+		for (let i$1 = 0; i$1 < length; ++i$1) {
 			codePoint = string.charCodeAt(i$1);
 			if (codePoint > 55295 && codePoint < 57344) {
 				if (!leadSurrogate) {
@@ -1254,14 +1429,14 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		return bytes;
 	}
 	function asciiToBytes(str) {
-		var byteArray = [];
-		for (var i$1 = 0; i$1 < str.length; ++i$1) byteArray.push(str.charCodeAt(i$1) & 255);
+		const byteArray = [];
+		for (let i$1 = 0; i$1 < str.length; ++i$1) byteArray.push(str.charCodeAt(i$1) & 255);
 		return byteArray;
 	}
 	function utf16leToBytes(str, units) {
-		var c, hi, lo;
-		var byteArray = [];
-		for (var i$1 = 0; i$1 < str.length; ++i$1) {
+		let c, hi, lo;
+		const byteArray = [];
+		for (let i$1 = 0; i$1 < str.length; ++i$1) {
 			if ((units -= 2) < 0) break;
 			c = str.charCodeAt(i$1);
 			hi = c >> 8;
@@ -1275,7 +1450,8 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 		return base64.toByteArray(base64clean(str));
 	}
 	function blitBuffer(src, dst, offset, length) {
-		for (var i$1 = 0; i$1 < length; ++i$1) {
+		let i$1;
+		for (i$1 = 0; i$1 < length; ++i$1) {
 			if (i$1 + offset >= dst.length || i$1 >= src.length) break;
 			dst[i$1 + offset] = src[i$1];
 		}
@@ -1287,15 +1463,21 @@ var require_buffer = __commonJS({ "../../node_modules/buffer/index.js"(exports)
 	function numberIsNaN(obj) {
 		return obj !== obj;
 	}
-	var hexSliceLookupTable = function() {
-		var alphabet = "0123456789abcdef";
-		var table = new Array(256);
-		for (var i$1 = 0; i$1 < 16; ++i$1) {
-			var i16 = i$1 * 16;
-			for (var j = 0; j < 16; ++j) table[i16 + j] = alphabet[i$1] + alphabet[j];
+	const hexSliceLookupTable = function() {
+		const alphabet = "0123456789abcdef";
+		const table = new Array(256);
+		for (let i$1 = 0; i$1 < 16; ++i$1) {
+			const i16 = i$1 * 16;
+			for (let j = 0; j < 16; ++j) table[i16 + j] = alphabet[i$1] + alphabet[j];
 		}
 		return table;
 	}();
+	function defineBigIntMethod(fn) {
+		return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+	}
+	function BufferBigIntNotDefined() {
+		throw new Error("BigInt not supported");
+	}
 } });
 var import_buffer = __toESM(require_buffer(), 1);