(() => {
var exports$3 = {}, _dewExec$2 = !1;
function dew$2() {
if (_dewExec$2) return exports$3;
_dewExec$2 = !0, exports$3.byteLength = byteLength, exports$3.toByteArray = toByteArray, exports$3.fromByteArray = fromByteArray;
for (var lookup = [], revLookup = [], Arr = typeof Uint8Array != "undefined" ? Uint8Array : Array, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i = 0, len = code.length; i < len; ++i)
lookup[i] = code[i], revLookup[code.charCodeAt(i)] = i;
revLookup[45] = 62, revLookup[95] = 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("=");
validLen === -1 && (validLen = len2);
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
return [validLen, placeHoldersLen];
}
function byteLength(b64) {
var lens = getLens(b64), validLen = lens[0], 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, lens = getLens(b64), validLen = lens[0], placeHoldersLen = lens[1], arr = new Arr(_byteLength(b64, 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;
return placeHoldersLen === 2 && (tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4, arr[curByte++] = tmp & 255), 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), 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) {
for (var tmp, output = [], 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) {
for (var tmp, len2 = uint8.length, extraBytes = len2 % 3, parts = [], maxChunkLength = 16383, i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength)
parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
return extraBytes === 1 ? (tmp = uint8[len2 - 1], parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==")) : extraBytes === 2 && (tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1], parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=")), parts.join("");
}
return exports$3;
}
var exports$2 = {}, _dewExec$1 = !1;
function dew$1() {
if (_dewExec$1) return exports$2;
_dewExec$1 = !0;
return exports$2.read = function(buffer, offset, isLE, mLen, nBytes) {
var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i];
for (i += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8)
;
for (m = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8)
;
if (e === 0)
e = 1 - eBias;
else {
if (e === eMax)
return m ? NaN : (s ? -1 : 1) * (1 / 0);
m = m + Math.pow(2, mLen), e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
}, exports$2.write = function(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, i = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
for (value = Math.abs(value), isNaN(value) || value === 1 / 0 ? (m = isNaN(value) ? 1 : 0, e = eMax) : (e = Math.floor(Math.log(value) / Math.LN2), value * (c = Math.pow(2, -e)) < 1 && (e--, c *= 2), e + eBias >= 1 ? value += rt / c : value += rt * Math.pow(2, 1 - eBias), value * c >= 2 && (e++, c /= 2), e + eBias >= eMax ? (m = 0, e = eMax) : e + eBias >= 1 ? (m = (value * c - 1) * Math.pow(2, mLen), e = e + eBias) : (m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen), e = 0)); mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8)
;
for (e = e << mLen | m, eLen += mLen; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8)
;
buffer[offset + i - d] |= s * 128;
}, exports$2;
}
var exports$1 = {}, _dewExec = !1;
function dew() {
if (_dewExec) return exports$1;
_dewExec = !0;
let base64 = dew$2(), ieee754 = dew$1(), customInspectSymbol = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
exports$1.Buffer = Buffer2, exports$1.SlowBuffer = SlowBuffer, exports$1.INSPECT_MAX_BYTES = 50;
let K_MAX_LENGTH = 2147483647;
exports$1.kMaxLength = K_MAX_LENGTH, Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport(), !Buffer2.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 {
let arr = new Uint8Array(1), proto = {
foo: function() {
return 42;
}
};
return Object.setPrototypeOf(proto, Uint8Array.prototype), Object.setPrototypeOf(arr, proto), arr.foo() === 42;
} catch {
return !1;
}
}
Object.defineProperty(Buffer2.prototype, "parent", {
enumerable: !0,
get: function() {
if (Buffer2.isBuffer(this))
return this.buffer;
}
}), Object.defineProperty(Buffer2.prototype, "offset", {
enumerable: !0,
get: function() {
if (Buffer2.isBuffer(this))
return this.byteOffset;
}
});
function createBuffer(length) {
if (length > K_MAX_LENGTH)
throw new RangeError('The value "' + length + '" is invalid for option "size"');
let buf = new Uint8Array(length);
return Object.setPrototypeOf(buf, Buffer2.prototype), buf;
}
function Buffer2(arg, encodingOrOffset, length) {
if (typeof arg == "number") {
if (typeof encodingOrOffset == "string")
throw new TypeError('The "string" argument must be of type string. Received type number');
return allocUnsafe(arg);
}
return from(arg, encodingOrOffset, length);
}
Buffer2.poolSize = 8192;
function from(value, encodingOrOffset, length) {
if (typeof value == "string")
return fromString(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) || 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');
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 != "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] == "function")
return Buffer2.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);
}
Buffer2.from = function(value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length);
}, Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype), Object.setPrototypeOf(Buffer2, Uint8Array);
function assertSize(size) {
if (typeof size != "number")
throw new TypeError('"size" argument must be of type number');
if (size < 0)
throw new RangeError('The value "' + size + '" is invalid for option "size"');
}
function alloc(size, fill, encoding) {
return assertSize(size), size <= 0 ? createBuffer(size) : fill !== void 0 ? typeof encoding == "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill) : createBuffer(size);
}
Buffer2.alloc = function(size, fill, encoding) {
return alloc(size, fill, encoding);
};
function allocUnsafe(size) {
return assertSize(size), createBuffer(size < 0 ? 0 : checked(size) | 0);
}
Buffer2.allocUnsafe = function(size) {
return allocUnsafe(size);
}, Buffer2.allocUnsafeSlow = function(size) {
return allocUnsafe(size);
};
function fromString(string, encoding) {
if ((typeof encoding != "string" || encoding === "") && (encoding = "utf8"), !Buffer2.isEncoding(encoding))
throw new TypeError("Unknown encoding: " + encoding);
let length = byteLength(string, encoding) | 0, buf = createBuffer(length), actual = buf.write(string, encoding);
return actual !== length && (buf = buf.slice(0, actual)), buf;
}
function fromArrayLike(array) {
let length = array.length < 0 ? 0 : checked(array.length) | 0, buf = createBuffer(length);
for (let i = 0; i < length; i += 1)
buf[i] = array[i] & 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 new RangeError('"offset" is outside of buffer bounds');
if (array.byteLength < byteOffset + (length || 0))
throw new RangeError('"length" is outside of buffer bounds');
let buf;
return byteOffset === void 0 && length === void 0 ? buf = new Uint8Array(array) : length === void 0 ? buf = new Uint8Array(array, byteOffset) : buf = new Uint8Array(array, byteOffset, length), Object.setPrototypeOf(buf, Buffer2.prototype), buf;
}
function fromObject(obj) {
if (Buffer2.isBuffer(obj)) {
let len = checked(obj.length) | 0, buf = createBuffer(len);
return buf.length === 0 || obj.copy(buf, 0, 0, len), buf;
}
if (obj.length !== void 0)
return typeof obj.length != "number" || numberIsNaN(obj.length) ? createBuffer(0) : fromArrayLike(obj);
if (obj.type === "Buffer" && Array.isArray(obj.data))
return fromArrayLike(obj.data);
}
function checked(length) {
if (length >= K_MAX_LENGTH)
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
return length | 0;
}
function SlowBuffer(length) {
return +length != length && (length = 0), Buffer2.alloc(+length);
}
Buffer2.isBuffer = function(b) {
return b != null && b._isBuffer === !0 && b !== Buffer2.prototype;
}, Buffer2.compare = function(a, b) {
if (isInstance(a, Uint8Array) && (a = Buffer2.from(a, a.offset, a.byteLength)), isInstance(b, Uint8Array) && (b = Buffer2.from(b, b.offset, b.byteLength)), !Buffer2.isBuffer(a) || !Buffer2.isBuffer(b))
throw new 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 i = 0, len = Math.min(x, y); i < len; ++i)
if (a[i] !== b[i]) {
x = a[i], y = b[i];
break;
}
return x < y ? -1 : y < x ? 1 : 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 !0;
default:
return !1;
}
}, Buffer2.concat = function(list, length) {
if (!Array.isArray(list))
throw new TypeError('"list" argument must be an Array of Buffers');
if (list.length === 0)
return Buffer2.alloc(0);
let i;
if (length === void 0)
for (length = 0, i = 0; i < list.length; ++i)
length += list[i].length;
let buffer = Buffer2.allocUnsafe(length), pos = 0;
for (i = 0; i < list.length; ++i) {
let buf = list[i];
if (isInstance(buf, Uint8Array))
pos + buf.length > buffer.length ? (Buffer2.isBuffer(buf) || (buf = Buffer2.from(buf)), buf.copy(buffer, pos)) : Uint8Array.prototype.set.call(buffer, buf, pos);
else if (Buffer2.isBuffer(buf))
buf.copy(buffer, pos);
else
throw new TypeError('"list" argument must be an Array of Buffers');
pos += buf.length;
}
return buffer;
};
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 new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
let len = string.length, mustMatch = arguments.length > 2 && arguments[2] === !0;
if (!mustMatch && len === 0) return 0;
let loweredCase = !1;
for (; ; )
switch (encoding) {
case "ascii":
case "latin1":
case "binary":
return len;
case "utf8":
case "utf-8":
return utf8ToBytes(string).length;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return len * 2;
case "hex":
return len >>> 1;
case "base64":
return base64ToBytes(string).length;
default:
if (loweredCase)
return mustMatch ? -1 : utf8ToBytes(string).length;
encoding = ("" + encoding).toLowerCase(), loweredCase = !0;
}
}
Buffer2.byteLength = byteLength;
function slowToString(encoding, start, end) {
let loweredCase = !1;
if ((start === void 0 || start < 0) && (start = 0), start > this.length || ((end === void 0 || end > this.length) && (end = this.length), end <= 0) || (end >>>= 0, start >>>= 0, end <= start))
return "";
for (encoding || (encoding = "utf8"); ; )
switch (encoding) {
case "hex":
return hexSlice(this, start, end);
case "utf8":
case "utf-8":
return utf8Slice(this, start, end);
case "ascii":
return asciiSlice(this, start, end);
case "latin1":
case "binary":
return latin1Slice(this, start, end);
case "base64":
return base64Slice(this, start, end);
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return utf16leSlice(this, start, end);
default:
if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
encoding = (encoding + "").toLowerCase(), loweredCase = !0;
}
}
Buffer2.prototype._isBuffer = !0;
function swap(b, n, m) {
let i = b[n];
b[n] = b[m], b[m] = i;
}
Buffer2.prototype.swap16 = function() {
let len = this.length;
if (len % 2 !== 0)
throw new RangeError("Buffer size must be a multiple of 16-bits");
for (let i = 0; i < len; i += 2)
swap(this, i, i + 1);
return this;
}, Buffer2.prototype.swap32 = function() {
let len = this.length;
if (len % 4 !== 0)
throw new RangeError("Buffer size must be a multiple of 32-bits");
for (let i = 0; i < len; i += 4)
swap(this, i, i + 3), swap(this, i + 1, i + 2);
return this;
}, Buffer2.prototype.swap64 = function() {
let len = this.length;
if (len % 8 !== 0)
throw new RangeError("Buffer size must be a multiple of 64-bits");
for (let i = 0; i < len; i += 8)
swap(this, i, i + 7), swap(this, i + 1, i + 6), swap(this, i + 2, i + 5), swap(this, i + 3, i + 4);
return this;
}, Buffer2.prototype.toString = function() {
let length = this.length;
return length === 0 ? "" : arguments.length === 0 ? utf8Slice(this, 0, length) : slowToString.apply(this, arguments);
}, Buffer2.prototype.toLocaleString = Buffer2.prototype.toString, Buffer2.prototype.equals = function(b) {
if (!Buffer2.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
return this === b ? !0 : Buffer2.compare(this, b) === 0;
}, Buffer2.prototype.inspect = function() {
let str = "", max = exports$1.INSPECT_MAX_BYTES;
return str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(), this.length > max && (str += " ... "), "<Buffer " + str + ">";
}, 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)), !Buffer2.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), end === void 0 && (end = target ? target.length : 0), thisStart === void 0 && (thisStart = 0), thisEnd === void 0 && (thisEnd = this.length), 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;
if (start >>>= 0, end >>>= 0, thisStart >>>= 0, thisEnd >>>= 0, this === target) return 0;
let x = thisEnd - thisStart, y = end - start, len = Math.min(x, y), thisCopy = this.slice(thisStart, thisEnd), targetCopy = target.slice(start, end);
for (let i = 0; i < len; ++i)
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i], y = targetCopy[i];
break;
}
return x < y ? -1 : y < x ? 1 : 0;
};
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
if (buffer.length === 0) return -1;
if (typeof byteOffset == "string" ? (encoding = byteOffset, byteOffset = 0) : byteOffset > 2147483647 ? byteOffset = 2147483647 : byteOffset < -2147483648 && (byteOffset = -2147483648), byteOffset = +byteOffset, numberIsNaN(byteOffset) && (byteOffset = dir ? 0 : buffer.length - 1), byteOffset < 0 && (byteOffset = buffer.length + byteOffset), byteOffset >= buffer.length) {
if (dir) return -1;
byteOffset = buffer.length - 1;
} else if (byteOffset < 0)
if (dir) byteOffset = 0;
else return -1;
if (typeof val == "string" && (val = Buffer2.from(val, encoding)), Buffer2.isBuffer(val))
return val.length === 0 ? -1 : arrayIndexOf(buffer, val, byteOffset, encoding, dir);
if (typeof val == "number")
return val = val & 255, typeof Uint8Array.prototype.indexOf == "function" ? dir ? Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) : Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) : arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
throw new 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 !== void 0 && (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 read(buf, i2) {
return indexSize === 1 ? buf[i2] : buf.readUInt16BE(i2 * indexSize);
}
let i;
if (dir) {
let foundIndex = -1;
for (i = byteOffset; i < arrLength; i++)
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1 && (foundIndex = i), i - foundIndex + 1 === valLength) return foundIndex * indexSize;
} else
foundIndex !== -1 && (i -= i - foundIndex), foundIndex = -1;
} else
for (byteOffset + valLength > arrLength && (byteOffset = arrLength - valLength), i = byteOffset; i >= 0; i--) {
let found = !0;
for (let j = 0; j < valLength; j++)
if (read(arr, i + j) !== read(val, j)) {
found = !1;
break;
}
if (found) return i;
}
return -1;
}
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, !0);
}, Buffer2.prototype.lastIndexOf = function(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, !1);
};
function hexWrite(buf, string, offset, length) {
offset = Number(offset) || 0;
let remaining = buf.length - offset;
length ? (length = Number(length), length > remaining && (length = remaining)) : length = remaining;
let strLen = string.length;
length > strLen / 2 && (length = strLen / 2);
let i;
for (i = 0; i < length; ++i) {
let parsed = parseInt(string.substr(i * 2, 2), 16);
if (numberIsNaN(parsed)) return i;
buf[offset + i] = parsed;
}
return i;
}
function utf8Write(buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
}
function asciiWrite(buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length);
}
function 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);
}
Buffer2.prototype.write = function(string, offset, length, encoding) {
if (offset === void 0)
encoding = "utf8", length = this.length, offset = 0;
else if (length === void 0 && typeof offset == "string")
encoding = offset, length = this.length, offset = 0;
else if (isFinite(offset))
offset = offset >>> 0, isFinite(length) ? (length = length >>> 0, encoding === void 0 && (encoding = "utf8")) : (encoding = length, length = void 0);
else
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
let remaining = this.length - offset;
if ((length === void 0 || length > remaining) && (length = remaining), string.length > 0 && (length < 0 || offset < 0) || offset > this.length)
throw new RangeError("Attempt to write outside buffer bounds");
encoding || (encoding = "utf8");
let loweredCase = !1;
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 new TypeError("Unknown encoding: " + encoding);
encoding = ("" + encoding).toLowerCase(), loweredCase = !0;
}
}, Buffer2.prototype.toJSON = function() {
return {
type: "Buffer",
data: Array.prototype.slice.call(this._arr || this, 0)
};
};
function base64Slice(buf, start, end) {
return start === 0 && end === buf.length ? base64.fromByteArray(buf) : base64.fromByteArray(buf.slice(start, end));
}
function utf8Slice(buf, start, end) {
end = Math.min(buf.length, end);
let res = [], i = start;
for (; i < end; ) {
let firstByte = buf[i], codePoint = null, bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i + bytesPerSequence <= end) {
let secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
firstByte < 128 && (codePoint = firstByte);
break;
case 2:
secondByte = buf[i + 1], (secondByte & 192) === 128 && (tempCodePoint = (firstByte & 31) << 6 | secondByte & 63, tempCodePoint > 127 && (codePoint = tempCodePoint));
break;
case 3:
secondByte = buf[i + 1], thirdByte = buf[i + 2], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63, tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343) && (codePoint = tempCodePoint));
break;
case 4:
secondByte = buf[i + 1], thirdByte = buf[i + 2], fourthByte = buf[i + 3], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128 && (tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63, tempCodePoint > 65535 && tempCodePoint < 1114112 && (codePoint = tempCodePoint));
}
}
codePoint === null ? (codePoint = 65533, bytesPerSequence = 1) : codePoint > 65535 && (codePoint -= 65536, res.push(codePoint >>> 10 & 1023 | 55296), codePoint = 56320 | codePoint & 1023), res.push(codePoint), i += bytesPerSequence;
}
return decodeCodePointsArray(res);
}
let MAX_ARGUMENTS_LENGTH = 4096;
function decodeCodePointsArray(codePoints) {
let len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH)
return String.fromCharCode.apply(String, codePoints);
let res = "", i = 0;
for (; i < len; )
res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
return res;
}
function asciiSlice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i)
ret += String.fromCharCode(buf[i] & 127);
return ret;
}
function latin1Slice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i)
ret += String.fromCharCode(buf[i]);
return ret;
}
function hexSlice(buf, start, end) {
let len = buf.length;
(!start || start < 0) && (start = 0), (!end || end < 0 || end > len) && (end = len);
let out = "";
for (let i = start; i < end; ++i)
out += hexSliceLookupTable[buf[i]];
return out;
}
function utf16leSlice(buf, start, end) {
let bytes = buf.slice(start, end), res = "";
for (let i = 0; i < bytes.length - 1; i += 2)
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
return res;
}
Buffer2.prototype.slice = function(start, end) {
let len = this.length;
start = ~~start, end = end === void 0 ? len : ~~end, start < 0 ? (start += len, start < 0 && (start = 0)) : start > len && (start = len), end < 0 ? (end += len, end < 0 && (end = 0)) : end > len && (end = len), end < start && (end = start);
let newBuf = this.subarray(start, end);
return Object.setPrototypeOf(newBuf, Buffer2.prototype), newBuf;
};
function checkOffset(offset, ext, length) {
if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
}
Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let val = this[offset], mul = 1, i = 0;
for (; ++i < byteLength2 && (mul *= 256); )
val += this[offset + i] * mul;
return val;
}, Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let val = this[offset + --byteLength2], mul = 1;
for (; byteLength2 > 0 && (mul *= 256); )
val += this[offset + --byteLength2] * mul;
return val;
}, Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 1, this.length), this[offset];
}, Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 2, this.length), this[offset] | this[offset + 1] << 8;
}, Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 2, this.length), this[offset] << 8 | this[offset + 1];
}, Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
}, Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), 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];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24, hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
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];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset], lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
}), Buffer2.prototype.readIntLE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let val = this[offset], mul = 1, i = 0;
for (; ++i < byteLength2 && (mul *= 256); )
val += this[offset + i] * mul;
return mul *= 128, val >= mul && (val -= Math.pow(2, 8 * byteLength2)), val;
}, Buffer2.prototype.readIntBE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let i = byteLength2, mul = 1, val = this[offset + --i];
for (; i > 0 && (mul *= 256); )
val += this[offset + --i] * mul;
return mul *= 128, val >= mul && (val -= Math.pow(2, 8 * byteLength2)), val;
}, Buffer2.prototype.readInt8 = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 1, this.length), this[offset] & 128 ? (255 - this[offset] + 1) * -1 : this[offset];
}, Buffer2.prototype.readInt16LE = function(offset, noAssert) {
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) {
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) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
}, Buffer2.prototype.readInt32BE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), 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];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let 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);
}), Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let 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);
}), Buffer2.prototype.readFloatLE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), ieee754.read(this, offset, !0, 23, 4);
}, Buffer2.prototype.readFloatBE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), ieee754.read(this, offset, !1, 23, 4);
}, Buffer2.prototype.readDoubleLE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 8, this.length), ieee754.read(this, offset, !0, 52, 8);
}, Buffer2.prototype.readDoubleBE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 8, this.length), ieee754.read(this, offset, !1, 52, 8);
};
function checkInt(buf, value, offset, ext, max, min) {
if (!Buffer2.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
if (offset + ext > buf.length) throw new RangeError("Index out of range");
}
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, i = 0;
for (this[offset] = value & 255; ++i < byteLength2 && (mul *= 256); )
this[offset + i] = 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 i = byteLength2 - 1, mul = 1;
for (this[offset + i] = value & 255; --i >= 0 && (mul *= 256); )
this[offset + i] = value / mul & 255;
return offset + byteLength2;
}, Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 1, 255, 0), this[offset] = value & 255, offset + 1;
}, Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 65535, 0), this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
}, Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 65535, 0), this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
}, Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, 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, offset + 4;
}, Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, 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, 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));
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;
}
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 i = 0, mul = 1, sub = 0;
for (this[offset] = value & 255; ++i < byteLength2 && (mul *= 256); )
value < 0 && sub === 0 && this[offset + i - 1] !== 0 && (sub = 1), this[offset + i] = (value / mul >> 0) - sub & 255;
return offset + byteLength2;
}, Buffer2.prototype.writeIntBE = 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 i = byteLength2 - 1, mul = 1, sub = 0;
for (this[offset + i] = value & 255; --i >= 0 && (mul *= 256); )
value < 0 && sub === 0 && this[offset + i + 1] !== 0 && (sub = 1), this[offset + i] = (value / mul >> 0) - sub & 255;
return offset + byteLength2;
}, Buffer2.prototype.writeInt8 = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 1, 127, -128), value < 0 && (value = 255 + value + 1), this[offset] = value & 255, offset + 1;
}, Buffer2.prototype.writeInt16LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 32767, -32768), this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
}, Buffer2.prototype.writeInt16BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 32767, -32768), this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
}, Buffer2.prototype.writeInt32LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, 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, offset + 4;
}, Buffer2.prototype.writeInt32BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 4, 2147483647, -2147483648), 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, offset + 4;
}, Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
}), Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function(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");
}
function writeFloat(buf, value, offset, littleEndian, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkIEEE754(buf, value, offset, 4), ieee754.write(buf, value, offset, littleEndian, 23, 4), offset + 4;
}
Buffer2.prototype.writeFloatLE = function(value, offset, noAssert) {
return writeFloat(this, value, offset, !0, noAssert);
}, Buffer2.prototype.writeFloatBE = function(value, offset, noAssert) {
return writeFloat(this, value, offset, !1, noAssert);
};
function writeDouble(buf, value, offset, littleEndian, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkIEEE754(buf, value, offset, 8), ieee754.write(buf, value, offset, littleEndian, 52, 8), offset + 8;
}
Buffer2.prototype.writeDoubleLE = function(value, offset, noAssert) {
return writeDouble(this, value, offset, !0, noAssert);
}, Buffer2.prototype.writeDoubleBE = function(value, offset, noAssert) {
return writeDouble(this, value, offset, !1, noAssert);
}, Buffer2.prototype.copy = function(target, targetStart, start, end) {
if (!Buffer2.isBuffer(target)) throw new TypeError("argument should be a Buffer");
if (start || (start = 0), !end && end !== 0 && (end = this.length), targetStart >= target.length && (targetStart = target.length), targetStart || (targetStart = 0), end > 0 && end < start && (end = start), end === start || target.length === 0 || this.length === 0) return 0;
if (targetStart < 0)
throw new RangeError("targetStart out of bounds");
if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
if (end < 0) throw new RangeError("sourceEnd out of bounds");
end > this.length && (end = this.length), target.length - targetStart < end - start && (end = target.length - targetStart + start);
let len = end - start;
return this === target && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(targetStart, start, end) : Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart), len;
}, Buffer2.prototype.fill = function(val, start, end, encoding) {
if (typeof val == "string") {
if (typeof start == "string" ? (encoding = start, start = 0, end = this.length) : typeof end == "string" && (encoding = end, end = this.length), encoding !== void 0 && typeof encoding != "string")
throw new TypeError("encoding must be a string");
if (typeof encoding == "string" && !Buffer2.isEncoding(encoding))
throw new TypeError("Unknown encoding: " + encoding);
if (val.length === 1) {
let code = val.charCodeAt(0);
(encoding === "utf8" && code < 128 || encoding === "latin1") && (val = code);
}
} else typeof val == "number" ? val = val & 255 : typeof val == "boolean" && (val = Number(val));
if (start < 0 || this.length < start || this.length < end)
throw new RangeError("Out of range index");
if (end <= start)
return this;
start = start >>> 0, end = end === void 0 ? this.length : end >>> 0, val || (val = 0);
let i;
if (typeof val == "number")
for (i = start; i < end; ++i)
this[i] = val;
else {
let bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding), len = bytes.length;
if (len === 0)
throw new TypeError('The value "' + val + '" is invalid for argument "value"');
for (i = 0; i < end - start; ++i)
this[i + start] = bytes[i % len];
}
return this;
};
let errors = {};
function E(sym, getMessage, Base) {
errors[sym] = class extends Base {
constructor() {
super(), Object.defineProperty(this, "message", {
value: getMessage.apply(this, arguments),
writable: !0,
configurable: !0
}), this.name = `${this.name} [${sym}]`, this.stack, delete this.name;
}
get code() {
return sym;
}
set code(value) {
Object.defineProperty(this, "code", {
configurable: !0,
enumerable: !0,
value,
writable: !0
});
}
toString() {
return `${this.name} [${sym}]: ${this.message}`;
}
};
}
E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
return name ? `${name} is outside of buffer bounds` : "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.`, received = input;
return Number.isInteger(input) && Math.abs(input) > 2 ** 32 ? received = addNumericalSeparator(String(input)) : typeof input == "bigint" && (received = String(input), (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) && (received = addNumericalSeparator(received)), received += "n"), msg += ` It must be ${range}. Received ${received}`, msg;
}, RangeError);
function addNumericalSeparator(val) {
let res = "", i = val.length, start = val[0] === "-" ? 1 : 0;
for (; i >= start + 4; i -= 3)
res = `_${val.slice(i - 3, i)}${res}`;
return `${val.slice(0, i)}${res}`;
}
function checkBounds(buf, offset, byteLength2) {
validateNumber(offset, "offset"), (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) && 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;
throw byteLength2 > 3 ? min === 0 || min === BigInt(0) ? range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}` : range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}` : range = `>= ${min}${n} and <= ${max}${n}`, new errors.ERR_OUT_OF_RANGE("value", range, value);
}
checkBounds(buf, offset, byteLength2);
}
function validateNumber(value, name) {
if (typeof value != "number")
throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
}
function boundsError(value, length, type) {
throw Math.floor(value) !== value ? (validateNumber(value, type), new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value)) : length < 0 ? new errors.ERR_BUFFER_OUT_OF_BOUNDS() : new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
}
let INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
function base64clean(str) {
if (str = str.split("=")[0], str = str.trim().replace(INVALID_BASE64_RE, ""), str.length < 2) return "";
for (; 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 i = 0; i < length; ++i) {
if (codePoint = string.charCodeAt(i), codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
(units -= 3) > -1 && bytes.push(239, 191, 189);
continue;
} else if (i + 1 === length) {
(units -= 3) > -1 && bytes.push(239, 191, 189);
continue;
}
leadSurrogate = codePoint;
continue;
}
if (codePoint < 56320) {
(units -= 3) > -1 && bytes.push(239, 191, 189), leadSurrogate = codePoint;
continue;
}
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
} else leadSurrogate && (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 new Error("Invalid code point");
}
return bytes;
}
function asciiToBytes(str) {
let byteArray = [];
for (let i = 0; i < str.length; ++i)
byteArray.push(str.charCodeAt(i) & 255);
return byteArray;
}
function utf16leToBytes(str, units) {
let c, hi, lo, byteArray = [];
for (let i = 0; i < str.length && !((units -= 2) < 0); ++i)
c = str.charCodeAt(i), hi = c >> 8, lo = c % 256, byteArray.push(lo), byteArray.push(hi);
return byteArray;
}
function base64ToBytes(str) {
return base64.toByteArray(base64clean(str));
}
function blitBuffer(src, dst, offset, length) {
let i;
for (i = 0; i < length && !(i + offset >= dst.length || i >= src.length); ++i)
dst[i + offset] = src[i];
return i;
}
function isInstance(obj, type) {
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
}
function numberIsNaN(obj) {
return obj !== obj;
}
let hexSliceLookupTable = function() {
let alphabet = "0123456789abcdef", table = new Array(256);
for (let i = 0; i < 16; ++i) {
let i16 = i * 16;
for (let j = 0; j < 16; ++j)
table[i16 + j] = alphabet[i] + alphabet[j];
}
return table;
}();
function defineBigIntMethod(fn) {
return typeof BigInt == "undefined" ? BufferBigIntNotDefined : fn;
}
function BufferBigIntNotDefined() {
throw new Error("BigInt not supported");
}
return exports$1;
}
var exports = dew();
exports.Buffer;
exports.SlowBuffer;
exports.INSPECT_MAX_BYTES;
exports.kMaxLength;
var Buffer = exports.Buffer, INSPECT_MAX_BYTES = exports.INSPECT_MAX_BYTES, kMaxLength = exports.kMaxLength;
var plugin = {
replaceText: {
"Convert to Dia": async function(app, text) {
text = text.trim();
let { type, text: parsedText } = await plugin._parseUserIntentFromText(app, text);
if (type !== "cancel")
return await plugin._toDiagram(app, type, text, parsedText), null;
}
},
insertText: {
"Create Diagram": async function(app) {
let { type, text } = await plugin._parseUserIntentFromText(app, null);
if (type !== "cancel")
return text = text.trim(), await plugin._toDiagram(app, type, text, text), null;
}
},
imageOption: {
"Convert to Text": {
check: (app, image) => {
try {
if (new URL(image.src).searchParams.get("text") != null)
return !0;
} catch {
}
return !1;
},
run: async (app, image) => (await plugin._toText(app, image), null)
}
},
async _parseUserIntentFromText(app, text) {
if (typeof text == "string" && text.match(/^\$\$(.*?)\$\$$/s))
return { type: "tex-display", text: text.replace(/^\$\$(.*?)\$\$$/s, "$1") };
if (typeof text == "string" && text.match(/^\$(.*?)\$$/s))
return { type: "tex", text: text.replace(/^\$(.*?)\$$/s, "$1") };
let promptInputs = [
{
label: "Diagram Type",
type: "select",
options: [
{ label: "Tex (Inline)", value: "tex" },
{ label: "Tex (Display)", value: "tex-display" },
{ label: "Mermaid", value: "mermaid" },
{ label: "PlantUML", value: "plantuml" },
{ label: "Graphviz", value: "graphviz" },
{ label: "Ditaa", value: "ditaa" },
{ label: "DBML", value: "dbml" }
],
value: "ditaa"
}
], type;
if (text == null) {
let arr = await app.prompt("Options for creating image:", {
inputs: [{ label: "Text / Code", placeholder: `+--+
|A |
+--+`, type: "text" }, ...promptInputs]
});
if (!arr) return { type: "cancel" };
if (text = arr[0], !text || text === "") return { type: "cancel" };
type = arr[1];
} else if (type = await app.prompt("Options for creating image:", {
inputs: promptInputs
}), !type) return { type: "cancel" };
return { type, text };
},
async _toDiagram(app, type, text, parsedText) {
try {
console.log(text);
let response;
if (type == null) return;
if (type === "tex" || type === "tex-display" ? response = await fetch("https://kroki.io/tikz/svg", {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded"
},
body: `\\documentclass{article}
\\usepackage{amsmath}
\\usepackage[dvipsnames]{xcolor}
\\usepackage[active,tightpage]{preview}
\\PreviewEnvironment{equation*}
\\setlength\\PreviewBorder{0.125pt}
\\begin{document}
\\${type === "tex-display" ? "huge" : "large"}
\\begin{equation*}
{${type === "tex-display" ? "\\displaystyle" : ""} \\color{Emerald} ${parsedText}}
\\end{equation*}
\\end{document}`
}) : (type === "mermaid" || type === "plantuml" || type === "graphviz" || type === "ditaa" || type === "dbml") && (response = await fetch(`https://kroki.io/${type}/svg`, {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded"
},
body: parsedText
})), !response)
throw new Error("No response from kroki.io");
if (!response.ok) {
let error = await response.text();
throw new Error(error);
}
let blob = await response.blob(), svgDataURL = await plugin._dataURLFromBlob(blob), pngDataURL = await plugin._svgToPng(svgDataURL), noteHandle = { uuid: app.context.noteUUID }, appendedFileURL = await app.attachNoteMedia(noteHandle, pngDataURL) + "?text=" + window.encodeURIComponent(Buffer.from(text, "utf8").toString("base64"));
return app.context.replaceSelection(`<a> </a>![${text || ""}](${appendedFileURL}) <!-- dummy comment -->`), null;
} catch (e) {
app.alert("Failed _toDiagram - " + e);
}
},
async _toText(app, image) {
try {
let url = new URL(image.src);
if (url.searchParams.get("text") == null) throw new Error("No text information found in image. It is possible that the image was not created by this plugin.");
let text = Buffer.from(window.decodeURIComponent(url.searchParams.get("text")), "base64").toString("utf8");
console.log(text), app.context.replaceSelection(text);
} catch (e) {
app.alert("Failed _toText - " + e);
}
},
async _svgToPng(svgBase64) {
return new Promise(async function(resolve, reject) {
let image = new Image();
image.src = svgBase64, image.onload = function() {
let canvas = document.createElement("canvas");
canvas.width = image.width, canvas.height = image.height, canvas.getContext("2d").drawImage(image, 0, 0);
let output = canvas.toDataURL("image/png");
resolve(output);
};
});
},
async _dataURLFromBlob(blob) {
return new Promise((resolve, reject) => {
let reader = new FileReader();
reader.onload = (event) => {
resolve(event.target.result);
}, reader.onerror = function(event) {
reader.abort(), reject(event.target.error);
}, reader.readAsDataURL(blob);
});
}
}, plugin_default = plugin;
return plugin;
})()