image-exporter
Version:
Easily download one or more DOM elements as images
1,232 lines (1,231 loc) • 538 kB
JavaScript
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __moduleCache = /* @__PURE__ */ new WeakMap;
var __toCommonJS = (from) => {
var entry = __moduleCache.get(from), desc;
if (entry)
return entry;
entry = __defProp({}, "__esModule", { value: true });
if (from && typeof from === "object" || typeof from === "function")
__getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
}));
__moduleCache.set(from, entry);
return entry;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
// node:buffer
var exports_buffer = {};
__export(exports_buffer, {
transcode: () => transcode,
resolveObjectURL: () => resolveObjectURL,
kStringMaxLength: () => kStringMaxLength,
kMaxLength: () => kMaxLength,
isUtf8: () => isUtf8,
isAscii: () => isAscii,
default: () => buffer_default,
constants: () => constants,
btoa: () => btoa,
atob: () => atob,
INSPECT_MAX_BYTES: () => INSPECT_MAX_BYTES,
File: () => File,
Buffer: () => Buffer2,
Blob: () => Blob2
});
function getLens(b64) {
var len2 = b64.length;
if (len2 % 4 > 0)
throw 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 _byteLength(validLen, placeHoldersLen) {
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function toByteArray(b64) {
var tmp, lens = getLens(b64), validLen = lens[0], placeHoldersLen = lens[1], arr = new Uint8Array(_byteLength(validLen, placeHoldersLen)), curByte = 0, len2 = placeHoldersLen > 0 ? validLen - 4 : validLen, i2;
for (i2 = 0;i2 < len2; i2 += 4)
tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)], arr[curByte++] = tmp >> 16 & 255, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
if (placeHoldersLen === 2)
tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4, arr[curByte++] = tmp & 255;
if (placeHoldersLen === 1)
tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 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, output = [];
for (var i2 = start;i2 < end; i2 += 3)
tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255), output.push(tripletToBase64(tmp));
return output.join("");
}
function fromByteArray(uint8) {
var tmp, len2 = uint8.length, extraBytes = len2 % 3, parts = [], maxChunkLength = 16383;
for (var i2 = 0, len22 = len2 - extraBytes;i2 < len22; i2 += maxChunkLength)
parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + 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("");
}
function read(buffer, offset, isLE, mLen, nBytes) {
var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i2 = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i2];
i2 += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen;
for (;nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
;
m = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen;
for (;nBits > 0; m = m * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
;
if (e === 0)
e = 1 - eBias;
else if (e === eMax)
return m ? NaN : (s ? -1 : 1) * (1 / 0);
else
m = m + Math.pow(2, mLen), e = e - eBias;
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
}
function write(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i2 = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
if (value = Math.abs(value), isNaN(value) || value === 1 / 0)
m = isNaN(value) ? 1 : 0, e = eMax;
else {
if (e = Math.floor(Math.log(value) / Math.LN2), 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 + i2] = m & 255, i2 += d, m /= 256, mLen -= 8)
;
e = e << mLen | m, eLen += mLen;
for (;eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8)
;
buffer[offset + i2 - d] |= s * 128;
}
function createBuffer(length) {
if (length > kMaxLength)
throw RangeError('The value "' + length + '" is invalid for option "size"');
let buf = new Uint8Array(length);
return Object.setPrototypeOf(buf, Buffer2.prototype), buf;
}
function E(sym, getMessage, Base) {
return class 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}`;
}
};
}
function Buffer2(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
if (typeof encodingOrOffset === "string")
throw TypeError('The "string" argument must be of type string. Received type number');
return allocUnsafe(arg);
}
return from(arg, encodingOrOffset, length);
}
function from(value, encodingOrOffset, length) {
if (typeof value === "string")
return fromString(value, encodingOrOffset);
if (ArrayBuffer.isView(value))
return fromArrayView(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 SharedArrayBuffer < "u" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer)))
return fromArrayBuffer(value, encodingOrOffset, length);
if (typeof value === "number")
throw TypeError('The "value" argument must not be of type number. Received type number');
let valueOf = value.valueOf && value.valueOf();
if (valueOf != null && valueOf !== value)
return Buffer2.from(valueOf, encodingOrOffset, length);
let b = fromObject(value);
if (b)
return b;
if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function")
return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
}
function assertSize(size) {
if (typeof size !== "number")
throw TypeError('"size" argument must be of type number');
else if (size < 0)
throw RangeError('The value "' + size + '" is invalid for option "size"');
}
function alloc(size, fill, encoding) {
if (assertSize(size), size <= 0)
return createBuffer(size);
if (fill !== undefined)
return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
return createBuffer(size);
}
function allocUnsafe(size) {
return assertSize(size), createBuffer(size < 0 ? 0 : checked(size) | 0);
}
function fromString(string, encoding) {
if (typeof encoding !== "string" || encoding === "")
encoding = "utf8";
if (!Buffer2.isEncoding(encoding))
throw TypeError("Unknown encoding: " + encoding);
let length = byteLength(string, encoding) | 0, buf = createBuffer(length), actual = buf.write(string, encoding);
if (actual !== length)
buf = buf.slice(0, actual);
return buf;
}
function fromArrayLike(array) {
let length = array.length < 0 ? 0 : checked(array.length) | 0, buf = createBuffer(length);
for (let i2 = 0;i2 < length; i2 += 1)
buf[i2] = array[i2] & 255;
return buf;
}
function fromArrayView(arrayView) {
if (isInstance(arrayView, Uint8Array)) {
let copy = new Uint8Array(arrayView);
return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
}
return fromArrayLike(arrayView);
}
function fromArrayBuffer(array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset)
throw RangeError('"offset" is outside of buffer bounds');
if (array.byteLength < byteOffset + (length || 0))
throw RangeError('"length" is outside of buffer bounds');
let 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 Object.setPrototypeOf(buf, Buffer2.prototype), buf;
}
function fromObject(obj) {
if (Buffer2.isBuffer(obj)) {
let len2 = checked(obj.length) | 0, buf = createBuffer(len2);
if (buf.length === 0)
return buf;
return obj.copy(buf, 0, 0, len2), buf;
}
if (obj.length !== undefined) {
if (typeof obj.length !== "number" || Number.isNaN(obj.length))
return createBuffer(0);
return fromArrayLike(obj);
}
if (obj.type === "Buffer" && Array.isArray(obj.data))
return fromArrayLike(obj.data);
}
function checked(length) {
if (length >= kMaxLength)
throw RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength.toString(16) + " bytes");
return length | 0;
}
function byteLength(string, encoding) {
if (Buffer2.isBuffer(string))
return string.length;
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer))
return string.byteLength;
if (typeof string !== "string")
throw TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
let len2 = string.length, mustMatch = arguments.length > 2 && arguments[2] === true;
if (!mustMatch && len2 === 0)
return 0;
let loweredCase = false;
for (;; )
switch (encoding) {
case "ascii":
case "latin1":
case "binary":
return len2;
case "utf8":
case "utf-8":
return utf8ToBytes(string).length;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return len2 * 2;
case "hex":
return len2 >>> 1;
case "base64":
return base64ToBytes(string).length;
default:
if (loweredCase)
return mustMatch ? -1 : utf8ToBytes(string).length;
encoding = ("" + encoding).toLowerCase(), loweredCase = true;
}
}
function slowToString(encoding, start, end) {
let loweredCase = false;
if (start === undefined || start < 0)
start = 0;
if (start > this.length)
return "";
if (end === undefined || end > this.length)
end = this.length;
if (end <= 0)
return "";
if (end >>>= 0, start >>>= 0, 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 TypeError("Unknown encoding: " + encoding);
encoding = (encoding + "").toLowerCase(), loweredCase = true;
}
}
function swap(b, n, m) {
let i2 = b[n];
b[n] = b[m], b[m] = i2;
}
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
if (buffer.length === 0)
return -1;
if (typeof byteOffset === "string")
encoding = byteOffset, byteOffset = 0;
else if (byteOffset > 2147483647)
byteOffset = 2147483647;
else if (byteOffset < -2147483648)
byteOffset = -2147483648;
if (byteOffset = +byteOffset, Number.isNaN(byteOffset))
byteOffset = dir ? 0 : buffer.length - 1;
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;
if (typeof val === "string")
val = Buffer2.from(val, encoding);
if (Buffer2.isBuffer(val)) {
if (val.length === 0)
return -1;
return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
} else if (typeof val === "number") {
if (val = val & 255, 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 TypeError("val must be string, number or Buffer");
}
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
let indexSize = 1, arrLength = arr.length, valLength = val.length;
if (encoding !== undefined) {
if (encoding = String(encoding).toLowerCase(), 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 read2(buf, i3) {
if (indexSize === 1)
return buf[i3];
else
return buf.readUInt16BE(i3 * indexSize);
}
let i2;
if (dir) {
let foundIndex = -1;
for (i2 = byteOffset;i2 < arrLength; i2++)
if (read2(arr, i2) === read2(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
if (foundIndex === -1)
foundIndex = i2;
if (i2 - foundIndex + 1 === valLength)
return foundIndex * indexSize;
} else {
if (foundIndex !== -1)
i2 -= i2 - foundIndex;
foundIndex = -1;
}
} else {
if (byteOffset + valLength > arrLength)
byteOffset = arrLength - valLength;
for (i2 = byteOffset;i2 >= 0; i2--) {
let found = true;
for (let j = 0;j < valLength; j++)
if (read2(arr, i2 + j) !== read2(val, j)) {
found = false;
break;
}
if (found)
return i2;
}
}
return -1;
}
function hexWrite(buf, string, offset, length) {
offset = Number(offset) || 0;
let remaining = buf.length - offset;
if (!length)
length = remaining;
else if (length = Number(length), length > remaining)
length = remaining;
let strLen = string.length;
if (length > strLen / 2)
length = strLen / 2;
let i2;
for (i2 = 0;i2 < length; ++i2) {
let parsed = parseInt(string.substr(i2 * 2, 2), 16);
if (Number.isNaN(parsed))
return i2;
buf[offset + i2] = parsed;
}
return i2;
}
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 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);
}
function base64Slice(buf, start, end) {
if (start === 0 && end === buf.length)
return fromByteArray(buf);
else
return fromByteArray(buf.slice(start, end));
}
function utf8Slice(buf, start, end) {
end = Math.min(buf.length, end);
let res = [], i2 = start;
while (i2 < end) {
let firstByte = buf[i2], codePoint = null, bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i2 + bytesPerSequence <= end) {
let secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 128)
codePoint = firstByte;
break;
case 2:
if (secondByte = buf[i2 + 1], (secondByte & 192) === 128) {
if (tempCodePoint = (firstByte & 31) << 6 | secondByte & 63, tempCodePoint > 127)
codePoint = tempCodePoint;
}
break;
case 3:
if (secondByte = buf[i2 + 1], thirdByte = buf[i2 + 2], (secondByte & 192) === 128 && (thirdByte & 192) === 128) {
if (tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63, tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343))
codePoint = tempCodePoint;
}
break;
case 4:
if (secondByte = buf[i2 + 1], thirdByte = buf[i2 + 2], fourthByte = buf[i2 + 3], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
if (tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63, 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), i2 += bytesPerSequence;
}
return decodeCodePointsArray(res);
}
function decodeCodePointsArray(codePoints) {
let len2 = codePoints.length;
if (len2 <= MAX_ARGUMENTS_LENGTH)
return String.fromCharCode.apply(String, codePoints);
let res = "", i2 = 0;
while (i2 < len2)
res += String.fromCharCode.apply(String, codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH));
return res;
}
function asciiSlice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i2 = start;i2 < end; ++i2)
ret += String.fromCharCode(buf[i2] & 127);
return ret;
}
function latin1Slice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i2 = start;i2 < end; ++i2)
ret += String.fromCharCode(buf[i2]);
return ret;
}
function hexSlice(buf, start, end) {
let len2 = buf.length;
if (!start || start < 0)
start = 0;
if (!end || end < 0 || end > len2)
end = len2;
let out = "";
for (let i2 = start;i2 < end; ++i2)
out += hexSliceLookupTable[buf[i2]];
return out;
}
function utf16leSlice(buf, start, end) {
let bytes = buf.slice(start, end), res = "";
for (let i2 = 0;i2 < bytes.length - 1; i2 += 2)
res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256);
return res;
}
function checkOffset(offset, ext, length) {
if (offset % 1 !== 0 || offset < 0)
throw RangeError("offset is not uint");
if (offset + ext > length)
throw RangeError("Trying to access beyond buffer length");
}
function checkInt(buf, value, offset, ext, max, min) {
if (!Buffer2.isBuffer(buf))
throw TypeError('"buffer" argument must be a Buffer instance');
if (value > max || value < min)
throw RangeError('"value" argument is out of bounds');
if (offset + ext > buf.length)
throw RangeError("Index out of range");
}
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));
return buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, 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));
return buf[offset + 3] = hi, hi = hi >> 8, buf[offset + 2] = hi, hi = hi >> 8, buf[offset + 1] = hi, hi = hi >> 8, buf[offset] = hi, offset + 8;
}
function checkIEEE754(buf, value, offset, ext, max, min) {
if (offset + ext > buf.length)
throw RangeError("Index out of range");
if (offset < 0)
throw RangeError("Index out of range");
}
function writeFloat(buf, value, offset, littleEndian, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert)
checkIEEE754(buf, value, offset, 4, 340282346638528860000000000000000000000, -340282346638528860000000000000000000000);
return write(buf, value, offset, littleEndian, 23, 4), offset + 4;
}
function writeDouble(buf, value, offset, littleEndian, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert)
checkIEEE754(buf, value, offset, 8, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000);
return write(buf, value, offset, littleEndian, 52, 8), offset + 8;
}
function addNumericalSeparator(val) {
let res = "", i2 = val.length, start = val[0] === "-" ? 1 : 0;
for (;i2 >= start + 4; i2 -= 3)
res = `_${val.slice(i2 - 3, i2)}${res}`;
return `${val.slice(0, i2)}${res}`;
}
function checkBounds(buf, offset, byteLength2) {
if (validateNumber(offset, "offset"), buf[offset] === undefined || buf[offset + byteLength2] === undefined)
boundsError(offset, buf.length - (byteLength2 + 1));
}
function checkIntBI(value, min, max, buf, offset, byteLength2) {
if (value > max || value < min) {
let n = typeof min === "bigint" ? "n" : "", range;
if (byteLength2 > 3)
if (min === 0 || min === BigInt(0))
range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
else
range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
else
range = `>= ${min}${n} and <= ${max}${n}`;
throw new ERR_OUT_OF_RANGE("value", range, value);
}
checkBounds(buf, offset, byteLength2);
}
function validateNumber(value, name) {
if (typeof value !== "number")
throw new ERR_INVALID_ARG_TYPE(name, "number", value);
}
function boundsError(value, length, type) {
if (Math.floor(value) !== value)
throw validateNumber(value, type), new ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
if (length < 0)
throw new ERR_BUFFER_OUT_OF_BOUNDS;
throw new ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
}
function base64clean(str) {
if (str = str.split("=")[0], str = str.trim().replace(INVALID_BASE64_RE, ""), str.length < 2)
return "";
while (str.length % 4 !== 0)
str = str + "=";
return str;
}
function utf8ToBytes(string, units) {
units = units || 1 / 0;
let codePoint, length = string.length, leadSurrogate = null, bytes = [];
for (let i2 = 0;i2 < length; ++i2) {
if (codePoint = string.charCodeAt(i2), codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
continue;
} else if (i2 + 1 === length) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
continue;
}
leadSurrogate = codePoint;
continue;
}
if (codePoint < 56320) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
leadSurrogate = codePoint;
continue;
}
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
} else if (leadSurrogate) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
}
if (leadSurrogate = null, codePoint < 128) {
if ((units -= 1) < 0)
break;
bytes.push(codePoint);
} else if (codePoint < 2048) {
if ((units -= 2) < 0)
break;
bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
} else if (codePoint < 65536) {
if ((units -= 3) < 0)
break;
bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
} else if (codePoint < 1114112) {
if ((units -= 4) < 0)
break;
bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
} else
throw Error("Invalid code point");
}
return bytes;
}
function asciiToBytes(str) {
let byteArray = [];
for (let i2 = 0;i2 < str.length; ++i2)
byteArray.push(str.charCodeAt(i2) & 255);
return byteArray;
}
function utf16leToBytes(str, units) {
let c, hi, lo, byteArray = [];
for (let i2 = 0;i2 < str.length; ++i2) {
if ((units -= 2) < 0)
break;
c = str.charCodeAt(i2), hi = c >> 8, lo = c % 256, byteArray.push(lo), byteArray.push(hi);
}
return byteArray;
}
function base64ToBytes(str) {
return toByteArray(base64clean(str));
}
function blitBuffer(src, dst, offset, length) {
let i2;
for (i2 = 0;i2 < length; ++i2) {
if (i2 + offset >= dst.length || i2 >= src.length)
break;
dst[i2 + offset] = src[i2];
}
return i2;
}
function isInstance(obj, type) {
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
}
function defineBigIntMethod(fn) {
return typeof BigInt > "u" ? BufferBigIntNotDefined : fn;
}
function BufferBigIntNotDefined() {
throw Error("BigInt not supported");
}
function notimpl(name) {
return () => {
throw Error(name + " is not implemented for node:buffer browser polyfill");
};
}
var lookup, revLookup, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i, len, customInspectSymbol, INSPECT_MAX_BYTES = 50, kMaxLength = 2147483647, kStringMaxLength = 536870888, btoa, atob, File, Blob2, constants, ERR_BUFFER_OUT_OF_BOUNDS, ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE, MAX_ARGUMENTS_LENGTH = 4096, INVALID_BASE64_RE, hexSliceLookupTable, resolveObjectURL, isUtf8, isAscii = (str) => {
for (let char of str)
if (char.charCodeAt(0) > 127)
return false;
return true;
}, transcode, buffer_default;
var init_buffer = __esm(() => {
lookup = [];
revLookup = [];
for (i = 0, len = code.length;i < len; ++i)
lookup[i] = code[i], revLookup[code.charCodeAt(i)] = i;
revLookup[45] = 62;
revLookup[95] = 63;
customInspectSymbol = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
btoa = globalThis.btoa;
atob = globalThis.atob;
File = globalThis.File;
Blob2 = globalThis.Blob;
constants = { MAX_LENGTH: kMaxLength, MAX_STRING_LENGTH: kStringMaxLength };
ERR_BUFFER_OUT_OF_BOUNDS = 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);
ERR_INVALID_ARG_TYPE = E("ERR_INVALID_ARG_TYPE", function(name, actual) {
return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
}, TypeError);
ERR_OUT_OF_RANGE = E("ERR_OUT_OF_RANGE", function(str, range, input) {
let msg = `The value of "${str}" is out of range.`, received = input;
if (Number.isInteger(input) && Math.abs(input) > 4294967296)
received = addNumericalSeparator(String(input));
else if (typeof input === "bigint") {
if (received = String(input), input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32)))
received = addNumericalSeparator(received);
received += "n";
}
return msg += ` It must be ${range}. Received ${received}`, msg;
}, RangeError);
Object.defineProperty(Buffer2.prototype, "parent", { enumerable: true, get: function() {
if (!Buffer2.isBuffer(this))
return;
return this.buffer;
} });
Object.defineProperty(Buffer2.prototype, "offset", { enumerable: true, get: function() {
if (!Buffer2.isBuffer(this))
return;
return this.byteOffset;
} });
Buffer2.poolSize = 8192;
Buffer2.from = function(value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length);
};
Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
Object.setPrototypeOf(Buffer2, Uint8Array);
Buffer2.alloc = function(size, fill, encoding) {
return alloc(size, fill, encoding);
};
Buffer2.allocUnsafe = function(size) {
return allocUnsafe(size);
};
Buffer2.allocUnsafeSlow = function(size) {
return allocUnsafe(size);
};
Buffer2.isBuffer = function(b) {
return b != null && b._isBuffer === true && b !== Buffer2.prototype;
};
Buffer2.compare = function(a, b) {
if (isInstance(a, Uint8Array))
a = Buffer2.from(a, a.offset, a.byteLength);
if (isInstance(b, Uint8Array))
b = Buffer2.from(b, b.offset, b.byteLength);
if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b))
throw TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
if (a === b)
return 0;
let x = a.length, y = b.length;
for (let i2 = 0, len2 = Math.min(x, y);i2 < len2; ++i2)
if (a[i2] !== b[i2]) {
x = a[i2], y = b[i2];
break;
}
if (x < y)
return -1;
if (y < x)
return 1;
return 0;
};
Buffer2.isEncoding = function(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;
}
};
Buffer2.concat = function(list, length) {
if (!Array.isArray(list))
throw TypeError('"list" argument must be an Array of Buffers');
if (list.length === 0)
return Buffer2.alloc(0);
let i2;
if (length === undefined) {
length = 0;
for (i2 = 0;i2 < list.length; ++i2)
length += list[i2].length;
}
let buffer = Buffer2.allocUnsafe(length), pos = 0;
for (i2 = 0;i2 < list.length; ++i2) {
let buf = list[i2];
if (isInstance(buf, Uint8Array))
if (pos + buf.length > buffer.length) {
if (!Buffer2.isBuffer(buf))
buf = Buffer2.from(buf);
buf.copy(buffer, pos);
} else
Uint8Array.prototype.set.call(buffer, buf, pos);
else if (!Buffer2.isBuffer(buf))
throw TypeError('"list" argument must be an Array of Buffers');
else
buf.copy(buffer, pos);
pos += buf.length;
}
return buffer;
};
Buffer2.byteLength = byteLength;
Buffer2.prototype._isBuffer = true;
Buffer2.prototype.swap16 = function() {
let len2 = this.length;
if (len2 % 2 !== 0)
throw RangeError("Buffer size must be a multiple of 16-bits");
for (let i2 = 0;i2 < len2; i2 += 2)
swap(this, i2, i2 + 1);
return this;
};
Buffer2.prototype.swap32 = function() {
let len2 = this.length;
if (len2 % 4 !== 0)
throw RangeError("Buffer size must be a multiple of 32-bits");
for (let i2 = 0;i2 < len2; i2 += 4)
swap(this, i2, i2 + 3), swap(this, i2 + 1, i2 + 2);
return this;
};
Buffer2.prototype.swap64 = function() {
let len2 = this.length;
if (len2 % 8 !== 0)
throw RangeError("Buffer size must be a multiple of 64-bits");
for (let i2 = 0;i2 < len2; i2 += 8)
swap(this, i2, i2 + 7), swap(this, i2 + 1, i2 + 6), swap(this, i2 + 2, i2 + 5), swap(this, i2 + 3, i2 + 4);
return this;
};
Buffer2.prototype.toString = function() {
let length = this.length;
if (length === 0)
return "";
if (arguments.length === 0)
return utf8Slice(this, 0, length);
return slowToString.apply(this, arguments);
};
Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
Buffer2.prototype.equals = function(b) {
if (!Buffer2.isBuffer(b))
throw TypeError("Argument must be a Buffer");
if (this === b)
return true;
return Buffer2.compare(this, b) === 0;
};
Buffer2.prototype.inspect = function() {
let str = "", max = INSPECT_MAX_BYTES;
if (str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(), this.length > max)
str += " ... ";
return "<Buffer " + str + ">";
};
if (customInspectSymbol)
Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
Buffer2.prototype.compare = function(target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array))
target = Buffer2.from(target, target.offset, target.byteLength);
if (!Buffer2.isBuffer(target))
throw 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 RangeError("out of range index");
if (thisStart >= thisEnd && start >= end)
return 0;
if (thisStart >= thisEnd)
return -1;
if (start >= end)
return 1;
if (start >>>= 0, end >>>= 0, thisStart >>>= 0, thisEnd >>>= 0, this === target)
return 0;
let x = thisEnd - thisStart, y = end - start, len2 = Math.min(x, y), thisCopy = this.slice(thisStart, thisEnd), targetCopy = target.slice(start, end);
for (let i2 = 0;i2 < len2; ++i2)
if (thisCopy[i2] !== targetCopy[i2]) {
x = thisCopy[i2], y = targetCopy[i2];
break;
}
if (x < y)
return -1;
if (y < x)
return 1;
return 0;
};
Buffer2.prototype.includes = function(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
};
Buffer2.prototype.indexOf = function(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
};
Buffer2.prototype.lastIndexOf = function(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
};
Buffer2.prototype.write = function(string, offset, length, encoding) {
if (offset === undefined)
encoding = "utf8", length = this.length, offset = 0;
else if (length === undefined && typeof offset === "string")
encoding = offset, length = this.length, offset = 0;
else if (isFinite(offset))
if (offset = offset >>> 0, isFinite(length)) {
if (length = length >>> 0, encoding === undefined)
encoding = "utf8";
} else
encoding = length, length = undefined;
else
throw Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
let remaining = this.length - offset;
if (length === undefined || length > remaining)
length = remaining;
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length)
throw RangeError("Attempt to write outside buffer bounds");
if (!encoding)
encoding = "utf8";
let 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":
case "latin1":
case "binary":
return asciiWrite(this, string, offset, length);
case "base64":
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 TypeError("Unknown encoding: " + encoding);
encoding = ("" + encoding).toLowerCase(), loweredCase = true;
}
};
Buffer2.prototype.toJSON = function() {
return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
};
Buffer2.prototype.slice = function(start, end) {
let len2 = this.length;
if (start = ~~start, end = end === undefined ? len2 : ~~end, start < 0) {
if (start += len2, start < 0)
start = 0;
} else if (start > len2)
start = len2;
if (end < 0) {
if (end += len2, end < 0)
end = 0;
} else if (end > len2)
end = len2;
if (end < start)
end = start;
let newBuf = this.subarray(start, end);
return Object.setPrototypeOf(newBuf, Buffer2.prototype), newBuf;
};
Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function(offset, byteLength2, noAssert) {
if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
checkOffset(offset, byteLength2, this.length);
let val = this[offset], mul = 1, i2 = 0;
while (++i2 < byteLength2 && (mul *= 256))
val += this[offset + i2] * mul;
return val;
};
Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function(offset, byteLength2, noAssert) {
if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
checkOffset(offset, byteLength2, this.length);
let val = this[offset + --byteLength2], mul = 1;
while (byteLength2 > 0 && (mul *= 256))
val += this[offset + --byteLength2] * mul;
return val;
};
Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 1, this.length);
return this[offset];
};
Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 2, this.length);
return this[offset] | this[offset + 1] << 8;
};
Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 2, this.length);
return this[offset] << 8 | this[offset + 1];
};
Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 4, this.length);
return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
};
Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 4, this.length);
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
};
Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
if (first === undefined || last === undefined)
boundsError(offset, this.length - 8);
let lo = first + this[++offset] * 256 + this[++offset] * 65536 + this[++offset] * 16777216, hi = this[++offset] + this[++offset] * 256 + this[++offset] * 65536 + last * 16777216;
return BigInt(lo) + (BigInt(hi) << BigInt(32));
});
Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
if (first === undefined || last === undefined)
boundsError(offset, this.length - 8);
let hi = first * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + this[++offset], lo = this[++offset] * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + last;
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
});
Buffer2.prototype.readIntLE = function(offset, byteLength2, noAssert) {
if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
checkOffset(offset, byteLength2, this.length);
let val = this[offset], mul = 1, i2 = 0;
while (++i2 < byteLength2 && (mul *= 256))
val += this[offset + i2] * mul;
if (mul *= 128, val >= mul)
val -= Math.pow(2, 8 * byteLength2);
return val;
};
Buffer2.prototype.readIntBE = function(offset, byteLength2, noAssert) {
if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
checkOffset(offset, byteLength2, this.length);
let i2 = byteLength2, mul = 1, val = this[offset + --i2];
while (i2 > 0 && (mul *= 256))
val += this[offset + --i2] * mul;
if (mul *= 128, val >= mul)
val -= Math.pow(2, 8 * byteLength2);
return val;
};
Buffer2.prototype.readInt8 = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 1, this.length);
if (!(this[offset] & 128))
return this[offset];
return (255 - this[offset] + 1) * -1;
};
Buffer2.prototype.readInt16LE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 2, this.length);
let val = this[offset] | this[offset + 1] << 8;
return val & 32768 ? val | 4294901760 : val;
};
Buffer2.prototype.readInt16BE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 2, this.length);
let val = this[offset + 1] | this[offset] << 8;
return val & 32768 ? val | 4294901760 : val;
};
Buffer2.prototype.readInt32LE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 4, this.length);
return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
};
Buffer2.prototype.readInt32BE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 4, this.length);
return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
};
Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
if (first === undefined || last === undefined)
boundsError(offset, this.length - 8);
let val = this[offset + 4] + this[offset + 5] * 256 + this[offset + 6] * 65536 + (last << 24);
return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 256 + this[++offset] * 65536 + this[++offset] * 16777216);
});
Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
if (first === undefined || last === undefined)
boundsError(offset, this.length - 8);
let val = (first << 24) + this[++offset] * 65536 + this[++offset] * 256 + this[++offset];
return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + last);
});
Buffer2.prototype.readFloatLE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 4, this.length);
return read(this, offset, true, 23, 4);
};
Buffer2.prototype.readFloatBE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 4, this.length);
return read(this, offset, false, 23, 4);
};
Buffer2.prototype.readDoubleLE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 8, this.length);
return read(this, offset, true, 52, 8);
};
Buffer2.prototype.readDoubleBE = function(offset, noAssert) {
if (offset = offset >>> 0, !noAssert)
checkOffset(offset, 8, this.length);
return read(this, offset, false, 52, 8);
};
Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
checkInt(this, value, offset, byteLength2, maxBytes, 0);
}
let mul = 1, i2 = 0;
this[offset] = value & 255;
while (++i2 < byteLength2 && (mul *= 256))
this[offset + i2] = value / mul & 255;
return offset + byteLength2;
};
Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
checkInt(this, value, offset, byteLength2, maxBytes, 0);
}
let i2 = byteLength2 - 1, mul = 1;
this[offset + i2] = value & 255;
while (--i2 >= 0 && (mul *= 256))
this[offset + i2] = value / mul & 255;
return offset + byteLength2;
};
Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function(value, offset, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert)
checkInt(this, value, offset, 1, 255, 0);
return this[offset] = value & 255, offset + 1;
};
Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function(value, offset, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert)
checkInt(this, value, offset, 2, 65535, 0);
return this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
};
Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function(value, offset, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert)
checkInt(this, value, offset, 2, 65535, 0);
return this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
};
Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function(value, offset, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert)
checkInt(this, value, offset, 4, 4294967295, 0);
return this[offset + 3] = value >>> 24, this[offset + 2] = value >>> 16, this[offset + 1] = value >>> 8, this[offset] = value & 255, offset + 4;
};
Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function(value, offset, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert)
checkInt(this, value, offset, 4, 4294967295, 0);
return this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = value & 255, offset + 4;
};
Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
});
Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function(value, offset = 0) {
return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
});
Buffer2.prototype.writeIntLE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert) {
let limit = Math.pow(2, 8 * byteLength2 - 1);
checkInt(this, value, offset, byteLength2, limit - 1, -limit);
}
let i2 = 0, mul = 1, sub = 0;
this[offset] = value & 255;
while (++i2 < byteLength2 && (mul *= 256)) {
if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0)
sub = 1;
this[offset + i2] = (value / mul >> 0) - sub & 255;
}
return offset + byteLength2;
};
Buffer2.prototype.writeIntBE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset